diff --git a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
index 6d860362c1..7d370fa686 100644
--- a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
@@ -1,1262 +1,1263 @@
 /*=========================================================================
 
  Program:   Medical Imaging & Interaction Toolkit
  Language:  C++
  Date:      $Date: 2010-03-31 16:40:27 +0200 (Mi, 31 Mrz 2010) $
  Version:   $Revision: 21975 $
 
  Copyright (c) German Cancer Research Center, Division of Medical and
  Biological Informatics. All rights reserved.
  See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.  See the above copyright notices for more information.
 
  =========================================================================*/
 
 
 #include "mitkFiberBundleX.h"
 
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarFigureComposite.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 <math.h>
 
 const char* mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED = "Color_Orient";
 //const char* mitk::FiberBundleX::COLORCODING_FA_AS_OPACITY = "Color_Orient_FA_Opacity";
 const char* mitk::FiberBundleX::COLORCODING_FA_BASED = "FA_Values";
 const char* mitk::FiberBundleX::COLORCODING_CUSTOM = "custom";
 const char* mitk::FiberBundleX::FIBER_ID_ARRAY = "Fiber_IDs";
 
 
 mitk::FiberBundleX::FiberBundleX( vtkPolyData* fiberPolyData )
   : m_CurrentColorCoding(NULL)
   , m_NumFibers(0)
 {
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   if (fiberPolyData != NULL)
   {
     vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
     cleaner->SetInput(fiberPolyData);
     cleaner->Update();
     fiberPolyData = cleaner->GetOutput();
 
     m_FiberPolyData->DeepCopy(fiberPolyData);
     this->DoColorCodingOrientationBased();
   }
 
   if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED))
     MITK_DEBUG << "ok";
 
   vtkUnsignedCharArray* tmpColors = (vtkUnsignedCharArray*) m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED);
   if (tmpColors!=NULL)
   {
     int tmpColorss = tmpColors->GetNumberOfTuples();
     int tmpColorc = tmpColors->GetNumberOfComponents();
   }
 
   m_NumFibers = m_FiberPolyData->GetNumberOfLines();
 
   this->UpdateFiberGeometry();
   this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
   this->GenerateFiberIds();
 }
 
 mitk::FiberBundleX::~FiberBundleX()
 {
 
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::GetDeepCopy()
 {
   mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(m_FiberPolyData);
 
   if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED))
     MITK_DEBUG << "ok";
 
   vtkUnsignedCharArray* tmpColors = (vtkUnsignedCharArray*) m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED);
   int tmpColorss = tmpColors->GetNumberOfTuples();
   int tmpColorc = tmpColors->GetNumberOfComponents();
 
   newFib->SetColorCoding(m_CurrentColorCoding);
   return newFib;
 }
 
 vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GeneratePolyDataByIds(std::vector<long> fiberIds)
 {
   MITK_DEBUG << "\n=====FINAL RESULT: fib_id ======\n";
   MITK_DEBUG << "Number of new Fibers: " << fiberIds.size();
   // iterate through the vectorcontainer hosting all desired fiber Ids
 
   vtkSmartPointer<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
 
   // if FA array available, initialize fa double array
   // if color orient array is available init color array
   vtkSmartPointer<vtkDoubleArray> faValueArray;
   vtkSmartPointer<vtkUnsignedCharArray> colorsT;
   //colors and alpha value for each single point, RGBA = 4 components
   unsigned char rgba[4] = {0,0,0,0};
   int componentSize = sizeof(rgba);
 
   if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_FA_BASED)){
     MITK_DEBUG << "FA VALUES AVAILABLE, init array for new fiberbundle";
     faValueArray = vtkSmartPointer<vtkDoubleArray>::New();
   }
 
   if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED)){
     MITK_DEBUG << "colorValues available, init array for new fiberbundle";
     colorsT = vtkUnsignedCharArray::New();
     colorsT->SetNumberOfComponents(componentSize);
     colorsT->SetName(COLORCODING_ORIENTATION_BASED);
   }
 
 
 
   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++)
     {
       //            MITK_DEBUG << "id: " << fiber->GetPointId(i);
       //            MITK_DEBUG << fibPoints->GetPoint(i)[0] << " | " << fibPoints->GetPoint(i)[1] << " | " << fibPoints->GetPoint(i)[2];
       newFiber->GetPointIds()->SetId(i, newPointSet->GetNumberOfPoints());
       newPointSet->InsertNextPoint(fibPoints->GetPoint(i)[0], fibPoints->GetPoint(i)[1], fibPoints->GetPoint(i)[2]);
 
 
       if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_FA_BASED)){
         //                MITK_DEBUG << m_FiberIdDataSet->GetPointData()->GetArray(FA_VALUE_ARRAY)->GetTuple(fiber->GetPointId(i));
       }
 
       if (m_FiberIdDataSet->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED)){
         //                MITK_DEBUG << "ColorValue: " << m_FiberIdDataSet->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetTuple(fiber->GetPointId(i))[0];
       }
     }
 
     newLineSet->InsertNextCell(newFiber);
     ++finIt;
   }
 
   newFiberPolyData->SetPoints(newPointSet);
   newFiberPolyData->SetLines(newLineSet);
   MITK_DEBUG << "new fiberbundle polydata points: " << newFiberPolyData->GetNumberOfPoints();
   MITK_DEBUG << "new fiberbundle polydata lines: " << newFiberPolyData->GetNumberOfLines();
   MITK_DEBUG << "=====================\n";
 
   //    mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(newFiberPolyData);
   return newFiberPolyData;
 }
 
 // merge two fiber bundles
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::AddBundle(mitk::FiberBundleX* fib)
 {
 
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
   vLines->InitTraversal();
 
   // add current fiber bundle
   int numFibers = GetNumFibers();
   for( int i=0; i<numFibers; i++ )
   {
     vtkIdType   numPoints(0);
     vtkIdType*  points(NULL);
     vLines->GetNextCell ( numPoints, points );
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for( int j=0; j<numPoints; j++)
     {
       vtkIdType id = vNewPoints->InsertNextPoint(m_FiberPolyData->GetPoint(points[j]));
       container->GetPointIds()->InsertNextId(id);
     }
     vNewLines->InsertNextCell(container);
   }
 
   vLines = fib->m_FiberPolyData->GetLines();
   vLines->InitTraversal();
 
   // add new fiber bundle
   numFibers = fib->GetNumFibers();
   for( int i=0; i<numFibers; i++ )
   {
     vtkIdType   numPoints(0);
     vtkIdType*  points(NULL);
     vLines->GetNextCell ( numPoints, points );
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for( int j=0; j<numPoints; j++)
     {
       vtkIdType id = vNewPoints->InsertNextPoint(fib->m_FiberPolyData->GetPoint(points[j]));
       container->GetPointIds()->InsertNextId(id);
     }
     vNewLines->InsertNextCell(container);
   }
 
   // initialize polydata
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
   return newFib;
 }
 
 // subtract two fiber bundles
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::SubtractBundle(mitk::FiberBundleX* fib)
 {
 
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
   vLines->InitTraversal();
 
   // iterate over current fibers
   int numFibers = GetNumFibers();
   for( int i=0; i<numFibers; i++ )
   {
     vtkIdType   numPoints(0);
     vtkIdType*  points(NULL);
     vLines->GetNextCell ( numPoints, points );
 
     vtkSmartPointer<vtkCellArray> vLines2 = fib->m_FiberPolyData->GetLines();
     vLines2->InitTraversal();
     int numFibers2 = fib->GetNumFibers();
     bool contained = false;
     for( int i2=0; i2<numFibers2; i2++ )
     {
       vtkIdType   numPoints2(0);
       vtkIdType*  points2(NULL);
       vLines2->GetNextCell ( numPoints2, points2 );
 
       // check endpoints
       itk::Point<float, 3> point_start = GetItkPoint(m_FiberPolyData->GetPoint(points[0]));
       itk::Point<float, 3> point_end = GetItkPoint(m_FiberPolyData->GetPoint(points[numPoints-1]));
       itk::Point<float, 3> point2_start = GetItkPoint(fib->m_FiberPolyData->GetPoint(points2[0]));
       itk::Point<float, 3> point2_end = GetItkPoint(fib->m_FiberPolyData->GetPoint(points2[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;
       }
     }
 
     // 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(m_FiberPolyData->GetPoint(points[j]));
         container->GetPointIds()->InsertNextId(id);
       }
       vNewLines->InsertNextCell(container);
     }
   }
 
   // initialize polydata
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
   return newFib;
 }
 
 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();
   SetColorCoding(COLORCODING_ORIENTATION_BASED);
   GenerateFiberIds();
 }
 
 /*
  * return vtkPolyData
  */
 vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GetFiberPolyData()
 {
   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
   //=================================================
 
 
   /*  make sure that processing colorcoding is only called when necessary */
   if ( m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED) &&
       m_FiberPolyData->GetNumberOfPoints() ==
       m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetNumberOfTuples() )
   {
     // fiberstructure is already colorcoded
     MITK_DEBUG << " NO NEED TO REGENERATE COLORCODING! " ;
     this->ResetFiberOpacity();
     this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
     return;
   }
 
   /* Finally, execute color calculation */
   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 = sizeof(rgba);
   int componentSize = 4;
 
   vtkSmartPointer<vtkUnsignedCharArray> colorsT = vtkUnsignedCharArray::New();
   colorsT->Allocate(numOfPoints * componentSize);
   colorsT->SetNumberOfComponents(componentSize);
   colorsT->SetName(COLORCODING_ORIENTATION_BASED);
 
 
 
   /* checkpoint: does polydata contain any fibers */
   int numOfFibers = m_FiberPolyData->GetNumberOfLines();
   if (numOfFibers < 1) {
     MITK_DEBUG << "\n ========= Number of Fibers is 0 and below ========= \n";
     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);
 
     //    MITK_DEBUG << "Fib#: " << fi << " of " << numOfFibers << " pnts in fiber: " << pointsPerFiber ;
 
     /* 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);
 
         }
 
         colorsT->InsertTupleValue(idList[i], rgba);
 
       } //end for loop
 
     } else if (pointsPerFiber == 1) {
       /* a single point does not define a fiber (use vertex mechanisms instead */
       continue;
       //      colorsT->InsertTupleValue(0, rgba);
 
     } else {
       MITK_DEBUG << "Fiber with 0 points detected... please check your tractography algorithm!" ;
       continue;
 
     }
 
 
   }//end for loop
 
   m_FiberPolyData->GetPointData()->AddArray(colorsT);
 
   /*=========================
       - this is more relevant for renderer than for fiberbundleX datastructure
       - think about sourcing this to a explicit method which coordinates colorcoding */
   this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
   //  ===========================
 
   //mini test, shall be ported to MITK TESTINGS!
   if (colorsT->GetSize() != numOfPoints*componentSize)
     MITK_DEBUG << "ALLOCATION ERROR IN INITIATING COLOR ARRAY";
 
 
 }
 
 void mitk::FiberBundleX::DoColorCodingFaBased()
 {
   if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED) != 1 )
     return;
 
   this->SetColorCoding(COLORCODING_FA_BASED);
   MITK_DEBUG << "FBX: done CC FA based";
   this->GenerateFiberIds();
 }
 
 void mitk::FiberBundleX::DoUseFaFiberOpacity()
 {
   if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED) != 1 )
     return;
 
   if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED) != 1 )
     return;
 
   vtkDoubleArray* FAValArray = (vtkDoubleArray*) m_FiberPolyData->GetPointData()->GetArray(COLORCODING_FA_BASED);
   vtkUnsignedCharArray* ColorArray = dynamic_cast<vtkUnsignedCharArray*>  (m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED));
 
   for(long i=0; i<ColorArray->GetNumberOfTuples(); i++) {
     double faValue = FAValArray->GetValue(i);
     faValue = faValue * 255.0;
     ColorArray->SetComponent(i,3, (unsigned char) faValue );
   }
 
   this->SetColorCoding(COLORCODING_ORIENTATION_BASED);
   MITK_DEBUG << "FBX: done CC OPACITY";
   this->GenerateFiberIds();
 }
 
 void mitk::FiberBundleX::ResetFiberOpacity() {
   vtkUnsignedCharArray* ColorArray = dynamic_cast<vtkUnsignedCharArray*>  (m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED));
   for(long i=0; i<ColorArray->GetNumberOfTuples(); i++) {
     ColorArray->SetComponent(i,3, 255.0 );
   }
 }
 
 void mitk::FiberBundleX::SetFAMap(mitk::Image::Pointer FAimage)
 {
   MITK_DEBUG << "SetFAMap";
   vtkSmartPointer<vtkDoubleArray> faValues = vtkDoubleArray::New();
   faValues->SetName(COLORCODING_FA_BASED);
   faValues->Allocate(m_FiberPolyData->GetNumberOfPoints());
   //    MITK_DEBUG << faValues->GetNumberOfTuples();
   //    MITK_DEBUG << faValues->GetSize();
 
   faValues->SetNumberOfValues(m_FiberPolyData->GetNumberOfPoints());
   //    MITK_DEBUG << faValues->GetNumberOfTuples();
   //    MITK_DEBUG << faValues->GetSize();
 
   vtkPoints* pointSet = m_FiberPolyData->GetPoints();
   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 faPixelValue = FAimage->GetPixelValueByWorldCoordinate(px) * 0.01;
     //        faValues->InsertNextTuple1(faPixelValue);
     faValues->InsertValue(i, faPixelValue);
     //        MITK_DEBUG << faPixelValue;
     //        MITK_DEBUG << faValues->GetValue(i);
 
   }
 
   m_FiberPolyData->GetPointData()->AddArray(faValues);
   this->GenerateFiberIds();
 
   if(m_FiberPolyData->GetPointData()->HasArray(COLORCODING_FA_BASED))
     MITK_DEBUG << "FA VALUE ARRAY SET";
 
   //    vtkDoubleArray* valueArray = (vtkDoubleArray*) m_FiberPolyData->GetPointData()->GetArray(FA_VALUE_ARRAY);
   //    for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); i++)
   //    {
   //        MITK_DEBUG << "value at pos "<<  i << ": " << valueArray->GetValue(i);
   //    }
 }
 
 void mitk::FiberBundleX::GenerateFiberIds()
 {
   if (m_FiberPolyData == NULL)
     return;
 
   vtkSmartPointer<vtkIdFilter> idFiberFilter = vtkSmartPointer<vtkIdFilter>::New();
   idFiberFilter->SetInput(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_DEBUG << "Generating Fiber Ids...[done] | " << m_FiberIdDataSet->GetNumberOfCells();
 
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(mitk::PlanarFigure::Pointer pf)
 {
   std::vector<long> tmp = ExtractFiberIdSubset(pf);
   if (tmp.size()<=0)
     return mitk::FiberBundleX::New();
   vtkSmartPointer<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp);
   return mitk::FiberBundleX::New(pTmp);
 }
 
 std::vector<long> mitk::FiberBundleX::ExtractFiberIdSubset(mitk::PlanarFigure::Pointer pf)
 {
 
   MITK_DEBUG << "Extracting fibers!";
   // vector which is returned, contains all extracted FiberIds
   std::vector<long> FibersInROI;
 
   /* Handle type of planarfigure */
   // if incoming pf is a pfc
   mitk::PlanarFigureComposite::Pointer pfcomp= dynamic_cast<mitk::PlanarFigureComposite*>(pf.GetPointer());
   if (!pfcomp.IsNull()) {
     // process requested boolean operation of PFC
     switch (pfcomp->getOperationType()) {
     case 0:
     {
       MITK_DEBUG << "AND PROCESSING";
       //AND
       //temporarly store results of the child in this vector, we need that to accumulate the
       std::vector<long> childResults = this->ExtractFiberIdSubset(pfcomp->getChildAt(0));
       MITK_DEBUG << "first roi got fibers in ROI: " << childResults.size();
       MITK_DEBUG << "sorting...";
       std::sort(childResults.begin(), childResults.end());
       MITK_DEBUG << "sorting done";
       std::vector<long> AND_Assamblage(childResults.size());
       //std::vector<unsigned long> AND_Assamblage;
       fill(AND_Assamblage.begin(), AND_Assamblage.end(), -1);
       //AND_Assamblage.reserve(childResults.size()); //max size AND can reach anyway
 
       std::vector<long>::iterator it;
       for (int i=1; i<pfcomp->getNumberOfChildren(); ++i)
       {
         std::vector<long> tmpChild = this->ExtractFiberIdSubset(pfcomp->getChildAt(i));
         MITK_DEBUG << "ROI " << i << " has fibers in ROI: " << tmpChild.size();
         sort(tmpChild.begin(), tmpChild.end());
 
         it = std::set_intersection(childResults.begin(), childResults.end(),
                                    tmpChild.begin(), tmpChild.end(),
                                    AND_Assamblage.begin() );
       }
 
       MITK_DEBUG << "resize Vector";
       long i=0;
       while (i < AND_Assamblage.size() && AND_Assamblage[i] != -1){ //-1 represents a placeholder in the array
         ++i;
       }
       AND_Assamblage.resize(i);
 
       MITK_DEBUG << "returning AND vector, size: " << AND_Assamblage.size();
       return AND_Assamblage;
       //            break;
 
     }
     case 1:
     {
       //OR
       std::vector<long> OR_Assamblage = this->ExtractFiberIdSubset(pfcomp->getChildAt(0));
       std::vector<long>::iterator it;
       MITK_DEBUG << OR_Assamblage.size();
 
       for (int i=1; i<pfcomp->getNumberOfChildren(); ++i) {
         it = OR_Assamblage.end();
         std::vector<long> tmpChild = this->ExtractFiberIdSubset(pfcomp->getChildAt(i));
         OR_Assamblage.insert(it, tmpChild.begin(), tmpChild.end());
         MITK_DEBUG << "ROI " << i << " has fibers in ROI: " << tmpChild.size() << " OR Assamblage: " << OR_Assamblage.size();
       }
 
       sort(OR_Assamblage.begin(), OR_Assamblage.end());
       it = unique(OR_Assamblage.begin(), OR_Assamblage.end());
       OR_Assamblage.resize( it - OR_Assamblage.begin() );
       MITK_DEBUG << "returning OR vector, size: " << OR_Assamblage.size();
 
       return OR_Assamblage;
     }
     case 2:
     {
       //NOT
       //get IDs of all fibers
       std::vector<long> childResults;
       childResults.reserve(this->GetNumFibers());
       vtkSmartPointer<vtkDataArray> idSet = m_FiberIdDataSet->GetCellData()->GetArray(FIBER_ID_ARRAY);
       MITK_DEBUG << "m_NumOfFib: " << this->GetNumFibers() << " cellIdNum: " << idSet->GetNumberOfTuples();
       for(long i=0; i<this->GetNumFibers(); i++)
       {
         MITK_DEBUG << "i: " << i << " idset: " << idSet->GetTuple(i)[0];
         childResults.push_back(idSet->GetTuple(i)[0]);
       }
 
       std::sort(childResults.begin(), childResults.end());
       std::vector<long> NOT_Assamblage(childResults.size());
       //fill it with -1, otherwise 0 will be stored and 0 can also be an ID of fiber!
       fill(NOT_Assamblage.begin(), NOT_Assamblage.end(), -1);
       std::vector<long>::iterator it;
 
       for (long i=0; i<pfcomp->getNumberOfChildren(); ++i)
       {
         std::vector<long> tmpChild = ExtractFiberIdSubset(pfcomp->getChildAt(i));
         sort(tmpChild.begin(), tmpChild.end());
 
         it = std::set_difference(childResults.begin(), childResults.end(),
                                  tmpChild.begin(), tmpChild.end(),
                                  NOT_Assamblage.begin() );
 
       }
 
       MITK_DEBUG << "resize Vector";
       long i=0;
       while (NOT_Assamblage[i] != -1){ //-1 represents a placeholder in the array
         ++i;
       }
       NOT_Assamblage.resize(i);
 
       return NOT_Assamblage;
     }
     default:
       MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
       break;
 
     }
   }
   else
   {
     mitk::Geometry2D::ConstPointer pfgeometry = pf->GetGeometry2D();
     const mitk::PlaneGeometry* planeGeometry = dynamic_cast<const mitk::PlaneGeometry*> (pfgeometry.GetPointer());
     Vector3D planeNormal = planeGeometry->GetNormal();
     planeNormal.Normalize();
     Point3D planeOrigin = planeGeometry->GetOrigin();
 
     MITK_DEBUG << "planeOrigin: " << planeOrigin[0] << " | " << planeOrigin[1] << " | " << planeOrigin[2] << endl;
     MITK_DEBUG << "planeNormal: " << planeNormal[0] << " | " << planeNormal[1] << " | " << planeNormal[2] << endl;
 
     std::vector<int> PointsOnPlane; // contains all pointIds which are crossing the cutting plane
     std::vector<int> PointsInROI; // based on PointsOnPlane, all ROI relevant point IDs are stored here
 
     /* Define cutting plane by ROI (PlanarFigure) */
     vtkSmartPointer<vtkPlane> plane = vtkSmartPointer<vtkPlane>::New();
     plane->SetOrigin(planeOrigin[0],planeOrigin[1],planeOrigin[2]);
     plane->SetNormal(planeNormal[0],planeNormal[1],planeNormal[2]);
 
     //same plane but opposite normal direction. so point cloud will be reduced -> better performance
     //        vtkSmartPointer<vtkPlane> planeR = vtkSmartPointer<vtkPlane>::New();
 
     //define new origin along the normal but close to the original one
     // OriginNew = OriginOld + 1*Normal
     //        Vector3D extendedNormal;
     //        int multiplyFactor = 1;
     //        extendedNormal[0] = planeNormal[0] * multiplyFactor;
     //        extendedNormal[1] = planeNormal[1] * multiplyFactor;
     //        extendedNormal[2] = planeNormal[2] * multiplyFactor;
     //        Point3D RplaneOrigin = planeOrigin - extendedNormal;
     //        planeR->SetOrigin(RplaneOrigin[0],RplaneOrigin[1],RplaneOrigin[2]);
     //        planeR->SetNormal(-planeNormal[0],-planeNormal[1],-planeNormal[2]);
     //        MITK_DEBUG << "RPlaneOrigin: " << RplaneOrigin[0] << " | " << RplaneOrigin[1]
     //                  << " | " << RplaneOrigin[2];
 
     /* get all points/fibers cutting the plane */
     MITK_DEBUG << "start clipping";
     vtkSmartPointer<vtkClipPolyData> clipper = vtkSmartPointer<vtkClipPolyData>::New();
     clipper->SetInput(m_FiberIdDataSet);
     clipper->SetClipFunction(plane);
     clipper->GenerateClipScalarsOn();
     clipper->GenerateClippedOutputOn();
     vtkSmartPointer<vtkPolyData> clipperout = clipper->GetClippedOutput();
     MITK_DEBUG << "end clipping";
 
     /* for some reason clipperoutput is not initialized for futher processing
       * so far only writing out clipped polydata provides requested
       */
     //        MITK_DEBUG << "writing clipper output";
     //        vtkSmartPointer<vtkPolyDataWriter> writerC = vtkSmartPointer<vtkPolyDataWriter>::New();
     //        writerC->SetInput(clipperout1);
     //        writerC->SetFileName("/vtkOutput/Clipping.vtk");
     //        writerC->SetFileTypeToASCII();
     //        writerC->Write();
     //        MITK_DEBUG << "writing done";
 
     MITK_DEBUG << "init and update clipperoutput";
     clipperout->GetPointData()->Initialize();
     clipperout->Update();
     MITK_DEBUG << "init and update clipperoutput completed";
 
     //        MITK_DEBUG << "start clippingRecursive";
     //        vtkSmartPointer<vtkClipPolyData> Rclipper = vtkSmartPointer<vtkClipPolyData>::New();
     //        Rclipper->SetInput(clipperout1);
     //        Rclipper->SetClipFunction(planeR);
     //        Rclipper->GenerateClipScalarsOn();
     //        Rclipper->GenerateClippedOutputOn();
     //        vtkSmartPointer<vtkPolyData> clipperout = Rclipper->GetClippedOutput();
     //        MITK_DEBUG << "end clipping recursive";
 
     //        MITK_DEBUG << "writing clipper output 2";
     //        vtkSmartPointer<vtkPolyDataWriter> writerC1 = vtkSmartPointer<vtkPolyDataWriter>::New();
     //        writerC1->SetInput(clipperout);
     //        writerC1->SetFileName("/vtkOutput/RClipping.vtk");
     //        writerC1->SetFileTypeToASCII();
     //        writerC1->Write();
     //        MITK_DEBUG << "init and update clipperoutput";
     //        clipperout->GetPointData()->Initialize();
     //        clipperout->Update();
     //        MITK_DEBUG << "init and update clipperoutput completed";
 
     MITK_DEBUG << "STEP 1: find all points which have distance 0 to the given plane";
     /*======STEP 1======
       * extract all points, which are crossing the plane */
     // Scalar values describe the distance between each remaining point to the given plane. Values sorted by point index
     vtkSmartPointer<vtkDataArray> distanceList = clipperout->GetPointData()->GetScalars();
     vtkIdType sizeOfList =  distanceList->GetNumberOfTuples();
     PointsOnPlane.reserve(sizeOfList); /* use reserve for high-performant push_back, no hidden copy procedures are processed then!
                                          * size of list can be optimized by reducing allocation, but be aware of iterator and vector size*/
 
     for (int i=0; i<sizeOfList; ++i) {
       double *distance = distanceList->GetTuple(i);
 
       // check if point is on plane.
       // 0.01 due to some approximation errors when calculating distance
       if (distance[0] >= -0.01 && distance[0] <= 0.01)
         PointsOnPlane.push_back(i);
     }
 
     // DEBUG print out all interesting points, stop where array starts with value -1. after -1 no more interesting idx are set!
     //        std::vector<int>::iterator rit = PointsOnPlane.begin();
     //        while (rit != PointsOnPlane.end() ) {
     //            std::cout << "interesting point: " << *rit << " coord: " << clipperout->GetPoint(*rit)[0] << " | " <<  clipperout->GetPoint(*rit)[1] << " | " << clipperout->GetPoint(*rit)[2] << endl;
     //            rit++;
     //        }
 
 
     MITK_DEBUG << "Num Of points on plane: " <<  PointsOnPlane.size();
 
     MITK_DEBUG << "Step 2: extract Interesting points with respect to given extraction planarFigure";
 
     PointsInROI.reserve(PointsOnPlane.size());
     /*=======STEP 2=====
      * extract ROI relevant pointIds */
 
     mitk::PlanarCircle::Pointer circleName = mitk::PlanarCircle::New();
     mitk::PlanarPolygon::Pointer polyName = mitk::PlanarPolygon::New();
     if ( pf->GetNameOfClass() == circleName->GetNameOfClass() )
     {
       //calculate circle radius
       mitk::Point3D V1w = pf->GetWorldControlPoint(0); //centerPoint
       mitk::Point3D V2w  = pf->GetWorldControlPoint(1); //radiusPoint
 
       double distPF = V1w.EuclideanDistanceTo(V2w);
 
       for (int i=0; i<PointsOnPlane.size(); i++)
       {
         //distance between circle radius and given point
         double XdistPnt =  sqrt((double) (clipperout->GetPoint(PointsOnPlane[i])[0] - V1w[0]) * (clipperout->GetPoint(PointsOnPlane[i])[0] - V1w[0]) +
                                 (clipperout->GetPoint(PointsOnPlane[i])[1] - V1w[1]) * (clipperout->GetPoint(PointsOnPlane[i])[1] - V1w[1]) +
                                 (clipperout->GetPoint(PointsOnPlane[i])[2] - V1w[2]) * (clipperout->GetPoint(PointsOnPlane[i])[2] - V1w[2])) ;
 
         if( XdistPnt <= distPF)
           PointsInROI.push_back(PointsOnPlane[i]);
       }
     }
     else if ( pf->GetNameOfClass() == polyName->GetNameOfClass() )
     {
       //create vtkPolygon using controlpoints from planarFigure polygon
       vtkSmartPointer<vtkPolygon> polygonVtk = vtkPolygon::New();
 
       //get the control points from pf and insert them to vtkPolygon
       unsigned int nrCtrlPnts = pf->GetNumberOfControlPoints();
 
       for (int i=0; i<nrCtrlPnts; ++i)
       {
         polygonVtk->GetPoints()->InsertNextPoint((double)pf->GetWorldControlPoint(i)[0], (double)pf->GetWorldControlPoint(i)[1], (double)pf->GetWorldControlPoint(i)[2] );
       }
 
       //prepare everything for using pointInPolygon function
       double n[3];
       polygonVtk->ComputeNormal(polygonVtk->GetPoints()->GetNumberOfPoints(),
                                 static_cast<double*>(polygonVtk->GetPoints()->GetData()->GetVoidPointer(0)), n);
 
       double bounds[6];
       polygonVtk->GetPoints()->GetBounds(bounds);
 
       for (int i=0; i<PointsOnPlane.size(); i++)
       {
         double checkIn[3] = {clipperout->GetPoint(PointsOnPlane[i])[0], clipperout->GetPoint(PointsOnPlane[i])[1], clipperout->GetPoint(PointsOnPlane[i])[2]};
         int isInPolygon = polygonVtk->PointInPolygon(checkIn, polygonVtk->GetPoints()->GetNumberOfPoints()
                                                      , static_cast<double*>(polygonVtk->GetPoints()->GetData()->GetVoidPointer(0)), bounds, n);
         if( isInPolygon )
           PointsInROI.push_back(PointsOnPlane[i]);
       }
     }
 
     MITK_DEBUG << "Step3: Identify fibers";
     // we need to access the fiberId Array, so make sure that this array is available
     if (!clipperout->GetCellData()->HasArray(FIBER_ID_ARRAY))
     {
       MITK_DEBUG << "ERROR: FiberID array does not exist, no correlation between points and fiberIds possible! Make sure calling GenerateFiberIds()";
       return FibersInROI; // FibersInRoi is empty then
     }
     if (PointsInROI.size()<=0)
       return FibersInROI;
 
     // prepare a structure where each point id is represented as an indexId.
     // vector looks like: | pntId | fiberIdx |
     std::vector< long > pointindexFiberMap;
 
     // walk through the whole subline section and create an vector sorted by point index
     vtkCellArray *clipperlines = clipperout->GetLines();
     clipperlines->InitTraversal();
     long numOfLineCells = clipperlines->GetNumberOfCells();
     long numofClippedPoints = clipperout->GetNumberOfPoints();
     pointindexFiberMap.reserve(numofClippedPoints);
 
 
     //prepare resulting vector
     FibersInROI.reserve(PointsInROI.size());
 
     MITK_DEBUG << "\n===== Pointindex based structure initialized ======\n";
 
     // go through resulting "sub"lines which are stored as cells, "i" corresponds to current line id.
     for (int i=0, ic=0 ; i<numOfLineCells; i++, ic+=3)
     { //ic is the index counter for the cells hosting the desired information, eg. 2 | 45 | 46. each cell consits of 3 items.
 
       vtkIdType npts;
       vtkIdType *pts;
       clipperlines->GetCell(ic, npts, pts);
 
       // go through point ids in hosting subline, "j" corresponds to current pointindex in current line i. eg. idx[0]=45; idx[1]=46
       for (long j=0; j<npts; j++)
       {
         // MITK_DEBUG << "writing fiber id: " << clipperout->GetCellData()->GetArray(FIBER_ID_ARRAY)->GetTuple(i)[0] << " to pointId: " << pts[j];
         pointindexFiberMap[ pts[j] ] = clipperout->GetCellData()->GetArray(FIBER_ID_ARRAY)->GetTuple(i)[0];
         // MITK_DEBUG << "in array: " << pointindexFiberMap[ pts[j] ];
       }
 
     }
 
     MITK_DEBUG << "\n===== Pointindex based structure finalized ======\n";
 
     // get all Points in ROI with according fiberID
     for (long k = 0; k < PointsInROI.size(); k++)
     {
       //MITK_DEBUG << "point " << PointsInROI[k] << " belongs to fiber " << pointindexFiberMap[ PointsInROI[k] ];
       if (pointindexFiberMap[ PointsInROI[k] ]<=GetNumFibers() && pointindexFiberMap[ PointsInROI[k] ]>=0)
         FibersInROI.push_back(pointindexFiberMap[ PointsInROI[k] ]);
       else
         MITK_INFO << "ERROR in ExtractFiberIdSubset; impossible fiber id detected";
     }
 
   }
 
   //  detecting fiberId duplicates
   MITK_DEBUG << "check for duplicates";
 
   sort(FibersInROI.begin(), FibersInROI.end());
   bool hasDuplicats = false;
   for(long i=0; i<FibersInROI.size()-1; ++i)
   {
     if(FibersInROI[i] == FibersInROI[i+1])
       hasDuplicats = true;
   }
 
   if(hasDuplicats)
   {
     std::vector<long>::iterator it;
     it = unique (FibersInROI.begin(), FibersInROI.end());
     FibersInROI.resize( it - FibersInROI.begin() );
   }
 
   return FibersInROI;
 }
 
 void mitk::FiberBundleX::UpdateFiberGeometry()
 {
-  if (m_NumFibers<=0)
+  if (m_NumFibers<=0) // no fibers present; apply default geometry
   {
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
     geometry->SetImageGeometry(true);
     float b[] = {0, 1, 0, 1, 0, 1};
     geometry->SetFloatBounds(b);
     SetGeometry(geometry);
     return;
   }
-  float min = itk::NumericTraits<float>::min();
+  float min = itk::NumericTraits<float>::NonpositiveMin();
   float max = itk::NumericTraits<float>::max();
   float b[] = {max, min, max, min, max, min};
 
   vtkCellArray* cells = m_FiberPolyData->GetLines();
   cells->InitTraversal();
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int p = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
     for (int j=0; j<p; j++)
     {
       double p[3];
       points->GetPoint(j, p);
 
+      MITK_INFO << p[0] << ", " << p[1] << ", " << p[2];
+
       if (p[0]<b[0])
         b[0]=p[0];
       if (p[0]>b[1])
         b[1]=p[0];
 
       if (p[1]<b[2])
         b[2]=p[1];
       if (p[1]>b[3])
         b[3]=p[1];
 
       if (p[2]<b[4])
         b[4]=p[2];
       if (p[2]>b[5])
         b[5]=p[2];
     }
   }
-
   // provide some border margin
   for(int i=0; i<=4; i+=2)
     b[i] -=10;
   for(int i=1; i<=5; i+=2)
     b[i] +=10;
 
+  MITK_INFO << b[0] << ", " << b[1] << ", " << b[2] << ", " << b[3] << ", " << b[4] << ", " << b[5];
   mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
-  geometry->SetImageGeometry(true);
   geometry->SetFloatBounds(b);
   this->SetGeometry(geometry);
 }
 
 QStringList mitk::FiberBundleX::GetAvailableColorCodings()
 {
   QStringList availableColorCodings;
   int numColors = m_FiberPolyData->GetPointData()->GetNumberOfArrays();
   for(int i=0; i<numColors; i++)
   {
     availableColorCodings.append(m_FiberPolyData->GetPointData()->GetArrayName(i));
   }
 
   //this controlstructure shall be implemented by the calling method
   if (availableColorCodings.isEmpty())
     MITK_DEBUG << "no colorcodings available in fiberbundleX";
 
   //    for(int i=0; i<availableColorCodings.size(); i++)
   //    {
   //            MITK_DEBUG << availableColorCodings.at(i).toLocal8Bit().constData();
   //    }
 
   return availableColorCodings;
 }
 
 
 char* mitk::FiberBundleX::GetCurrentColorCoding()
 {
   return m_CurrentColorCoding;
 }
 
 void mitk::FiberBundleX::SetColorCoding(const char* requestedColorCoding)
 {
 
   if (requestedColorCoding==NULL)
     return;
   MITK_DEBUG << "SetColorCoding:" << requestedColorCoding;
 
   if( strcmp (COLORCODING_ORIENTATION_BASED,requestedColorCoding) == 0 )    {
     this->m_CurrentColorCoding = (char*) COLORCODING_ORIENTATION_BASED;
 
   } else if( strcmp (COLORCODING_FA_BASED,requestedColorCoding) == 0 ) {
     this->m_CurrentColorCoding = (char*) COLORCODING_FA_BASED;
 
   } else if( strcmp (COLORCODING_CUSTOM,requestedColorCoding) == 0 ) {
     this->m_CurrentColorCoding = (char*) COLORCODING_CUSTOM;
 
   } else {
     MITK_DEBUG << "FIBERBUNDLE X: UNKNOWN COLORCODING in FIBERBUNDLEX Datastructure";
     this->m_CurrentColorCoding = (char*) COLORCODING_CUSTOM; //will cause blank colorcoding of fibers
   }
 }
 
 void mitk::FiberBundleX::DoFiberSmoothing(int pointsPerCm)
 {
 
   vtkSmartPointer<vtkPoints> vtkSmoothPoints = 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 = vtkCellArray::New(); //cellcontainer for smoothed lines
 
   vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
   vLines->InitTraversal();
   vtkIdType pointHelperCnt = 0;
   for (int i=0; i<m_NumFibers; i++)
   {
     vtkIdType   numPoints(0);
     vtkIdType*  pointIds(NULL);
     vLines->GetNextCell ( numPoints, pointIds );
 
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
     float length = 0;
     itk::Point<double> lastP;
     for (int j=0; j<numPoints; j++)
     {
       double* p = m_FiberPolyData->GetPoint(pointIds[j]);
       points->InsertNextPoint(p);
       if (j>0)
         length += sqrt(pow(p[0]-lastP[0], 2)+pow(p[1]-lastP[1], 2)+pow(p[2]-lastP[2], 2));
       lastP[0] = p[0];
       lastP[1] = p[1];
       lastP[2] = p[2];
     }
     length /=10;
     int sampling = pointsPerCm*length;
 
     /////PROCESS POLYLINE SMOOTHING/////
     vtkSmartPointer<vtkKochanekSpline> xSpline = vtkKochanekSpline::New();
     vtkSmartPointer<vtkKochanekSpline> ySpline = vtkKochanekSpline::New();
     vtkSmartPointer<vtkKochanekSpline> zSpline = vtkKochanekSpline::New();
 
     vtkSmartPointer<vtkParametricSpline> spline = vtkParametricSpline::New();
     spline->SetXSpline(xSpline);
     spline->SetYSpline(ySpline);
     spline->SetZSpline(zSpline);
     spline->SetPoints(points);
 
     vtkSmartPointer<vtkParametricFunctionSource> functionSource = 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 = 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);
   UpdateColorCoding();
   UpdateFiberGeometry();
 }
 
 // Resample fiber to get equidistant points
 void mitk::FiberBundleX::ResampleFibers(float pointDistance)
 {
   vtkSmartPointer<vtkPolyData> newPoly = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> newCellArray = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints>    newPoints = vtkSmartPointer<vtkPoints>::New();
 
   vtkSmartPointer<vtkCellArray> vLines = m_FiberPolyData->GetLines();
   vLines->InitTraversal();
   int numberOfLines = m_NumFibers;
 
   for (int i=0; i<numberOfLines; i++)
   {
     vtkIdType   numPoints(0);
     vtkIdType*  points(NULL);
     vLines->GetNextCell ( numPoints, points );
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
     double* point = m_FiberPolyData->GetPoint(points[0]);
     vtkIdType pointId = newPoints->InsertNextPoint(point);
     container->GetPointIds()->InsertNextId(pointId);
 
     float dtau = 0;
     int cur_p = 1;
     itk::Vector<float,3> dR;
     float normdR = 0;
 
     for (;;)
     {
       while (dtau <= pointDistance && cur_p < numPoints)
       {
         itk::Vector<float,3> v1;
         point = m_FiberPolyData->GetPoint(points[cur_p-1]);
         v1[0] = point[0];
         v1[1] = point[1];
         v1[2] = point[2];
         itk::Vector<float,3> v2;
         point = m_FiberPolyData->GetPoint(points[cur_p]);
         v2[0] = point[0];
         v2[1] = point[1];
         v2[2] = point[2];
 
         dR  = v2 - v1;
         normdR = std::sqrt(dR.GetSquaredNorm());
         dtau += normdR;
         cur_p++;
       }
 
       if (dtau >= pointDistance)
       {
         itk::Vector<float,3> v1;
         point = m_FiberPolyData->GetPoint(points[cur_p-1]);
         v1[0] = point[0];
         v1[1] = point[1];
         v1[2] = point[2];
 
         itk::Vector<float,3> v2 = v1 - dR*( (dtau-pointDistance)/normdR );
         pointId = newPoints->InsertNextPoint(v2.GetDataPointer());
         container->GetPointIds()->InsertNextId(pointId);
       }
       else
       {
         point = m_FiberPolyData->GetPoint(points[numPoints-1]);
         pointId = newPoints->InsertNextPoint(point);
         container->GetPointIds()->InsertNextId(pointId);
         break;
       }
       dtau = dtau-pointDistance;
     }
 
     newCellArray->InsertNextCell(container);
   }
 
   newPoly->SetPoints(newPoints);
   newPoly->SetLines(newCellArray);
   m_FiberPolyData = newPoly;
   UpdateFiberGeometry();
   UpdateColorCoding();
 }
 
 // reapply selected colorcoding in case polydata structure has changed
 void mitk::FiberBundleX::UpdateColorCoding()
 {
   char* cc = GetCurrentColorCoding();
 
   if( strcmp (COLORCODING_ORIENTATION_BASED,cc) == 0 )
     DoColorCodingOrientationBased();
   else if( strcmp (COLORCODING_FA_BASED,cc) == 0 )
     DoColorCodingFaBased();
 }
 
 /* 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( itk::DataObject *data )
 {
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkODFDetailsWidget.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkODFDetailsWidget.cpp
index 3cc2bbfd30..faf92ede4a 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkODFDetailsWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkODFDetailsWidget.cpp
@@ -1,64 +1,64 @@
 /*=========================================================================
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkODFDetailsWidget.h"
 
 #include <qwt_scale_engine.h>
 
 QmitkODFDetailsWidget::QmitkODFDetailsWidget( QWidget * parent )
   : QmitkPlotWidget(parent)
 {
   m_Plot->setCanvasLineWidth(0);
   m_Plot->setMargin(0);
 
   QwtLinearScaleEngine* scale = new QwtLinearScaleEngine();
   m_Plot->setAxisScaleEngine(0, scale);
 
   m_Plot->setAxisScale   ( 0, -0.5, 0.5 );
 }
 
 QmitkODFDetailsWidget::~QmitkODFDetailsWidget()
 {
 }
 
 void QmitkODFDetailsWidget::SetParameters( itk::OrientationDistributionFunction<double, QBALL_ODFSIZE> odf )
 {
   this->Clear();
 
   std::vector<double> xVals;
   std::vector<double> yVals;
-  float max = itk::NumericTraits<float>::min();
+  float max = itk::NumericTraits<float>::NonpositiveMin();
   float min = itk::NumericTraits<float>::max();
 
   for (int i=0; i<QBALL_ODFSIZE; i++){
     xVals.push_back(i);
     yVals.push_back(odf[i]);
     if (odf[i]>max)
       max = odf[i];
     if (odf[i]<min)
       min = odf[i];
   }
 
   if(min>0)
     m_Plot->setAxisScale ( 0, 0, max );
   else
     m_Plot->setAxisScale ( 0, min, max );
 
   int curveId = this->InsertCurve( "ODF Values" );
   this->SetCurveData( curveId, xVals, yVals );
   this->SetCurvePen( curveId, QPen(Qt::blue, 0.5, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin) );
 
   QwtLegend* legend = new QwtLegend();
   //m_Plot->insertLegend(legend, QwtPlot::BottomLegend);
 
   this->Replot();
 }
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
index 6b6fd83070..4e5e42af8b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
@@ -1,282 +1,282 @@
 /*=========================================================================
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkODFDetailsView.h"
 #include <QmitkStdMultiWidget.h>
 #include <QTableWidgetItem>
 #include <vtkFloatArray.h>
 #include <vtkPointData.h>
 #include <vtkCellData.h>
 #include <vtkLookupTable.h>
 #include <mitkOdfNormalizationMethodProperty.h>
 #include <QTextEdit>
 #include <mitkTensorImage.h>
 #include <QMessageBox>
 
 const std::string QmitkODFDetailsView::VIEW_ID = "org.mitk.views.odfdetails";
 
 QmitkODFDetailsView::QmitkODFDetailsView()
   : QmitkFunctionality()
   , m_Controls( 0 )
   , m_MultiWidget( NULL )
   , m_OdfNormalization(0)
 {
   m_VtkActor = vtkActor::New();
   m_VtkMapper = vtkPolyDataMapper::New();
   m_Renderer = vtkRenderer::New();
   m_VtkRenderWindow = vtkRenderWindow::New();
   m_RenderWindowInteractor = vtkRenderWindowInteractor::New();
   m_Camera = vtkCamera::New();
   m_VtkRenderWindow->SetSize(300,300);
 }
 
 QmitkODFDetailsView::~QmitkODFDetailsView()
 {
   QmitkStdMultiWidget* MultiWidget = this->GetActiveStdMultiWidget(false);
 
   if(MultiWidget)
   {
     //unregister observers when view is destroyed
     if( MultiWidget->mitkWidget1 != NULL && m_SliceObserverTag1 != 0)
     {
       mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget1->GetSliceNavigationController();
       slicer->RemoveObserver( m_SliceObserverTag1 );
     }
 
     if( MultiWidget->mitkWidget2 != NULL && m_SliceObserverTag2 != 0)
     {
       mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget2->GetSliceNavigationController();
       slicer->RemoveObserver( m_SliceObserverTag2 );
     }
 
     if( MultiWidget->mitkWidget3!= NULL && m_SliceObserverTag3 != 0)
     {
       mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget3->GetSliceNavigationController();
       slicer->RemoveObserver( m_SliceObserverTag3 );
     }
   }
 }
 
 void QmitkODFDetailsView::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::QmitkODFDetailsViewControls;
     m_Controls->setupUi( parent );
     m_Controls->m_OdfBox->setVisible(false);
   }
 }
 
 void QmitkODFDetailsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
     itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
     command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
     m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
   }
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
     itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
     command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
     m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
   }
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
     itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
     command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
     m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
   }
 
 }
 
 void QmitkODFDetailsView::StdMultiWidgetNotAvailable()
 {
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
     slicer->RemoveObserver( m_SliceObserverTag1 );
   }
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
     slicer->RemoveObserver( m_SliceObserverTag2 );
   }
 
   {
     mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
     slicer->RemoveObserver( m_SliceObserverTag3 );
   }
 
   m_MultiWidget = NULL;
 }
 
 void QmitkODFDetailsView::OnSliceChanged(const itk::EventObject& /*e*/)
 {
   try
     {
     m_Values.clear();
     std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
     if (nodes.empty()) return;
     if (!nodes.front()) return;
 
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(nodes.front()->GetData());
 
     if (!img) return;
     if (!m_MultiWidget) return;
 
     // ODF Normalization Property
     mitk::OdfNormalizationMethodProperty* nmp = dynamic_cast<mitk::OdfNormalizationMethodProperty*>(nodes.front()->GetProperty( "Normalization" ));
     if(nmp)
       m_OdfNormalization = nmp->GetNormalization();
 
     m_TemplateOdf = itk::OrientationDistributionFunction<float,QBALL_ODFSIZE>::GetBaseMesh();
     m_OdfTransform = vtkSmartPointer<vtkTransform>::New();
     m_OdfTransform->Identity();
     m_OdfVals = vtkSmartPointer<vtkDoubleArray>::New();
     m_OdfSource = vtkSmartPointer<vtkOdfSource>::New();
     itk::OrientationDistributionFunction<double, QBALL_ODFSIZE> odf;
     itk::OrientationDistributionFunction<double, QBALL_ODFSIZE> originalOdf;
 
     mitk::Point3D world = m_MultiWidget->GetCrossPosition();
     mitk::Point3D index;
     img->GetTimeSlicedGeometry()->WorldToIndex(world, index);
 
     float sum = 0;
-    float max = itk::NumericTraits<float>::min();
+    float max = itk::NumericTraits<float>::NonpositiveMin();
     float min = itk::NumericTraits<float>::max();
     QString values;
     QString overviewText;
     // check if dynamic_cast successfull and if the crosshair position is inside of the geometry of the ODF data
     // otherwise possible crash for a scenario with multiple nodes
     if (dynamic_cast<mitk::QBallImage*>(nodes.front()->GetData()) && ( nodes.front()->GetData()->GetGeometry()->IsInside(world) ) )
     {
       m_Controls->m_OdfBox->setVisible(true);
       OdfVectorImgType::Pointer itkQBallImage = OdfVectorImgType::New();
       mitk::CastToItkImage<OdfVectorImgType>(dynamic_cast<mitk::QBallImage*>(nodes.front()->GetData()), itkQBallImage);
 
       OdfVectorImgType::IndexType ind;
       ind[0] = (int)(index[0]+0.5);
       ind[1] = (int)(index[1]+0.5);
       ind[2] = (int)(index[2]+0.5);
 
       OdfVectorImgType::PixelType pixel = itkQBallImage->GetPixel(ind);
 
       for (int i=0; i<QBALL_ODFSIZE; i++)
       {
         float val = pixel[i];
         odf.SetNthComponent(i, val);
         values += QString::number(i)+": "+QString::number(val)+"\n";
         sum += val;
         if (val>max)
           max = val;
         if (val<min)
           min = val;
       }
       float mean = sum/QBALL_ODFSIZE;
 
       QString pos = QString::number(ind[0])+", "+QString::number(ind[1])+", "+QString::number(ind[2]);
       overviewText += "Coordinates: "+pos+"\n";
       overviewText += "GFA: "+QString::number(odf.GetGeneralizedFractionalAnisotropy())+"\n";
       overviewText += "Sum: "+QString::number(sum)+"\n";
       overviewText += "Mean: "+QString::number(mean)+"\n";
       overviewText += "Min: "+QString::number(min)+"\n";
       overviewText += "Max: "+QString::number(max)+"\n";
       vnl_vector_fixed<double, 3> pd = odf.GetDirection(odf.GetPrincipleDiffusionDirection());
       overviewText += "Main Diffusion:\n     "+QString::number(pd[0])+"\n     "+QString::number(pd[1])+"\n     "+QString::number(pd[2])+"\n";
 
       m_Controls->m_OdfValuesTextEdit->setText(values);
     }
     else if (dynamic_cast<mitk::TensorImage*>(nodes.front()->GetData()))
     {
       m_Controls->m_OdfBox->setVisible(false);
       TensorImageType::Pointer itkQBallImage = TensorImageType::New();
       mitk::CastToItkImage<TensorImageType>(dynamic_cast<mitk::TensorImage*>(nodes.front()->GetData()), itkQBallImage);
 
       TensorImageType::IndexType ind;
       ind[0] = (int)(index[0]+0.5);
       ind[1] = (int)(index[1]+0.5);
       ind[2] = (int)(index[2]+0.5);
 
       TensorImageType::PixelType pixel = itkQBallImage->GetPixel(ind);
 
       float tensorelems[6] = {
         (float)pixel[0],
         (float)pixel[1],
         (float)pixel[2],
         (float)pixel[3],
         (float)pixel[4],
         (float)pixel[5],
       };
       itk::DiffusionTensor3D<float> tensor(tensorelems);
 
       odf.InitFromTensor(tensor);
 
 
       /** Array of eigen-values. */
       typedef itk::FixedArray<float, 3> EigenValuesArrayType;
       /** Matrix of eigen-vectors. */
       typedef itk::Matrix<float, 3, 3> MatrixType;
       typedef itk::Matrix<float, 3, 3> EigenVectorsMatrixType;
 
       EigenValuesArrayType eigenValues;
       EigenVectorsMatrixType eigenVectors;
 
       QString pos = QString::number(ind[0])+", "+QString::number(ind[1])+", "+QString::number(ind[2]);
       overviewText += "Coordinates: "+pos+"\n";
       overviewText += "FA: "+QString::number(tensor.GetFractionalAnisotropy())+"\n";
       overviewText += "RA: "+QString::number(tensor.GetRelativeAnisotropy())+"\n";
       overviewText += "Trace: "+QString::number(tensor.GetTrace())+"\n";
       tensor.ComputeEigenAnalysis(eigenValues,eigenVectors);
       overviewText += "Eigenvalues:\n     "+QString::number(eigenValues[2])+"\n     "+QString::number(eigenValues[1])+"\n     "+QString::number(eigenValues[0])+"\n";
       overviewText += "Main Diffusion:\n     "+QString::number(eigenVectors[0][0])+"\n     "+QString::number(eigenVectors[1][0])+"\n     "+QString::number(eigenVectors[2][0])+"\n";
       overviewText += "Values:\n     "+QString::number(tensorelems[0])+"\n     "+QString::number(tensorelems[1])+"\n     "+QString::number(tensorelems[2])+"\n     "+QString::number(tensorelems[3])+"\n     "+QString::number(tensorelems[4])+"\n     "+QString::number(tensorelems[5])+"\n     "+"\n";
     }
 
 
     originalOdf = odf;
 
     switch(m_OdfNormalization)
     {
     case 0:
       odf = odf.MinMaxNormalize();
       break;
     case 1:
       odf = odf.MaxNormalize();
       break;
     case 2:
       // nothing
       break;
     default:
       odf = odf.MinMaxNormalize();
     }
 
     m_Controls->m_ODFDetailsWidget->SetParameters(originalOdf);
     m_Controls->m_ODFRenderWidget->GenerateODF(odf);
 
     m_Controls->m_OverviewTextEdit->setText(overviewText.toStdString().c_str());
   }
   catch(...)
   {
     QMessageBox::critical(0, "Error", "Data could not be analyzed. The image might be corrupted.");
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
index 2db143d7d3..6b079cbe23 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
@@ -1,272 +1,280 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-31 16:40:27 +0200 (Mi, 31 Mrz 2010) $
 Version:   $Revision: 21975 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStochasticFiberTrackingView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkImageToItk.h>
 #include <mitkFiberBundleX.h>
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyLine.h>
 #include <vtkCellData.h>
 
 
 const std::string QmitkStochasticFiberTrackingView::VIEW_ID = "org.mitk.views.stochasticfibertracking";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 QmitkStochasticFiberTrackingView::QmitkStochasticFiberTrackingView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 , m_DiffusionImage( NULL )
 , m_SeedRoi( NULL )
 {
 }
 
 // Destructor
 QmitkStochasticFiberTrackingView::~QmitkStochasticFiberTrackingView()
 {
 
 }
 
 void QmitkStochasticFiberTrackingView::CreateQtPartControl( QWidget *parent )
 {
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkStochasticFiberTrackingViewControls;
     m_Controls->setupUi( parent );
 
     connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
     connect( m_Controls->m_SeedsPerVoxelSlider, SIGNAL(valueChanged(int)), this, SLOT(OnSeedsPerVoxelChanged(int)) );
     connect( m_Controls->m_MaxCacheSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxCacheSizeChanged(int)) );
     connect( m_Controls->m_MaxTractLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxTractLengthChanged(int)) );
   }
 }
 
 void QmitkStochasticFiberTrackingView::OnSeedsPerVoxelChanged(int value)
 {
   m_Controls->m_SeedsPerVoxelLabel->setText(QString("Seeds per Voxel: ")+QString::number(value));
 }
 
 void QmitkStochasticFiberTrackingView::OnMaxTractLengthChanged(int value)
 {
   m_Controls->m_MaxTractLengthLabel->setText(QString("Max. Tract Length: ")+QString::number(value));
 }
 
 void QmitkStochasticFiberTrackingView::OnMaxCacheSizeChanged(int value)
 {
   m_Controls->m_MaxCacheSizeLabel->setText(QString("Max. Cache Size: ")+QString::number(value)+"GB");
 }
 
 void QmitkStochasticFiberTrackingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkStochasticFiberTrackingView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkStochasticFiberTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
