diff --git a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
index c72e805dbb..52a1e36559 100644
--- a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
@@ -1,398 +1,403 @@
 /*=========================================================================
 
  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>
 
 // 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) /*&&
+    if ( m_FiberPolyData->GetPointData()->HasArray(COLORCODING_ORIENTATION_BASED) &&
          m_FiberPolyData->GetNumberOfPoints() ==
-         m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetNumberOfTuples() */)
+         m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetNumberOfTuples() )
     {
         // fiberstructure is already colorcoded
         MITK_INFO << " NO NEED TO REGENERATE COLORCODING! " ;
-        MITK_INFO <<  m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetName();
-        MITK_INFO <<   m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetNumberOfComponents();
-         MITK_INFO <<  m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetNumberOfTuples();
+//     set current colorcoding to orientationbased if needed
+        if (m_currentColorCoding != COLORCODING_ORIENTATION_BASED ) {
+            m_currentColorCoding = (char*) COLORCODING_ORIENTATION_BASED;
+            m_isModified = true;
+        }
+
         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 below 1 ========= \n";
+        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;
-        MITK_INFO << sizeof(idList);
-
-
-
+    //    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;
-                    diff1.normalize();
 
                     vnl_vector_fixed< double, 3 > diff2;
                     diff2 = currentPntvtk - prevPntvtk;
-                    diff2.normalize();
 
                     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 */
     m_currentColorCoding = (char*) 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";
     }
 
-MITK_INFO << " AfterColorcodingFiber " << m_FiberPolyData->GetNumberOfPoints() << " " <<  m_FiberPolyData->GetPointData()->GetArray(COLORCODING_ORIENTATION_BASED)->GetNumberOfTuples();
-    //===== clean memory =====
-
-
-    //========================
 }
 
 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();
 
 }
 
 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)
     {
         MITK_INFO << m_FiberPolyData->GetPointData()->GetArrayName(i);
         //todo store sting in QStringList
     }
 
     if (availableColorCodings.isEmpty())
         MITK_INFO << "no colorcodings available in fiberbundleX";
     return availableColorCodings;
 }
 
-char* mitk::FiberBundleX::getCurrentColorCoding()
+char* mitk::FiberBundleX::GetCurrentColorCoding()
 {
     return m_currentColorCoding;
 }
 
