diff --git a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
index 6df23209a3..004511e5ca 100644
--- a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
@@ -1,415 +1,447 @@
 /*=========================================================================
 
  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"
 
 /* musthave */
 //#include <mitkGeometry3D.h> // without geometry, fibers are not rendered
 
 #include <vtkPointData.h>
 #include <vtkDataArray.h>
 #include <vtkUnsignedCharArray.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkIdFilter.h>
+#include <vtkClipPolyData.h>
 
 // baptize array names
 const char* mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED = "Color_Orient";
 const char* mitk::FiberBundleX::COLORCODING_FA_BASED = "Color_FA";
 const char* mitk::FiberBundleX::FIBER_ID_ARRAY = "Fiber_IDs";
 
 
 
 
 mitk::FiberBundleX::FiberBundleX(vtkSmartPointer<vtkPolyData> fiberPolyData )
     : m_currentColorCoding(NULL)
     , m_isModified(false)
 {
     //generate geometry of passed polydata
     if (fiberPolyData == NULL)
         this->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     else
         this->m_FiberPolyData = fiberPolyData;
 
     this->UpdateFiberGeometry();
 
 
 }
 
 
 mitk::FiberBundleX::~FiberBundleX()
 {
     // Memory Management
     m_FiberPolyData->Delete();
 }
 
 /* === main input method ====
  * set computed fibers from tractography algorithms
  */
 void mitk::FiberBundleX::SetFiberPolyData(vtkSmartPointer<vtkPolyData> fiberPD)
 { 
     if (fiberPD == NULL)
         this->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     else
         this->m_FiberPolyData = fiberPD;
 
     m_isModified = true;
 }
 
 
 /* === main output method ===
  * return fiberbundle as vtkPolyData
  * Depending on processing of input fibers, this method returns
  * the latest processed fibers.
  */
 vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GetFiberPolyData()
 {
     return m_FiberPolyData;
 }
 
 
 
 
 /*===================================
  *++++ PROCESSING WITH FIBERS +++++++
  ====================================*/
 
 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_INFO << " NO NEED TO REGENERATE COLORCODING! " ;
         return;
     }
 
 
     /* Finally, execute color calculation */
     vtkPoints* extrPoints = m_FiberPolyData->GetPoints();
     int 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);
 
     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_INFO << "\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_INFO << "Fib#: " << fi << " of " << numOfFibers << " pnts in fiber: " << pointsPerFiber ;
