diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
index af04213966..143241325d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.cpp
@@ -1,924 +1,975 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkTbssRoiAnalysisWidget.h"
 
 
 #include <qlabel.h>
 #include <qpen.h>
 #include <qgroupbox.h>
 
 #include <qwt_text.h>
 #include <qwt_plot_grid.h>
 #include <qwt_painter.h>
 #include <qwt_legend.h>
 #include <qwt_plot_marker.h>
 
 
 #include <iostream>
 #include <fstream>
 #include <limits>
 
 #include <vtkCellArray.h>
 
 
 
 
 
 
 QmitkTbssRoiAnalysisWidget::QmitkTbssRoiAnalysisWidget( QWidget * parent )
   : QmitkPlotWidget(parent)
 {
   m_PlotPicker = new QwtPlotPicker(m_Plot->canvas());
   m_PlotPicker->setSelectionFlags(QwtPicker::PointSelection | QwtPicker::ClickSelection | QwtPicker::DragSelection);
   m_PlotPicker->setTrackerMode(QwtPicker::ActiveOnly);
 
   m_PlottingFiberBundle = false;
 }
 
 
 
 void QmitkTbssRoiAnalysisWidget::DoPlotFiberBundles(mitk::FiberBundleX *fib, mitk::Image* img,
                                                     mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg, int number)
 {
 
   TractContainerType tracts = CreateTracts(fib, startRoi, endRoi);
 
   TractContainerType resampledTracts = ParameterizeTracts(tracts, number);
 
   // Now we have the resampled tracts. Next we should use these points to read out the values
 
 
 
   PlotFiberBundles(resampledTracts, img, avg);
   m_CurrentTracts = resampledTracts;
 }
 
 
 TractContainerType QmitkTbssRoiAnalysisWidget::CreateTracts(mitk::FiberBundleX *fib,
                                                             mitk::PlanarFigure *startRoi,
                                                             mitk::PlanarFigure *endRoi)
 {
     mitk::PlaneGeometry* startGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(startRoi->GetGeometry2D()) );
     mitk::PlaneGeometry* endGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(endRoi->GetGeometry2D()) );
 
 
     mitk::Point3D startCenter = startRoi->GetWorldControlPoint(0); //center Point of start roi
     mitk::Point3D endCenter = endRoi->GetWorldControlPoint(0); //center Point of end roi
 
     mitk::FiberBundleX::Pointer inStart = fib->ExtractFiberSubset(startRoi);
     mitk::FiberBundleX::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
 
 
 
     int num = inBoth->GetNumFibers();
 
 
     TractContainerType tracts;
 
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = inBoth->GetFiberPolyData();
     vtkCellArray* lines = fiberPolyData->GetLines();
     lines->InitTraversal();
 
 
 
     // Now find out for each fiber which ROI is encountered first. If this is the startRoi, the direction is ok
     // Otherwise the plot should be in the reverse direction
     for( int fiberID( 0 ); fiberID < num; fiberID++ )
     {
       vtkIdType   numPointsInCell(0);
       vtkIdType*  pointsInCell(NULL);
       lines->GetNextCell ( numPointsInCell, pointsInCell );
 
       int startId = 0;
       int endId = 0;
 
       float minDistStart = std::numeric_limits<float>::max();
       float minDistEnd = std::numeric_limits<float>::max();
 
 
 
       for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
       {
 
 
         double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
 
         mitk::Point3D point;
         point[0] = p[0];
         point[1] = p[1];
         point[2] = p[2];
 
         float distanceToStart = point.EuclideanDistanceTo(startCenter);
         float distanceToEnd = point.EuclideanDistanceTo(endCenter);
 
         if(distanceToStart < minDistStart)
         {
           minDistStart = distanceToStart;
           startId = pointInCellID;
         }
 
         if(distanceToEnd < minDistEnd)
         {
           minDistEnd = distanceToEnd;
           endId = pointInCellID;
         }
 
 
 
       }
 
       /* We found the start and end points of of the part that should be plottet for
          the current fiber. now we need to plot them. If the endId is smaller than the startId the plot order
          must be reversed*/
 
       TractType singleTract;
       PointType point;
 
       if(startId < endId)
       {
 
         // Calculate the intersection of the ROI with the startRoi and decide if the startId is part of the roi or must be cut of
         double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
         mitk::Vector3D p0;
         p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
         p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
         mitk::Vector3D p1;
         p1[0] = p[0];       p1[1] = p[1];       p1[2] = p[2];
 
         // Check if p and p2 are both on the same side of the plane
         mitk::Vector3D normal = startGeometry2D->GetNormal();
 
         mitk::Point3D pStart;
         pStart[0] = p0[0];      pStart[1] = p0[1];      pStart[2] = p0[2];
 
         mitk::Point3D pSecond;
         pSecond[0] = p1[0];      pSecond[1] = p1[1];      pSecond[2] = p1[2];
 
         bool startOnPositive = startGeometry2D->IsAbove(pStart);
         bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
 
         mitk::Vector3D onPlane;
         onPlane[0] = startCenter[0];      onPlane[1] = startCenter[1];      onPlane[2] = startCenter[2];
 
 
 
         if(! (secondOnPositive ^ startOnPositive) )
         {
           /* startId and startId+1 lie on the same side of the plane, so we need
              need startId-1 to calculate the intersection with the planar figure*/
           p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
           p1[0] = p[0];        p1[1] = p[1];        p1[2] = p[2];
         }
 
 
         double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
         mitk::Vector3D newPoint = (p0-p1);
 
         point[0] = d*newPoint[0] + p0[0];
         point[1] = d*newPoint[1] + p0[1];
         point[2] = d*newPoint[2] + p0[2];
 
         singleTract.push_back(point);
 
         if(! (secondOnPositive ^ startOnPositive) )
         {
           /* StartId and startId+1 lie on the same side of the plane
              so startId is also part of the ROI*/
 
           double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
           point[0] = start[0]; point[1] = start[1]; point[2] = start[2];
           singleTract.push_back(point);
         }
 
 
 
         for( int pointInCellID( startId+1 ); pointInCellID < endId ; pointInCellID++)
         {
           // push back point
           double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
           point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
           singleTract.push_back( point );
 
         }
 
         /* endId must be included if endId and endId-1 lie on the same side of the
                  plane defined by endRoi*/
 
 
         p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
         p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
         p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
         p1[0] = p[0];      p1[1] = p[1];      p1[2] = p[2];
 
         mitk::Point3D pLast;
         pLast[0] = p0[0];      pLast[1] = p0[1];      pLast[2] = p0[2];
 
         mitk::Point3D pBeforeLast;
         pBeforeLast[0] = p1[0];      pBeforeLast[1] = p1[1];      pBeforeLast[2] = p1[2];
 
         normal = endGeometry2D->GetNormal();
         bool lastOnPositive = endGeometry2D->IsAbove(pLast);
         bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
 
 
         onPlane[0] = endCenter[0];
         onPlane[1] = endCenter[1];
         onPlane[2] = endCenter[2];
 
         if(! (lastOnPositive ^ secondLastOnPositive) )
         {
           /* endId and endId-1 lie on the same side of the plane, so we need
              need endId+1 to calculate the intersection with the planar figure.
              this should exist since we know that the fiber crosses the planar figure
              endId is also part of the tract and can be inserted here */
 
           p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
           point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
           singleTract.push_back( point );
 
           p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
         }
 
         d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
         newPoint = (p0-p1);
 
         point[0] = d*newPoint[0] + p0[0];
         point[1] = d*newPoint[1] + p0[1];
         point[2] = d*newPoint[2] + p0[2];
 
         singleTract.push_back(point);
 
 
 
       }
       else{
 
         // Calculate the intersection of the ROI with the startRoi and decide if the startId is part of the roi or must be cut of
         double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
         mitk::Vector3D p0;
         p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
         p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
         mitk::Vector3D p1;
         p1[0] = p[0];       p1[1] = p[1];       p1[2] = p[2];
 
         // Check if p and p2 are both on the same side of the plane
         mitk::Vector3D normal = startGeometry2D->GetNormal();
 
         mitk::Point3D pStart;
         pStart[0] = p0[0];      pStart[1] = p0[1];      pStart[2] = p0[2];
 
         mitk::Point3D pSecond;
         pSecond[0] = p1[0];      pSecond[1] = p1[1];      pSecond[2] = p1[2];
 
         bool startOnPositive = startGeometry2D->IsAbove(pStart);
         bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
         mitk::Vector3D onPlane;
         onPlane[0] = startCenter[0];      onPlane[1] = startCenter[1];      onPlane[2] = startCenter[2];
 
 
         if(! (secondOnPositive ^ startOnPositive) )
         {
           /* startId and startId+1 lie on the same side of the plane, so we need
              need startId-1 to calculate the intersection with the planar figure*/
           p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
           p1[0] = p[0];        p1[1] = p[1];        p1[2] = p[2];
         }
 
 
         double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
         mitk::Vector3D newPoint = (p0-p1);
 
 
         point[0] = d*newPoint[0] + p0[0];
         point[1] = d*newPoint[1] + p0[1];
         point[2] = d*newPoint[2] + p0[2];
 
 
         singleTract.push_back(point);
 
         if(! (secondOnPositive ^ startOnPositive) )
         {
           /* StartId and startId+1 lie on the same side of the plane
              so startId is also part of the ROI*/
 
           double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
           point[0] = start[0]; point[1] = start[1]; point[2] = start[2];
           singleTract.push_back(point);
         }
 
 
 
         for( int pointInCellID( startId-1 ); pointInCellID > endId ; pointInCellID--)
         {
           // push back point
           double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
           point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
           singleTract.push_back( point );
 
         }
 
         /* endId must be included if endId and endI+1 lie on the same side of the
                  plane defined by endRoi*/
 
 
         p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
         p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
         p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
         p1[0] = p[0];      p1[1] = p[1];      p1[2] = p[2];
 
         mitk::Point3D pLast;
         pLast[0] = p0[0];      pLast[1] = p0[1];      pLast[2] = p0[2];
 
         mitk::Point3D pBeforeLast;
         pBeforeLast[0] = p1[0];      pBeforeLast[1] = p1[1];      pBeforeLast[2] = p1[2];
 
         bool lastOnPositive = endGeometry2D->IsAbove(pLast);
         bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
         normal = endGeometry2D->GetNormal();
 
 
 
         onPlane[0] = endCenter[0];
         onPlane[1] = endCenter[1];
         onPlane[2] = endCenter[2];
 
         if(! (lastOnPositive ^ secondLastOnPositive) )
         {
           /* endId and endId+1 lie on the same side of the plane, so we need
              need endId-1 to calculate the intersection with the planar figure.
              this should exist since we know that the fiber crosses the planar figure
              endId is also part of the tract and can be inserted here */
 
           p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
           point[0] = p[0]; point[1] = p[1]; point[2] = p[2];
           singleTract.push_back( point );
 
           p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
         }
 
         d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
         newPoint = (p0-p1);
 
         point[0] = d*newPoint[0] + p0[0];
         point[1] = d*newPoint[1] + p0[1];
         point[2] = d*newPoint[2] + p0[2];
 
         singleTract.push_back(point);
 
       }
 
 
       tracts.push_back(singleTract);
 
 
     }
 
     return tracts;
 }
 
 void QmitkTbssRoiAnalysisWidget::PlotFiberBetweenRois(mitk::FiberBundleX *fib, mitk::Image* img,
                                 mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg, int number)
 {
 
   if(fib == NULL || img == NULL || startRoi == NULL || endRoi == NULL)
     return;
 
 
   m_Fib = fib;
   m_CurrentImage = img;
   m_CurrentStartRoi = startRoi;
   m_CurrentEndRoi = endRoi;
 
 
   DoPlotFiberBundles(fib, img, startRoi, endRoi, avg, number);
 }
 
 
 
 void QmitkTbssRoiAnalysisWidget::ModifyPlot(int number, bool avg)
 {
   if(m_Fib == NULL || m_CurrentImage == NULL || m_CurrentStartRoi == NULL || m_CurrentEndRoi == NULL)
     return;
 
   DoPlotFiberBundles(m_Fib, m_CurrentImage, m_CurrentStartRoi, m_CurrentEndRoi, avg, number);
 
 
 }
 
 
 
 TractContainerType QmitkTbssRoiAnalysisWidget::ParameterizeTracts(TractContainerType tracts, int number)
 {
   TractContainerType resampledTracts;
 
 
 
   for(TractContainerType::iterator it = tracts.begin(); it != tracts.end(); ++it)
   {
     TractType resampledTract;
     TractType tract = *it;
 
     // Calculate the total length
     float totalLength = 0;
 
     if(tract.size() < 2)
       continue;
 
     PointType p0 = tract.at(0);
     for(int i = 1; i<tract.size(); i++)
     {
       PointType p1 = tract.at(i);
       float length = p0.EuclideanDistanceTo(p1);
       totalLength += length;
       p0 = p1;
     }
 
     float stepSize = totalLength / number;
 
 
 
     p0 = tract.at(0);
     PointType p1 = tract.at(1);
     int tractCounter = 2;
     float distance = p0.EuclideanDistanceTo(p1);
     float locationBetween = 0;
 
     for(float position = 0;
         position <= totalLength+0.001 && resampledTract.size() <= (number+1);
         position+=stepSize)
     {
 
       /* In case we walked to far we need to find the next segment we are on and on what relative position on that
          tract we are on. Small correction for rounding errors */
       while(locationBetween > distance+0.001)
       {
 
         if(tractCounter == tract.size())
           std::cout << "problem";
 
         // Determine by what distance we are no on the next segment
         locationBetween = locationBetween - distance;
         p0 = p1;
         p1 = tract.at(tractCounter);
         tractCounter++;
 
         distance = p0.EuclideanDistanceTo(p1);
 
       }
 
       // Direction
       PointType::VectorType direction = p1-p0;
       direction.Normalize();
 
       PointType newSample = p0 + direction*locationBetween;
       resampledTract.push_back(newSample);
 
 
       locationBetween += stepSize;
 
 
     }
 
     resampledTracts.push_back(resampledTract);
 
 
   }
   return resampledTracts;
 }
 
 
 mitk::Point3D QmitkTbssRoiAnalysisWidget::GetPositionInWorld(int index)
 {
   TractContainerType tractsAtIndex;
 
   float xSum = 0.0;
   float ySum = 0.0;
   float zSum = 0.0;
   for(TractContainerType::iterator it = m_CurrentTracts.begin();
       it!=m_CurrentTracts.end(); ++it)
   {
     TractType tract = *it;
     PointType p = tract.at(index);
     xSum += p[0];
     ySum += p[1];
     zSum += p[2];
   }
 
   int number = m_CurrentTracts.size();
 
   float xPos = xSum / number;
   float yPos = ySum / number;
   float zPos = zSum / number;
 
 
   mitk::Point3D pos;
   pos[0] = xPos;
   pos[1] = yPos;
   pos[2] = zPos;
 
   return pos;
 }
 
 
 std::vector< std::vector<double> > QmitkTbssRoiAnalysisWidget::CalculateGroupProfiles()
 {
   MITK_INFO << "make profiles!";
   std::vector< std::vector<double> > profiles;
 
 
   int size = m_Projections->GetVectorLength();
   for(int s=0; s<size; s++)
   {
     // Iterate trough the roi
     std::vector<double> profile;
     RoiType::iterator it;
     it = m_Roi.begin();
     while(it != m_Roi.end())
     {
       itk::Index<3> ix = *it;
       profile.push_back(m_Projections->GetPixel(ix).GetElement(s));
       it++;
     }
 
     profiles.push_back(profile);
   }
 
 
 
   m_IndividualProfiles = profiles;
   // Calculate the averages
 
   // Here a check could be build in to check whether all profiles have
   // the same length, but this should normally be the case if the input
   // data were corrected with the TBSS Module.
 
   std::vector< std::vector<double> > groupProfiles;
 
   std::vector< std::pair<std::string, int> >::iterator it;
   it = m_Groups.begin();
 
   int c = 0; //the current profile number
 
   while(it != m_Groups.end() && profiles.size() > 0)
   {
     std::pair<std::string, int> p = *it;
     int size = p.second;
 
     //initialize a vector of the right length with zeroes
     std::vector<double> averageProfile;
     for(int i=0; i<profiles.at(0).size(); i++)
     {
       averageProfile.push_back(0.0);
     }
 
     // Average the right number of profiles
 
     for(int i=0; i<size; i++)
     {
       for(int j=0; j<averageProfile.size(); ++j)
       {
         averageProfile.at(j) = averageProfile.at(j) + profiles.at(c).at(j);
       }
       c++;
     }
 
     // Divide by the number of profiles to get group average
     for(int i=0; i<averageProfile.size(); i++)
     {
       averageProfile.at(i) = averageProfile.at(i) / size;
     }
 
     groupProfiles.push_back(averageProfile);
 
     ++it;
   }
 
   return groupProfiles;
 }
 
 
 void QmitkTbssRoiAnalysisWidget::DrawProfiles()
 {
-  this->Clear();
-
-  m_Vals.clear();
-
-  std::vector<double> v1;
-
   std::vector <std::vector<double> > groupProfiles = CalculateGroupProfiles();
+  Plot(groupProfiles);
+}
 
