diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/QmitkODFRenderWidget.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/QmitkODFRenderWidget.cpp
index 2b1a874e7b..d5acaa8a1f 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/QmitkODFRenderWidget.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/QmitkODFRenderWidget.cpp
@@ -1,131 +1,131 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 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 "QmitkODFRenderWidget.h"
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 #include <vtkSmartPointer.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkGeometry2D.h>
 
 QmitkODFRenderWidget::QmitkODFRenderWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 {
   //create Layouts
   QmitkODFRenderWidgetLayout = new QHBoxLayout( this );
 
   //Set Layout to widget
   this->setLayout(QmitkODFRenderWidgetLayout);
 
   //Create RenderWindow
   m_RenderWindow = new QmitkRenderWindow(this, "odf render widget");
   m_RenderWindow->setMaximumSize(300,300);
   m_RenderWindow->GetRenderer()->SetMapperID( mitk::BaseRenderer::Standard3D );
   //m_RenderWindow->SetLayoutIndex( 3 );
   QmitkODFRenderWidgetLayout->addWidget( m_RenderWindow );
 }
 
 
 QmitkODFRenderWidget::~QmitkODFRenderWidget()
 {
 }
 
 void QmitkODFRenderWidget::GenerateODF( itk::OrientationDistributionFunction<double, QBALL_ODFSIZE> odf )
 {
   m_Surface = mitk::Surface::New();
   m_ds = mitk::StandaloneDataStorage::New();
   m_Node = mitk::DataNode::New();
 
   vtkPolyData* m_TemplateOdf = itk::OrientationDistributionFunction<float,QBALL_ODFSIZE>::GetBaseMesh();
 
   vtkPolyData *polyData = vtkPolyData::New();
   vtkPoints *points = vtkPoints::New();
   vtkFloatArray *scalars = vtkFloatArray::New();
 
   double max = -10000;
   double min = 10000;
   for (int i=0; i<QBALL_ODFSIZE; i++)
     if(odf[i]<min)
       min = odf[i];
 
   if (min<0)
     return;
 
   for (int i=0; i<QBALL_ODFSIZE; i++)
     if(odf[i]>max)
       max = odf[i];
 
-  if (std::abs(max)<mitk::eps)
+  if (std::fabs(max)<mitk::eps)
     max = 0.0001;
 
   for (int i=0; i<QBALL_ODFSIZE; i++){
     double p[3];
     m_TemplateOdf->GetPoints()->GetPoint(i,p);
     double val = odf[i];
 
     p[0] *= val;
     p[1] *= val;
     p[2] *= val;
     points->InsertPoint(i,p);
 //    scalars->InsertTuple1(i, 1-val/max);
     scalars->InsertTuple1(i, 1-val/max);
   }
 
   polyData->SetPoints(points);
   vtkCellArray* polys = m_TemplateOdf->GetPolys();
   polyData->SetPolys(polys);
   polyData->GetPointData()->SetScalars(scalars);
 
   polys->Delete();
   scalars->Delete();
   points->Delete();
 
   m_Surface->SetVtkPolyData(polyData);
   m_Node->SetData(m_Surface);
 
   mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
   vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
   vtkLut->SetTableRange(0, 1);
 
   vtkLut->Build();
   mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
   mitkLutProp->SetLookupTable(mitkLut);
   m_Node->SetProperty( "LookupTable", mitkLutProp );
 
   m_Node->SetProperty("scalar visibility", mitk::BoolProperty::New(true));
   m_Node->SetProperty("color mode", mitk::BoolProperty::New(true));
   m_Node->SetProperty("material.specularCoefficient", mitk::FloatProperty::New(0.5));
 
   m_ds->Add(m_Node);
 
   m_RenderWindow->GetRenderer()->SetDataStorage( m_ds );
 
   // adjust camera to current plane rotation
   mitk::Geometry2D::ConstPointer worldGeometry = mitk::GlobalInteraction::GetInstance()->GetFocus()->GetCurrentWorldGeometry2D();
   mitk::PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry.GetPointer() );
   mitk::Vector3D normal = worldPlaneGeometry->GetNormal();
   mitk::Vector3D up = worldPlaneGeometry->GetAxisVector(1);
   normal.Normalize();
   up.Normalize();
 
   vtkSmartPointer<vtkCamera> cam = vtkSmartPointer<vtkCamera>::New();
   const double camPos[3] = {normal[0],normal[1],normal[2]};
   const double camUp[3] = {up[0],up[1],up[2]};
   cam->SetPosition(camPos);
   cam->SetViewUp(camUp);
   cam->SetParallelProjection(1);
   m_RenderWindow->GetRenderer()->GetVtkRenderer()->SetActiveCamera(cam);
 }
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/files.cmake b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/files.cmake
index 9cb5a6290f..373f0964d1 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/files.cmake
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/files.cmake
@@ -1,96 +1,98 @@
 SET(SRC_CPP_FILES
   QmitkDiffusionImagingAppApplication.cpp
   QmitkDiffusionImagingAppWorkbenchAdvisor.cpp
 )
 
 SET(INTERNAL_CPP_FILES
   mitkPluginActivator.cpp
   QmitkDiffusionImagingAppIntroPart.cpp
   QmitkDiffusionImagingAppPerspective.cpp
   QmitkWelcomePerspective.cpp
   QmitkDIAppConnectomicsPerspective.cpp
   QmitkDIAppDicomImportPerspective.cpp
   QmitkDIAppFiberTractographyPerspective.cpp
   QmitkDIAppIVIMPerspective.cpp
   QmitkDIAppPreprocessingReconstructionPerspective.cpp
   QmitkDIAppQuantificationPerspective.cpp
   QmitkDIAppScreenshotsMoviesPerspective.cpp
   QmitkDIAppTBSSPerspective.cpp
   QmitkDIAppVolumeVisualizationPerspective.cpp
+  QmitkDIAppTrackingEvaluationPerspective.cpp
 )
 
 SET(UI_FILES
   src/internal/QmitkWelcomeScreenViewControls.ui
 )
 
 SET(MOC_H_FILES
   src/internal/QmitkDiffusionImagingAppIntroPart.h
   src/internal/mitkPluginActivator.h
   src/QmitkDiffusionImagingAppApplication.h
   src/internal/QmitkDiffusionImagingAppPerspective.h
   src/internal/QmitkWelcomePerspective.h
   src/internal/QmitkDIAppConnectomicsPerspective.h
   src/internal/QmitkDIAppDicomImportPerspective.h
   src/internal/QmitkDIAppFiberTractographyPerspective.h
   src/internal/QmitkDIAppIVIMPerspective.h
   src/internal/QmitkDIAppPreprocessingReconstructionPerspective.h
   src/internal/QmitkDIAppQuantificationPerspective.h
   src/internal/QmitkDIAppScreenshotsMoviesPerspective.h
   src/internal/QmitkDIAppTBSSPerspective.h
   src/internal/QmitkDIAppVolumeVisualizationPerspective.h
+  src/internal/QmitkDIAppTrackingEvaluationPerspective.h
 )
 
 SET(CACHED_RESOURCE_FILES
 # list of resource files which can be used by the plug-in
 # system without loading the plug-ins shared library,
 # for example the icon used in the menu and tabs for the
 # plug-in views in the workbench
   plugin.xml
   resources/icon_dicom.xpm
   resources/diffusionimaging.png
   resources/preprocessing.png
   resources/Measurement_48.png
   resources/volvis.png
   resources/perspectives/diffusionimaging.png
   resources/perspectives/icon_home.png
   resources/perspectives/connectomics.png
   resources/perspectives/dicomimport.png
   resources/perspectives/tractography.png
   resources/perspectives/ivim.png
   resources/perspectives/preprocessingreconstruction.png
   resources/perspectives/quantification.png
   resources/perspectives/screenshotsmovies.png
   resources/perspectives/tbss.png
   resources/perspectives/volumevizualization.png
 )
 
 SET(QRC_FILES
 # uncomment the following line if you want to use Qt resources
   resources/welcome/QmitkWelcomeScreenView.qrc
   resources/org_mitk_gui_qt_diffusionimagingapp.qrc
 )
 
 # SET(CPP_FILES)
 
 foreach(file ${SRC_CPP_FILES})
   SET(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   SET(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
 
 
 #----------- Qt Help Collection Project -------------#
 
 IF (BLUEBERRY_USE_QT_HELP)
   SET(_plugin_qhcp_input "${CMAKE_CURRENT_SOURCE_DIR}/documentation/MitkDiffusionImagingAppQtHelpCollectionProject.qhcp")
   SET(_plugin_qhcp_output "${CMAKE_CURRENT_BINARY_DIR}/MitkDiffusionImagingAppQtHelpCollection.qhc")
   ADD_CUSTOM_COMMAND(OUTPUT ${_plugin_qhcp_output}
                      COMMAND ${QT_COLLECTIONGENERATOR_EXECUTABLE} ${_plugin_qhcp_input} -o ${_plugin_qhcp_output}
                      DEPENDS ${_plugin_qhcp_input}
                      )
 
   LIST(APPEND CACHED_RESOURCE_FILES ${_plugin_qhcp_output})
   #SET(FILE_DEPENDENCIES ${_plugin_qhcp_output})
 ENDIF()
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/plugin.xml b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/plugin.xml
index 174abdcf6d..d4c20d714a 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/plugin.xml
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/plugin.xml
@@ -1,69 +1,73 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?BlueBerry version="0.1"?>
 <plugin>
   <extension point="org.blueberry.osgi.applications">
     <application id="org.mitk.qt.diffusionimagingapp">
       <run class="QmitkDiffusionImagingAppApplication"/>
     </application>
   </extension>
 
   <extension point="org.blueberry.ui.intro">
     <intro id="org.mitk.qt.diffusionimagingappintro"
       class="QmitkDiffusionImagingAppIntroPart"
       role="editor"/>
     <introProductBinding
       productId=""
       introId="org.mitk.qt.diffusionimagingappintro"/>
   </extension>
 
   <extension point="org.blueberry.ui.perspectives">
 <!--    <perspective id="org.mitk.diffusionimagingapp.perspectives.diffusionimagingapp"
       name="Data Display"
       class="QmitkDiffusionImagingAppPerspective"
       icon="resources/perspectives/icon_home.png"/>-->
 
     <perspective id="org.mitk.diffusionimagingapp.perspectives.welcome"
       name="Data Display"
       class="QmitkWelcomePerspective"
       icon="resources/perspectives/icon_home.png"/>
     <perspective id="org.mitk.diffusionimagingapp.perspectives.dicomimport"
       name="DICOM Import"
       class="QmitkDIAppDicomImportPerspective"
       icon="resources/perspectives/dicomimport.png"/>
     <perspective id="org.mitk.diffusionimagingapp.perspectives.preprocessingreconstruction"
       name="Preprocessing Reconstruction"
       class="QmitkDIAppPreprocessingReconstructionPerspective"
       icon="resources/perspectives/preprocessingreconstruction.png"/>
     <perspective id="org.mitk.diffusionimagingapp.perspectives.quantification"
       name="Quantification"
       class="QmitkDIAppQuantificationPerspective"
       icon="resources/perspectives/quantification.png"/>
     <perspective id="org.mitk.diffusionimagingapp.perspectives.ivim"
       name="IVIM"
       class="QmitkDIAppIVIMPerspective"
       icon="resources/perspectives/ivim.png"/>
     <perspective id="org.mitk.diffusionimagingapp.perspectives.tbss"
       name="TBSS"
       class="QmitkDIAppTBSSPerspective"
       icon="resources/perspectives/tbss.png"/>
     <perspective id="org.mitk.diffusionimagingapp.perspectives.tractography"
       name="Tractography"
       class="QmitkDIAppFiberTractographyPerspective"
       icon="resources/perspectives/tractography.png"/>
     <perspective id="org.mitk.diffusionimagingapp.perspectives.connectomics"
       name="Connectomics"
       class="QmitkDIAppConnectomicsPerspective"
       icon="resources/perspectives/connectomics.png"/>
     <perspective id="org.mitk.diffusionimagingapp.perspectives.volumevisualization"
       name="Volume Visualization"
       class="QmitkDIAppVolumeVisualizationPerspective"
       icon="resources/perspectives/volumevizualization.png"/>
     <perspective id="org.mitk.diffusionimagingapp.perspectives.screenshotsmovies"
       name="Screenshots Movies"
       class="QmitkDIAppScreenshotsMoviesPerspective"
       icon="resources/perspectives/screenshotsmovies.png"/>
+    <perspective id="org.mitk.diffusionimagingapp.perspectives.trackingevaluation"
+      name="Tracking Evaluation"
+      class="QmitkDIAppTrackingEvaluationPerspective"
+      icon="resources/perspectives/screenshotsmovies.png"/>
 
   </extension>
 
 </plugin>
 
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkDIAppTrackingEvaluationPerspective.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkDIAppTrackingEvaluationPerspective.cpp
new file mode 100644
index 0000000000..fcd0d3dc94
--- /dev/null
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkDIAppTrackingEvaluationPerspective.cpp
@@ -0,0 +1,49 @@
+/*=========================================================================
+
+ Program:   BlueBerry Platform
+ Language:  C++
+ Date:      $Date: 2009-10-23 02:59:36 +0200 (Fr, 23 Okt 2009) $
+ Version:   $Revision: 19652 $
+
+ 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 "QmitkDIAppTrackingEvaluationPerspective.h"
+#include "berryIViewLayout.h"
+
+void QmitkDIAppTrackingEvaluationPerspective::CreateInitialLayout(berry::IPageLayout::Pointer layout)
+{
+  /////////////////////////////////////////////////////
+  // all di-app perspectives should have the following:
+  /////////////////////////////////////////////////////
+
+  std::string editorArea = layout->GetEditorArea();
+
+  layout->AddStandaloneView("org.mitk.views.datamanager",
+    false, berry::IPageLayout::LEFT, 0.3f, editorArea);
+
+  layout->AddStandaloneView("org.mitk.views.controlvisualizationpropertiesview",
+    false, berry::IPageLayout::BOTTOM, .2f, "org.mitk.views.datamanager");
+
+  berry::IFolderLayout::Pointer left =
+    layout->CreateFolder("org.mitk.diffusionimaginginternal.leftcontrols",
+    berry::IPageLayout::BOTTOM, 0.15f, "org.mitk.views.controlvisualizationpropertiesview");
+
+  layout->AddStandaloneView("org.mitk.views.imagenavigator",
+    false, berry::IPageLayout::BOTTOM, .4f, "org.mitk.diffusionimaginginternal.leftcontrols");
+
+  /////////////////////////////////////////////
+  // here goes the perspective specific stuff
+  /////////////////////////////////////////////
+
+  left->AddView("org.mitk.views.artificialqballevaluation");
+  berry::IViewLayout::Pointer lo = layout->GetViewLayout("org.mitk.views.artificialqballevaluation");
+  lo->SetCloseable(false);
+}
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkDIAppTrackingEvaluationPerspective.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkDIAppTrackingEvaluationPerspective.h
new file mode 100644
index 0000000000..327ae819be
--- /dev/null
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkDIAppTrackingEvaluationPerspective.h
@@ -0,0 +1,42 @@
+/*=========================================================================
+
+ Program:   BlueBerry Platform
+ Language:  C++
+ Date:      $Date: 2009-10-23 02:59:36 +0200 (Fr, 23 Okt 2009) $
+ Version:   $Revision: 19652 $
+
+ 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 QmitkDIAppTrackingEvaluationPerspective_H_
+#define QmitkDIAppTrackingEvaluationPerspective_H_
+
+#include <berryIPerspectiveFactory.h>
+
+class QmitkDIAppTrackingEvaluationPerspective : public QObject, public berry::IPerspectiveFactory
+{
+  Q_OBJECT
+  Q_INTERFACES(berry::IPerspectiveFactory)
+
+public:
+
+  QmitkDIAppTrackingEvaluationPerspective() {}
+  QmitkDIAppTrackingEvaluationPerspective(const QmitkDIAppTrackingEvaluationPerspective& other)
+  {
+    Q_UNUSED(other)
+    throw std::runtime_error("Copy constructor not implemented");
+  }
+  ~QmitkDIAppTrackingEvaluationPerspective() {}
+
+  void CreateInitialLayout(berry::IPageLayout::Pointer layout);
+};
+
+#endif /* QmitkDIAppTrackingEvaluationPerspective_H_ */
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/mitkPluginActivator.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/mitkPluginActivator.cpp
index c08bb4b388..b251a54b97 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/mitkPluginActivator.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimagingapp/src/internal/mitkPluginActivator.cpp
@@ -1,136 +1,138 @@
 /*=========================================================================
 
  Program:   BlueBerry Platform
  Language:  C++
  Date:      $Date$
  Version:   $Revision$
 
  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 "mitkPluginActivator.h"
 #include <QtPlugin>
 #include <mitkVersion.h>
 #include <berryQtAssistantUtil.h>
 
 #include "src/QmitkDiffusionImagingAppApplication.h"
 
 #include "QmitkWelcomePerspective.h"
 #include "src/internal/QmitkDiffusionImagingAppIntroPart.h"
 #include "src/internal/QmitkDiffusionImagingAppPerspective.h"
 
 #include "src/internal/QmitkDIAppConnectomicsPerspective.h"
 #include "src/internal/QmitkDIAppDicomImportPerspective.h"
 #include "src/internal/QmitkDIAppFiberTractographyPerspective.h"
 #include "src/internal/QmitkDIAppIVIMPerspective.h"
 #include "src/internal/QmitkDIAppPreprocessingReconstructionPerspective.h"
 #include "src/internal/QmitkDIAppQuantificationPerspective.h"
 #include "src/internal/QmitkDIAppScreenshotsMoviesPerspective.h"
 #include "src/internal/QmitkDIAppTBSSPerspective.h"
 #include "src/internal/QmitkDIAppVolumeVisualizationPerspective.h"
+#include "src/internal/QmitkDIAppTrackingEvaluationPerspective.h"
 
 #include <QFileInfo>
 #include <QDateTime>
 
 mitkPluginActivator* mitkPluginActivator::inst = 0;
 
 mitkPluginActivator::mitkPluginActivator()
     : pluginListener(0)
 {
   inst = this;
 }
 
 mitkPluginActivator::~mitkPluginActivator()
 {
   delete pluginListener;
 }
 
 mitkPluginActivator* mitkPluginActivator::GetDefault()
 {
   return inst;
 }
 
 void mitkPluginActivator::start(ctkPluginContext* context)
 {
   berry::AbstractUICTKPlugin::start(context);
 
   this->context = context;
 
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDiffusionImagingAppApplication, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDiffusionImagingAppIntroPart, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDiffusionImagingAppPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkWelcomePerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppConnectomicsPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppDicomImportPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppFiberTractographyPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppIVIMPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppPreprocessingReconstructionPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppQuantificationPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppScreenshotsMoviesPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppTBSSPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppVolumeVisualizationPerspective, context)
+  BERRY_REGISTER_EXTENSION_CLASS(QmitkDIAppTrackingEvaluationPerspective, context)
 
   delete pluginListener;
   pluginListener = new berry::QCHPluginListener(context);
   context->connectPluginListener(pluginListener, SLOT(pluginChanged(ctkPluginEvent)), Qt::DirectConnection);
 
   // register all QCH files from all the currently installed plugins
   pluginListener->processPlugins();
 
 
 }
 
 QString mitkPluginActivator::GetQtHelpCollectionFile() const
 {
 
     if (!helpCollectionFile.isEmpty())
     {
       return helpCollectionFile;
     }
 
     QString collectionFilename;
     QString na("n/a");
 //    if (na != MITK_REVISION)
 //      collectionFilename = "MitkDiffusionImagingAppQtHelpCollection_" MITK_REVISION ".qhc";
 //    else
       collectionFilename = "MitkDiffusionImagingAppQtHelpCollection.qhc";
 
     QFileInfo collectionFileInfo = context->getDataFile(collectionFilename);
     QFileInfo pluginFileInfo = QFileInfo(QUrl(context->getPlugin()->getLocation()).toLocalFile());
     if (!collectionFileInfo.exists() ||
         pluginFileInfo.lastModified() > collectionFileInfo.lastModified())
     {
       // extract the qhc file from the plug-in
       QByteArray content = context->getPlugin()->getResource(collectionFilename);
       if (content.isEmpty())
       {
         BERRY_WARN << "Could not get plug-in resource: " << collectionFilename.toStdString();
       }
       else
       {
         QFile file(collectionFileInfo.absoluteFilePath());
         file.open(QIODevice::WriteOnly);
         file.write(content);
         file.close();
       }
     }
 
     if (QFile::exists(collectionFileInfo.absoluteFilePath()))
     {
       helpCollectionFile = collectionFileInfo.absoluteFilePath();
     }
 
     return helpCollectionFile;
 
 }
 
 Q_EXPORT_PLUGIN2(org_mitk_gui_qt_diffusionimagingapp, mitkPluginActivator)
 
 
diff --git a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
index a12610701a..155b502c36 100644
--- a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
@@ -1,848 +1,848 @@
 /*=========================================================================
 
  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>
 
 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( vtkPolyData* fiberPolyData )
   : m_currentColorCoding(NULL)
   , m_isModified(false)
   , m_NumFibers(0)
 {
   if (fiberPolyData == NULL)
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   else
     m_FiberPolyData = fiberPolyData;
 
   m_NumFibers = m_FiberPolyData->GetNumberOfLines();
 
   UpdateFiberGeometry();
 }
 
 mitk::FiberBundleX::~FiberBundleX()
 {
 
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::GetDeepCopy()
 {
   mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New();
 
 //  newFib->m_FiberIdDataSet = vtkSmartPointer<vtkDataSet>::New();
 //  newFib->m_FiberIdDataSet->DeepCopy(m_FiberIdDataSet);
   newFib->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   newFib->m_FiberPolyData->DeepCopy(m_FiberPolyData);
   newFib->SetColorCoding(m_currentColorCoding);
   newFib->m_isModified = m_isModified;
   newFib->m_NumFibers = m_NumFibers;
   newFib->UpdateFiberGeometry();
 
   return newFib;
 }
 
 // merge two fiber bundles
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::operator+(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::operator-(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
         this->m_FiberPolyData = fiberPD;
 
   if (updateGeometry)
     UpdateFiberGeometry();
 
   m_NumFibers = m_FiberPolyData->GetNumberOfLines();
 
   m_isModified = true;
 }
 
 /*
  * 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_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 ;
 
         /* 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[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::abs(diff1[0]));
-                    rgba[1] = (unsigned char) (255.0 * std::abs(diff1[1]));
-                    rgba[2] = (unsigned char) (255.0 * std::abs(diff1[2]));
+                    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::abs(diff2[0]));
-                    rgba[1] = (unsigned char) (255.0 * std::abs(diff2[1]));
-                    rgba[2] = (unsigned char) (255.0 * std::abs(diff2[2]));
+                    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_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();
 
 }
 
 
 //temporarely include only
 #include <vtkPolyDataWriter.h>
 //==========================
 std::vector<int> mitk::FiberBundleX::DoExtractFiberIds(mitk::PlanarFigure::Pointer pf)
 {
 
     MITK_INFO << "Extracting fiber!";
     /* 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
     } 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_INFO << "planeOrigin: " << planeOrigin[0] << " | " << planeOrigin[1] << " | " << planeOrigin[2] << endl;
         MITK_INFO << "planeNormal: " << planeNormal[0] << " | " << planeNormal[1] << " | " << planeNormal[2] << endl;
 
 
         /* init necessary vectors hosting pointIds and FiberIds */
         // contains all pointIds which are crossing the cutting plane
         std::vector<int> PointsOnPlane;
 
         // based on PointsOnPlane, all ROI relevant point IDs are stored here
         std::vector<int> PointsInROI;
 
         // vector which is returned, contains all extracted FiberIds
         std::vector<int> FibersInROI;
 
 
         /* 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();
         planeR->SetOrigin(10.0,5.0,0.0);
         planeR->SetNormal(0.0,-1.0,0.0);
 
 
         /* get all points/fibers cutting the plane */
         vtkSmartPointer<vtkClipPolyData> clipper = vtkSmartPointer<vtkClipPolyData>::New();
         clipper->SetInput(m_FiberIdDataSet);
         clipper->SetClipFunction(plane);
         clipper->GenerateClipScalarsOn();
         clipper->GenerateClippedOutputOn();
         vtkSmartPointer<vtkPolyData> clipperout1 = clipper->GetClippedOutput();
 
         /* for some reason clipperoutput is not initialized for futher processing
       * so far only writing out clipped polydata provides requested
       */
         vtkSmartPointer<vtkPolyDataWriter> writerC = vtkSmartPointer<vtkPolyDataWriter>::New();
         writerC->SetInput(clipperout1);
         writerC->SetFileName("/vtkOutput/Cout1_FbId_clipLineId0+1+2-tests.vtk");
         writerC->SetFileTypeToASCII();
         writerC->Write();
 
 
         vtkSmartPointer<vtkClipPolyData> Rclipper = vtkSmartPointer<vtkClipPolyData>::New();
         Rclipper->SetInput(clipperout1);
         Rclipper->SetClipFunction(planeR);
         Rclipper->GenerateClipScalarsOn();
         Rclipper->GenerateClippedOutputOn();
         vtkSmartPointer<vtkPolyData> clipperout = Rclipper->GetClippedOutput();
 
 
         vtkSmartPointer<vtkPolyDataWriter> writerC1 = vtkSmartPointer<vtkPolyDataWriter>::New();
         writerC1->SetInput(clipperout);
         writerC1->SetFileName("/vtkOutput/FbId_clipLineId0+1+2-tests.vtk");
         writerC1->SetFileTypeToASCII();
         writerC1->Write();
 
 
         /*======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);
             std::cout << "distance of point " << i << " : " << distance[0] << std::endl;
 
             // 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)
             {
                 std::cout << "adding " << i << endl;
                 PointsOnPlane.push_back(i); //push back in combination with reserve is fastest way to fill vector with various values
             }
 
         }
 
         // 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++;
         }
 
 
 
 
 
         /*=======STEP 2=====
      * extract ROI relevant pointIds */
         //ToDo
 
         mitk::PlanarCircle::Pointer circleName = mitk::PlanarCircle::New();
         mitk::PlanarPolygon::Pointer polyName = mitk::PlanarPolygon::New();
         if (pf->GetNameOfClass() == circleName->GetNameOfClass() )
         {
 
             if( true /*point in ROI*/)
             {
                 PointsInROI = PointsOnPlane;
             }
         }
 
 
 
         /*======STEP 3=======
      * identify fiberIds for points in ROI */
         //prepare resulting vector
         FibersInROI.reserve(PointsInROI.size());
 
         vtkCellArray *clipperlines = clipperout->GetLines();
         clipperlines->InitTraversal();
         long numOfLineCells = clipperlines->GetNumberOfCells();
 
         // 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
 
             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.
             for (long j=0; j<npts; j++)
             {
 
                 //  std::cout << "pointWalker: subline " << i << " point idx: " << j << " hosting point id: " << pts[j] << endl;
 
                 for (long k = 0; k < PointsInROI.size(); k++)
                 { // k corresponds to index in PointsInRoi vector
                     /* ====================
                  *  check if current point occurs in ROI
                  ======================*/
                     if (pts[j] == PointsInROI[k]) {
                         //figure out which line does it belong to
                         if (clipperout->GetCellData()->HasArray("FB_IDs"))
                         {
                             int originalFibId = clipperout->GetCellData()->GetArray("FB_IDs")->GetTuple(i)[0];
                             std::cout << "found pointid " << PointsInROI[k] << ": " << clipperout->GetPoint(PointsInROI[k])[0] << " | " << clipperout->GetPoint(PointsInROI[k])[1] << " | " << clipperout->GetPoint(PointsInROI[k])[2] << " in subline: " << i << " which belongs to fiber id: " << originalFibId << "\n" << endl;
 
                             // do something to avoid duplicates
                             int oldFibInRoiSize = FibersInROI.size();
                             if (oldFibInRoiSize != 0) {
 
 
                                 for (int f=0; f<oldFibInRoiSize; f++)
                                 {
                                     if (FibersInROI[f] == originalFibId ) {
                                         break;
                                     } else if (f == FibersInROI.size() -1){ //if there was no break until last entry, then write it in.
                                         FibersInROI.push_back(originalFibId);
 
                                     }
                                 }
                             } else {
                                 FibersInROI.push_back(originalFibId);
                             }
                         }
                         // for performance in data overhead reason, set id of found point to -1 in ROI-set. sublines can host this id one or more times for the same fiber, therefore we do not need this information anymore.
                         PointsInROI[k] = -1;
 
 
                     }
                 }
 
             }
 
 
         }
 
         std::cout << "\n=====FINAL RESULT: fib_id ======\n";
         std::vector<int>::iterator finIt = FibersInROI.begin();
         while ( finIt != FibersInROI.end() )
         {
             std::cout << *finIt << endl;
             ++finIt;
         }
         std::cout << "=====================\n";
 
     }
 }
 
 void mitk::FiberBundleX::UpdateFiberGeometry()
 {
   if (m_NumFibers<=0)
   {
     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 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 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::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_INFO << "no colorcodings available in fiberbundleX";
 
     //    for(int i=0; i<availableColorCodings.size(); i++)
     //    {
     //            MITK_INFO << 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;
 
   if(strcmp (COLORCODING_ORIENTATION_BASED,requestedColorCoding) == 0 )
   {
       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;
 }
 
 void mitk::FiberBundleX::ResampleFibers()
 {
   mitk::Geometry3D::Pointer geometry = GetGeometry();
   mitk::Vector3D spacing = geometry->GetSpacing();
 
   float minSpacing = 1;
   if(spacing[0]<spacing[1] && spacing[0]<spacing[2])
       minSpacing = spacing[0];
   else if (spacing[1] < spacing[2])
       minSpacing = spacing[1];
   else
       minSpacing = spacing[2];
 
   ResampleFibers(minSpacing);
 }
 
 // Resample fiber to get equidistant points
 void mitk::FiberBundleX::ResampleFibers(float len)
 {
     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 <= len && 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 >= len)
             {
                 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-len)/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-len;
         }
 
         newCellArray->InsertNextCell(container);
     }
 
     newPoly->SetPoints(newPoints);
     newPoly->SetLines(newCellArray);
     m_FiberPolyData = newPoly;
     UpdateFiberGeometry();
 }
 
 
 /* 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 )
 {
 
 }