+  m_DiffusionImageNode = NULL;
   m_DiffusionImage = NULL;
   m_SeedRoi = NULL;
   m_Controls->m_DiffusionImageLabel->setText("-");
   m_Controls->m_RoiImageLabel->setText("-");
 
   if(nodes.empty())
     return;
 
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::DataNode::Pointer node = *it;
 
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       if( dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
       {
+        m_DiffusionImageNode = node;
         m_DiffusionImage = dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData());
         m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
       }
       else
       {
         bool isBinary = false;
         node->GetPropertyValue<bool>("binary", isBinary);
         if (isBinary)
         {
           m_SeedRoi = dynamic_cast<mitk::Image*>(node->GetData());
           m_Controls->m_RoiImageLabel->setText(node->GetName().c_str());
         }
       }
     }
   }
 
   if(m_DiffusionImage.IsNotNull() && m_SeedRoi.IsNotNull())
     m_Controls->commandLinkButton->setEnabled(true);
   else
     m_Controls->commandLinkButton->setEnabled(false);
 }
 
 
 
 void QmitkStochasticFiberTrackingView::DoFiberTracking()
 {
   /* get Gradients/Direction of dwi */
   itk::VectorContainer< unsigned int, vnl_vector_fixed<double,3> >::Pointer Pdir = m_DiffusionImage->GetDirections();
 
   /* bValueContainer, Container includes b-values according to corresponding gradient-direction*/
   PTFilterType::bValueContainerType::Pointer vecCont = PTFilterType::bValueContainerType::New();
 
   /* for each gradient set b-Value; for 0-gradient set b-value eq. 0 */
   for ( int i=0; i<(int)Pdir->size(); ++i)
   {
     vnl_vector_fixed<double,3> valsGrad = Pdir->at(i);
     if (valsGrad.get(0) == 0 && valsGrad.get(1) == 0 && valsGrad.get(2) == 0)
     {  //set 0-Gradient to bValue 0
       vecCont->InsertElement(i,0);
     }else{
       vecCont->InsertElement(i,m_DiffusionImage->GetB_Value());
     }
   }
 
   /* define measurement frame (identity-matrix 3x3) */
   PTFilterType::MeasurementFrameType measurement_frame = m_DiffusionImage->GetMeasurementFrame();
 
   /* generate white matterImage (dummy?)*/
   FloatImageType::Pointer wmImage = FloatImageType::New();
   wmImage->SetSpacing( m_DiffusionImage->GetVectorImage()->GetSpacing() );
   wmImage->SetOrigin( m_DiffusionImage->GetVectorImage()->GetOrigin() );
   wmImage->SetDirection( m_DiffusionImage->GetVectorImage()->GetDirection() );
   wmImage->SetLargestPossibleRegion( m_DiffusionImage->GetVectorImage()->GetLargestPossibleRegion() );
   wmImage->SetBufferedRegion( wmImage->GetLargestPossibleRegion() );
   wmImage->SetRequestedRegion( wmImage->GetLargestPossibleRegion() );
   wmImage->Allocate();
 
   itk::ImageRegionIterator<FloatImageType> ot(wmImage, wmImage->GetLargestPossibleRegion() );
   while (!ot.IsAtEnd())
   {
     ot.Set(1);
     ++ot;
   }
 
   /* init TractographyFilter */
   PTFilterType::Pointer trackingFilter = PTFilterType::New();
   trackingFilter->SetInput(m_DiffusionImage->GetVectorImage().GetPointer());
   trackingFilter->SetbValues(vecCont);
   trackingFilter->SetGradients(Pdir);
   trackingFilter->SetMeasurementFrame(measurement_frame);
   trackingFilter->SetWhiteMatterProbabilityImageInput(wmImage);
   trackingFilter->SetTotalTracts(m_Controls->m_SeedsPerVoxelSlider->value());
   trackingFilter->SetMaxLikelihoodCacheSize(m_Controls->m_MaxCacheSizeSlider->value()*1000);
   trackingFilter->SetMaxTractLength(m_Controls->m_MaxTractLengthSlider->value());
 
 
   m_tractcontainer = PTFilterType::TractContainerType::New();
 
   //itk::Image< char, 3 >
   mitk::ImageToItk< itk::Image< unsigned char, 3 > >::Pointer binaryImageToItk1 = mitk::ImageToItk< itk::Image< unsigned char, 3 > >::New();
   binaryImageToItk1->SetInput( m_SeedRoi );
   binaryImageToItk1->Update();
 
+  vtkSmartPointer<vtkPoints> vPoints = vtkSmartPointer<vtkPoints>::New();
+  vtkSmartPointer<vtkCellArray> vCellArray = vtkSmartPointer<vtkCellArray>::New();
+
   itk::ImageRegionConstIterator< BinaryImageType > it(binaryImageToItk1->GetOutput(), binaryImageToItk1->GetOutput()->GetRequestedRegion());
   it.Begin();
+  mitk::Geometry3D* geom = m_DiffusionImage->GetGeometry();
 
   while(!it.IsAtEnd())
   {
     itk::ImageConstIterator<BinaryImageType>::PixelType tmpPxValue = it.Get();
 
     if(tmpPxValue != 0){
+      mitk::Point3D point;
       itk::ImageRegionConstIterator< BinaryImageType >::IndexType seedIdx = it.GetIndex();
       trackingFilter->SetSeedIndex(seedIdx);
       trackingFilter->Update();
 
       /* get results from Filter */
       /* write each single tract into member container */
       PTFilterType::TractContainerType::Pointer container_tmp = trackingFilter->GetOutputTractContainer();
       PTFilterType::TractContainerType::Iterator elIt = container_tmp->Begin();
       PTFilterType::TractContainerType::Iterator end = container_tmp->End();
+      bool addTract = true;
 
       while( elIt != end ){
-        PTFilterType::TractContainerType::Element tract_tmp = elIt.Value();
-        m_tractcontainer->InsertElement(m_tractcontainer->Size(),tract_tmp);
-        ++elIt;
-      }
-    }
-    ++it;
-  }
-
-  /* allocate the VTK Polydata to output the tracts */
-  vtkSmartPointer<vtkPoints> vPoints = vtkSmartPointer<vtkPoints>::New();
-  vtkSmartPointer<vtkCellArray> vCellArray = vtkSmartPointer<vtkCellArray>::New();
-
-  for( int i=0; i<(int)m_tractcontainer->Size(); i++ )
-  {
-    mitk::Point3D point;
+        PTFilterType::TractContainerType::Element tract = elIt.Value();
+        PTFilterType::TractContainerType::Element::ObjectType::VertexListType::ConstPointer vertexlist = tract->GetVertexList();
 
-    PTFilterType::TractContainerType::Element tract = m_tractcontainer->GetElement(i);
-    PTFilterType::TractContainerType::Element::ObjectType::VertexListType::ConstPointer vertexlist = tract->GetVertexList();
-
-    vtkSmartPointer<vtkPolyLine> vPolyLine = vtkSmartPointer<vtkPolyLine>::New();
-    for( int j=0; j<(int)vertexlist->Size(); j++)
-    {
-      PTFilterType::TractContainerType::Element::ObjectType::VertexListType::Element vertex = vertexlist->GetElement(j);
-      mitk::Point3D index;
-      index[0] = (float)vertex[0];
-      index[1] = (float)vertex[1];
-      index[2] = (float)vertex[2];
+        vtkSmartPointer<vtkPolyLine> vPolyLine = vtkSmartPointer<vtkPolyLine>::New();
+        for( int j=0; j<(int)vertexlist->Size(); j++)
+        {
+          PTFilterType::TractContainerType::Element::ObjectType::VertexListType::Element vertex = vertexlist->GetElement(j);
+          mitk::Point3D index;
+          index[0] = (float)vertex[0];
+          index[1] = (float)vertex[1];
+          index[2] = (float)vertex[2];
+
+          if (geom->IsIndexInside(index))
+          {
+            geom->IndexToWorld(index, point);
+            vtkIdType id = vPoints->InsertNextPoint(point.GetDataPointer());
+            vPolyLine->GetPointIds()->InsertNextId(id);
+          }
+          else
+          {
+            addTract = false;
+            break;
+          }
+        }
 
-      m_DiffusionImage->GetGeometry()->IndexToWorld(index, point);
+        if (addTract)
+          vCellArray->InsertNextCell(vPolyLine);
 
-      vtkIdType id = vPoints->InsertNextPoint(point.GetDataPointer());
-      vPolyLine->GetPointIds()->InsertNextId(id);
+        ++elIt;
+      }
     }
-    vCellArray->InsertNextCell(vPolyLine);
+    ++it;
   }
 
   vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   fiberPolyData->SetPoints(vPoints);
   fiberPolyData->SetLines(vCellArray);
 
   mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberPolyData);
   mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
   fbNode->SetData(fib);