+void QmitkTbssRoiAnalysisWidget::Plot(std::vector <std::vector<double> > groupProfiles)
+{
+    this->Clear();
+    m_Vals.clear();
+    std::vector<double> v1;
 
-  std::vector<double> xAxis;
-  for(int i=0; i<groupProfiles.at(0).size(); ++i)
-  {
-    xAxis.push_back((double)i);
-  }
 
+    std::vector<double> xAxis;
+    for(int i=0; i<groupProfiles.at(0).size(); ++i)
+    {
+      xAxis.push_back((double)i);
+    }
 
-  // fill m_Vals. This might be used by the user to copy data to the clipboard
-  for(int i=0; i<groupProfiles.size(); i++)
-  {
 
-    v1.clear();
+    // fill m_Vals. This might be used by the user to copy data to the clipboard
+    for(int i=0; i<groupProfiles.size(); i++)
+    {
 
+      v1.clear();
 
-    for(int j=0; j<groupProfiles.at(i).size(); j++)
-    {
-      v1.push_back(groupProfiles.at(i).at(j));
-    }
 
-    m_Vals.push_back(v1);
+      for(int j=0; j<groupProfiles.at(i).size(); j++)
+      {
+        v1.push_back(groupProfiles.at(i).at(j));
+      }
 
-  }
+      m_Vals.push_back(v1);
 
-  std::string title = m_Measure + " profiles on the ";
-  title.append(m_Structure);
-  this->SetPlotTitle( title.c_str() );
-  QPen pen( Qt::SolidLine );
-  pen.setWidth(2);
+    }
 
+    std::string title = m_Measure + " profiles on the ";
+    title.append(m_Structure);
+    this->SetPlotTitle( title.c_str() );
+    QPen pen( Qt::SolidLine );
+    pen.setWidth(2);
 
 
-  std::vector< std::pair<std::string, int> >::iterator it;
-  it = m_Groups.begin();
 
-  int c = 0; //the current profile number
+    std::vector< std::pair<std::string, int> >::iterator it;
+    it = m_Groups.begin();
 
-  QColor colors[4] = {Qt::green, Qt::blue, Qt::yellow, Qt::red};
+    int c = 0; //the current profile number
 
-  while(it != m_Groups.end() && groupProfiles.size() > 0)
-  {
+    QColor colors[4] = {Qt::green, Qt::blue, Qt::yellow, Qt::red};
 
-    std::pair< std::string, int > group = *it;
+    while(it != m_Groups.end() && groupProfiles.size() > 0)
+    {
 
-    pen.setColor(colors[c]);
-    int curveId = this->InsertCurve( group.first.c_str() );
-    this->SetCurveData( curveId, xAxis, groupProfiles.at(c) );
+      std::pair< std::string, int > group = *it;
 
+      pen.setColor(colors[c]);
+      int curveId = this->InsertCurve( group.first.c_str() );
+      this->SetCurveData( curveId, xAxis, groupProfiles.at(c) );
 
-    this->SetCurvePen( curveId, pen );
 
-    c++;
-    it++;
+      this->SetCurvePen( curveId, pen );
 
-  }
+      c++;
+      it++;
 
+    }
 
-  QwtLegend *legend = new QwtLegend;
-  this->SetLegend(legend, QwtPlot::RightLegend, 0.5);
 
+    QwtLegend *legend = new QwtLegend;
+    this->SetLegend(legend, QwtPlot::RightLegend, 0.5);
 
-  std::cout << m_Measure << std::endl;
-  this->m_Plot->setAxisTitle(0, m_Measure.c_str());
-  this->m_Plot->setAxisTitle(3, "Position");
 
-  this->Replot();
+    std::cout << m_Measure << std::endl;
+    this->m_Plot->setAxisTitle(0, m_Measure.c_str());
+    this->m_Plot->setAxisTitle(3, "Position");
 
+    this->Replot();
 }
 
 