+        //    MITK_INFO << "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::abs(diff[0]));
                     rgba[1] = (unsigned char) (255.0 * std::abs(diff[1]));
                     rgba[2] = (unsigned char) (255.0 * std::abs(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::abs(diff1[0]));
                     rgba[1] = (unsigned char) (255.0 * std::abs(diff1[1]));
                     rgba[2] = (unsigned char) (255.0 * std::abs(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::abs(diff2[0]));
                     rgba[1] = (unsigned char) (255.0 * std::abs(diff2[1]));
                     rgba[2] = (unsigned char) (255.0 * std::abs(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_INFO << "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);
     m_isModified = true;
-//  ===========================
+    //  ===========================
 
     //mini test, shall be ported to MITK TESTINGS!
     if (colorsT->GetSize() != numOfPoints*componentSize) {
         MITK_INFO << "ALLOCATION ERROR IN INITIATING COLOR ARRAY";
     }
 
 }
 
 void mitk::FiberBundleX::DoGenerateFiberIds()
 {
     if (m_FiberPolyData == NULL)
         return;
 
     //  for (int i=0; i<10000000; ++i)
     //  {
     //   if(i%500 == 0)
     //     MITK_INFO << i;
     //  }
     //  MITK_INFO << "Generating Fiber Ids";
     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_INFO << "Generating Fiber Ids...[done] | " << m_FiberIdDataSet->GetNumberOfCells();
 
 }
 
+std::vector<int> mitk::FiberBundleX::DoGetFiberIds(/*mitk::PlanarFigure::Pointer slicing_plane */)
+{
+
+    /* get all points/fibers cutting the plane */
+    vtkSmartPointer<vtkClipPolyData> clipper = vtkSmartPointer<vtkClipPolyData>::New();
+    clipper->SetInput(m_FiberIdDataSet);
+//    clipper->SetClipFunction(slicing_plane);
+      clipper->GenerateClipScalarsOn();
+      clipper->GenerateClippedOutputOn();
+
+      vtkSmartPointer<vtkPolyData> clipperout = clipper->GetClippedOutput();
+// clipper throws all lines away which are not crossing plane
+//   clipper calculates distances to all points, also to those which are not crossing the plane but which are along the normal direction of the plane.
+// get the distances:
+      vtkSmartPointer<vtkDataArray> distanceList = clipperout->GetPointData()->GetScalars();
+      for (int i=0; i<distanceList->GetNumberOfTuples(); ++i) {
+          std::cout << "distance of point (idx in clippedpolydata) " << i << " :" ;
+              vtkIdType components = distanceList->GetNumberOfComponents();
+              double *distance = distanceList->GetTuple(i);
+
+              for (int j=0; j<components; ++j) {
+                  std::cout << "point distance " << distance[j] << std::endl;
+                  //even if points are on the plane (where distance shall be 0), they can store an approximation to 0 like 2.22045e-16
+                  //if distance is almost 0, remember that point :-)
+              }
+
+          }
+
+
+}
+
 void mitk::FiberBundleX::UpdateFiberGeometry()
 {
 
 
     float min = itk::NumericTraits<float>::min();
     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);
 
             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 buffer space at borders
 
     for(int i=0; i<=4; i+=2){
         b[i] -=10;
     }
 
     for(int i=1; i<=5; i+=2){
         b[i] +=10;
     }
 
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
     geometry->SetImageGeometry(true);
     geometry->SetFloatBounds(b);
     this->SetGeometry(geometry);
 
 
 
 
 }
 
 /*==============================
  *++++ FIBER INFORMATION +++++++
  ===============================*/
 
 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_INFO << "no colorcodings available in fiberbundleX";
 
-//    for(int i=0; i<availableColorCodings.size(); i++)
-//    {
-//            MITK_INFO << availableColorCodings.at(i).toLocal8Bit().constData();
-//    }
+    //    for(int i=0; i<availableColorCodings.size(); i++)
+    //    {
+    //            MITK_INFO << availableColorCodings.at(i).toLocal8Bit().constData();
+    //    }
 
     return availableColorCodings;
 }
 
 
- char* mitk::FiberBundleX::GetCurrentColorCoding()
+char* mitk::FiberBundleX::GetCurrentColorCoding()
 {
     return this->m_currentColorCoding;
 }
 
 void mitk::FiberBundleX::SetColorCoding(const char* requestedColorCoding)
 {
-//    MITK_INFO << "FbX try to set colorCoding: " << requestedColorCoding << " compare with: " << COLORCODING_ORIENTATION_BASED;
+    //    MITK_INFO << "FbX try to set colorCoding: " << requestedColorCoding << " compare with: " << COLORCODING_ORIENTATION_BASED;
     if(strcmp (COLORCODING_ORIENTATION_BASED,requestedColorCoding) == 0 )
     {
-            this->m_currentColorCoding = (char*) COLORCODING_ORIENTATION_BASED;
-            this->m_isModified = true;
+        this->m_currentColorCoding = (char*) COLORCODING_ORIENTATION_BASED;
+        this->m_isModified = true;
 
     } else if(strcmp (COLORCODING_FA_BASED,requestedColorCoding) == 0 ) {
         this->m_currentColorCoding = (char*) COLORCODING_FA_BASED;
         this->m_isModified = true;
     } else {
         MITK_INFO << "FIBERBUNDLE X: UNKNOWN COLORCODING in FIBERBUNDLEX Datastructure";
         this->m_currentColorCoding = "---"; //will cause blank colorcoding of fibers
         this->m_isModified = true;
     }
 
 }
 
 bool mitk::FiberBundleX::isFiberBundleXModified()
 {
     return m_isModified;
 }
 void mitk::FiberBundleX::setFBXModificationDone()
 {
     m_isModified = false;
 }
 
 
 
 
 
 
 /* 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/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.h b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.h
index df312ee528..9023b4d8c2 100644
--- a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.h
+++ b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.h
@@ -1,128 +1,129 @@
 
 /*=========================================================================
 
  Program:   Medical Imaging & Interaction Toolkit
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date$
  Version:   $Revision: 11989 $
 
  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.
 
  =========================================================================*/
 
 /* =============== IMPORTANT TODO ===================
  * ==== USE vtkSmartPointer<> when necessary ONLY!!!!
  */
 
 #ifndef _MITK_FiberBundleX_H
 #define _MITK_FiberBundleX_H
 
 //includes for MITK datastructure
 #include <mitkBaseData.h>
 #include "MitkDiffusionImagingExports.h"
 
 
 //includes storing fiberdata
 #include <vtkSmartPointer.h> //may be replaced by class precompile argument
 #include <vtkPolyData.h> // may be replaced by class
 #include <vtkPoints.h> // my be replaced by class
 #include <vtkDataSet.h>
 
 #include <QStringList>
 
 namespace mitk {
 
   /**
    * \brief Base Class for Fiber Bundles;   */
   class  MitkDiffusionImaging_EXPORT FiberBundleX : public BaseData
   {
   public:
   
     // names of certain arrays (e.g colorcodings, etc.) 
     static const char* COLORCODING_ORIENTATION_BASED;
     static const char* COLORCODING_FA_BASED;
     static const char* FIBER_ID_ARRAY;
     
     /* friend classes wanna access typedefs
     ContainerPointType, ContainerTractType, ContainerType */
     friend class FiberBundleXWriter;
     friend class FiberBundleXReader;
 
     
     // ======virtual methods must have======
     virtual void UpdateOutputInformation();
     virtual void SetRequestedRegionToLargestPossibleRegion();
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
     virtual bool VerifyRequestedRegion();
     virtual void SetRequestedRegion( itk::DataObject *data );
     //=======================================
     
     mitkClassMacro( FiberBundleX, BaseData )
     itkNewMacro( Self )
     //custom constructor with passing argument
     mitkNewMacro1Param(Self, vtkSmartPointer<vtkPolyData>)
 
 
     
     
     
     /*====FIBERBUNDLE I/O METHODS====*/
     void SetFiberPolyData(vtkSmartPointer<vtkPolyData>); //set result of tractography algorithm in vtkPolyData format using vtkPolyLines
     vtkSmartPointer<vtkPolyData> GetFiberPolyData();
     void UpdateFiberGeometry();
     char* GetCurrentColorCoding();
     QStringList GetAvailableColorCodings();
     void SetColorCoding(const char*);
     
     bool isFiberBundleXModified();
     void setFBXModificationDone();
 
 
     /*===FIBERBUNDLE PROCESSING METHODS====*/
     void DoColorCodingOrientationbased();
     void DoGenerateFiberIds();
+    std::vector<int> DoGetFiberIds(/* mitkPlanarfigure slicing plane*/);
     
     /*===FIBERBUNDLE ASSESSMENT METHODS====*/
 
 
 
 
   protected:
     FiberBundleX( vtkSmartPointer<vtkPolyData> fiberPolyData = NULL );
     virtual ~FiberBundleX();
 
 
 
   private:
         
     //      The following polydata variables are used for fiber- and pointbased representation of the tractography results. As VTK suggests, one vtkPolyData is used to manage vertices and the other for polylines.
     //      FiberPolyData stores all brain fibers using polylines (in world coordinates)
     //    this variable hosts the smoothed fiber data, this data we generate, therefore a smartpointer structure is recommended
 //    vtkSmartPointer<vtkPolyData> m_FiberPolyData;  is depricated
 //    
     //    this variable hosts the original fiber data, no smartpointer needed because who or whatever passes this data to FiberBundleX should use vtkSmartPointer structure
   
     vtkSmartPointer<vtkPolyData> m_FiberPolyData; //this is a common pointer because fiberDataStructure gets passed to this class. m_FiberStructureData is destroyed in the destructor then.
     
     // this variable contains all additional IDs of Fibers which are needed for efficient fiber manipulation such as extracting etc.
     vtkSmartPointer<vtkDataSet> m_FiberIdDataSet;
     char* m_currentColorCoding;
 
     //this flag conzerns only visual representation.
     bool m_isModified;
 
 
     
     
   };
 
 } // namespace mitk
 
 #endif /*  _MITK_FiberBundleX_H */