-
+void mitk::FiberBundleX::SetColorCoding(char* requestedColorCoding)
+{
+    m_currentColorCoding = requestedColorCoding;
+    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 d5b56e31b3..a70efd4ba8 100644
--- a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.h
+++ b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.h
@@ -1,125 +1,128 @@
 
 /*=========================================================================
 
  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();
-    char* getCurrentColorCoding();
-    bool isFiberBundleXModified();
-    void setFBXModificationDone();
     void UpdateFiberGeometry();
+    char* GetCurrentColorCoding();
     QStringList GetAvailableColorCodings();
+    void SetColorCoding(char*);
     
+    bool isFiberBundleXModified();
+    void setFBXModificationDone();
+
+
     /*===FIBERBUNDLE PROCESSING METHODS====*/
     void DoColorCodingOrientationbased();
     void DoGenerateFiberIds();
     
     /*===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 */
diff --git a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper3D.cpp b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper3D.cpp
index 004a2f4a40..cfd6f17e2a 100644
--- a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper3D.cpp
+++ b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXMapper3D.cpp
@@ -1,206 +1,204 @@
 /*=========================================================================
  
  Program:   Medical Imaging & Interaction Toolkit
  Language:  C++
  Date:      $Date: 2009-05-12 19:56:03 +0200 (Di, 12 Mai 2009) $
  Version:   $Revision: 17179 $
  
  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 "mitkFiberBundleXMapper3D.h"
 
 #include <mitkProperties.h>
 //#include <mitkFiberBundleInteractor.h>
 //#include <mitkGlobalInteraction.h>
 
 
 #include <vtkPropAssembly.h>
 #include <vtkPointData.h>
 #include <vtkProperty.h>
+#include <vtkLookupTable.h>
 
 //not essential for mapper
 #include <QTime>
 
 mitk::FiberBundleXMapper3D::FiberBundleXMapper3D()
 :m_FiberMapperGLSP(vtkSmartPointer<vtkOpenGLPolyDataMapper>::New()),
  m_FiberMapperGLWP(vtkOpenGLPolyDataMapper::New()),
  m_FiberActorSP(vtkSmartPointer<vtkOpenGLActor>::New()),
  m_FiberActorWP(vtkOpenGLActor::New()),
  m_FiberAssembly(vtkPropAssembly::New())
 {
 
 }
 
 
 mitk::FiberBundleXMapper3D::~FiberBundleXMapper3D()
 {
   m_FiberAssembly->Delete();
 }
 
 
 const mitk::FiberBundleX* mitk::FiberBundleXMapper3D::GetInput()
 {
   MITK_INFO << "FiberBundleXxXXMapper3D() GetInput()";
   return static_cast<const mitk::FiberBundleX * > ( GetData() );
 }
 
 
 /* 
  This method is called once the mapper gets new input, 
  for UI rotation or changes in colorcoding this method is NOT called 
  */
 void mitk::FiberBundleXMapper3D::GenerateData()
 {
   //MITK_INFO << "GENERATE DATA FOR FBX :)";
   //=====timer measurement====
   QTime myTimer;
   myTimer.start();
   //==========================
   
 //  mitk::FiberBundleX::Pointer FBX = dynamic_cast< mitk::FiberBundleX* > (this->GetData());
 
   mitk::FiberBundleX* FBX = dynamic_cast<mitk::FiberBundleX*> (this->GetData());
   if (FBX == NULL) {
     return;
   }
   //todo smartpointer
   vtkPolyData* FiberData = FBX->GetFiberPolyData();
 
   if (FiberData == NULL) {
     return;
   }
 
-  MITK_INFO << "NumOfFibs: " << FiberData->GetNumberOfLines();
-  MITK_INFO << "NumOfPoints: " << FiberData->GetNumberOfPoints();
-  
-  
+
   m_FiberMapperGLSP->SetInput(FiberData); 
   //  m_FiberMapperGLWP->SetInput(FiberData);
   
   
   if ( FiberData->GetPointData()->GetNumberOfArrays() > 0 )
   {
     if ( FiberData->GetPointData()->HasArray(FiberBundleX::COLORCODING_ORIENTATION_BASED) ) 
     {
       m_FiberMapperGLSP->SelectColorArray(FiberBundleX::COLORCODING_ORIENTATION_BASED);
       //      m_FiberMapperGLWP->SelectColorArray(FiberBundleX::COLORCODING_ORIENTATION_BASED);
     } else {
       //      iterate through polydata array and take the first best -but valid- array
       
       //===ToDo===
       //check of componentsize as well, if it is not RGB or RGBA (ie. size 3 or 4), then check if it is a scalar
       // if scalar then create lookuptable for that.
     }
     
     m_FiberMapperGLSP->ScalarVisibilityOn();
     //    m_FiberMapperGLWP->ScalarVisibilityOn();
     m_FiberMapperGLSP->SetScalarModeToUsePointFieldData();
     //    m_FiberMapperGLWP->SetScalarModeToUsePointFieldData();
   }
   
   
   m_FiberActorSP->SetMapper(m_FiberMapperGLSP);
   //  m_FiberActorWP->SetMapper(m_FiberMapperGLWP);
   
   m_FiberActorSP->GetProperty()->SetOpacity(1.0);
   //  m_FiberActorWP->GetProperty()->SetOpacity(1.0);
   
-  if (FBX->getCurrentColorCoding() != NULL)
-      m_FiberMapperGLSP->SelectColorArray(FBX->getCurrentColorCoding());
-  
+  if (FBX->GetCurrentColorCoding() != NULL)
+      m_FiberMapperGLSP->SelectColorArray(FBX->GetCurrentColorCoding());
+
   m_FiberAssembly->AddPart(m_FiberActorSP);
   
   //since this method is called after generating all necessary data for fiber visualization, all modifications are represented so far.
   FBX->setFBXModificationDone();
   //====timer measurement========
   MITK_INFO << "Execution Time GenerateData() (nmiliseconds): " << myTimer.elapsed();
   //=============================
   
 }
 
 
 
 void mitk::FiberBundleXMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   if ( !this->IsVisible( renderer ) )
   {
     return;
   }
   
   //MITK_INFO << "FiberBundleXxXXMapper3D()DataForRenderer";
   //ToDo do update checks
   mitk::FiberBundleX* FBX = dynamic_cast<mitk::FiberBundleX*> (this->GetData());
   if(FBX->isFiberBundleXModified())
     this->GenerateData();
 }
 
 
 void mitk::FiberBundleXMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   
 //  MITK_INFO << "FiberBundleXxXXMapper3D()SetDefaultProperties";
   
   
   //MITK_INFO << "FiberBundleMapperX3D SetDefault Properties(...)";
  //   node->AddProperty( "DisplayChannel", mitk::IntProperty::New( true ), renderer, overwrite );
   //  node->AddProperty( "LineWidth", mitk::IntProperty::New( true ), renderer, overwrite );
   //  node->AddProperty( "ColorCoding", mitk::IntProperty::New( 0 ), renderer, overwrite);
   //  node->AddProperty( "VertexOpacity_1", mitk::BoolProperty::New( false ), renderer, overwrite);
   //  node->AddProperty( "Set_FA_VertexAlpha", mitk::BoolProperty::New( false ), renderer, overwrite);
   //  node->AddProperty( "pointSize", mitk::FloatProperty::New(0.5), renderer, overwrite);
   //  node->AddProperty( "setShading", mitk::IntProperty::New(1), renderer, overwrite);
   //  node->AddProperty( "Xmove", mitk::IntProperty::New( 0 ), renderer, overwrite);
   //  node->AddProperty( "Ymove", mitk::IntProperty::New( 0 ), renderer, overwrite);
   //  node->AddProperty( "Zmove", mitk::IntProperty::New( 0 ), renderer, overwrite);
   //  node->AddProperty( "RepPoints", mitk::BoolProperty::New( false ), renderer, overwrite);
   //  node->AddProperty( "TubeSides", mitk::IntProperty::New( 8 ), renderer, overwrite);
   //  node->AddProperty( "TubeRadius", mitk::FloatProperty::New( 0.15 ), renderer, overwrite);
   //  node->AddProperty( "TubeOpacity", mitk::FloatProperty::New( 1.0 ), renderer, overwrite);
   
   node->AddProperty( "pickable", mitk::BoolProperty::New( true ), renderer, overwrite);
   
   Superclass::SetDefaultProperties(node, renderer, overwrite);
   
   
   
 }
 
 vtkProp* mitk::FiberBundleXMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   //MITK_INFO << "FiberBundleXxXXMapper3D()GetVTKProp";
   //this->GenerateData();
   return m_FiberAssembly;
   
 }
 
 void mitk::FiberBundleXMapper3D::ApplyProperties(mitk::BaseRenderer* renderer)
 {
 //  MITK_INFO << "FiberBundleXXXXMapper3D ApplyProperties(renderer)";
 }
 
 void mitk::FiberBundleXMapper3D::UpdateVtkObjects()
 {
 //  MITK_INFO << "FiberBundleXxxXMapper3D UpdateVtkObjects()";
   
   
 }
 
 void mitk::FiberBundleXMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *)
 {
   
   
   
 }