-void QmitkTbssRoiAnalysisWidget::PlotFiber4D(mitk::TbssImage::Pointer tbssImage,
-                                             mitk::FiberBundleX *fib,
-                                             mitk::PlanarFigure* startRoi,
-                                             mitk::PlanarFigure* endRoi,
-                                             int number)
+std::vector< std::vector<double> > QmitkTbssRoiAnalysisWidget::CalculateGroupProfilesFibers(mitk::TbssImage::Pointer tbssImage,
+                                                                                            mitk::FiberBundleX *fib,
+                                                                                            mitk::PlanarFigure* startRoi,
+                                                                                            mitk::PlanarFigure* endRoi,
+                                                                                            int number)
 {
-  TractContainerType tracts = CreateTracts(fib, startRoi, endRoi);
+    TractContainerType tracts = CreateTracts(fib, startRoi, endRoi);
 
-  TractContainerType resampledTracts = ParameterizeTracts(tracts, number);
-
-  this->Clear();
+    TractContainerType resampledTracts = ParameterizeTracts(tracts, number);
 
+    int nTracts = resampledTracts.size();
 
+    this->Clear();
 
-  // For every group we have m fibers * n subjects of profiles to fill
 
-  std::vector< std::vector<double> > profiles;
+    // For every group we have m fibers * n subjects of profiles to fill
 
-  // calculate individual profiles by going through all n subjects
-  int size = m_Projections->GetVectorLength();
-  for(int s=0; s<size; s++)
-  {
+    std::vector< std::vector<double> > profiles;
 
-    // Iterate through all tracts
-    int nTracts = resampledTracts.size();
-    for(int t=0; t<nTracts; t++)
+    // calculate individual profiles by going through all n subjects
+    int size = m_Projections->GetVectorLength();
+    for(int s=0; s<size; s++)
     {
-      // Iterate trough the tract
-      std::vector<double> profile;
-      TractType::iterator it = resampledTracts[t].begin();
-      while(it != resampledTracts[t].end())
+
+      // Iterate through all tracts
+
+      for(int t=0; t<nTracts; t++)
       {
-        PointType p = *it;
-        PointType index;
-        tbssImage->GetGeometry()->WorldToIndex(p, index);
+        // Iterate trough the tract
+        std::vector<double> profile;
+        TractType::iterator it = resampledTracts[t].begin();
+        while(it != resampledTracts[t].end())
+        {
+          PointType p = *it;
+          PointType index;
+          tbssImage->GetGeometry()->WorldToIndex(p, index);
+
+          itk::Index<3> ix;
+          ix[0] = index[0];
+          ix[1] = index[1];
+          ix[2] = index[2];
+          // Get value from image
 
-        itk::Index<3> ix;
-        ix[0] = index[0];
-        ix[1] = index[1];
-        ix[2] = index[2];
-        // Get value from image
+          profile.push_back(m_Projections->GetPixel(ix).GetElement(s));
 
-        profile.push_back(m_Projections->GetPixel(ix).GetElement(s));
+          it++;
+        }
+        profiles.push_back(profile);
       }
-      profiles.push_back(profile);
+
+
+
+
     }
 
+    m_IndividualProfiles = profiles;
 
     // Now create the group averages (every group contains m fibers * n_i group members
 
+    std::vector< std::pair<std::string, int> >::iterator it;
+    it = m_Groups.begin();
+    int c = 0; //the current profile number
+
+    // Calculate the group averages
+    std::vector< std::vector<double> > groupProfiles;
 
+    while(it != m_Groups.end() && profiles.size() > 0)
+    {
+      std::pair<std::string, int> p = *it;
+      int size = p.second;
 
+      //initialize a vector of the right length with zeroes
+      std::vector<double> averageProfile;
+      for(int i=0; i<profiles.at(0).size(); i++)
+      {
+        averageProfile.push_back(0.0);
+      }
 
+      // Average the right number of profiles
 
-  }
+      for(int i=0; i<size*nTracts; i++)
+      {
+        for(int j=0; j<averageProfile.size(); ++j)
+        {
+          averageProfile.at(j) = averageProfile.at(j) + profiles.at(c).at(j);
+        }
+        c++;
+      }
 
+      // Divide by the number of profiles to get group average
+      for(int i=0; i<averageProfile.size(); i++)
+      {
+        averageProfile.at(i) = averageProfile.at(i) / (size*nTracts);
+      }
 
+      groupProfiles.push_back(averageProfile);
 
-  m_IndividualProfiles = profiles;
+      ++it;
+    }
 
+    return groupProfiles;
+}
 
 
+void QmitkTbssRoiAnalysisWidget::PlotFiber4D(mitk::TbssImage::Pointer tbssImage,
+                                             mitk::FiberBundleX *fib,
+                                             mitk::PlanarFigure* startRoi,
+                                             mitk::PlanarFigure* endRoi,
+                                             int number)
+{
 
 
+  std::vector <std::vector<double> > groupProfiles = CalculateGroupProfilesFibers(tbssImage, fib, startRoi, endRoi, number);
+  Plot(groupProfiles);
 
 
 }
 
 
 
 void QmitkTbssRoiAnalysisWidget::PlotFiberBundles(TractContainerType tracts, mitk::Image *img, bool avg)
 {
   this->Clear();
   std::vector<TractType>::iterator it = tracts.begin();
 
 
   // Get the values along the curves from a 3D images. should also contain info about the position on screen.
   std::vector< std::vector <double > > profiles;
 
   it = tracts.begin();
   while(it != tracts.end())
   {
     std::cout << "Tract\n";
     TractType tract = *it;
     TractType::iterator tractIt = tract.begin();
 
     std::vector<double> profile;
 
     while(tractIt != tract.end())
     {
       PointType p = *tractIt;
       std::cout << p[0] << ' ' << p[1] << ' ' << p[2] << '\n';
 
 
       // Get value from image
       profile.push_back( (double)img->GetPixelValueByWorldCoordinate(p) );
 
       ++tractIt;
     }
 
     profiles.push_back(profile);
     std::cout << std::endl;
 
     ++it;
   }
 
 
   if(profiles.size() == 0)
     return;
 
   m_IndividualProfiles = profiles;
 
 
   std::string title = "Fiber bundle plot";
   this->SetPlotTitle( title.c_str() );
 
 
   // initialize average profile
   std::vector<double> averageProfile;
   std::vector<double> profile = profiles.at(0); // can do this because we checked the size of profiles before
   for(int i=0; i<profile.size(); ++i)
   {
     averageProfile.push_back(0.0);
   }
 
 
   std::vector< std::vector<double> >::iterator profit = profiles.begin();
 
   int id=0;
   while(profit != profiles.end())
   {
     std::vector<double> profile = *profit;
 
 
 
     std::vector<double> xAxis;
     for(int i=0; i<profile.size(); ++i)
     {
       xAxis.push_back((double)i);
       averageProfile.at(i) += profile.at(i) / profiles.size();
     }
 
     int curveId = this->InsertCurve( QString::number(id).toStdString().c_str() );
 
     this->SetCurveData( curveId, xAxis, profile );
 
     ++profit;
     id++;
 
 
   }
 
   m_Average = averageProfile;
 
 
   if(avg)
   {
 
     // Draw the average profile
     std::vector<double> xAxis;
     for(int i=0; i<averageProfile.size(); ++i)
     {
       xAxis.push_back((double)i);
     }
 
     int curveId = this->InsertCurve( QString::number(id).toStdString().c_str() );
     this->SetCurveData( curveId, xAxis, averageProfile );
 
 
 
 
     QPen pen( Qt::SolidLine );
     pen.setWidth(3);
     pen.setColor(Qt::red);
 
     this->SetCurvePen( curveId, pen );
 
 
 
     id++;
 
 
   }
 
   this->Replot();
 
 
 
 
 
 }
 
 
 void QmitkTbssRoiAnalysisWidget::drawBar(int x)
 {
 
   m_Plot->detachItems(QwtPlotItem::Rtti_PlotMarker, true);
 
 
   QwtPlotMarker *mX = new QwtPlotMarker();
   //mX->setLabel(QString::fromLatin1("selected point"));
   mX->setLabelAlignment(Qt::AlignLeft | Qt::AlignBottom);
   mX->setLabelOrientation(Qt::Vertical);
   mX->setLineStyle(QwtPlotMarker::VLine);
   mX->setLinePen(QPen(Qt::black, 0, Qt::SolidLine));
   mX->setXValue(x);
   mX->attach(m_Plot);
 
 
   this->Replot();
 
 }
 
 QmitkTbssRoiAnalysisWidget::~QmitkTbssRoiAnalysisWidget()
 {
   delete m_PlotPicker;
 
 }
 
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
index 71503a59e3..17a0a601c0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTbssRoiAnalysisWidget.h
@@ -1,227 +1,233 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkTbssRoiAnalysisWidget_H_
 #define QmitkTbssRoiAnalysisWidget_H_
 
 #include "QmitkPlotWidget.h"
 
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 
 #include "QmitkExtExports.h"
 #include "mitkPlanarFigure.h"
 #include "itkVectorImage.h"
 #include <mitkFiberBundleX.h>
 #include <mitkPlanarCircle.h>
 #include <mitkTbssImage.h>
 
 
 #include <qwt_plot.h>
 #include <qwt_plot_picker.h>
 
 typedef itk::VectorImage<float,3>     VectorImageType;
 typedef std::vector< itk::Index<3> > RoiType;
 
 typedef itk::Point<float,3>               PointType;
 typedef std::vector< PointType>           TractType;
 typedef std::vector< TractType > TractContainerType;
 
 
 /**
  * \brief Plot widget for TBSS Data
  * This widget can plot regions of interest on TBSS projection data.
  */
 class DIFFUSIONIMAGING_EXPORT QmitkTbssRoiAnalysisWidget : public QmitkPlotWidget
 {
 
 Q_OBJECT
 
 public:
 
 
   QmitkTbssRoiAnalysisWidget( QWidget * parent);
   virtual ~QmitkTbssRoiAnalysisWidget();
 
 
   /* \brief Set group information */
   void SetGroups(std::vector< std::pair<std::string, int> > groups)
   {
     m_Groups = groups;
   }
 
   /* \brief Draws the group averaged profiles */
   void DrawProfiles();
 
 
   void PlotFiber4D(mitk::TbssImage::Pointer tbssImage,
                    mitk::FiberBundleX *fib,
                    mitk::PlanarFigure* startRoi,
                    mitk::PlanarFigure* endRoi,
                    int number);
 
 
   void PlotFiberBundles(TractContainerType tracts, mitk::Image* img, bool avg=false);
 
 
   /* \brief Sets the projections of the individual subjects */
   void SetProjections(VectorImageType::Pointer projections)
   {
     m_Projections = projections;
   }
 
   /* \brief Set the region of interest*/
   void SetRoi(RoiType roi)
   {
     m_Roi = roi;
   }
 
   /* \brief Set structure information to display in the plot */
   void SetStructure(std::string structure)
   {
     m_Structure = structure;
   }
 
   /* \brief Set measurement type for display in the plot */
   void SetMeasure(std::string measure)
   {
     m_Measure = measure;
   }
 
   /* \brief Draws a bar to indicate were the user clicked in the plot */
   void drawBar(int x);
 
 
 
   /* \brief Returns the values of the group averaged profiles */
   std::vector <std::vector<double> > GetVals()
   {
     return m_Vals;
   }
 
 
   /* \brief Returns the values of the individual subjects profiles */
   std::vector <std::vector<double> > GetIndividualProfiles()
   {
     return m_IndividualProfiles;
   }
 
 
   std::vector<double> GetAverageProfile()
   {
     return m_Average;
   }
 
 
   void SetPlottingFiber(bool b)
   {
     m_PlottingFiberBundle = b;
   }
 
   bool IsPlottingFiber()
   {
     return m_PlottingFiberBundle;
   }
 
 
   void PlotFiberBetweenRois(mitk::FiberBundleX *fib, mitk::Image* img,
                             mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg=-1, int number=25);
 
 
 
 
   // Takes an index which is an x coordinate from the plot and finds the corresponding position in world space
   mitk::Point3D GetPositionInWorld(int index);
   void ModifyPlot(int number, bool avg);
 
 
 
   QwtPlotPicker* m_PlotPicker;
 
 protected:
 
   mitk::FiberBundleX* m_Fib;
 
 
   std::vector< std::vector<double> > m_Vals;
 
   std::vector< std::vector<double> > m_IndividualProfiles;
   std::vector< double > m_Average;
 
 
 
   std::vector< std::vector<double> > CalculateGroupProfiles();
+  std::vector< std::vector<double> > CalculateGroupProfilesFibers(mitk::TbssImage::Pointer tbssImage,
+                                                                  mitk::FiberBundleX *fib,
+                                                                  mitk::PlanarFigure* startRoi,
+                                                                  mitk::PlanarFigure* endRoi,
+                                                                  int number);
 
+  void Plot(std::vector <std::vector<double> > groupProfiles);
 
 
   void Tokenize(const std::string& str,
                 std::vector<std::string>& tokens,
                 const std::string& delimiters = " ")
   {
     // Skip delimiters at beginning.
     std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
     // Find first "non-delimiter".
     std::string::size_type pos     = str.find_first_of(delimiters, lastPos);
 
     while (std::string::npos != pos || std::string::npos != lastPos)
     {
         // Found a token, add it to the vector.
         tokens.push_back(str.substr(lastPos, pos - lastPos));
         // Skip delimiters.  Note the "not_of"
         lastPos = str.find_first_not_of(delimiters, pos);
         // Find next "non-delimiter"
         pos = str.find_first_of(delimiters, lastPos);
     }
   }
 
   std::vector< std::pair<std::string, int> > m_Groups;
 
   VectorImageType::Pointer m_Projections;
   RoiType m_Roi;
   std::string m_Structure;
   std::string m_Measure;
 
   bool m_PlottingFiberBundle; // true when the plot results from a fiber tracking result (vtk .fib file)
 
 
   // Resample a collection of tracts so that every tract contains #number equidistant samples
   TractContainerType ParameterizeTracts(TractContainerType tracts, int number);
 
 
 
 
   TractContainerType m_CurrentTracts;
 
 
 
   mitk::Image* m_CurrentImage;
 
   mitk::PlanarFigure* m_CurrentStartRoi;
   mitk::PlanarFigure* m_CurrentEndRoi;
 
 
   void DoPlotFiberBundles(mitk::FiberBundleX *fib, mitk::Image* img,
                           mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi, bool avg=false, int number=25);
 
 
 
   /* \brief Creates tracts from a mitk::FiberBundleX and two planar figures indicating the start end end point */
   TractContainerType CreateTracts(mitk::FiberBundleX *fib, mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi);
 
 
 
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
index 030ec06289..a81bb5cad5 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
@@ -1,1149 +1,1154 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkTractbasedSpatialStatisticsView.h"
 #include "QmitkStdMultiWidget.h"
 
 #include "mitkDataNodeObject.h"
 #include <itkCastImageFilter.h>
 
 // Qt
 #include <QMessageBox>
 #include <QInputDialog>
 #include <QClipboard>
 
 
 #include <mitkTractAnalyzer.h>
 #include <mitkTbssImporter.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarFigureInteractor.h>
 
 
 #include "vtkPoints.h"
 #include <vtkCellArray.h>
 #include <vtkPolyLine.h>
 
 
 const std::string QmitkTractbasedSpatialStatisticsView::VIEW_ID = "org.mitk.views.tractbasedspatialstatistics";
 
 using namespace berry;
 
 
 QmitkTractbasedSpatialStatisticsView::QmitkTractbasedSpatialStatisticsView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 {
 
 }
 
 QmitkTractbasedSpatialStatisticsView::~QmitkTractbasedSpatialStatisticsView()
 {
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::PerformChange()
 {
   m_Controls->m_RoiPlotWidget->ModifyPlot(m_Controls->m_Segments->value(), m_Controls->m_Average->isChecked());
 }
 
 void QmitkTractbasedSpatialStatisticsView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
   //datamanager selection changed
   if (!this->IsActivated())
     return;
 
 /*
   // Get DataManagerSelection
   if (!this->GetDataManagerSelection().empty())
   {
     mitk::DataNode::Pointer sourceImageNode = this->GetDataManagerSelection().front();
     mitk::Image::Pointer sourceImage = dynamic_cast<mitk::Image*>(sourceImageNode->GetData());
 
     if (!sourceImage)
     {
       m_Controls->m_TbssImageLabel->setText(
         QString( sourceImageNode->GetName().c_str() ) + " is no image"
         );
 
       return;
     }
 
     // set Text
     m_Controls->m_TbssImageLabel->setText(
       QString( sourceImageNode->GetName().c_str() ) + " (" +
       QString::number(sourceImage->GetDimension()) + "D)"
       );
 
 
   }
   else
   {
     m_Controls->m_TbssImageLabel->setText("Please select an image");
   }
 */
 
   // Check which datatypes are selected in the datamanager and enable/disable widgets accordingly
 
   bool foundTbssRoi = false;
   bool foundTbss = false;
   bool found3dImage = false;
   bool found4dImage = false;
   bool foundFiberBundle = false;
   bool foundStartRoi = false;
   bool foundEndRoi = false;
 
   mitk::TbssRoiImage* roiImage;
   mitk::TbssImage* image;
   mitk::Image* img;
   mitk::FiberBundleX* fib;
   mitk::PlanarFigure* start;
   mitk::PlanarFigure* end;
 
   m_CurrentStartRoi = NULL;
   m_CurrentEndRoi = NULL;
 
 
 
   for ( int i=0; i<nodes.size(); i++ )
   {
 
     // only look at interesting types
     // check for valid data
     mitk::BaseData* nodeData = nodes[i]->GetData();
     if( nodeData )
     {
       if(QString("TbssRoiImage").compare(nodeData->GetNameOfClass())==0)
       {
         foundTbssRoi = true;
         roiImage = static_cast<mitk::TbssRoiImage*>(nodeData);
       }
       else if (QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
       {
         foundTbss = true;
         image = static_cast<mitk::TbssImage*>(nodeData);
       }
       else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
           found3dImage = true;
         }
         else if(img->GetDimension() == 4)
         {
           found4dImage = true;
         }
       }
 
       else if (QString("FiberBundleX").compare(nodeData->GetNameOfClass())==0)
       {
         foundFiberBundle = true;
         fib = static_cast<mitk::FiberBundleX*>(nodeData);
         this->m_CurrentFiberNode = nodes[i];
       }
 
 
       if(QString("PlanarCircle").compare(nodeData->GetNameOfClass())==0)
       {
         if(!foundStartRoi)
         {
           start = dynamic_cast<mitk::PlanarFigure*>(nodeData);
           this->m_CurrentStartRoi = nodes[i];
           foundStartRoi =  true;
         }
         else
         {
           end = dynamic_cast<mitk::PlanarFigure*>(nodeData);
           this->m_CurrentEndRoi = nodes[i];
           foundEndRoi = true;
         }
       }
     }
   }
 
 
   this->m_Controls->m_CreateRoi->setEnabled(found3dImage);
   this->m_Controls->m_ImportFsl->setEnabled(found4dImage);
 
 
 
   if(foundTbss && foundTbssRoi)
   {
     this->Plot(image, roiImage);
   }
 
-  if(found3dImage && foundFiberBundle && foundStartRoi && foundEndRoi)
+  else if(found3dImage && foundFiberBundle && foundStartRoi && foundEndRoi)
   {
     this->PlotFiberBundle(fib, img, start, end);
   }
 
-  else if(found3dImage == true && foundFiberBundle)
+  else if(found3dImage && foundFiberBundle)
   {
     this->PlotFiberBundle(fib, img);
   }
 
+  else if(foundTbss && foundStartRoi && foundEndRoi && foundFiberBundle)
+  {
+    this->PlotFiber4D(image, fib, start, end);
+  }
+
   if(found3dImage)
   {
     this->InitPointsets();
   }
 
   this->m_Controls->m_Cut->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi);
   this->m_Controls->m_SegmentLabel->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
   this->m_Controls->m_Segments->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
   this->m_Controls->m_Average->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::InitPointsets()
 {
   // Check if PointSetStart exsits, if not create it.
   m_P1 = this->GetDefaultDataStorage()->GetNamedNode("PointSetNode");
 
   if (m_PointSetNode)
   {
     //m_PointSetNode = dynamic_cast<mitk::PointSet*>(m_P1->GetData());
     return;
   }
 
   if ((!m_P1) || (!m_PointSetNode))
   {
     // create new ones
     m_PointSetNode = mitk::PointSet::New();
     m_P1 = mitk::DataNode::New();
     m_P1->SetData( m_PointSetNode );
     m_P1->SetProperty( "name", mitk::StringProperty::New( "PointSet" ) );
     m_P1->SetProperty( "opacity", mitk::FloatProperty::New( 1 ) );
     m_P1->SetProperty( "helper object", mitk::BoolProperty::New(true) ); // CHANGE if wanted
     m_P1->SetProperty( "pointsize", mitk::FloatProperty::New( 0.1 ) );
     m_P1->SetColor( 1.0, 0.0, 0.0 );
     this->GetDefaultDataStorage()->Add(m_P1);
     m_Controls->m_PointWidget->SetPointSetNode(m_P1);
     m_Controls->m_PointWidget->SetMultiWidget(GetActiveStdMultiWidget());
   }
 }
 
 void QmitkTractbasedSpatialStatisticsView::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::QmitkTractbasedSpatialStatisticsViewControls;
     m_Controls->setupUi( parent );
     this->CreateConnections();
   }
 
 
   // Table for the FSL TBSS import
   m_GroupModel = new QmitkTbssTableModel();
   m_Controls->m_GroupInfo->setModel(m_GroupModel);
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::Activated()
 {
   QmitkFunctionality::Activated();
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkTractbasedSpatialStatisticsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_CreateRoi), SIGNAL(clicked()), this, SLOT(CreateRoi()) );
     connect( (QObject*)(m_Controls->m_ImportFsl), SIGNAL(clicked()), this, SLOT(TbssImport()) );
     connect( (QObject*)(m_Controls->m_AddGroup), SIGNAL(clicked()), this, SLOT(AddGroup()) );
     connect( (QObject*)(m_Controls->m_RemoveGroup), SIGNAL(clicked()), this, SLOT(RemoveGroup()) );
     connect( (QObject*)(m_Controls->m_Clipboard), SIGNAL(clicked()), this, SLOT(CopyToClipboard()) );
     connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(selected(const QwtDoublePoint&)), SLOT(Clicked(const QwtDoublePoint&) ) );
     connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(moved(const QwtDoublePoint&)), SLOT(Clicked(const QwtDoublePoint&) ) );
     connect( (QObject*)(m_Controls->m_Cut), SIGNAL(clicked()), this, SLOT(Cut()) );
     connect( (QObject*)(m_Controls->m_Average), SIGNAL(stateChanged(int)), this, SLOT(PerformChange()) );
     connect( (QObject*)(m_Controls->m_Segments), SIGNAL(valueChanged(int)), this, SLOT(PerformChange()) );
 
   }
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::CopyToClipboard()
 {
 
 
 
   if(m_Controls->m_RoiPlotWidget->IsPlottingFiber())
   {
     // Working with fiber bundles
     std::vector <std::vector<double> > profiles = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
 
     QString clipboardText;
     for (std::vector<std::vector<double> >::iterator it = profiles.begin(); it
                                                            != profiles.end(); ++it)
     {
       for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
             (*it).end(); ++it2)
       {
         clipboardText.append(QString("%1 \t").arg(*it2));
       }
       clipboardText.append(QString("\n"));
     }
 
 
 
     if(m_Controls->m_Average->isChecked())
     {
       std::vector<double> averages = m_Controls->m_RoiPlotWidget->GetAverageProfile();
       clipboardText.append(QString("\nAverage\n"));
 
       for (std::vector<double>::iterator it2 = averages.begin(); it2 !=
             averages.end(); ++it2)
       {
         clipboardText.append(QString("%1 \t").arg(*it2));
 
       }
     }
 
     QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
   }
 
   else{
 
     // Working with TBSS Data
     if(m_Controls->m_Average->isChecked())
     {
       std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetVals();
       QString clipboardText;
       for (std::vector<std::vector<double> >::iterator it = vals.begin(); it
                                                              != vals.end(); ++it)
       {
         for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
               (*it).end(); ++it2)
         {
           clipboardText.append(QString("%1 \t").arg(*it2));
 
           double d = *it2;
           std::cout << d <<std::endl;
         }
         clipboardText.append(QString("\n"));
       }
 
       QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
     }
     else
     {
       std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
       QString clipboardText;
       for (std::vector<std::vector<double> >::iterator it = vals.begin(); it
                                                              != vals.end(); ++it)
       {
         for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
               (*it).end(); ++it2)
         {
           clipboardText.append(QString("%1 \t").arg(*it2));
 
           double d = *it2;
           std::cout << d <<std::endl;
         }
         clipboardText.append(QString("\n"));
       }
       QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
     }
 
   }
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::RemoveGroup()
 {
 
   QTableView *temp = static_cast<QTableView*>(m_Controls->m_GroupInfo);
 
   QItemSelectionModel *selectionModel = temp->selectionModel();
 
   QModelIndexList indices = selectionModel->selectedRows();
 
   QModelIndex index;
 
   foreach(index, indices)
   {
     int row = index.row();
     m_GroupModel->removeRows(row, 1, QModelIndex());
   }
 
 }
 
 
 
 void QmitkTractbasedSpatialStatisticsView::AddGroup()
 {
   QString group("Group");
   int number = 0;
   QPair<QString, int> pair(group, number);
   QList< QPair<QString, int> >list = m_GroupModel->getList();
 
 
   if(!list.contains(pair))
   {
     m_GroupModel->insertRows(0, 1, QModelIndex());
 
     QModelIndex index = m_GroupModel->index(0, 0, QModelIndex());
     m_GroupModel->setData(index, group, Qt::EditRole);
     index = m_GroupModel->index(0, 1, QModelIndex());
     m_GroupModel->setData(index, number, Qt::EditRole);
 
   }
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::TbssImport()
 {
 
   // Read groups from the interface
   mitk::TbssImporter::Pointer importer = mitk::TbssImporter::New();
 
   QList< QPair<QString, int> >list = m_GroupModel->getList();
 
 
   if(list.size() == 0)
   {
     QMessageBox msgBox;
     msgBox.setText("No study group information has been set yet.");
     msgBox.exec();
     return;
   }
 
 
   std::vector < std::pair<std::string, int> > groups;
   for(int i=0; i<list.size(); i++)
   {
     QPair<QString, int> pair = list.at(i);
     std::string s = pair.first.toStdString();
     int n = pair.second;
 
     std::pair<std::string, int> p;
     p.first = s;
     p.second = n;
     groups.push_back(p);
   }
 
   importer->SetGroupInfo(groups);
 
   std::string minfo = m_Controls->m_MeasurementInfo->text().toStdString();
   importer->SetMeasurementInfo(minfo);
 
 
   std::string name = "";
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
     {
       mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
       if(img->GetDimension() == 4)
       {
         importer->SetImportVolume(img);
         name = nodes[i]->GetName();
       }
     }
   }
 
 
   mitk::TbssImage::Pointer tbssImage;
 
   tbssImage = importer->Import();
   name += "_tbss";
   AddTbssToDataStorage(tbssImage, name);
 
 
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::AddTbssToDataStorage(mitk::Image* image, std::string name)
 {
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( image );
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
 
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "name", mitk::StringProperty::New(name) );
   result->SetData( image );
   result->SetProperty( "levelwindow", levWinProp );
 
 
   // add new image to data storage and set as active to ease further processing
   GetDefaultDataStorage()->Add( result );
 
   // show the results
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::Clicked(const QwtDoublePoint& pos)
 {
   int index = (int)pos.x();
 
   if(m_Roi.size() > 0 && m_CurrentGeometry != NULL && !m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
   {
 
     index = std::min( (int)m_Roi.size()-1, std::max(0, index) );
     itk::Index<3> ix = m_Roi.at(index);
 
     mitk::Vector3D i;
     i[0] = ix[0];
     i[1] = ix[1];
     i[2] = ix[2];
 
     mitk::Vector3D w;
 
     m_CurrentGeometry->IndexToWorld(i, w);
 
     mitk::Point3D origin = m_CurrentGeometry->GetOrigin();
 
     mitk::Point3D p;
     p[0] = w[0] + origin[0];
     p[1] = w[1] + origin[1];
     p[2] = w[2] + origin[2];
 
     m_MultiWidget->MoveCrossToPosition(p);
     m_Controls->m_RoiPlotWidget->drawBar(index);
   }
 
   else if(m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
   {
 
     mitk::Point3D point = m_Controls->m_RoiPlotWidget->GetPositionInWorld(index);
     m_MultiWidget->MoveCrossToPosition(point);
 
 
   }
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::Cut()
 {
   mitk::BaseData* fibData = m_CurrentFiberNode->GetData();
   mitk::FiberBundleX* fib = static_cast<mitk::FiberBundleX*>(fibData);
 
   mitk::BaseData* startData = m_CurrentStartRoi->GetData();
   mitk::PlanarFigure* startRoi = static_cast<mitk::PlanarFigure*>(startData);
   mitk::PlaneGeometry* startGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(startRoi->GetGeometry2D()) );
 
   mitk::BaseData* endData = m_CurrentEndRoi->GetData();
   mitk::PlanarFigure* endRoi = static_cast<mitk::PlanarFigure*>(endData);
   mitk::PlaneGeometry* endGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(endRoi->GetGeometry2D()) );
 
   mitk::Point3D startCenter = startRoi->GetWorldControlPoint(0); //center Point of start roi
   mitk::Point3D endCenter = endRoi->GetWorldControlPoint(0); //center Point of end roi
 
   mitk::FiberBundleX::Pointer inStart = fib->ExtractFiberSubset(startRoi);
   mitk::FiberBundleX::Pointer inBoth = inStart->ExtractFiberSubset(endRoi);
 
   int num = inBoth->GetNumFibers();
 
   vtkSmartPointer<vtkPolyData> fiberPolyData = inBoth->GetFiberPolyData();
   vtkCellArray* lines = fiberPolyData->GetLines();
   lines->InitTraversal();
 
 
   // initialize new vtk polydata
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
 
   int pointIndex=0;
 
 
   // find start and endpoint
   for( int fiberID( 0 ); fiberID < num; fiberID++ )
   {
     vtkIdType   numPointsInCell(0);
     vtkIdType*  pointsInCell(NULL);
     lines->GetNextCell ( numPointsInCell, pointsInCell );
 
     int startId = 0;
     int endId = 0;
 
     float minDistStart = std::numeric_limits<float>::max();
     float minDistEnd = std::numeric_limits<float>::max();
 
 
     vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();
     int lineIndex=0;
 
 
     for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
     {
       double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
 
       mitk::Point3D point;
       point[0] = p[0];
       point[1] = p[1];
       point[2] = p[2];
 
       float distanceToStart = point.EuclideanDistanceTo(startCenter);
       float distanceToEnd = point.EuclideanDistanceTo(endCenter);
 
       if(distanceToStart < minDistStart)
       {
         minDistStart = distanceToStart;
         startId = pointInCellID;
       }
 
       if(distanceToEnd < minDistEnd)
       {
         minDistEnd = distanceToEnd;
         endId = pointInCellID;
       }
 
 
 
     }
 
 
 
     /* We found the start and end points of of the part that should be plottet for
        the current fiber. now we need to plot them. If the endId is smaller than the startId the plot order
        must be reversed*/
 
     if(startId < endId)
     {
 
       double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
 
       mitk::Vector3D p0;
       p0[0] = p[0];
       p0[1] = p[1];
       p0[2] = p[2];
 
       p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
 
       mitk::Vector3D p1;
       p1[0] = p[0];
       p1[1] = p[1];
       p1[2] = p[2];
 
 
       // Check if p and p2 are both on the same side of the plane
       mitk::Vector3D normal = startGeometry2D->GetNormal();
 
       mitk::Point3D pStart;
       pStart[0] = p0[0];
       pStart[1] = p0[1];
       pStart[2] = p0[2];
 
       bool startOnPositive = startGeometry2D->IsAbove(pStart);
 
       mitk::Point3D pSecond;
       pSecond[0] = p1[0];
       pSecond[1] = p1[1];
       pSecond[2] = p1[2];
 
       bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
 
       // Calculate intersection with the plane
 
       mitk::Vector3D onPlane;
       onPlane[0] = startCenter[0];
       onPlane[1] = startCenter[1];
       onPlane[2] = startCenter[2];
 
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* startId and startId+1 lie on the same side of the plane, so we need
            need startId-1 to calculate the intersection with the planar figure*/
         p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
       }
 
 
       double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       mitk::Vector3D newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
 
       double insertPoint[3];
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
 
       // First insert the intersection with the start roi
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* StartId and startId+1 lie on the same side of the plane
            so startId is also part of the ROI*/
 
         double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
         points->InsertNextPoint(start);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
 
       }
 
       // Insert the rest up and to including endId-1
       for( int pointInCellID( startId+1 ); pointInCellID < endId ; pointInCellID++)
       {
         // create new polyline for new polydata
         double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
         points->InsertNextPoint(p);
 
 
         // add point to line
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
       }
 
 
 
       /* endId must be included if endId and endId-1 lie on the same side of the
          plane defined by endRoi*/
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
       p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
       p1[0] = p[0];      p1[1] = p[1];      p1[2] = p[2];
 
 
       mitk::Point3D pLast;
       pLast[0] = p0[0];      pLast[1] = p0[1];      pLast[2] = p0[2];
 
       mitk::Point3D pBeforeLast;
       pBeforeLast[0] = p1[0];      pBeforeLast[1] = p1[1];      pBeforeLast[2] = p1[2];
 
       bool lastOnPositive = endGeometry2D->IsAbove(pLast);
       bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
       normal = endGeometry2D->GetNormal();
 
 
       onPlane[0] = endCenter[0];
       onPlane[1] = endCenter[1];
       onPlane[2] = endCenter[2];
 
 
 
       if(! (lastOnPositive ^ secondLastOnPositive) )
       {
         /* endId and endId-1 lie on the same side of the plane, so we need
            need endId+1 to calculate the intersection with the planar figure.
            this should exist since we know that the fiber crosses the planar figure
            endId is part of the roi so can also be included here*/
         p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
 
 
         double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
         points->InsertNextPoint(end);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
       }
 
       d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
       //Insert the Last Point (intersection with the end roi)
 
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
 
     }
 
     // Need to reverse walking order
     else{
       double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
 
       mitk::Vector3D p0;
       p0[0] = p[0];
       p0[1] = p[1];
       p0[2] = p[2];
 
       p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
 
       mitk::Vector3D p1;
       p1[0] = p[0];
       p1[1] = p[1];
       p1[2] = p[2];
 
 
       // Check if p and p2 are both on the same side of the plane
       mitk::Vector3D normal = startGeometry2D->GetNormal();
 
       mitk::Point3D pStart;
       pStart[0] = p0[0];
       pStart[1] = p0[1];
       pStart[2] = p0[2];
 
       bool startOnPositive = startGeometry2D->IsAbove(pStart);
 
       mitk::Point3D pSecond;
       pSecond[0] = p1[0];
       pSecond[1] = p1[1];
       pSecond[2] = p1[2];
 
       bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
 
       // Calculate intersection with the plane
 
       mitk::Vector3D onPlane;
       onPlane[0] = startCenter[0];
       onPlane[1] = startCenter[1];
       onPlane[2] = startCenter[2];
 
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* startId and startId-1 lie on the same side of the plane, so we need
            need startId+1 to calculate the intersection with the planar figure*/
         p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
       }
 
 
       double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       mitk::Vector3D newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
 
       double insertPoint[3];
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
 
       // First insert the intersection with the start roi
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* startId and startId-1 lie on the same side of the plane
            so endId is also part of the ROI*/
 
         double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
         points->InsertNextPoint(start);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
 
       }
 
       // Insert the rest up and to including endId-1
       for( int pointInCellID( startId-1 ); pointInCellID > endId ; pointInCellID--)
       {
         // create new polyline for new polydata
         double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
         points->InsertNextPoint(p);
 
 
         // add point to line
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
       }
 
 
 
       /* startId must be included if startId and startId+ lie on the same side of the
          plane defined by endRoi*/
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
       p0[0] = p[0];
       p0[1] = p[1];
       p0[2] = p[2];
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
       p1[0] = p[0];
       p1[1] = p[1];
       p1[2] = p[2];
 
 
       mitk::Point3D pLast;
       pLast[0] = p0[0];
       pLast[1] = p0[1];
       pLast[2] = p0[2];
 
       bool lastOnPositive = endGeometry2D->IsAbove(pLast);
 
       mitk::Point3D pBeforeLast;
       pBeforeLast[0] = p1[0];
       pBeforeLast[1] = p1[1];
       pBeforeLast[2] = p1[2];
 
       bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
 
       onPlane[0] = endCenter[0];
       onPlane[1] = endCenter[1];
       onPlane[2] = endCenter[2];
 
 
 
       if(! (lastOnPositive ^ secondLastOnPositive) )
       {
         /* endId and endId+1 lie on the same side of the plane, so we need
            need endId-1 to calculate the intersection with the planar figure.
            this should exist since we know that the fiber crosses the planar figure*/
         p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
 
 
         /* endId and endId+1 lie on the same side of the plane
            so startId is also part of the ROI*/
 
         double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
         points->InsertNextPoint(end);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
       }
 
       d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
 
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
 
 
       //Insert the Last Point (intersection with the end roi)
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
 
 
     }
 
 
     // add polyline to vtk cell array
      cells->InsertNextCell(polyLine);
 
   }
 
 
   // Add the points to the dataset
   polyData->SetPoints(points);
 
   // Add the lines to the dataset
   polyData->SetLines(cells);
 
   mitk::FiberBundleX::Pointer cutBundle = mitk::FiberBundleX::New(polyData);
 
 
   mitk::DataNode::Pointer cutNode = mitk::DataNode::New();
   cutNode->SetData(cutBundle);
   std::string name = "fiberCut";
   cutNode->SetName(name);
   GetDataStorage()->Add(cutNode);
 
 
 
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::CreateRoi()
 {
   bool ok;
   double threshold = QInputDialog::getDouble(m_Controls->m_CreateRoi, tr("Set an FA threshold"),
                                                       tr("Threshold:"), 0.2, 0.0, 1.0, 2, &ok);
 
   if(!ok)
     return;
 
   mitk::Image::Pointer image;
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
     {
         mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
         if(img->GetDimension() == 3)
         {
           image = img;
         }
     }
   }
 
   if(image.IsNull())
   {
     return;
   }
 
   mitk::TractAnalyzer analyzer;
   analyzer.SetInputImage(image);
   analyzer.SetThreshold(threshold);
 
   // Set Pointset to analyzer
   analyzer.SetPointSet(m_PointSetNode);
 
   // Run Analyzer
   analyzer.MakeRoi();
 
   // Obtain tbss roi image from analyzer
   mitk::TbssRoiImage::Pointer tbssRoi = analyzer.GetRoiImage();
 
   tbssRoi->SetStructure(m_Controls->m_Structure->text().toStdString());
 
   // get path description and set to interface
   std::string pathDescription = analyzer.GetPathDescription();
   m_Controls->m_PathTextEdit->setPlainText(QString(pathDescription.c_str()));
 
 
   // Add roi image to datastorage
   AddTbssToDataStorage(tbssRoi, m_Controls->m_RoiName->text().toStdString());
 
 
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::PlotFiber4D(mitk::TbssImage* image,
                                                             mitk::FiberBundleX* fib,
                                                             mitk::PlanarFigure* startRoi,
                                                             mitk::PlanarFigure* endRoi)
 {
 
 
   if(m_Controls->m_TabWidget->currentWidget() == m_Controls->m_MeasureTAB)
   {
     m_CurrentGeometry = image->GetGeometry();
 
     m_Controls->m_RoiPlotWidget->SetGroups(image->GetGroupInfo());
     m_Controls->m_RoiPlotWidget->SetProjections(image->GetImage());
     m_Controls->m_RoiPlotWidget->SetMeasure( image->GetMeasurementInfo() );
     m_Controls->m_RoiPlotWidget->PlotFiber4D(image, fib, startRoi, endRoi, m_Controls->m_Segments->value());
   }
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView:: PlotFiberBundle(mitk::FiberBundleX *fib, mitk::Image* img,
                                                            mitk::PlanarFigure* startRoi, mitk::PlanarFigure* endRoi)
 {
   bool avg = m_Controls->m_Average->isChecked();
   int segments = m_Controls->m_Segments->value();
   m_Controls->m_RoiPlotWidget->PlotFiberBetweenRois(fib, img, startRoi ,endRoi, avg, segments);
   m_Controls->m_RoiPlotWidget->SetPlottingFiber(true);
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::Plot(mitk::TbssImage* image, mitk::TbssRoiImage* roiImage)
 {
   if(m_Controls->m_TabWidget->currentWidget() == m_Controls->m_MeasureTAB)
   {
 
     std::vector< itk::Index<3> > roi = roiImage->GetRoi();
     m_Roi = roi;
     m_CurrentGeometry = image->GetGeometry();
 
 
     std::string structure = roiImage->GetStructure();
 
     m_Controls->m_RoiPlotWidget->SetGroups(image->GetGroupInfo());
     m_Controls->m_RoiPlotWidget->SetProjections(image->GetImage());
     m_Controls->m_RoiPlotWidget->SetRoi(roi);
     m_Controls->m_RoiPlotWidget->SetStructure(structure);
     m_Controls->m_RoiPlotWidget->SetMeasure( image->GetMeasurementInfo() );
     m_Controls->m_RoiPlotWidget->DrawProfiles();
   }
 
   m_Controls->m_RoiPlotWidget->SetPlottingFiber(false);
 
 }