-  fbNode->SetName("GroupFinberBundle");
+  QString name(m_DiffusionImageNode->GetName().c_str());
+  name += "_FiberBundle";
+  fbNode->SetName(name.toStdString());
   fbNode->SetVisibility(true);
   GetDataStorage()->Add(fbNode);
 }
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
index 34f31895ba..d6857a757b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
@@ -1,102 +1,103 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-31 16:40:27 +0200 (Mi, 31 Mrz 2010) $
 Version:   $Revision: 21975 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef QmitkStochasticFiberTrackingView_h
 #define QmitkStochasticFiberTrackingView_h
 
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 #include <QmitkFunctionality.h>
 
 #include "ui_QmitkStochasticFiberTrackingViewControls.h"
 
 #include <mitkDiffusionImage.h>
 #include <mitkDataStorage.h>
 
 #include <itkVectorImage.h>
 #include <itkImage.h>
 #include <itkDTITubeSpatialObject.h>
 #include <itkDTITubeSpatialObjectPoint.h>
 #include <itkSceneSpatialObject.h>
 #include <itkStochasticTractographyFilter.h>
 
 //define the input/output types
 typedef itk::VectorImage< short int, 3 > DWIVectorImageType;
 typedef itk::Image< float, 3 > FloatImageType;
 typedef itk::Image< unsigned int, 3 > CImageType;
 typedef itk::StochasticTractographyFilter< DWIVectorImageType, FloatImageType, CImageType > PTFilterType;
 typedef itk::DTITubeSpatialObject<3>      DTITubeType;
 typedef itk::DTITubeSpatialObjectPoint<3>  DTITubePointType;
 typedef itk::SceneSpatialObject<3>        SceneSpatialObjectType;
 
 /*!
 \brief QmitkFiberTrackingView
 
 \warning  This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
 
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 class QmitkStochasticFiberTrackingView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkStochasticFiberTrackingView();
   virtual ~QmitkStochasticFiberTrackingView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   protected slots:
 
   void DoFiberTracking();
 
 protected:
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
   Ui::QmitkStochasticFiberTrackingViewControls* m_Controls;
   QmitkStdMultiWidget* m_MultiWidget;
 
 protected slots:
 
   void OnSeedsPerVoxelChanged(int value);
   void OnMaxTractLengthChanged(int value);
   void OnMaxCacheSizeChanged(int value);
 
 private:
 
   mitk::Image::Pointer m_SeedRoi;
   mitk::DiffusionImage<short>::Pointer m_DiffusionImage;
+  mitk::DataNode::Pointer m_DiffusionImageNode;
 
   typedef itk::Image< unsigned char, 3 > BinaryImageType;
   PTFilterType::TractContainerType::Pointer m_tractcontainer;
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED