diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index 39899d5651..34b504c2a6 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1844 +1,1844 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkControlVisualizationPropertiesView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 #include "mitkModuleRegistry.h"
 
 #include "mitkTbssImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkFiberBundleX.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 #include "mitkFiberBundleInteractor.h"
 #include "mitkPlanarFigureInteractor.h"
 #include <mitkQBallImage.h>
 #include <mitkTensorImage.h>
 #include <mitkDiffusionImage.h>
 #include <mitkConnectomicsNetwork.h>
 #include "mitkGlobalInteraction.h"
 
 #include "mitkGeometry2D.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include <itkTractDensityImageFilter.h>
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 
 #define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 static bool DetermineAffectedImageSlice( const mitk::Image* image, const mitk::PlaneGeometry* plane, int& affectedDimension, int& affectedSlice )
 {
   assert(image);
   assert(plane);
 
   // compare normal of plane to the three axis vectors of the image
   mitk::Vector3D normal       = plane->GetNormal();
   mitk::Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
   mitk::Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
   mitk::Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
 
   normal.Normalize();
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   imageNormal0.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal0.GetVnlVector()) );
   imageNormal1.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal1.GetVnlVector()) );
   imageNormal2.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal2.GetVnlVector()) );
 
   double eps( 0.00001 );
   // axial
   if ( imageNormal2.GetNorm() <= eps )
   {
     affectedDimension = 2;
   }
   // sagittal
   else if ( imageNormal1.GetNorm() <= eps )
   {
     affectedDimension = 1;
   }
   // frontal
   else if ( imageNormal0.GetNorm() <= eps )
   {
     affectedDimension = 0;
   }
   else
   {
     affectedDimension = -1; // no idea
     return false;
   }
 
   // determine slice number in image
   mitk::Geometry3D* imageGeometry = image->GetGeometry(0);
   mitk::Point3D testPoint = imageGeometry->GetCenter();
   mitk::Point3D projectedPoint;
   plane->Project( testPoint, projectedPoint );
 
   mitk::Point3D indexPoint;
 
   imageGeometry->WorldToIndex( projectedPoint, indexPoint );
   affectedSlice = ROUND( indexPoint[affectedDimension] );
   MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice " << affectedSlice;
 
   // check if this index is still within the image
   if ( affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)) ) return false;
 
   return true;
 }
 
 const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
 
 using namespace berry;
 
 struct CvpSelListener : ISelectionListener
 {
 
   berryObjectMacro(CvpSelListener);
 
   CvpSelListener(QmitkControlVisualizationPropertiesView* view)
   {
     m_View = view;
   }
 
   void ApplySettings(mitk::DataNode::Pointer node)
   {
     bool tex_int;
     node->GetBoolProperty("texture interpolation", tex_int);
     if(tex_int)
     {
       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
       m_View->m_Controls->m_TextureIntON->setChecked(true);
       m_View->m_TexIsOn = true;
     }
     else
     {
       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
       m_View->m_Controls->m_TextureIntON->setChecked(false);
       m_View->m_TexIsOn = false;
     }
 
     int val;
     node->GetIntProperty("ShowMaxNumber", val);
     m_View->m_Controls->m_ShowMaxNumber->setValue(val);
 
     m_View->m_Controls->m_NormalizationDropdown->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId());
 
     float fval;
     node->GetFloatProperty("Scaling",fval);
     m_View->m_Controls->m_ScalingFactor->setValue(fval);
 
     m_View->m_Controls->m_AdditionalScaling->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
 
     node->GetFloatProperty("IndexParam1",fval);
     m_View->m_Controls->m_IndexParam1->setValue(fval);
 
     node->GetFloatProperty("IndexParam2",fval);
     m_View->m_Controls->m_IndexParam2->setValue(fval);
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     m_View->m_Controls->m_VisibleOdfsON_T->setVisible(false);
     m_View->m_Controls->m_VisibleOdfsON_S->setVisible(false);
     m_View->m_Controls->m_VisibleOdfsON_C->setVisible(false);
     m_View->m_Controls->m_TextureIntON->setVisible(false);
 
     m_View->m_Controls->m_ImageControlsFrame->setVisible(false);
     m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(false);
     m_View->m_Controls->m_BundleControlsFrame->setVisible(false);
     m_View->m_SelectedNode = 0;
 
     if(m_View->m_CurrentSelection.IsNull())
       return;
 
     if(m_View->m_CurrentSelection->Size() == 1)
     {
       mitk::DataNodeObject::Pointer nodeObj = m_View->m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
       if(nodeObj.IsNotNull())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
         // check if node has data,
         // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
         mitk::BaseData* nodeData = node->GetData();
 
         if(nodeData != NULL )
         {
           if(dynamic_cast<mitk::PlanarFigure*>(nodeData) != 0)
           {
             m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(true);
             m_View->m_SelectedNode = node;
 
             float val;
             node->GetFloatProperty("planarfigure.line.width", val);
             m_View->m_Controls->m_PFWidth->setValue((int)(val*10.0));
 
             QString label = "Width %1";
             label = label.arg(val);
             m_View->m_Controls->label_pfwidth->setText(label);
 
             float color[3];
             node->GetColor( color, NULL, "planarfigure.default.line.color");
             QString styleSheet = "background-color:rgb(";
             styleSheet.append(QString::number(color[0]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[1]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[2]*255.0));
             styleSheet.append(")");
             m_View->m_Controls->m_PFColor->setAutoFillBackground(true);
             m_View->m_Controls->m_PFColor->setStyleSheet(styleSheet);
 
             node->GetColor( color, NULL, "color");
             styleSheet = "background-color:rgb(";
             styleSheet.append(QString::number(color[0]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[1]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[2]*255.0));
             styleSheet.append(")");
 
             m_View->PlanarFigureFocus();
           }
 
           if(dynamic_cast<mitk::FiberBundleX*>(nodeData) != 0)
           {
             m_View->m_Controls->m_BundleControlsFrame->setVisible(true);
             m_View->m_SelectedNode = node;
 
             if(m_View->m_CurrentPickingNode != 0 && node.GetPointer() != m_View->m_CurrentPickingNode)
             {
               m_View->m_Controls->m_Crosshair->setEnabled(false);
             }
             else
             {
               m_View->m_Controls->m_Crosshair->setEnabled(true);
             }
 
             float val;
             node->GetFloatProperty("TubeRadius", val);
             m_View->m_Controls->m_TubeRadius->setValue((int)(val * 100.0));
 
             QString label = "Radius %1";
             label = label.arg(val);
             m_View->m_Controls->label_tuberadius->setText(label);
 
             int width;
             node->GetIntProperty("LineWidth", width);
             m_View->m_Controls->m_LineWidth->setValue(width);
 
             label = "Width %1";
             label = label.arg(width);
             m_View->m_Controls->label_linewidth->setText(label);
 
             float range;
             node->GetFloatProperty("Fiber2DSliceThickness",range);
             label = "Range %1";
             label = label.arg(range*0.1);
             m_View->m_Controls->label_range->setText(label);
 
           }
 
         } // check node data != NULL
       }
     }
 
     if(m_View->m_CurrentSelection->Size() > 0 && m_View->m_SelectedNode == 0)
     {
       m_View->m_Controls->m_ImageControlsFrame->setVisible(true);
 
       bool foundDiffusionImage = false;
       bool foundQBIVolume = false;
       bool foundTensorVolume = false;
       bool foundImage = false;
       bool foundMultipleOdfImages = false;
       bool foundRGBAImage = false;
       bool foundTbssImage = false;
 
       // do something with the selected items
       if(m_View->m_CurrentSelection)
       {
         // iterate selection
         for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
           i != m_View->m_CurrentSelection->End(); ++i)
         {
 
           // extract datatree node
           if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
           {
             mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
             mitk::BaseData* nodeData = node->GetData();
 
             if(nodeData != NULL )
             {
               // only look at interesting types
               if(QString("DiffusionImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundDiffusionImage = true;
                 bool tex_int;
                 node->GetBoolProperty("texture interpolation", tex_int);
                 if(tex_int)
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
                   m_View->m_Controls->m_TextureIntON->setChecked(true);
                   m_View->m_TexIsOn = true;
                 }
                 else
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
                   m_View->m_Controls->m_TextureIntON->setChecked(false);
                   m_View->m_TexIsOn = false;
                 }
                 int val;
                 node->GetIntProperty("DisplayChannel", val);
                 m_View->m_Controls->m_DisplayIndex->setValue(val);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setValue(val);
 
                 QString label = "Channel %1";
                 label = label.arg(val);
                 m_View->m_Controls->label_channel->setText(label);
 
                 int maxVal = (dynamic_cast<mitk::DiffusionImage<short>* >(nodeData))->GetVectorImage()->GetVectorLength();
                 m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setMaximum(maxVal-1);
               }
 
               if(QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundTbssImage = true;
                 bool tex_int;
                 node->GetBoolProperty("texture interpolation", tex_int);
                 if(tex_int)
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
                   m_View->m_Controls->m_TextureIntON->setChecked(true);
                   m_View->m_TexIsOn = true;
                 }
                 else
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
                   m_View->m_Controls->m_TextureIntON->setChecked(false);
                   m_View->m_TexIsOn = false;
                 }
                 int val;
                 node->GetIntProperty("DisplayChannel", val);
                 m_View->m_Controls->m_DisplayIndex->setValue(val);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setValue(val);
 
                 QString label = "Channel %1";
                 label = label.arg(val);
                 m_View->m_Controls->label_channel->setText(label);
 
                 int maxVal = (dynamic_cast<mitk::TbssImage* >(nodeData))->GetImage()->GetVectorLength();
                 m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setMaximum(maxVal-1);
               }
 
 
               else if(QString("QBallImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
                 foundQBIVolume = true;
                 ApplySettings(node);
               }
 
               else if(QString("TensorImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
                 foundTensorVolume = true;
                 ApplySettings(node);
               }
 
               else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
               {
                 foundImage = true;
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(nodeData);
                 if(img.IsNotNull()
                   && img->GetPixelType().GetPixelType() == itk::ImageIOBase::RGBA
                   && img->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR )
                 {
                   foundRGBAImage = true;
                 }
 
                 bool tex_int;
                 node->GetBoolProperty("texture interpolation", tex_int);
                 if(tex_int)
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
                   m_View->m_Controls->m_TextureIntON->setChecked(true);
                   m_View->m_TexIsOn = true;
                 }
                 else
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
                   m_View->m_Controls->m_TextureIntON->setChecked(false);
                   m_View->m_TexIsOn = false;
                 }
               }
 
             } // END CHECK node != NULL
           }
         }
       }
 
       m_View->m_FoundSingleOdfImage = (foundQBIVolume || foundTensorVolume)
         && !foundMultipleOdfImages;
       m_View->m_Controls->m_NumberGlyphsFrame->setVisible(m_View->m_FoundSingleOdfImage);
 
       m_View->m_Controls->m_NormalizationDropdown->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->label->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_ScalingFactor->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_AdditionalScaling->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_NormalizationScalingFrame->setVisible(m_View->m_FoundSingleOdfImage);
 
       m_View->m_Controls->OpacMinFrame->setVisible(foundRGBAImage || m_View->m_FoundSingleOdfImage);
 
       // changed for SPIE paper, Principle curvature scaling
       //m_View->m_Controls->params_frame->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->params_frame->setVisible(false);
 
       m_View->m_Controls->m_VisibleOdfsON_T->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_VisibleOdfsON_S->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_VisibleOdfsON_C->setVisible(m_View->m_FoundSingleOdfImage);
 
       bool foundAnyImage = foundDiffusionImage ||
         foundQBIVolume || foundTensorVolume || foundImage || foundTbssImage;
 
       m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
       m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
       m_View->m_Controls->m_TSMenu->setVisible(foundAnyImage);
 
     }
   }
 
   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
   {
     // check, if selection comes from datamanager
     if (part)
     {
       QString partname(part->GetPartName().c_str());
       if(partname.compare("Datamanager")==0)
       {
 
         // apply selection
         DoSelectionChanged(selection);
 
       }
     }
   }
 
   QmitkControlVisualizationPropertiesView* m_View;
 };
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
   : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL),
   m_NodeUsedForOdfVisualization(NULL),
   m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
   m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
   m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")),
   m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")),
   m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")),
   m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")),
   m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")),
   m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")),
   m_CurrentSelection(0),
   m_CurrentPickingNode(0),
   m_GlyIsOn_S(false),
   m_GlyIsOn_C(false),
   m_GlyIsOn_T(false),
   m_FiberBundleObserverTag(0),
   m_Color(NULL)
 {
   currentThickSlicesMode = 1;
   m_MyMenu = NULL;
 }
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other)
 {
   Q_UNUSED(other)
     throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
 {
   if(m_SlicesRotationObserverTag1 )
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if( coordinator)
       coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
   }
   if( m_SlicesRotationObserverTag2)
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if( coordinator )
       coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
   }
 
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkControlVisualizationPropertiesView::OnThickSlicesModeSelected( QAction* action )
 {
   currentThickSlicesMode = action->data().toInt();
 
   switch(currentThickSlicesMode)
   {
   default:
   case 1:
     this->m_Controls->m_TSMenu->setText("MIP");
     break;
   case 2:
     this->m_Controls->m_TSMenu->setText("SUM");
     break;
   case 3:
     this->m_Controls->m_TSMenu->setText("WEIGH");
     break;
   }
 
   mitk::DataNode* n;
   n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
   n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
   n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 
   mitk::BaseRenderer::Pointer renderer =
     this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer->GetRenderingManager()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::OnTSNumChanged(int num)
 {
   if(num==0)
   {
     mitk::DataNode* n;
     n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
     n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
     n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
   }
   else
   {
     mitk::DataNode* n;
     n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 
     n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
   }
 
   m_TSLabel->setText(QString::number(num*2+1));
 
   mitk::BaseRenderer::Pointer renderer =
     this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer->GetRenderingManager()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
 }
 
 void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     // hide warning (ODFs in rotated planes)
     m_Controls->m_lblRotatedPlanesWarning->hide();
 
     m_MyMenu = new QMenu(parent);
     connect( m_MyMenu, SIGNAL( aboutToShow() ), this, SLOT(OnMenuAboutToShow()) );
 
     // button for changing rotation mode
     m_Controls->m_TSMenu->setMenu( m_MyMenu );
     //m_CrosshairModeButton->setIcon( QIcon( iconCrosshairMode_xpm ) );
 
     m_Controls->params_frame->setVisible(false);
 
     QIcon icon5(":/QmitkDiffusionImaging/Refresh_48.png");
     m_Controls->m_Reinit->setIcon(icon5);
     m_Controls->m_Focus->setIcon(icon5);
 
     QIcon iconColor(":/QmitkDiffusionImaging/color24.gif");
     m_Controls->m_PFColor->setIcon(iconColor);
     m_Controls->m_Color->setIcon(iconColor);
 
     QIcon iconReset(":/QmitkDiffusionImaging/reset.png");
     m_Controls->m_ResetColoring->setIcon(iconReset);
 
     m_Controls->m_PFColor->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
 
     QIcon iconCrosshair(":/QmitkDiffusionImaging/crosshair.png");
     m_Controls->m_Crosshair->setIcon(iconCrosshair);
     // was is los
     QIcon iconPaint(":/QmitkDiffusionImaging/paint2.png");
     m_Controls->m_TDI->setIcon(iconPaint);
 
     QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
     m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
 
     m_Controls->m_TextureIntON->setCheckable(true);
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     int size = m_Controls->m_AdditionalScaling->count();
     for(int t=0; t<size; t++)
     {
       if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
       {
         m_Controls->m_AdditionalScaling->removeItem(t);
       }
     }
 #endif
 
     m_Controls->m_OpacitySlider->setRange(0.0,1.0);
     m_Controls->m_OpacitySlider->setLowerValue(0.0);
     m_Controls->m_OpacitySlider->setUpperValue(0.0);
 
     m_Controls->m_ScalingFrame->setVisible(false);
     m_Controls->m_NormalizationFrame->setVisible(false);
     m_Controls->frame_tube->setVisible(false);
     m_Controls->frame_wire->setVisible(false);
   }
 
 
 
   m_IsInitialized = false;
   m_SelListener = berry::ISelectionListener::Pointer(new CvpSelListener(this));
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
   berry::ISelection::ConstPointer sel(
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
   m_IsInitialized = true;
 }
 
 void QmitkControlVisualizationPropertiesView::OnMenuAboutToShow ()
 {
   // THICK SLICE SUPPORT
   QMenu *myMenu = m_MyMenu;
   myMenu->clear();
 
   QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu);
   thickSlicesActionGroup->setExclusive(true);
 
   mitk::BaseRenderer::Pointer renderer =
     this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
 
   int currentTSMode = 0;
   {
     mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(renderer->GetCurrentWorldGeometry2DNode()->GetProperty( "reslice.thickslices" ));
     if( m.IsNotNull() )
       currentTSMode = m->GetValueAsId();
   }
 
   const int maxTS = 30;
 
   int currentNum = 0;
   {
     mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(renderer->GetCurrentWorldGeometry2DNode()->GetProperty( "reslice.thickslices.num" ));
     if( m.IsNotNull() )
     {
       currentNum = m->GetValue();
       if(currentNum < 0) currentNum = 0;
       if(currentNum > maxTS) currentNum = maxTS;
     }
   }
 
   if(currentTSMode==0)
     currentNum=0;
 
   QSlider *m_TSSlider = new QSlider(myMenu);
   m_TSSlider->setMinimum(0);
   m_TSSlider->setMaximum(maxTS-1);
   m_TSSlider->setValue(currentNum);
 
   m_TSSlider->setOrientation(Qt::Horizontal);
 
   connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) );
 
   QHBoxLayout* _TSLayout = new QHBoxLayout;
   _TSLayout->setContentsMargins(4,4,4,4);
   _TSLayout->addWidget(m_TSSlider);
   _TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu));
 
   QWidget* _TSWidget = new QWidget;
   _TSWidget->setLayout(_TSLayout);
 
   QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu);
   thickSliceModeActionGroup->setExclusive(true);
 
   QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu);
   m_TSSliderAction->setDefaultWidget(_TSWidget);
   myMenu->addAction(m_TSSliderAction);
 
   QAction* mipThickSlicesAction = new QAction(myMenu);
   mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   mipThickSlicesAction->setText("MIP (max. intensity proj.)");
   mipThickSlicesAction->setCheckable(true);
   mipThickSlicesAction->setChecked(currentThickSlicesMode==1);
   mipThickSlicesAction->setData(1);
   myMenu->addAction( mipThickSlicesAction );
 
   QAction* sumThickSlicesAction = new QAction(myMenu);
   sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   sumThickSlicesAction->setText("SUM (sum intensity proj.)");
   sumThickSlicesAction->setCheckable(true);
   sumThickSlicesAction->setChecked(currentThickSlicesMode==2);
   sumThickSlicesAction->setData(2);
   myMenu->addAction( sumThickSlicesAction );
 
   QAction* weightedThickSlicesAction = new QAction(myMenu);
   weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)");
   weightedThickSlicesAction->setCheckable(true);
   weightedThickSlicesAction->setChecked(currentThickSlicesMode==3);
   weightedThickSlicesAction->setData(3);
   myMenu->addAction( weightedThickSlicesAction );
 
   connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) );
 }
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 
   if (m_MultiWidget)
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
       m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
 
     coordinator = m_MultiWidget->GetSlicesSwiveller();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
       m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SliceRotation(const itk::EventObject&)
 {
   // test if plane rotated
   if( m_GlyIsOn_T || m_GlyIsOn_C || m_GlyIsOn_S )
   {
     if( this->IsPlaneRotated() )
     {
       // show label
       m_Controls->m_lblRotatedPlanesWarning->show();
     }
     else
     {
       //hide label
       m_Controls->m_lblRotatedPlanesWarning->hide();
     }
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkControlVisualizationPropertiesView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_DisplayIndex), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
     connect( (QObject*)(m_Controls->m_DisplayIndexSpinBox), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
 
     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
     connect( (QObject*)(m_Controls->m_Reinit), SIGNAL(clicked()), this, SLOT(Reinit()) );
 
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) );
 
     connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
     connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
     connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
     connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
     connect( (QObject*)(m_Controls->m_IndexParam1), SIGNAL(valueChanged(double)), this, SLOT(IndexParam1Changed(double)) );
     connect( (QObject*)(m_Controls->m_IndexParam2), SIGNAL(valueChanged(double)), this, SLOT(IndexParam2Changed(double)) );
 
     connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
 
     connect( (QObject*)(m_Controls->m_OpacitySlider), SIGNAL(spanChanged(double,double)), this, SLOT(OpacityChanged(double,double)) );
 
     connect((QObject*) m_Controls->m_Wire, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationWire()));
     connect((QObject*) m_Controls->m_Tube, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationTube()));
     connect((QObject*) m_Controls->m_Color, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationColor()));
     connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
     connect((QObject*) m_Controls->m_Focus, SIGNAL(clicked()), (QObject*) this, SLOT(PlanarFigureFocus()));
     connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) ));
 
     connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor()));
 
     connect((QObject*) m_Controls->m_PFWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(PFWidth(int)));
     connect((QObject*) m_Controls->m_PFColor, SIGNAL(clicked()), (QObject*) this, SLOT(PFColor()));
 
     connect((QObject*) m_Controls->m_TDI, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateTdi()));
 
     connect((QObject*) m_Controls->m_LineWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(LineWidthChanged(int)));
     connect((QObject*) m_Controls->m_TubeRadius, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(TubeRadiusChanged(int)));
   }
 }
 
 void QmitkControlVisualizationPropertiesView::Activated()
 {
   berry::ISelection::ConstPointer sel(
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
   QmitkFunctionality::Activated();
 }
 
 void QmitkControlVisualizationPropertiesView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 int QmitkControlVisualizationPropertiesView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkControlVisualizationPropertiesView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return m_FoundSingleOdfImage ? 120 : 80;
   }
   else
   {
     return preferredResult;
   }
 }
 
 // set diffusion image channel to b0 volume
 void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
 {
   mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
   if (dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData()))
   {
     mitk::DiffusionImage<short>::Pointer dimg = dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData());
 
     // if there is no b0 image in the dataset, the GetB0Indices() returns a vector of size 0
     // and hence we cannot set the Property directly to .front()
     int displayChannelPropertyValue = 0;
     if( dimg->GetB0Indices().size() > 0)
       displayChannelPropertyValue = dimg->GetB0Indices().front();
 
     notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue );
   }
 }
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
 implement SelectionService Listener explicitly */
 void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
   // deactivate channel slider if no diffusion weighted image or tbss image is selected
   m_Controls->m_DisplayIndex->setVisible(false);
   m_Controls->m_DisplayIndexSpinBox->setVisible(false);
   m_Controls->label_channel->setVisible(false);
 
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::DataNode::Pointer node = *it;
 
     // check if node has data,
     // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
     mitk::BaseData* nodeData = node->GetData();
     if(nodeData == NULL)
       continue;
 
     if (node.IsNotNull() && (dynamic_cast<mitk::TbssImage*>(nodeData) ||
       dynamic_cast<mitk::DiffusionImage<short>*>(nodeData)))
     {
       m_Controls->m_DisplayIndex->setVisible(true);
       m_Controls->m_DisplayIndexSpinBox->setVisible(true);
       m_Controls->label_channel->setVisible(true);
     }
     else if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
     {
       if (m_Color.IsNotNull())
         m_Color->RemoveObserver(m_FiberBundleObserverTag);
 
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor );
       m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", NULL));
       if (m_Color.IsNotNull())
         m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command );
     }
   }
 
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::DataNode::Pointer node = *it;
 
     // check if node has data,
     // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
     mitk::BaseData* nodeData = node->GetData();
     if(nodeData == NULL)
       continue;
 
     if( node.IsNotNull() && (dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData)) )
     {
       if(m_NodeUsedForOdfVisualization.IsNotNull())
       {
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false);
       }
       m_NodeUsedForOdfVisualization = node;
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
       if(m_MultiWidget)
         m_MultiWidget->RequestUpdate();
 
       m_Controls->m_TSMenu->setVisible(false);  // deactivate mip etc. for tensor and q-ball images
       break;
     }
     else if( node.IsNotNull() && dynamic_cast<mitk::ConnectomicsNetwork*>(nodeData) )
       m_Controls->m_TSMenu->setVisible(false);
     else
       m_Controls->m_TSMenu->setVisible(true);
   }
 }
 
 mitk::DataStorage::SetOfObjects::Pointer
   QmitkControlVisualizationPropertiesView::ActiveSet(std::string classname)
 {
   if (m_CurrentSelection)
   {
     mitk::DataStorage::SetOfObjects::Pointer set =
       mitk::DataStorage::SetOfObjects::New();
 
     int at = 0;
     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
       i != m_CurrentSelection->End();
       ++i)
     {
 
       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
         // check if node has data,
         // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
         const mitk::BaseData* nodeData = node->GetData();
         if(nodeData == NULL)
           continue;
 
         if(QString(classname.c_str()).compare(nodeData->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     return set;
   }
 
   return 0;
 }
 
 void QmitkControlVisualizationPropertiesView::SetBoolProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, bool value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetBoolProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetIntProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, int value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetFloatProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, float value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetFloatProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetLevelWindowProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, mitk::LevelWindow value)
 {
   if(set.IsNotNull())
   {
 
     mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), prop);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetEnumProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, mitk::EnumerationProperty::Pointer value)
 {
   if(set.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 
 
 void QmitkControlVisualizationPropertiesView::DisplayIndexChanged(int dispIndex)
 {
 
   m_Controls->m_DisplayIndex->setValue(dispIndex);
   m_Controls->m_DisplayIndexSpinBox->setValue(dispIndex);
 
   QString label = "Channel %1";
   label = label.arg(dispIndex);
   m_Controls->label_channel->setText(label);
 
   std::vector<std::string> sets;
   sets.push_back("DiffusionImage");
   sets.push_back("TbssImage");
 
   std::vector<std::string>::iterator it = sets.begin();
   while(it != sets.end())
   {
     std::string s = *it;
     mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet(s);
 
     if(set.IsNotNull())
     {
 
       mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
       mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
       while ( itemiter != itemiterend )
       {
         (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
         ++itemiter;
       }
 
       //m_MultiWidget->RequestUpdate();
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     it++;
   }
 
 
 }
 
 void QmitkControlVisualizationPropertiesView::Reinit()
 {
   if (m_CurrentSelection)
   {
     mitk::DataNodeObject::Pointer nodeObj =
       m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
     mitk::DataNode::Pointer node = nodeObj->GetDataNode();
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
       mitk::RenderingManager::GetInstance()->InitializeViews(
         basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::TextIntON()
 {
   if(m_TexIsOn)
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
   }
   else
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("DiffusionImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("QBallImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("Image");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   m_TexIsOn = !m_TexIsOn;
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S()
 {
   m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
   VisibleOdfsON(0);
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
 {
   m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
   VisibleOdfsON(1);
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
 {
   m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
   VisibleOdfsON(2);
 }
 
 bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
 {
 
   // for all 2D renderwindows of m_MultiWidget check alignment
   mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D() );
   if (displayPlane.IsNull()) return false;
 
   mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
   if( currentImage == NULL )
   {
     MITK_ERROR << " Casting problems. Returning false";
     return false;
   }
 
   int affectedDimension(-1);
   int affectedSlice(-1);
   return !(DetermineAffectedImageSlice( currentImage, displayPlane, affectedDimension, affectedSlice ));
 
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON(int view)
 {
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
 {
   int maxNr = m_Controls->m_ShowMaxNumber->value();
   if ( maxNr < 1 )
   {
     m_Controls->m_ShowMaxNumber->setValue( 1 );
     maxNr = 1;
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   set = ActiveSet("TensorImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
 {
   typedef mitk::OdfNormalizationMethodProperty PropType;
   PropType::Pointer normMeth = PropType::New();
 
   switch(normDropdown)
   {
   case 0:
     normMeth->SetNormalizationToMinMax();
     break;
   case 1:
     normMeth->SetNormalizationToMax();
     break;
   case 2:
     normMeth->SetNormalizationToNone();
     break;
   case 3:
     normMeth->SetNormalizationToGlobalMax();
     break;
   default:
     normMeth->SetNormalizationToMinMax();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   //  if(m_MultiWidget)
   //    m_MultiWidget->RequestUpdate();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
 {
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
 {
 
   typedef mitk::OdfScaleByProperty PropType;
   PropType::Pointer scaleBy = PropType::New();
 
   switch(additionalScaling)
   {
   case 0:
     scaleBy->SetScaleByNothing();
     break;
   case 1:
     scaleBy->SetScaleByGFA();
     //m_Controls->params_frame->setVisible(true);
     break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
   case 2:
     scaleBy->SetScaleByPrincipalCurvature();
     // commented in for SPIE paper, Principle curvature scaling
     //m_Controls->params_frame->setVisible(true);
     break;
 #endif
   default:
     scaleBy->SetScaleByNothing();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::IndexParam1Changed(double param1)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkControlVisualizationPropertiesView::IndexParam2Changed(double param2)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkControlVisualizationPropertiesView::OpacityChanged(double l, double u)
 {
   mitk::LevelWindow olw;
   olw.SetRangeMinMax(l*255, u*255);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("TensorImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("Image");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingCheckbox()
 {
   m_Controls->m_ScalingFrame->setVisible(
     m_Controls->m_ScalingCheckbox->isChecked());
 
   if(!m_Controls->m_ScalingCheckbox->isChecked())
   {
     m_Controls->m_AdditionalScaling->setCurrentIndex(0);
     m_Controls->m_ScalingFactor->setValue(1.0);
   }
 }
 
 void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX()
 {
   if (m_SelectedNode)
   {
     bool currentMode;
     m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode);
     m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 
 }
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
 {
   if (m_SelectedNode)
   {
 
 
     float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1;
     m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
 {
   QString label = "Range %1";
   label = label.arg(value * 0.1);
   m_Controls->label_range->setText(label);
 
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationWire()
 {
   if(m_SelectedNode)
   {
     int width = m_Controls->m_LineWidth->value();
     m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(width));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(15));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(18));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(1));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(2));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(4));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationTube()
 {
   if(m_SelectedNode)
   {
     float radius = m_Controls->m_TubeRadius->value() / 100.0;
     m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(radius));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(17));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(13));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(16));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
 {
   float color[3];
   m_SelectedNode->GetColor(color);
   m_Controls->m_Color->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color[0]*255.0));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[1]*255.0));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[2]*255.0));
   styleSheet.append(")");
   m_Controls->m_Color->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color[0], color[1], color[2]));
   mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
   fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
   m_SelectedNode->Modified();
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationColor()
 {
   if(m_SelectedNode)
   {
     QColor color = QColorDialog::getColor();
     if (!color.isValid())
       return;
 
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(color.red()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.green()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.blue()));
     styleSheet.append(")");
     m_Controls->m_Color->setStyleSheet(styleSheet);
 
     m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
     mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
     fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
     m_SelectedNode->Modified();
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
 {
   if(m_SelectedNode)
   {
     MITK_INFO << "reset colorcoding to oBased";
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(255,255,255)";
     m_Controls->m_Color->setStyleSheet(styleSheet);
     //    m_SelectedNode->SetProperty("color",NULL);
     m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(1.0, 1.0, 1.0));
 
     mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
     fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED);
     fib->DoColorCodingOrientationBased();
     m_SelectedNode->Modified();
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
 {
   if(m_SelectedNode)
   {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
 
     if (_PlanarFigure && _PlanarFigure->GetGeometry2D())
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       QmitkRenderWindow* RenderWindow1 =
         this->GetActiveStdMultiWidget()->GetRenderWindow1();
 
       if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
         PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow1;
       }
 
       QmitkRenderWindow* RenderWindow2 =
         this->GetActiveStdMultiWidget()->GetRenderWindow2();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
         RenderWindow2->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow2;
       }
 
       QmitkRenderWindow* RenderWindow3 =
         this->GetActiveStdMultiWidget()->GetRenderWindow3();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
         RenderWindow3->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow3;
       }
 
       QmitkRenderWindow* RenderWindow4 =
         this->GetActiveStdMultiWidget()->GetRenderWindow4();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
         RenderWindow4->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow4;
       }
 
       const mitk::PlaneGeometry
         * _PlaneGeometry =
         dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
 
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry1 =
         RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane1 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry2 =
         RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane2 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry3 =
         RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane3 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
       mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
       normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
       normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
       normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
       normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
       double ang1 = angle(normal, normal1);
       double ang2 = angle(normal, normal2);
       double ang3 = angle(normal, normal3);
 
       if(ang1 < ang2 && ang1 < ang3)
       {
         selectedRenderWindow = RenderWindow1;
       }
       else
       {
         if(ang2 < ang3)
         {
           selectedRenderWindow = RenderWindow2;
         }
         else
         {
           selectedRenderWindow = RenderWindow3;
         }
       }
 
       // make node visible
       if (selectedRenderWindow)
       {
         const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
           centerP, _PlaneGeometry->GetNormal());
       }
     }
 
     // set interactor for new node (if not already set)
     mitk::PlanarFigureInteractor::Pointer figureInteractor
-        = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor());
+        = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
 
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( m_SelectedNode );
     }
 
     m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetInteractor()
 {
   typedef std::vector<mitk::DataNode*> Container;
   Container _NodeSet = this->GetDataManagerSelection();
   mitk::DataNode* node = 0;
   mitk::FiberBundleX* bundle = 0;
   mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
 
   // finally add all nodes to the model
   for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
     ; it++)
   {
     node = const_cast<mitk::DataNode*>(*it);
     bundle = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
 
     if(bundle)
     {
       bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
 
       if(bundleInteractor.IsNotNull())
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
 
       if(!m_Controls->m_Crosshair->isChecked())
       {
         m_Controls->m_Crosshair->setChecked(false);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
         m_CurrentPickingNode = 0;
       }
       else
       {
         m_Controls->m_Crosshair->setChecked(true);
         bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
         mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
         m_CurrentPickingNode = node;
       }
 
     }
   }
 
 }
 
 void QmitkControlVisualizationPropertiesView::PFWidth(int w)
 {
 
   double width = w/10.0;
   m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QString label = "Width %1";
   label = label.arg(width);
   m_Controls->label_pfwidth->setText(label);
 
 }
 
 void QmitkControlVisualizationPropertiesView::PFColor()
 {
 
   QColor color = QColorDialog::getColor();
   if (!color.isValid())
     return;
 
   m_Controls->m_PFColor->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.blue()));
   styleSheet.append(")");
   m_Controls->m_PFColor->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::GenerateTdi()
 {
   if(m_SelectedNode)
   {
     mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
     if(!bundle)
       return;
 
     typedef float OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
 
     // run generator
     itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
     generator->SetFiberBundle(bundle);
     generator->SetOutputAbsoluteValues(true);
     generator->SetUpsamplingFactor(1);
     generator->Update();
 
     // get result
     OutImageType::Pointer outImg = generator->GetOutput();
 
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // to datastorage
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     QString name(m_SelectedNode->GetName().c_str());
     name += "_TDI";
     node->SetName(name.toStdString());
     node->SetVisibility(true);
 
     GetDataStorage()->Add(node);
   }
 }
 
 void QmitkControlVisualizationPropertiesView::LineWidthChanged(int w)
 {
   QString label = "Width %1";
   label = label.arg(w);
   m_Controls->label_linewidth->setText(label);
   BundleRepresentationWire();
 }
 
 void QmitkControlVisualizationPropertiesView::TubeRadiusChanged(int r)
 {
   QString label = "Radius %1";
   label = label.arg(r / 100.0);
   m_Controls->label_tuberadius->setText(label);
   this->BundleRepresentationTube();
 }
 
 void QmitkControlVisualizationPropertiesView::Welcome()
 {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
     GetSite()->GetWorkbenchWindow(), false);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
index 6e60b6e3a2..4c80a721b4 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
@@ -1,1816 +1,1816 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 //=========FOR TESTING==========
 //random generation, number of points equal requested points
 
 
 
 // Blueberry application and interaction service
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberBundleDeveloperView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QTimer>
 
 // MITK
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkGlobalInteraction.h>
 
 //===needed when timeSlicedGeometry is null to invoke rendering mechansims ====
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 
 #include "mitkModuleRegistry.h"
 
 
 // VTK
 #include <vtkPointSource.h> //for randomized FiberStructure
 #include <vtkPolyLine.h>  //for fiberStructure
 #include <vtkCellArray.h> //for fiberStructure
 #include <vtkMatrix4x4.h> //for geometry
 
 //ITK
 #include <itkTimeProbe.h>
 
 //==============================================
 //======== W O R K E R S ____ S T A R T ========
 //==============================================
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --generate FiberIDs--*/
 
 QmitkFiberIDWorker::QmitkFiberIDWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberIDWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
    * accurate time measurement using ITK timeProbe*/
     itk::TimeProbe clock;
     clock.Start();
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     m_itemPackage.st_FBX->GenerateFiberIds();
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * -- extract fibers by given PlanarFigure --*/
 QmitkFiberExtractorWorker::QmitkFiberExtractorWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberExtractorWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
    * accurate time measurement using ITK timeProbe*/
     itk::TimeProbe clock;
     clock.Start();
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerExtractFibers->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     std::vector<long> fibIds = m_itemPackage.st_FBX->ExtractFiberIdSubset(m_itemPackage.st_PlanarFigure);
 
     //generate new fiberbundle by fiber iDs
     vtkSmartPointer<vtkPolyData> newFBPolyData = m_itemPackage.st_FBX->GeneratePolyDataByIds(fibIds);
 
     // call function to convert fiberstructure into fiberbundleX and pass it to datastorage
     (m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(newFBPolyData);
 
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerExtractFibers->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --set FA values to fiberbundle--*/
 QmitkFiberColoringWorker::QmitkFiberColoringWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage)
     , m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberColoringWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
    * accurate time measurement using ITK timeProbe*/
     itk::TimeProbe clock;
     clock.Start();
 
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerColorCoding->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     if(m_itemPackage.st_Controls->radioButton_ColorOrient->isChecked()) {
         m_itemPackage.st_FBX->DoColorCodingOrientationBased();
 
     } else if(m_itemPackage.st_Controls->radioButton_ColorFA->isChecked()) {
         m_itemPackage.st_FBX->DoColorCodingFaBased();
 
     } else if(m_itemPackage.st_Controls->radioButton_OpacityFA->isChecked()) {
         //        m_itemPackage.st_FBX->SetColorCoding("");
         m_itemPackage.st_PassedDataNode->SetOpacity(0.999);
         m_itemPackage.st_FBX->DoUseFaFiberOpacity();
     } else if(m_itemPackage.st_Controls->radioButton_ColorCustom->isChecked()){
         m_itemPackage.st_FBX->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
     }
 
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerColorCoding->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 
 QmitkFiberFeederFAWorker::QmitkFiberFeederFAWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberFeederFAWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS
      * accurate time measurement using ITK timeProbe */
     itk::TimeProbe clock;
     clock.Start();
     //set GUI representation of timer to 0, is essential for correct timer incrementation
     m_itemPackage.st_Controls->infoTimerSetFA->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing
     mitk::Image::Pointer FAImg = dynamic_cast<mitk::Image*>(m_itemPackage.st_PassedDataNode->GetData());
     if(FAImg.IsNotNull())
         m_itemPackage.st_FBX->SetFAMap(FAImg);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     clock.Stop();
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerSetFA->setText( QString::number(clock.GetTotal()) );
 
     disconnect(m_itemPackage.st_FancyGUITimer1);
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --generate random fibers--*/
 QmitkFiberGenerateRandomWorker::QmitkFiberGenerateRandomWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
     : m_itemPackage(itemPackage),
       m_hostingThread(hostingThread)
 {
 
 }
 void QmitkFiberGenerateRandomWorker::run()
 {
     if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
         m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS */
     //MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
     m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText(QString::number(0));
     m_itemPackage.st_FancyGUITimer1->start();
 
     //do processing, generateRandomFibers
     int numOfFibers = m_itemPackage.st_Controls->boxFiberNumbers->value();
     int distrRadius = m_itemPackage.st_Controls->boxDistributionRadius->value();
     int numOfPoints = numOfFibers * distrRadius;
 
     std::vector< std::vector<int> > fiberStorage;
     for (int i=0; i<numOfFibers; ++i) {
         std::vector<int> a;
         fiberStorage.push_back( a );
     }
 
     /* Generate Point Cloud */
     vtkSmartPointer<vtkPointSource> randomPoints = vtkSmartPointer<vtkPointSource>::New();
     randomPoints->SetCenter(0.0, 0.0, 0.0);
     randomPoints->SetNumberOfPoints(numOfPoints);
     randomPoints->SetRadius(distrRadius);
     randomPoints->Update();
     vtkPoints* pnts = randomPoints->GetOutput()->GetPoints();
 
     /* ASSIGN EACH POINT TO A RANDOM FIBER */
     srand((unsigned)time(0)); // init randomizer
     for (int i=0; i<pnts->GetNumberOfPoints(); ++i) {
 
         //generate random number between 0 and numOfFibers-1
         int random_integer;
         random_integer = (rand()%numOfFibers);
 
         //add current point to random fiber
         fiberStorage.at(random_integer).push_back(i);
         //    MITK_INFO << "point" << i << " |" << pnts->GetPoint(random_integer)[0] << "|" << pnts->GetPoint(random_integer)[1]<< "|" << pnts->GetPoint(random_integer)[2] << "| into fiber" << random_integer;
     }
 
     // initialize accurate time measurement
     itk::TimeProbe clock;
     clock.Start();
 
     /* GENERATE VTK POLYLINES OUT OF FIBERSTORAGE */
     vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New(); // Host vtkPolyLines
     linesCell->Allocate(pnts->GetNumberOfPoints()*2); //allocate for each cellindex also space for the pointId, e.g. [idx | pntID]
     for (long i=0; i<fiberStorage.size(); ++i)
     {
         std::vector<int> singleFiber = fiberStorage.at(i);
         vtkSmartPointer<vtkPolyLine> fiber = vtkSmartPointer<vtkPolyLine>::New();
         fiber->GetPointIds()->SetNumberOfIds((int)singleFiber.size());
 
         for (long si=0; si<singleFiber.size(); ++si)
         {  //hopefully long to double works fine in VTK ;-)
             fiber->GetPointIds()->SetId( si, singleFiber.at(si) );
         }
 
         linesCell->InsertNextCell(fiber);
     }
 
     /* checkpoint for cellarray allocation */
     if ( (linesCell->GetSize()/pnts->GetNumberOfPoints()) != 2 ) //e.g. size: 12, number of points:6 .... each cell hosts point ids (6 ids) + cell index for each idPoint. 6 * 2 = 12
     {
         MITK_INFO << "RANDOM FIBER ALLOCATION CAN NOT BE TRUSTED ANYMORE! Correct leak or remove command: linesCell->Allocate(pnts->GetNumberOfPoints()*2) but be aware of possible loss in performance.";
     }
 
     /* HOSTING POLYDATA FOR RANDOM FIBERSTRUCTURE */
     vtkSmartPointer<vtkPolyData> PDRandom = vtkSmartPointer<vtkPolyData>::New(); //could also be a standard pointer instead of smartpointer cuz ther is no need to delete because data is managed in datastorage.
     PDRandom->SetPoints(pnts);
     PDRandom->SetLines(linesCell);
 
     // accurate timer measurement stop
     clock.Stop();
     //MITK_INFO << "=====Assambling random Fibers to Polydata======\nMean: " << clock.GetMean() << " Total: " << clock.GetTotal() << std::endl;
 
     // call function to convert fiberstructure into fiberbundleX and pass it to datastorage
     (m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(PDRandom);
 
     /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
     m_itemPackage.st_FancyGUITimer1->stop();
     m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText( QString::number(clock.GetTotal()) );
     delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
     m_hostingThread->quit();
 
 }
 
 
 /*===================================================================================
  * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
  * --update GUI elements of thread monitor--
  * implementation not thread safe, not needed so far because
  * there exists only 1 thread for fiberprocessing
  * for threadsafety, you need to implement checking mechanisms in methods "::threadFor...." */
 QmitkFiberThreadMonitorWorker::QmitkFiberThreadMonitorWorker( QThread* hostingThread, Package4WorkingThread itemPackage )
     : m_itemPackage(itemPackage)
     , m_hostingThread(hostingThread)
     , m_pixelstepper(10) //for next rendering call, move object 10px
     , m_steppingDistance(220) //use only a multiple value of pixelstepper, x-axis border for fancy stuff
 {
 
 
     //set timers
     m_thtimer_initMonitor = new QTimer;
     m_thtimer_initMonitor->setInterval(10);
 
     m_thtimer_initMonitorSetFinalPosition = new QTimer;
     m_thtimer_initMonitorSetFinalPosition->setInterval(10);
 
     m_thtimer_initMonitorSetMasks = new QTimer;
     m_thtimer_initMonitorSetFinalPosition->setInterval(10);
 
 
     m_thtimer_threadStarted  = new QTimer;
     m_thtimer_threadStarted->setInterval(50);
 
     m_thtimer_threadFinished = new QTimer;
     m_thtimer_threadFinished->setInterval(50);
 
     m_thtimer_threadTerminated = new QTimer;
     m_thtimer_threadTerminated->setInterval(50);
 
 
 
     connect (m_thtimer_initMonitor, SIGNAL( timeout()), this, SLOT( fancyMonitorInitialization() ) );
     connect ( m_thtimer_initMonitorSetFinalPosition, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationFinalPos() ) );
     connect ( m_thtimer_initMonitorSetMasks, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationMask() ) );
 
     connect (m_thtimer_threadStarted, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadStarted() ) );
     connect (m_thtimer_threadFinished, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadFinished() ) );
     connect (m_thtimer_threadTerminated, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadTerminated() ) );
 
     //first, the current text shall turn transparent
     m_decreaseOpacity_threadStarted = true;
     m_decreaseOpacity_threadFinished = true;
     m_decreaseOpacity_threadTerminated = true;
 
 
 
 
 }
 void QmitkFiberThreadMonitorWorker::run()
 {
 
 }
 
 void QmitkFiberThreadMonitorWorker::initializeMonitor()
 {
     //fancy configuration of animation start
     mitk::Point2D pntOpen;
     pntOpen[0] = 118;
     pntOpen[1] = 10;
 
     mitk::Point2D headPos;
     headPos[0] = 19;
     headPos[1] = 10;
 
     mitk::Point2D statusPos;
     statusPos[0] = 105;
     statusPos[1] = 23;
 
     mitk::Point2D startedPos;
     startedPos[0] = 68;
     startedPos[1] = 10;
 
     mitk::Point2D finishedPos;
     finishedPos[0] = 143;
     finishedPos[1] = 10;
 
     mitk::Point2D terminatedPos;
     terminatedPos[0] = 240;
     terminatedPos[1] = 10;
 
     m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntOpen);
     m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
     m_itemPackage.st_FBX_Monitor->setHeadingPosition(headPos);
     m_itemPackage.st_FBX_Monitor->setMaskPosition(headPos);
     m_itemPackage.st_FBX_Monitor->setStatusPosition(statusPos);
     m_itemPackage.st_FBX_Monitor->setStartedPosition(startedPos);
     m_itemPackage.st_FBX_Monitor->setFinishedPosition(finishedPos);
     m_itemPackage.st_FBX_Monitor->setTerminatedPosition(terminatedPos);
 
 
     m_thtimer_initMonitor->start();
 }
 
 void QmitkFiberThreadMonitorWorker::setThreadStatus(QString status)
 {
     m_itemPackage.st_FBX_Monitor->setStatus(status);
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 }
 
 /* Methods to set status of running threads
  * Following three methods are usually called
  - before a thread starts and
  - a thread is finished or terminated */
 void QmitkFiberThreadMonitorWorker::threadForFiberProcessingStarted()
 {
     if(!m_thtimer_threadStarted->isActive())  {
         m_thtimer_threadStarted->start();
     } else {
         //fast change without fancy stuff, needed to keep threaddebugger info up to date
         int counter = m_itemPackage.st_FBX_Monitor->getStarted();
         m_itemPackage.st_FBX_Monitor->setStarted(++counter);
 
     }
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::threadForFiberProcessingFinished()
 {
     if(!m_thtimer_threadFinished->isActive())  {
         m_thtimer_threadFinished->start();
     } else {
         //fast change without fancy stuff
         int counter = m_itemPackage.st_FBX_Monitor->getFinished();
         m_itemPackage.st_FBX_Monitor->setFinished(++counter);
 
     }
 
 }
 
 void QmitkFiberThreadMonitorWorker::threadForFiberProcessingTerminated()
 {
     if(!m_thtimer_threadTerminated->isActive())  {
         m_thtimer_threadTerminated->start();
     } else {
         //fast change without fancy stuff
         int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
         m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
 
     }
 
 }
 
 
 /* Helper methods for fancy fading efx for thread monitor */
 void QmitkFiberThreadMonitorWorker::fancyTextFading_threadStarted()
 {
 
     if (m_decreaseOpacity_threadStarted) {
         int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
         m_itemPackage.st_FBX_Monitor->setStartedOpacity( --startedOpacity );
 
         if (startedOpacity == 0) {
             int counter = m_itemPackage.st_FBX_Monitor->getStarted();
             m_itemPackage.st_FBX_Monitor->setStarted(++counter);
             m_decreaseOpacity_threadStarted = false;
         }
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     } else {
 
         int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
         m_itemPackage.st_FBX_Monitor->setStartedOpacity( ++startedOpacity );
 
         if (startedOpacity >= 10) {
             m_thtimer_threadStarted->stop();
             m_decreaseOpacity_threadStarted = true; //set back to true, cuz next iteration shall decrease opacity as well
         }
 
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     }
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyTextFading_threadFinished()
 {
     if (m_decreaseOpacity_threadFinished) {
         int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
         m_itemPackage.st_FBX_Monitor->setFinishedOpacity( --finishedOpacity );
 
         if (finishedOpacity == 0) {
             int counter = m_itemPackage.st_FBX_Monitor->getFinished();
             m_itemPackage.st_FBX_Monitor->setFinished(++counter);
             m_decreaseOpacity_threadFinished = false;
         }
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     } else {
 
         int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
         m_itemPackage.st_FBX_Monitor->setFinishedOpacity( ++finishedOpacity );
 
         if (finishedOpacity >= 10) {
             m_thtimer_threadFinished->stop();
             m_decreaseOpacity_threadFinished = true; //set back to true, cuz next iteration shall decrease opacity as well
         }
 
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     }
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyTextFading_threadTerminated()
 {
     if (m_decreaseOpacity_threadTerminated) {
         int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
         m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( --terminatedOpacity );
 
         if (terminatedOpacity == 0) {
             int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
             m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
             m_decreaseOpacity_threadTerminated = false;
         }
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     } else {
 
         int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
         m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( ++terminatedOpacity );
 
         if (terminatedOpacity >= 10) {
             m_thtimer_threadTerminated->stop();
             m_decreaseOpacity_threadTerminated = true; //set back to true, cuz next iteration shall decrease opacity as well
         }
 
         m_itemPackage.st_ThreadMonitorDataNode->Modified();
         m_itemPackage.st_MultiWidget->RequestUpdate();
 
     }
 
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyMonitorInitialization()
 {
 
     mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition(); //possible bottleneck, set pntClose to member
     mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition(); //possible bottleneck, set pntClose to member
 
     pntClose[0] += m_pixelstepper;
     pntOpen[0] -= m_pixelstepper;
     //MITK_INFO << pntClose[0] << " " << pntOpen[0];
 
     m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
     m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
 
     int opacity = m_itemPackage.st_FBX_Monitor->getHeadingOpacity() + 1;
     if (opacity > 10)
         opacity = 10;
     m_itemPackage.st_FBX_Monitor->setHeadingOpacity(opacity);
 
 
     if (pntClose[0] >= m_steppingDistance)
     {
         if (m_itemPackage.st_FBX_Monitor->getHeadingOpacity() != 10 )
         {
             m_itemPackage.st_FBX_Monitor->setHeadingOpacity(10);
             m_itemPackage.st_ThreadMonitorDataNode->Modified();
             m_itemPackage.st_MultiWidget->RequestUpdate();
         }
 
         m_thtimer_initMonitor->stop();
 
         //position them to obt y=25
         m_thtimer_initMonitorSetFinalPosition->start();
     }
 
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationFinalPos()
 {
     //get y pos of
     mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition();
     mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition();
     mitk::Point2D pntHead = m_itemPackage.st_FBX_Monitor->getHeadingPosition();
 
     pntClose[1] += 5;
     pntOpen[1] += 5;
     pntHead[1] += 5;
 
     m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
     m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
     m_itemPackage.st_FBX_Monitor->setHeadingPosition(pntHead);
 
 
     if (pntClose[1] >= 35) { //35 = y position
         m_thtimer_initMonitorSetFinalPosition->stop();
         //now init mask of labels
         m_thtimer_initMonitorSetMasks->start();
     }
 
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationMask()
 {
     //increase opacity
     int opacity = m_itemPackage.st_FBX_Monitor->getMaskOpacity();
     opacity++;
     m_itemPackage.st_FBX_Monitor->setMaskOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setStartedOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setFinishedOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setTerminatedOpacity(opacity);
     m_itemPackage.st_FBX_Monitor->setStatusOpacity(opacity);
 
     if (opacity >=10) {
         m_thtimer_initMonitorSetMasks->stop();
     }
 
     m_itemPackage.st_ThreadMonitorDataNode->Modified();
     m_itemPackage.st_MultiWidget->RequestUpdate();
 
 }
 
 //==============================================
 //======== W O R K E R S ________ E N D ========
 //==============================================
 
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //                   HERE STARTS THE ACTUAL FIBERBUNDLE DEVELOPER VIEW IMPLEMENTATION
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 //========#########################===============###########################=====================#########################
 
 
 
 const std::string QmitkFiberBundleDeveloperView::VIEW_ID = "org.mitk.views.fiberbundledeveloper";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 
 QmitkFiberBundleDeveloperView::QmitkFiberBundleDeveloperView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_FiberIDGenerator( NULL)
     , m_GeneratorFibersRandom( NULL )
     , m_FiberFeederFASlave( NULL )
     , m_FiberColoringSlave(NULL)
     , m_FiberExtractor(NULL)
     , m_fiberMonitorIsOn( false )
     , m_CircleCounter( 0 )
     , m_suppressSignal(false)
 {
     m_hostThread = new QThread;
     m_threadInProgress = false;
 
 }
 
 // Destructor
 QmitkFiberBundleDeveloperView::~QmitkFiberBundleDeveloperView()
 {
     //m_FiberBundleX->Delete(); using weakPointer, therefore no delete necessary
     delete m_hostThread;
 }
 
 
 void QmitkFiberBundleDeveloperView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done in QtDesigner, etc.
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberBundleDeveloperViewControls;
         m_Controls->setupUi( parent );
 
         /*=========INITIALIZE BUTTON CONFIGURATION ================*/
         m_Controls->radioButton_directionX->setEnabled(false);
         m_Controls->radioButton_directionY->setEnabled(false);
         m_Controls->radioButton_directionZ->setEnabled(false);
         m_Controls->buttonGenerateFiberIds->setEnabled(false);
         m_Controls->buttonGenerateFibers->setEnabled(true);
         m_Controls->buttonColorFibers->setEnabled(false);
         m_Controls->ddAvailableColorcodings->setEnabled(false);
         m_Controls->buttonExtractFibers->setEnabled(false);
         m_Controls->button_FAMap->setEnabled(true);
 
         m_Controls->buttonSMFibers->setEnabled(false);//not yet implemented
         m_Controls->buttonVtkDecimatePro->setEnabled(false);//not yet implemented
         m_Controls->buttonVtkSmoothPD->setEnabled(false);//not yet implemented
         m_Controls->buttonGenerateTubes->setEnabled(false);//not yet implemented
 
 
         connect( m_Controls->buttonGenerateFibers, SIGNAL(clicked()), this, SLOT(DoGenerateFibers()) );
         connect( m_Controls->buttonGenerateFiberIds, SIGNAL(clicked()), this, SLOT(DoGenerateFiberIDs()) );
         connect( m_Controls->button_FAMapExecute, SIGNAL(clicked()), this, SLOT(DoSetFAValues()) );
         connect( m_Controls->button_FAMap, SIGNAL(clicked()), this, SLOT(DoSetFAMap()) );
         connect( m_Controls->buttonExtractFibers, SIGNAL(clicked()), this, SLOT(DoExtractFibers()) );
         connect( m_Controls->radioButton_directionRandom, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->radioButton_directionX, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->radioButton_directionY, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->radioButton_directionZ, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
         connect( m_Controls->toolBox, SIGNAL(currentChanged ( int ) ), this, SLOT(SelectionChangedToolBox(int)) );
 
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( ActionDrawEllipseTriggered() ) );
         connect( m_Controls->buttonColorFibers, SIGNAL(clicked()), this, SLOT(DoColorFibers()) );
         //        connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
         connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
 
         connect( m_Controls->checkBoxMonitorFiberThreads, SIGNAL(stateChanged(int)), this, SLOT(DoMonitorFiberThreads(int)) );
 
 
 
     }
 
     //  Checkpoint for fiber ORIENTATION
     if ( m_DirectionRadios.empty() )
     {
         m_DirectionRadios.insert(0, m_Controls->radioButton_directionRandom);
         m_DirectionRadios.insert(1, m_Controls->radioButton_directionX);
         m_DirectionRadios.insert(2, m_Controls->radioButton_directionY);
         m_DirectionRadios.insert(3, m_Controls->radioButton_directionZ);
     }
 
     // set GUI elements of FiberGenerator to according configuration
     DoUpdateGenerateFibersWidget();
 
 
 }
 /* THIS METHOD UPDATES ALL GUI ELEMENTS OF QGroupBox DEPENDING ON CURRENTLY SELECTED
  * RADIO BUTTONS
  */
 void QmitkFiberBundleDeveloperView::DoUpdateGenerateFibersWidget()
 {
     //get selected radioButton
     QString fibDirection; //stores the object_name of selected radiobutton
     QVector<QRadioButton*>::const_iterator i;
     for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
     {
         QRadioButton* rdbtn = *i;
         if (rdbtn->isChecked())
             fibDirection = rdbtn->objectName();
     }
 
     if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
         // disable radiobuttons
         if (m_Controls->boxFiberMinLength->isEnabled())
             m_Controls->boxFiberMinLength->setEnabled(false);
 
         if (m_Controls->labelFiberMinLength->isEnabled())
             m_Controls->labelFiberMinLength->setEnabled(false);
 
         if (m_Controls->boxFiberMaxLength->isEnabled())
             m_Controls->boxFiberMaxLength->setEnabled(false);
 
         if (m_Controls->labelFiberMaxLength->isEnabled())
             m_Controls->labelFiberMaxLength->setEnabled(false);
 
         //enable radiobuttons
         if (!m_Controls->labelFibersTotal->isEnabled())
             m_Controls->labelFibersTotal->setEnabled(true);
 
         if (!m_Controls->boxFiberNumbers->isEnabled())
             m_Controls->boxFiberNumbers->setEnabled(true);
 
         if (!m_Controls->labelDistrRadius->isEnabled())
             m_Controls->labelDistrRadius->setEnabled(true);
 
         if (!m_Controls->boxDistributionRadius->isEnabled())
             m_Controls->boxDistributionRadius->setEnabled(true);
 
 
     } else {
         // disable radiobuttons
         if (m_Controls->labelDistrRadius->isEnabled())
             m_Controls->labelDistrRadius->setEnabled(false);
 
         if (m_Controls->boxDistributionRadius->isEnabled())
             m_Controls->boxDistributionRadius->setEnabled(false);
 
 
         //enable radiobuttons
         if (!m_Controls->labelFibersTotal->isEnabled())
             m_Controls->labelFibersTotal->setEnabled(true);
 
         if (!m_Controls->boxFiberNumbers->isEnabled())
             m_Controls->boxFiberNumbers->setEnabled(true);
 
         if (!m_Controls->boxFiberMinLength->isEnabled())
             m_Controls->boxFiberMinLength->setEnabled(true);
 
         if (!m_Controls->labelFiberMinLength->isEnabled())
             m_Controls->labelFiberMinLength->setEnabled(true);
 
         if (!m_Controls->boxFiberMaxLength->isEnabled())
             m_Controls->boxFiberMaxLength->setEnabled(true);
 
         if (!m_Controls->labelFiberMaxLength->isEnabled())
             m_Controls->labelFiberMaxLength->setEnabled(true);
 
     }
 
 }
 
 void QmitkFiberBundleDeveloperView::DoGenerateFibers()
 {
 
     // GET SELECTED FIBER DIRECTION
     QString fibDirection; //stores the object_name of selected radiobutton
     QVector<QRadioButton*>::const_iterator i;
     for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
     {
         QRadioButton* rdbtn = *i;
         if (rdbtn->isChecked())
             fibDirection = rdbtn->objectName();
     }
 
     //  vtkPolyData* output; // FiberPD stores the generated PolyData... going to be generated in thread
     if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
         //    build polydata with random lines and fibers
         //    output =
         GenerateVtkFibersRandom();
 
     } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_X ) {
         //    build polydata with XDirection fibers
         //output = GenerateVtkFibersDirectionX();
 
     } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Y ) {
         //    build polydata with YDirection fibers
         // output = GenerateVtkFibersDirectionY();
 
     } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Z ) {
         //    build polydata with ZDirection fibers
         //  output = GenerateVtkFibersDirectionZ();
 
     }
 
 
 }
 
 void QmitkFiberBundleDeveloperView::DoExtractFibers()
 {
 
     /* ===== TIMER CONFIGURATIONS for visual effect ======
    * start and stop is called in Thread */
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateExtractFibersTimer()) );
 
     struct Package4WorkingThread ItemPackageForExtractor;
     ItemPackageForExtractor.st_FBX = m_FiberBundleX;
     ItemPackageForExtractor.st_Controls = m_Controls;
     ItemPackageForExtractor.st_FancyGUITimer1 = localTimer;
     ItemPackageForExtractor.st_host = this; //needed to access method "PutFibersToDataStorage()"
     ItemPackageForExtractor.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
     ItemPackageForExtractor.st_PlanarFigure = m_PlanarFigure;
 
     //set element for thread monitoring
     if (m_fiberMonitorIsOn)
         ItemPackageForExtractor.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_FiberExtractor = new QmitkFiberExtractorWorker(m_hostThread, ItemPackageForExtractor);
     m_FiberExtractor->moveToThread(m_hostThread);
 
     //connections
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberExtraction() ));
     connect(m_hostThread, SIGNAL(started()), m_FiberExtractor, SLOT( run() ));
     connect(m_hostThread, SIGNAL(finished()), this, SLOT( AfterThread_FiberExtraction() ));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT( AfterThread_FiberExtraction() ));
 
     m_hostThread->start(QThread::HighestPriority) ;
 }
 
 void QmitkFiberBundleDeveloperView::UpdateExtractFibersTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric! shall be done in beforeThreadstarted()
     QString crntValue = m_Controls->infoTimerExtractFibers->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerExtractFibers->setText(QString::number(++tmpVal));
     m_Controls->infoTimerExtractFibers->update();
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_FiberExtraction()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
         //m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_FiberExtraction()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     //    disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
 
     //    m_FiberExtractor->disconnect();
     delete m_FiberExtractor;
 
     m_FiberBundleNode->Modified();
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkFiberBundleDeveloperView::PutFibersToDataStorage( vtkSmartPointer<vtkPolyData> threadOutput)
 {
 
     MITK_INFO << "lines: " << threadOutput->GetNumberOfLines() << "pnts: " << threadOutput->GetNumberOfPoints();
     //qthread mutex lock
     mitk::FiberBundleX::Pointer FB = mitk::FiberBundleX::New(threadOutput);
     mitk::DataNode::Pointer FBNode;
     FBNode = mitk::DataNode::New();
     FBNode->SetName("FiberBundleX");
     FBNode->SetData(FB);
     FBNode->SetVisibility(true);
     FBNode->SetOpacity(1.0);
 
     GetDataStorage()->Add(FBNode);
     FBNode->Modified();
 
     const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
     if (tsgeo == NULL) {
         /* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
         // get all nodes that have not set "includeInBoundingBox" to false
         mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
                                                                                                             , mitk::BoolProperty::New(false)));
         mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
         // calculate bounding geometry of these nodes
         mitk::TimeSlicedGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
         // initialize the views to the bounding geometry
         mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 
     } else {
 
         GetDataStorage()->Modified();
         m_MultiWidget->RequestUpdate(); //necessary??
     }
 
     //qthread mutex unlock
 }
 
 void QmitkFiberBundleDeveloperView::PutFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name)
 {
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
 
 
 
     std::vector<mitk::DataNode*> selectedNodes = GetDataManagerSelection();
     for(unsigned int i = 0; i < selectedNodes.size(); i++)
     {
         selectedNodes[i]->SetSelected(false);
     }
 
     newNode->SetSelected(true);
 
     newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,0.0,0.0));
     newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(2.0));
     newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true));
 
     newNode->AddProperty( "selected", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(false) );
     newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
 
     newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(3.0) );
     newNode->AddProperty( "planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.helperline.width", mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
     newNode->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(0.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0)  );
     newNode->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(2.0));
     newNode->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(2.0));
 
     // figure drawn on the topmost layer / image
     this->GetDataStorage()->Add(newNode);
 }
 
 /*
  * Generate polydata of random fibers
  */
 void QmitkFiberBundleDeveloperView::GenerateVtkFibersRandom()
 {
 
     /* ===== TIMER CONFIGURATIONS for visual effect ======
    * start and stop is called in Thread */
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateGenerateRandomFibersTimer()) );
 
     struct Package4WorkingThread ItemPackageForRandomGenerator;
     ItemPackageForRandomGenerator.st_FBX = m_FiberBundleX;
     ItemPackageForRandomGenerator.st_Controls = m_Controls;
     ItemPackageForRandomGenerator.st_FancyGUITimer1 = localTimer;
     ItemPackageForRandomGenerator.st_host = this; //needed to access method "PutFibersToDataStorage()"
     ItemPackageForRandomGenerator.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
 
     //set element for thread monitoring
     if (m_fiberMonitorIsOn)
         ItemPackageForRandomGenerator.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_GeneratorFibersRandom = new QmitkFiberGenerateRandomWorker(m_hostThread, ItemPackageForRandomGenerator);
     m_GeneratorFibersRandom->moveToThread(m_hostThread);
 
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_GenerateFibersRandom()) );
     connect(m_hostThread, SIGNAL(started()), m_GeneratorFibersRandom, SLOT(run()) );
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_GenerateFibersRandom()) );
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_GenerateFibersRandom()) );
 
     m_hostThread->start(QThread::LowestPriority);
 
 }
 
 void QmitkFiberBundleDeveloperView::UpdateColorFibersTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric!
     QString crntValue = m_Controls->infoTimerColorCoding->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerColorCoding->setText(QString::number(++tmpVal));
     m_Controls->infoTimerColorCoding->update();
 }
 
 void QmitkFiberBundleDeveloperView::UpdateGenerateRandomFibersTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric!
     QString crntValue = m_Controls->infoTimerGenerateFiberBundle->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerGenerateFiberBundle->setText(QString::number(++tmpVal));
     m_Controls->infoTimerGenerateFiberBundle->update();
 
 }
 
 void QmitkFiberBundleDeveloperView::UpdateSetFAValuesTimer()
 {
     // Make sure that thread has set according info-label to number! here we do not check if value is numeric!
     QString crntValue = m_Controls->infoTimerSetFA->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerSetFA->setText(QString::number(++tmpVal));
     m_Controls->infoTimerSetFA->update();
 
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_GenerateFibersRandom()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
         //m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_GenerateFibersRandom()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     //    disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     delete m_GeneratorFibersRandom;
 
 
 }
 
 vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionX()
 {
     int numOfFibers = m_Controls->boxFiberNumbers->value();
     vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
 
     //insert Origin point, this point has index 0 in point array
     double originX = 0.0;
     double originY = 0.0;
     double originZ = 0.0;
 
     //after each iteration the origin of the new fiber increases
     //here you set which direction is affected.
     double increaseX = 0.0;
     double increaseY = 1.0;
     double increaseZ = 0.0;
 
 
     //walk along X axis
     //length of fibers increases in each iteration
     for (int i=0; i<numOfFibers; ++i) {
 
         vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
         newFiber->GetPointIds()->SetNumberOfIds(i+2);
 
         //create starting point and add it to pointset
         points->InsertNextPoint(originX + (double)i * increaseX , originY + (double)i * increaseY, originZ + (double)i * increaseZ);
 
         //add starting point to fiber
         newFiber->GetPointIds()->SetId(0,points->GetNumberOfPoints()-1);
 
         //insert remaining points for fiber
         for (int pj=0; pj<=i ; ++pj)
         { //generate next point on X axis
             points->InsertNextPoint( originX + (double)pj+1 , originY + (double)i * increaseY, originZ + (double)i * increaseZ );
             newFiber->GetPointIds()->SetId(pj+1,points->GetNumberOfPoints()-1);
         }
 
         linesCell->InsertNextCell(newFiber);
     }
 
     vtkSmartPointer<vtkPolyData> PDX = vtkSmartPointer<vtkPolyData>::New();
     PDX->SetPoints(points);
     PDX->SetLines(linesCell);
     return PDX;
 }
 
 vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionY()
 {
     vtkSmartPointer<vtkPolyData> PDY = vtkSmartPointer<vtkPolyData>::New();
     //todo
 
 
 
     return PDY;
 }
 
 vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionZ()
 {
     vtkSmartPointer<vtkPolyData> PDZ = vtkSmartPointer<vtkPolyData>::New();
     //todo
 
 
 
     return PDZ;
 }
 
 void QmitkFiberBundleDeveloperView::DoSetFAValues()
 {
 
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateSetFAValuesTimer() ) );
 
     // pack items which are needed by thread processing
     struct Package4WorkingThread ItemPackageToSetFAMap;
     ItemPackageToSetFAMap.st_FBX = m_FiberBundleX;
     ItemPackageToSetFAMap.st_FancyGUITimer1 = localTimer;
     ItemPackageToSetFAMap.st_PassedDataNode = m_FANode;
     ItemPackageToSetFAMap.st_Controls = m_Controls;
 
     if (m_fiberMonitorIsOn)
         ItemPackageToSetFAMap.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_FiberFeederFASlave = new QmitkFiberFeederFAWorker(m_hostThread, ItemPackageToSetFAMap);
     m_FiberFeederFASlave->moveToThread(m_hostThread);
 
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberSetFA()) );
     connect(m_hostThread, SIGNAL(started()), m_FiberFeederFASlave, SLOT(run()) );
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberSetFA()));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberSetFA()));
     m_hostThread->start(QThread::LowestPriority);
 }
 
 void QmitkFiberBundleDeveloperView::DoSetFAMap()
 {
     std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
     if (nodes.empty())
     {
         m_Controls->lineEdit_FAMap->setText("N/A");
         return;
     }
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
          it != nodes.end();
          ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
         {
             // this node is what we want
             m_FANode = node;
             m_Controls->lineEdit_FAMap->setText(node->GetName().c_str());
             return;
         }
     }
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_FiberSetFA()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_FiberSetFA()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     //update renderer
     m_FiberBundleNode->Modified();
     m_MultiWidget->ForceImmediateUpdate();
 
     //update QComboBox(dropDown menu) in view of available ColorCodings
     this->DoGatherColorCodings();
 
     delete m_FiberFeederFASlave;
 }
 
 void QmitkFiberBundleDeveloperView::DoColorFibers()
 {
     //
     MITK_INFO << "call fibercoloring in fiberBundleX";
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateColorFibersTimer() ) );
 
     // pack items which are needed by thread processing
     struct Package4WorkingThread ItemPackageForFiberColoring;
     ItemPackageForFiberColoring.st_FBX = m_FiberBundleX;
     ItemPackageForFiberColoring.st_PassedDataNode = m_FiberBundleNode;
     ItemPackageForFiberColoring.st_FancyGUITimer1 = localTimer;
     ItemPackageForFiberColoring.st_Controls = m_Controls; //needed to catch up some selections and set options in GUI
 
     if (m_fiberMonitorIsOn)
         ItemPackageForFiberColoring.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     m_FiberColoringSlave = new QmitkFiberColoringWorker(m_hostThread, ItemPackageForFiberColoring);
     m_FiberColoringSlave->moveToThread(m_hostThread);
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberColorCoding()) );
     connect(m_hostThread, SIGNAL(started()), m_FiberColoringSlave, SLOT(run()) );
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberColorCoding()));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberColorCoding()));
     m_hostThread->start(QThread::LowestPriority);
 
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_FiberColorCoding()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
     }
 }
 
 
 void QmitkFiberBundleDeveloperView::AfterThread_FiberColorCoding()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     //update renderer
     m_FiberBundleNode->Modified();
     m_MultiWidget->ForceImmediateUpdate();
 
 
     //update QComboBox(dropDown menu) in view of available ColorCodings
     this->DoGatherColorCodings();
 
     delete m_FiberColoringSlave;
 }
 
 
 void QmitkFiberBundleDeveloperView::DoGatherColorCodings()
 {
     QStringList fbxColorCodings = m_FiberBundleX->GetAvailableColorCodings();
 
     //update dropDown Menu
     //remove all items from menu
     m_suppressSignal = true;
     int ddItems = m_Controls->ddAvailableColorcodings->count();
     for(int i=ddItems-1; i>=0; i--)
     {   //note, after each item remove, index in QComboBox is updated. sending signal: index changed
         m_Controls->ddAvailableColorcodings->removeItem(i);
     }
     //fill new data into menu
     m_Controls->ddAvailableColorcodings->addItems(fbxColorCodings);
     m_Controls->ddAvailableColorcodings->addItem(m_FiberBundleX->COLORCODING_CUSTOM);
 
     //highlight current colorcoding
     QString cc = m_FiberBundleX->GetCurrentColorCoding();
     MITK_INFO << cc.toStdString().c_str() << " is at idx: " << m_Controls->ddAvailableColorcodings->findText(cc);
     m_Controls->ddAvailableColorcodings->setCurrentIndex( m_Controls->ddAvailableColorcodings->findText(cc) );
     m_Controls->ddAvailableColorcodings->update();
     m_suppressSignal = false;
 }
 
 
 void QmitkFiberBundleDeveloperView::SetCurrentColorCoding(int idx)
 {
     if(!m_suppressSignal){
         QString selectedColorCoding = m_Controls->ddAvailableColorcodings->itemText(idx);
         m_FiberBundleX->SetColorCoding(selectedColorCoding.toStdString().c_str() ); //QString to char
         // update rendering
         m_FiberBundleNode->Modified();
         m_MultiWidget->ForceImmediateUpdate();
     }
 }
 
 /* === OutSourcedMethod: THIS METHOD GENERATES ESSENTIAL GEOMETRY PARAMETERS FOR THE MITK FRAMEWORK ===
  * WITHOUT, the rendering mechanism will ignore objects without valid Geometry
  * for each object, MITK requires: ORIGIN, SPACING, TRANSFORM MATRIX, BOUNDING-BOX */
 mitk::Geometry3D::Pointer QmitkFiberBundleDeveloperView::GenerateStandardGeometryForMITK()
 {
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
 
     // generate origin
     mitk::Point3D origin;
     origin[0] = 0;
     origin[1] = 0;
     origin[2] = 0;
     geometry->SetOrigin(origin);
 
     // generate spacing
     float spacing[3] = {1,1,1};
     geometry->SetSpacing(spacing);
 
 
     // generate identity transform-matrix
     vtkSmartPointer<vtkMatrix4x4> m = vtkSmartPointer<vtkMatrix4x4>::New();
     geometry->SetIndexToWorldTransformByVtkMatrix(m);
 
     // generate boundingbox
     // for an usable bounding-box use gui parameters to estimate the boundingbox
     float bounds[] = {500, 500, 500, -500, -500, -500};
 
     // GET SELECTED FIBER DIRECTION
     QString fibDirection; //stores the object_name of selected radiobutton
     QVector<QRadioButton*>::const_iterator i;
     for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
     {
         QRadioButton* rdbtn = *i;
         if (rdbtn->isChecked())
             fibDirection = rdbtn->objectName();
     }
 
     if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
         // use information about distribution parameter to calculate bounding box
         int distrRadius = m_Controls->boxDistributionRadius->value();
         bounds[0] = distrRadius;
         bounds[1] = distrRadius;
         bounds[2] = distrRadius;
         bounds[3] = -distrRadius;
         bounds[4] = -distrRadius;
         bounds[5] = -distrRadius;
 
     } else {
         // so far only X,Y,Z directions are available
         MITK_INFO << "_______GEOMETRY ISSUE_____\n***BoundingBox for X, Y, Z fiber directions are not optimized yet!***";
 
         int maxFibLength = m_Controls->boxFiberMaxLength->value();
         bounds[0] = maxFibLength;
         bounds[1] = maxFibLength;
         bounds[2] = maxFibLength;
         bounds[3] = -maxFibLength;
         bounds[4] = -maxFibLength;
         bounds[5] = -maxFibLength;
     }
 
     geometry->SetFloatBounds(bounds);
     geometry->SetImageGeometry(true); //??
 
     return geometry;
 
 
 }
 
 void QmitkFiberBundleDeveloperView::UpdateFiberIDTimer()
 {
     //MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
     QString crntValue = m_Controls->infoTimerGenerateFiberIds->text();
     int tmpVal = crntValue.toInt();
     m_Controls->infoTimerGenerateFiberIds->setText(QString::number(++tmpVal));
     m_Controls->infoTimerGenerateFiberIds->update();
 
 }
 
 /* Initialie ID dataset in FiberBundleX */
 void QmitkFiberBundleDeveloperView::DoGenerateFiberIDs()
 {
 
     /* ===== TIMER CONFIGURATIONS for visual effect ======
    * start and stop is called in Thread */
     QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
     localTimer->setInterval( 10 );
     connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateFiberIDTimer()) );
 
 
     // pack items which are needed by thread processing
     struct Package4WorkingThread FiberIdPackage;
     FiberIdPackage.st_FBX = m_FiberBundleX;
     FiberIdPackage.st_FancyGUITimer1 = localTimer;
     FiberIdPackage.st_Controls = m_Controls;
 
     //set element for thread monitoring
     if (m_fiberMonitorIsOn)
         FiberIdPackage.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
 
 
     if (m_threadInProgress)
         return; //maybe popup window saying, working thread still in progress...pls wait
 
     // THREAD CONFIGURATION
     m_FiberIDGenerator = new QmitkFiberIDWorker(m_hostThread, FiberIdPackage);
     m_FiberIDGenerator->moveToThread(m_hostThread);
     connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_IdGenerate()) );
     connect(m_hostThread, SIGNAL(started()), m_FiberIDGenerator, SLOT(run()));
     connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_IdGenerate()));
     connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_IdGenerate()));
     m_hostThread->start(QThread::LowestPriority);
 
 
 
     // m_Controls->infoTimerGenerateFiberIds->setText(QString::number(clock.GetTotal()));
 
 }
 
 void QmitkFiberBundleDeveloperView::BeforeThread_IdGenerate()
 {
     m_threadInProgress = true;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
     }
 }
 
 void QmitkFiberBundleDeveloperView::AfterThread_IdGenerate()
 {
     m_threadInProgress = false;
     if (m_fiberMonitorIsOn){
         m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
         m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
     }
     disconnect(m_hostThread, 0, 0, 0);
     m_hostThread->disconnect();
     delete m_FiberIDGenerator;
 
 }
 
 
 void  QmitkFiberBundleDeveloperView::ResetFiberInfoWidget()
 {
     if (m_Controls->infoAnalyseNumOfFibers->isEnabled()) {
         m_Controls->infoAnalyseNumOfFibers->setText("-");
         m_Controls->infoAnalyseNumOfPoints->setText("-");
         m_Controls->infoAnalyseNumOfFibers->setEnabled(false);
     }
 }
 
 void  QmitkFiberBundleDeveloperView::FeedFiberInfoWidget()
 {
     if (!m_Controls->infoAnalyseNumOfFibers->isEnabled())
         m_Controls->infoAnalyseNumOfFibers->setEnabled(true);
 
     QString numOfFibers;
     numOfFibers.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfLines() );
     QString numOfPoints;
     numOfPoints.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfPoints() );
 
     m_Controls->infoAnalyseNumOfFibers->setText( numOfFibers );
     m_Controls->infoAnalyseNumOfPoints->setText( numOfPoints );
 }
 
 void QmitkFiberBundleDeveloperView::SelectionChangedToolBox(int idx)
 {
     // show/reset items of selected toolbox page FiberInfo
     if (m_Controls->page_FiberInfo->isVisible())
     {
         if (m_FiberBundleX != NULL) {
             FeedFiberInfoWidget();
 
         } else {
             //if infolables are disabled: return
             //else set info back to - and set label and info to disabled
             ResetFiberInfoWidget();
         }
     }
 
     // show/reset items of selected toolbox page FiberProcessing
     if (m_Controls->page_FiberProcessing->isVisible())
     {
         if (m_FiberBundleX.IsNotNull() && m_PlanarFigure.IsNotNull() )
         {
             //show fiber extraction button
             m_Controls->buttonExtractFibers->setEnabled(true);
 
         } else {
             m_Controls->buttonExtractFibers->setEnabled(false);
         }
 
         if (m_FiberBundleX.IsNotNull())
         {
             //show button colorCoding
             m_Controls->buttonColorFibers->setEnabled(true);
             m_Controls->ddAvailableColorcodings->setEnabled(true);
             m_Controls->buttonGenerateFiberIds->setEnabled(true);
 
             //       m_Controls->buttonSMFibers->setEnabled(true);
             //       m_Controls->buttonVtkDecimatePro->setEnabled(true);
             //       m_Controls->buttonVtkSmoothPD->setEnabled(true);
             //       m_Controls->buttonGenerateTubes->setEnabled(true);
 
         } else {
             m_Controls->buttonColorFibers->setEnabled(false);
             m_Controls->ddAvailableColorcodings->setEnabled(false);
             m_Controls->buttonGenerateFiberIds->setEnabled(false);
             m_Controls->buttonSMFibers->setEnabled(false);
             m_Controls->buttonVtkDecimatePro->setEnabled(false);
             m_Controls->buttonVtkSmoothPD->setEnabled(false);
             m_Controls->buttonGenerateTubes->setEnabled(true);
 
         }
 
 
     }
 
 }
 
 void QmitkFiberBundleDeveloperView::FBXDependendGUIElementsConfigurator()
 {
     // ==== FIBER PROCESSING ELEMENTS and ALL ELEMENTS WHICH NEED A FBX DATANODE======
     //  m_Controls->buttonGenerateFiberIds->setEnabled(isVisible); moved to selectionChangedToolBox
 
     SelectionChangedToolBox(-1); //set gui elements with respect to active tab, widget, etc. -1 has no effect
 
 }
 
 
 void QmitkFiberBundleDeveloperView::DoMonitorFiberThreads(int checkStatus)
 {
     //check if in datanode exists already a node of type mitkFiberBundleXThreadMonitor
     //if not then put node to datastorage
 
     //if checkStatus is 1 then start qtimer using fading in starting text in datanode
     //if checkStatus is 0 then fade out dataNode using qtimer
 
     if (checkStatus)
     {
         m_fiberMonitorIsOn = true;
         // Generate Node hosting thread information
         mitk::FiberBundleXThreadMonitor::Pointer FBXThreadMonitor = mitk::FiberBundleXThreadMonitor::New();
         FBXThreadMonitor->SetGeometry(this->GenerateStandardGeometryForMITK());
 
         m_MonitorNode = mitk::DataNode::New();
         m_MonitorNode->SetName("FBX_threadMonitor");
         m_MonitorNode->SetData(FBXThreadMonitor);
         m_MonitorNode->SetVisibility(true);
         m_MonitorNode->SetOpacity(1.0);
 
         GetDataStorage()->Add(m_MonitorNode);
 
         //following code is needed for rendering text in mitk! without geometry nothing is rendered
         const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
         if (tsgeo == NULL) {
             /* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
             // get all nodes that have not set "includeInBoundingBox" to false
             mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New( "includeInBoundingBox"
                                                                                                                  , mitk::BoolProperty::New(false)));
             mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
             // calculate bounding geometry of these nodes
             mitk::TimeSlicedGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
             // initialize the views to the bounding geometry
             mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
         } else {
 
             GetDataStorage()->Modified();
             m_MultiWidget->RequestUpdate(); //necessary??
         }
         //__GEOMETRY FOR THREADMONITOR GENERATED
 
         /* ====== initialize thread for managing fiberThread information ========= */
         m_monitorThread = new QThread;
         // the package needs datastorage, MonitorDatanode, standardmultiwidget,
         struct Package4WorkingThread ItemPackageForThreadMonitor;
         ItemPackageForThreadMonitor.st_DataStorage = GetDataStorage();
         ItemPackageForThreadMonitor.st_ThreadMonitorDataNode = m_MonitorNode;
         ItemPackageForThreadMonitor.st_MultiWidget = m_MultiWidget;
         ItemPackageForThreadMonitor.st_FBX_Monitor = FBXThreadMonitor;
 
         m_fiberThreadMonitorWorker = new QmitkFiberThreadMonitorWorker(m_monitorThread, ItemPackageForThreadMonitor);
 
         m_fiberThreadMonitorWorker->moveToThread(m_monitorThread);
         connect ( m_monitorThread, SIGNAL( started() ), m_fiberThreadMonitorWorker, SLOT( run() ) );
         m_monitorThread->start(QThread::LowestPriority);
         m_fiberThreadMonitorWorker->initializeMonitor();//do some init animation ;-)
 
 
     } else {
         m_fiberMonitorIsOn = false;
 
         m_monitorThread->quit();
         //think about outsourcing following lines to quit / terminate slot of thread
         GetDataStorage()->Remove(m_MonitorNode);
         GetDataStorage()->Modified();
         m_MultiWidget->RequestUpdate(); //necessary??
     }
 
 
 
 }
 
 
 
 void QmitkFiberBundleDeveloperView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkFiberBundleDeveloperView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
  implement SelectionService Listener explicitly */
 void QmitkFiberBundleDeveloperView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
 
     if (nodes.empty())
         return;
     /* ==== reset everyhing related to FiberBundleX ======
    * - variable m_FiberBundleX
    * - visualization of analysed fiberbundle
    */
     m_FiberBundleNode = NULL;
     m_FiberBundleX = NULL; //reset pointer, so that member does not point to depricated locations
     m_PlanarFigure = NULL;
     ResetFiberInfoWidget();
 
 
     //timer reset only when no thread is in progress
     if (!m_threadInProgress) {
         m_Controls->infoTimerGenerateFiberIds->setText("-"); //set GUI representation of timer to -
         m_Controls->infoTimerGenerateFiberBundle->setText( "-" );
         m_Controls->infoTimerColorCoding->setText( "-" );
     }
     //====================================================
 
 
 
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         /* CHECKPOINT: FIBERBUNDLE*/
         if( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
         {
             m_FiberBundleNode = node;
             m_FiberBundleX = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
             if (m_FiberBundleX.IsNull()){
                 MITK_INFO << "========ATTENTION=========\n unable to load selected FiberBundleX to FiberBundleDeveloper-plugin \n";
                 m_FiberBundleNode = NULL;
             }
             // ==== FIBERBUNDLE_INFO ELEMENTS ====
             if ( m_Controls->page_FiberInfo->isVisible() )
                 FeedFiberInfoWidget();
 
             // enable FiberBundleX related Gui Elements, such as buttons etc.
             this->FBXDependendGUIElementsConfigurator();
             this->DoGatherColorCodings();
 
         }
         /* CHECKPOINT: PLANARFIGURE */
         else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarFigure*>(node->GetData()) )
         {
             m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
             MITK_INFO << "PF selected";
 
             if (m_PlanarFigure.IsNull())
                 MITK_INFO << "========ATTENTION=========\n unable to load selected Planarfigure to FiberBundleDeveloper-plugin \n";
 
         }
 
     }
     //update gui elements depending on given nodes
 
     FBXDependendGUIElementsConfigurator(); //every gui element which needs a FBX for processing is disabled
 }
 
 
 void QmitkFiberBundleDeveloperView::ActionDrawEllipseTriggered()
 {
     //    bool checked = m_Controls->m_CircleButton->isChecked();
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     this->PutFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
 
     MITK_INFO << "PlanarCircle created ...";
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
     mitk::PlanarFigure* figureP = 0;
 
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figureP = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figureP)
         {
-          figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor());
+          figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
           if(figureInteractor.IsNull())
           {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( node );
           }
         }
     }
 
 }
 
 void QmitkFiberBundleDeveloperView::Activated()
 {
 
     MITK_INFO << "FB DevelopersV ACTIVATED()";
 
 
 }
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberExtractionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberExtractionView.cpp
index d9719a2c76..8105354ab7 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberExtractionView.cpp
@@ -1,1443 +1,1443 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberExtractionView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
 #include <mitkDiffusionImage.h>
 #include <mitkTensorImage.h>
 #include "mitkModuleRegistry.h"
 
 // ITK
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 
 #include <math.h>
 
 
 const std::string QmitkFiberExtractionView::VIEW_ID = "org.mitk.views.fiberextraction";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkFiberExtractionView::QmitkFiberExtractionView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_CircleCounter(0)
     , m_PolygonCounter(0)
     , m_UpsamplingFactor(5)
 {
 
 }
 
 // Destructor
 QmitkFiberExtractionView::~QmitkFiberExtractionView()
 {
 
 }
 
 void QmitkFiberExtractionView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberExtractionViewControls;
         m_Controls->setupUi( parent );
         m_Controls->doExtractFibersButton->setDisabled(true);
         m_Controls->PFCompoANDButton->setDisabled(true);
         m_Controls->PFCompoORButton->setDisabled(true);
         m_Controls->PFCompoNOTButton->setDisabled(true);
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
         m_Controls->m_RectangleButton->setVisible(false);
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( OnDrawCircle() ) );
         connect( m_Controls->m_PolygonButton, SIGNAL( clicked() ), this, SLOT( OnDrawPolygon() ) );
         connect(m_Controls->PFCompoANDButton, SIGNAL(clicked()), this, SLOT(GenerateAndComposite()) );
         connect(m_Controls->PFCompoORButton, SIGNAL(clicked()), this, SLOT(GenerateOrComposite()) );
         connect(m_Controls->PFCompoNOTButton, SIGNAL(clicked()), this, SLOT(GenerateNotComposite()) );
         connect(m_Controls->m_JoinBundles, SIGNAL(clicked()), this, SLOT(JoinBundles()) );
         connect(m_Controls->m_SubstractBundles, SIGNAL(clicked()), this, SLOT(SubstractBundles()) );
         connect(m_Controls->m_GenerateRoiImage, SIGNAL(clicked()), this, SLOT(GenerateRoiImage()) );
 
         connect(m_Controls->m_Extract3dButton, SIGNAL(clicked()), this, SLOT(ExtractPassingMask()));
         connect( m_Controls->m_ExtractMask, SIGNAL(clicked()), this, SLOT(ExtractEndingInMask()) );
         connect( m_Controls->doExtractFibersButton, SIGNAL(clicked()), this, SLOT(DoFiberExtraction()) );
 
         connect( m_Controls->m_RemoveOutsideMaskButton, SIGNAL(clicked()), this, SLOT(DoRemoveOutsideMask()));
         connect( m_Controls->m_RemoveInsideMaskButton, SIGNAL(clicked()), this, SLOT(DoRemoveInsideMask()));
     }
 }
 
 void QmitkFiberExtractionView::DoRemoveInsideMask()
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage<itkUCharImageType>(mitkMask, mask);
         mitk::FiberBundleX::Pointer newFib = fib->RemoveFibersOutside(mask, true);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
         name += "_Cut";
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberExtractionView::DoRemoveOutsideMask()
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage<itkUCharImageType>(mitkMask, mask);
         mitk::FiberBundleX::Pointer newFib = fib->RemoveFibersOutside(mask);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
         name += "_Cut";
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberExtractionView::ExtractEndingInMask()
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage<itkUCharImageType>(mitkMask, mask);
         mitk::FiberBundleX::Pointer newFib = fib->ExtractFiberSubset(mask, false);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
         name += "_ending-in-mask";
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberExtractionView::ExtractPassingMask()
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage<itkUCharImageType>(mitkMask, mask);
         mitk::FiberBundleX::Pointer newFib = fib->ExtractFiberSubset(mask, true);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
         name += "_passing-mask";
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberExtractionView::GenerateRoiImage(){
 
     if (m_SelectedPF.empty())
         return;
 
     mitk::Geometry3D::Pointer geometry;
     if (!m_SelectedFB.empty())
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.front()->GetData());
         geometry = fib->GetGeometry();
     }
     else
         return;
 
     itk::Vector<double,3> spacing = geometry->GetSpacing();
     spacing /= m_UpsamplingFactor;
 
     mitk::Point3D newOrigin = geometry->GetOrigin();
     mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
     newOrigin[0] += bounds.GetElement(0);
     newOrigin[1] += bounds.GetElement(2);
     newOrigin[2] += bounds.GetElement(4);
 
     itk::Matrix<double, 3, 3> direction;
     itk::ImageRegion<3> imageRegion;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
             direction[j][i] = geometry->GetMatrixColumn(i)[j]/spacing[j];
     imageRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
     imageRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
     imageRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
 
     m_PlanarFigureImage = itkUCharImageType::New();
     m_PlanarFigureImage->SetSpacing( spacing );   // Set the image spacing
     m_PlanarFigureImage->SetOrigin( newOrigin );     // Set the image origin
     m_PlanarFigureImage->SetDirection( direction );  // Set the image direction
     m_PlanarFigureImage->SetRegions( imageRegion );
     m_PlanarFigureImage->Allocate();
     m_PlanarFigureImage->FillBuffer( 0 );
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
 
     for (int i=0; i<m_SelectedPF.size(); i++)
         CompositeExtraction(m_SelectedPF.at(i), tmpImage);
 
     DataNode::Pointer node = DataNode::New();
     tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
     node->SetData(tmpImage);
     node->SetName("ROI Image");
     this->GetDefaultDataStorage()->Add(node);
 }
 
 void QmitkFiberExtractionView::CompositeExtraction(mitk::DataNode::Pointer node, mitk::Image* image)
 {
     if (dynamic_cast<mitk::PlanarFigure*>(node.GetPointer()->GetData()) && !dynamic_cast<mitk::PlanarFigureComposite*>(node.GetPointer()->GetData()))
     {
         m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node.GetPointer()->GetData());
         AccessFixedDimensionByItk_2(
                     image,
                     InternalReorientImagePlane, 3,
                     m_PlanarFigure->GetGeometry(), -1);
 
         AccessFixedDimensionByItk_2(
                     m_InternalImage,
                     InternalCalculateMaskFromPlanarFigure,
                     3, 2, node->GetName() );
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberExtractionView::InternalReorientImagePlane( const itk::Image< TPixel, VImageDimension > *image, mitk::Geometry3D* planegeo3D, int additionalIndex )
 {
 
     MITK_DEBUG << "InternalReorientImagePlane() start";
 
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::Image< float, VImageDimension > FloatImageType;
 
     typedef itk::ResampleImageFilter<ImageType, FloatImageType, double> ResamplerType;
     typename ResamplerType::Pointer resampler = ResamplerType::New();
 
     mitk::PlaneGeometry* planegeo = dynamic_cast<mitk::PlaneGeometry*>(planegeo3D);
 
     float upsamp = m_UpsamplingFactor;
     float gausssigma = 0.5;
 
     // Spacing
     typename ResamplerType::SpacingType spacing = planegeo->GetSpacing();
     spacing[0] = image->GetSpacing()[0] / upsamp;
     spacing[1] = image->GetSpacing()[1] / upsamp;
     spacing[2] = image->GetSpacing()[2];
     resampler->SetOutputSpacing( spacing );
 
     // Size
     typename ResamplerType::SizeType size;
     size[0] = planegeo->GetParametricExtentInMM(0) / spacing[0];
     size[1] = planegeo->GetParametricExtentInMM(1) / spacing[1];
     size[2] = 1;
     resampler->SetSize( size );
 
     // Origin
     typename mitk::Point3D orig = planegeo->GetOrigin();
     typename mitk::Point3D corrorig;
     planegeo3D->WorldToIndex(orig,corrorig);
     corrorig[0] += 0.5/upsamp;
     corrorig[1] += 0.5/upsamp;
     corrorig[2] += 0;
     planegeo3D->IndexToWorld(corrorig,corrorig);
     resampler->SetOutputOrigin(corrorig );
 
     // Direction
     typename ResamplerType::DirectionType direction;
     typename mitk::AffineTransform3D::MatrixType matrix = planegeo->GetIndexToWorldTransform()->GetMatrix();
     for(int c=0; c<matrix.ColumnDimensions; c++)
     {
         double sum = 0;
         for(int r=0; r<matrix.RowDimensions; r++)
         {
             sum += matrix(r,c)*matrix(r,c);
         }
         for(int r=0; r<matrix.RowDimensions; r++)
         {
             direction(r,c) = matrix(r,c)/sqrt(sum);
         }
     }
     resampler->SetOutputDirection( direction );
 
     // Gaussian interpolation
     if(gausssigma != 0)
     {
         double sigma[3];
         for( unsigned int d = 0; d < 3; d++ )
         {
             sigma[d] = gausssigma * image->GetSpacing()[d];
         }
         double alpha = 2.0;
 
         typedef itk::GaussianInterpolateImageFunction<ImageType, double>
                 GaussianInterpolatorType;
 
         typename GaussianInterpolatorType::Pointer interpolator
                 = GaussianInterpolatorType::New();
 
         interpolator->SetInputImage( image );
         interpolator->SetParameters( sigma, alpha );
 
         resampler->SetInterpolator( interpolator );
     }
     else
     {
         //      typedef typename itk::BSplineInterpolateImageFunction<ImageType, double>
         //          InterpolatorType;
         typedef typename itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
 
         typename InterpolatorType::Pointer interpolator
                 = InterpolatorType::New();
 
         interpolator->SetInputImage( image );
 
         resampler->SetInterpolator( interpolator );
 
     }
 
     // Other resampling options
     resampler->SetInput( image );
     resampler->SetDefaultPixelValue(0);
 
     MITK_DEBUG << "Resampling requested image plane ... ";
     resampler->Update();
     MITK_DEBUG << " ... done";
 
     if(additionalIndex < 0)
     {
         this->m_InternalImage = mitk::Image::New();
         this->m_InternalImage->InitializeByItk( resampler->GetOutput() );
         this->m_InternalImage->SetVolume( resampler->GetOutput()->GetBufferPointer() );
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberExtractionView::InternalCalculateMaskFromPlanarFigure( itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string nodeName )
 {
 
     MITK_DEBUG << "InternalCalculateMaskFromPlanarFigure() start";
 
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::CastImageFilter< ImageType, itkUCharImageType > CastFilterType;
 
     // Generate mask image as new image with same header as input image and
     // initialize with "1".
     itkUCharImageType::Pointer newMaskImage = itkUCharImageType::New();
     newMaskImage->SetSpacing( image->GetSpacing() );   // Set the image spacing
     newMaskImage->SetOrigin( image->GetOrigin() );     // Set the image origin
     newMaskImage->SetDirection( image->GetDirection() );  // Set the image direction
     newMaskImage->SetRegions( image->GetLargestPossibleRegion() );
     newMaskImage->Allocate();
     newMaskImage->FillBuffer( 1 );
 
     // Generate VTK polygon from (closed) PlanarFigure polyline
     // (The polyline points are shifted by -0.5 in z-direction to make sure
     // that the extrusion filter, which afterwards elevates all points by +0.5
     // in z-direction, creates a 3D object which is cut by the the plane z=0)
     const Geometry2D *planarFigureGeometry2D = m_PlanarFigure->GetGeometry2D();
     const PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
     const Geometry3D *imageGeometry3D = m_InternalImage->GetGeometry( 0 );
 
     vtkPolyData *polyline = vtkPolyData::New();
     polyline->Allocate( 1, 1 );
 
     // Determine x- and y-dimensions depending on principal axis
     int i0, i1;
     switch ( axis )
     {
     case 0:
         i0 = 1;
         i1 = 2;
         break;
 
     case 1:
         i0 = 0;
         i1 = 2;
         break;
 
     case 2:
     default:
         i0 = 0;
         i1 = 1;
         break;
     }
 
     // Create VTK polydata object of polyline contour
     vtkPoints *points = vtkPoints::New();
     PlanarFigure::PolyLineType::const_iterator it;
     std::vector<vtkIdType> indices;
 
     unsigned int numberOfPoints = 0;
 
     for ( it = planarFigurePolyline.begin();
           it != planarFigurePolyline.end();
           ++it )
     {
         Point3D point3D;
 
         // Convert 2D point back to the local index coordinates of the selected
         // image
         Point2D point2D = it->Point;
         planarFigureGeometry2D->WorldToIndex(point2D, point2D);
         point2D[0] -= 0.5/m_UpsamplingFactor;
         point2D[1] -= 0.5/m_UpsamplingFactor;
         planarFigureGeometry2D->IndexToWorld(point2D, point2D);
         planarFigureGeometry2D->Map( point2D, point3D );
 
         // Polygons (partially) outside of the image bounds can not be processed
         // further due to a bug in vtkPolyDataToImageStencil
         if ( !imageGeometry3D->IsInside( point3D ) )
         {
             float bounds[2] = {0,0};
             bounds[0] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i0);
             bounds[1] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i1);
 
             imageGeometry3D->WorldToIndex( point3D, point3D );
 
             //      if (point3D[i0]<0)
             //        point3D[i0] = 0.5;
             //      else if (point3D[i0]>bounds[0])
             //        point3D[i0] = bounds[0]-0.5;
 
             //      if (point3D[i1]<0)
             //        point3D[i1] = 0.5;
             //      else if (point3D[i1]>bounds[1])
             //        point3D[i1] = bounds[1]-0.5;
 
             if (point3D[i0]<0)
                 point3D[i0] = 0.0;
             else if (point3D[i0]>bounds[0])
                 point3D[i0] = bounds[0]-0.001;
 
             if (point3D[i1]<0)
                 point3D[i1] = 0.0;
             else if (point3D[i1]>bounds[1])
                 point3D[i1] = bounds[1]-0.001;
 
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
         else
         {
             imageGeometry3D->WorldToIndex( point3D, point3D );
 
             // Add point to polyline array
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
     }
     polyline->SetPoints( points );
     points->Delete();
 
     vtkIdType *ptIds = new vtkIdType[numberOfPoints];
     for ( vtkIdType i = 0; i < numberOfPoints; ++i )
     {
         ptIds[i] = i;
     }
     polyline->InsertNextCell( VTK_POLY_LINE, numberOfPoints, ptIds );
 
 
     // Extrude the generated contour polygon
     vtkLinearExtrusionFilter *extrudeFilter = vtkLinearExtrusionFilter::New();
     extrudeFilter->SetInput( polyline );
     extrudeFilter->SetScaleFactor( 1 );
     extrudeFilter->SetExtrusionTypeToNormalExtrusion();
     extrudeFilter->SetVector( 0.0, 0.0, 1.0 );
 
     // Make a stencil from the extruded polygon
     vtkPolyDataToImageStencil *polyDataToImageStencil = vtkPolyDataToImageStencil::New();
     polyDataToImageStencil->SetInput( extrudeFilter->GetOutput() );
 
 
 
     // Export from ITK to VTK (to use a VTK filter)
     typedef itk::VTKImageImport< itkUCharImageType > ImageImportType;
     typedef itk::VTKImageExport< itkUCharImageType > ImageExportType;
 
     typename ImageExportType::Pointer itkExporter = ImageExportType::New();
     itkExporter->SetInput( newMaskImage );
 
     vtkImageImport *vtkImporter = vtkImageImport::New();
     this->ConnectPipelines( itkExporter, vtkImporter );
     vtkImporter->Update();
 
 
     // Apply the generated image stencil to the input image
     vtkImageStencil *imageStencilFilter = vtkImageStencil::New();
     imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
     imageStencilFilter->SetStencil( polyDataToImageStencil->GetOutput() );
     imageStencilFilter->ReverseStencilOff();
     imageStencilFilter->SetBackgroundValue( 0 );
     imageStencilFilter->Update();
 
 
     // Export from VTK back to ITK
     vtkImageExport *vtkExporter = vtkImageExport::New();
     vtkExporter->SetInputConnection( imageStencilFilter->GetOutputPort() );
     vtkExporter->Update();
 
     typename ImageImportType::Pointer itkImporter = ImageImportType::New();
     this->ConnectPipelines( vtkExporter, itkImporter );
     itkImporter->Update();
 
     // calculate cropping bounding box
     m_InternalImageMask3D = itkImporter->GetOutput();
     m_InternalImageMask3D->SetDirection(image->GetDirection());
 
     itk::ImageRegionConstIterator<itkUCharImageType>
             itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
     itk::ImageRegionIterator<ImageType>
             itimage(image, image->GetLargestPossibleRegion());
 
     itmask = itmask.Begin();
     itimage = itimage.Begin();
 
     typename ImageType::SizeType lowersize = {{9999999999,9999999999,9999999999}};
     typename ImageType::SizeType uppersize = {{0,0,0}};
     while( !itmask.IsAtEnd() )
     {
         if(itmask.Get() == 0)
         {
             itimage.Set(0);
         }
         else
         {
             typename ImageType::IndexType index = itimage.GetIndex();
             typename ImageType::SizeType signedindex;
             signedindex[0] = index[0];
             signedindex[1] = index[1];
             signedindex[2] = index[2];
 
             lowersize[0] = signedindex[0] < lowersize[0] ? signedindex[0] : lowersize[0];
             lowersize[1] = signedindex[1] < lowersize[1] ? signedindex[1] : lowersize[1];
             lowersize[2] = signedindex[2] < lowersize[2] ? signedindex[2] : lowersize[2];
 
             uppersize[0] = signedindex[0] > uppersize[0] ? signedindex[0] : uppersize[0];
             uppersize[1] = signedindex[1] > uppersize[1] ? signedindex[1] : uppersize[1];
             uppersize[2] = signedindex[2] > uppersize[2] ? signedindex[2] : uppersize[2];
         }
 
         ++itmask;
         ++itimage;
     }
 
     typename ImageType::IndexType index;
     index[0] = lowersize[0];
     index[1] = lowersize[1];
     index[2] = lowersize[2];
 
     typename ImageType::SizeType size;
     size[0] = uppersize[0] - lowersize[0] + 1;
     size[1] = uppersize[1] - lowersize[1] + 1;
     size[2] = uppersize[2] - lowersize[2] + 1;
 
     itk::ImageRegion<3> cropRegion = itk::ImageRegion<3>(index, size);
 
     // crop internal mask
     typedef itk::RegionOfInterestImageFilter< itkUCharImageType, itkUCharImageType > ROIMaskFilterType;
     typename ROIMaskFilterType::Pointer roi2 = ROIMaskFilterType::New();
     roi2->SetRegionOfInterest(cropRegion);
     roi2->SetInput(m_InternalImageMask3D);
     roi2->Update();
     m_InternalImageMask3D = roi2->GetOutput();
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_InternalImageMask3D.GetPointer());
     tmpImage->SetVolume(m_InternalImageMask3D->GetBufferPointer());
 
     Image::Pointer tmpImage2 = Image::New();
     tmpImage2->InitializeByItk(m_PlanarFigureImage.GetPointer());
     const Geometry3D *pfImageGeometry3D = tmpImage2->GetGeometry( 0 );
 
     const Geometry3D *intImageGeometry3D = tmpImage->GetGeometry( 0 );
 
     typedef itk::ImageRegionIteratorWithIndex<itkUCharImageType> IteratorType;
     IteratorType imageIterator (m_InternalImageMask3D, m_InternalImageMask3D->GetRequestedRegion());
     imageIterator.GoToBegin();
     while ( !imageIterator.IsAtEnd() )
     {
         unsigned char val = imageIterator.Value();
         if (val>0)
         {
             itk::Index<3> index = imageIterator.GetIndex();
             Point3D point;
             point[0] = index[0];
             point[1] = index[1];
             point[2] = index[2];
 
             intImageGeometry3D->IndexToWorld(point, point);
             pfImageGeometry3D->WorldToIndex(point, point);
 
             point[i0] += 0.5;
             point[i1] += 0.5;
 
             index[0] = point[0];
             index[1] = point[1];
             index[2] = point[2];
 
             if (pfImageGeometry3D->IsIndexInside(index))
                 m_PlanarFigureImage->SetPixel(index, 1);
         }
         ++imageIterator;
     }
 
     // Clean up VTK objects
     polyline->Delete();
     extrudeFilter->Delete();
     polyDataToImageStencil->Delete();
     vtkImporter->Delete();
     imageStencilFilter->Delete();
     //vtkExporter->Delete(); // TODO: crashes when outcommented; memory leak??
     delete[] ptIds;
 
 }
 
 void QmitkFiberExtractionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkFiberExtractionView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
  implement SelectionService Listener explicitly */
 
 void QmitkFiberExtractionView::UpdateGui()
 {
     m_Controls->m_Extract3dButton->setEnabled(false);
     m_Controls->m_ExtractMask->setEnabled(false);
     m_Controls->m_RemoveOutsideMaskButton->setEnabled(false);
     m_Controls->m_RemoveInsideMaskButton->setEnabled(false);
 
     // are fiber bundles selected?
     if ( m_SelectedFB.empty() )
     {
         m_Controls->m_InputData->setTitle("Please Select Input Data");
 
         m_Controls->m_JoinBundles->setEnabled(false);
         m_Controls->m_SubstractBundles->setEnabled(false);
         m_Controls->doExtractFibersButton->setEnabled(false);
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
     }
     else
     {
         m_Controls->m_InputData->setTitle("Input Data");
 
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
 
         // one bundle and one planar figure needed to extract fibers
         if (!m_SelectedPF.empty())
             m_Controls->doExtractFibersButton->setEnabled(true);
 
         // more than two bundles needed to join/subtract
         if (m_SelectedFB.size() > 1)
         {
             m_Controls->m_JoinBundles->setEnabled(true);
             m_Controls->m_SubstractBundles->setEnabled(true);
         }
         else
         {
             m_Controls->m_JoinBundles->setEnabled(false);
             m_Controls->m_SubstractBundles->setEnabled(false);
         }
 
         if (m_MaskImageNode.IsNotNull())
         {
             m_Controls->m_Extract3dButton->setEnabled(true);
             m_Controls->m_ExtractMask->setEnabled(true);
             m_Controls->m_RemoveOutsideMaskButton->setEnabled(true);
             m_Controls->m_RemoveInsideMaskButton->setEnabled(true);
         }
     }
 
     // are planar figures selected?
     if ( m_SelectedPF.empty() )
     {
         m_Controls->doExtractFibersButton->setEnabled(false);
         m_Controls->PFCompoANDButton->setEnabled(false);
         m_Controls->PFCompoORButton->setEnabled(false);
         m_Controls->PFCompoNOTButton->setEnabled(false);
         m_Controls->m_GenerateRoiImage->setEnabled(false);
     }
     else
     {
         if ( !m_SelectedFB.empty() )
             m_Controls->m_GenerateRoiImage->setEnabled(true);
         else
             m_Controls->m_GenerateRoiImage->setEnabled(false);
 
         if (m_SelectedPF.size() > 1)
         {
             m_Controls->PFCompoANDButton->setEnabled(true);
             m_Controls->PFCompoORButton->setEnabled(true);
             m_Controls->PFCompoNOTButton->setEnabled(false);
         }
         else
         {
             m_Controls->PFCompoANDButton->setEnabled(false);
             m_Controls->PFCompoORButton->setEnabled(false);
             m_Controls->PFCompoNOTButton->setEnabled(true);
         }
     }
 }
 
 void QmitkFiberExtractionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     //reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
     m_SelectedFB.clear();
     m_SelectedPF.clear();
     m_SelectedSurfaces.clear();
     m_SelectedImage = NULL;
     m_MaskImageNode = NULL;
 
     m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_PfLabel->setText("<font color='grey'>needed for extraction</font>");
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
         if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
         {
             m_Controls->m_FibLabel->setText(node->GetName().c_str());
             m_SelectedFB.push_back(node);
         }
         else if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
         {
             m_Controls->m_PfLabel->setText(node->GetName().c_str());
             m_SelectedPF.push_back(node);
         }
         else if (dynamic_cast<mitk::Image*>(node->GetData()))
         {
             m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
 
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
             {
                 m_MaskImageNode = node;
                 m_Controls->m_PfLabel->setText(node->GetName().c_str());
             }
         }
         else if (dynamic_cast<mitk::Surface*>(node->GetData()))
         {
             m_Controls->m_PfLabel->setText(node->GetName().c_str());
             m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
         }
     }
     UpdateGui();
     GenerateStats();
 }
 
 void QmitkFiberExtractionView::OnDrawPolygon()
 {
     //  bool checked = m_Controls->m_PolygonButton->isChecked();
     //  if(!this->AssertDrawingIsPossible(checked))
     //    return;
 
     mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
     figure->ClosedOn();
     this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
 
     MITK_DEBUG << "PlanarPolygon created ...";
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
     mitk::PlanarFigure* figureP = 0;
 
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figureP = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figureP)
         {
-          figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor());
+          figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
           if(figureInteractor.IsNull())
           {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( node );
           }
         }
     }
 
 }
 
 void QmitkFiberExtractionView::OnDrawCircle()
 {
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
 
     this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
 
     this->GetDataStorage()->Modified();
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
     mitk::PlanarFigure* figureP = 0;
 
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End(); it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figureP = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figureP)
         {
-            figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor());
+            figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
             if(figureInteractor.IsNull())
           {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( node );
           }
         }
     }
 }
 
 void QmitkFiberExtractionView::Activated()
 {
 
 }
 
 void QmitkFiberExtractionView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
                                                       const char *propertyKey, mitk::BaseProperty *property )
 {
     // initialize figure's geometry with empty geometry
     mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
     figure->SetGeometry2D( emptygeometry );
 
     //set desired data to DataNode where Planarfigure is stored
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
 
     newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,0.0,0.0));
     newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(2.0));
     newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true));
 
     newNode->AddProperty( "selected", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
     newNode->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(false) );
     newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
 
     newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(3.0) );
     newNode->AddProperty( "planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.helperline.width", mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
     newNode->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(0.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0)  );
     newNode->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(2.0) );
 
     newNode->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(2.0));
     newNode->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(2.0) );
     newNode->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
     newNode->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(2.0));
 
     // figure drawn on the topmost layer / image
     newNode->SetColor(1.0,1.0,1.0);
     newNode->SetOpacity(0.8);
     GetDataStorage()->Add(newNode );
 
     std::vector<mitk::DataNode*> selectedNodes = GetDataManagerSelection();
     for(unsigned int i = 0; i < selectedNodes.size(); i++)
     {
         selectedNodes[i]->SetSelected(false);
     }
 
     newNode->SetSelected(true);
 }
 
 void QmitkFiberExtractionView::DoFiberExtraction()
 {
     if ( m_SelectedFB.empty() ){
         QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
         MITK_WARN("QmitkFiberExtractionView") << "no fibe bundle selected";
         return;
     }
 
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         mitk::PlanarFigure::Pointer roi = dynamic_cast<mitk::PlanarFigure*> (m_SelectedPF.at(0)->GetData());
 
         mitk::FiberBundleX::Pointer extFB = fib->ExtractFiberSubset(roi);
         if (extFB->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         mitk::DataNode::Pointer node;
         node = mitk::DataNode::New();
         node->SetData(extFB);
         QString name(m_SelectedFB.at(i)->GetName().c_str());
         name += "_";
         name += m_SelectedPF.at(0)->GetName().c_str();
         node->SetName(name.toStdString());
         GetDataStorage()->Add(node);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberExtractionView::GenerateAndComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCAnd = mitk::PlanarFigureComposite::New();
 
     mitk::PlaneGeometry* currentGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D()));
     PFCAnd->SetGeometry2D(currentGeometry2D);
     PFCAnd->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
 
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin();
          it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         mitk::PlanarFigure::Pointer tmpPF =  dynamic_cast<mitk::PlanarFigure*>( nodePF->GetData() );
         PFCAnd->addPlanarFigure( tmpPF );
         PFCAnd->addDataNode( nodePF );
         PFCAnd->setDisplayName("AND_COMPO");
     }
 
     AddCompositeToDatastorage(PFCAnd, NULL);
 }
 
 void QmitkFiberExtractionView::GenerateOrComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCOr = mitk::PlanarFigureComposite::New();
     mitk::PlaneGeometry* currentGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D()));
     PFCOr->SetGeometry2D(currentGeometry2D);
     PFCOr->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
 
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin();
          it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         mitk::PlanarFigure::Pointer tmpPF =  dynamic_cast<mitk::PlanarFigure*>( nodePF->GetData() );
         PFCOr->addPlanarFigure( tmpPF );
         PFCOr->addDataNode( nodePF );
         PFCOr->setDisplayName("OR_COMPO");
     }
 
     AddCompositeToDatastorage(PFCOr, NULL);
 }
 
 void QmitkFiberExtractionView::GenerateNotComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCNot = mitk::PlanarFigureComposite::New();
     mitk::PlaneGeometry* currentGeometry2D = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D()));
     PFCNot->SetGeometry2D(currentGeometry2D);
     PFCNot->setOperationType(mitk::PFCOMPOSITION_NOT_OPERATION);
 
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin();
          it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         mitk::PlanarFigure::Pointer tmpPF =  dynamic_cast<mitk::PlanarFigure*>( nodePF->GetData() );
         PFCNot->addPlanarFigure( tmpPF );
         PFCNot->addDataNode( nodePF );
         PFCNot->setDisplayName("NOT_COMPO");
     }
 
     AddCompositeToDatastorage(PFCNot, NULL);
 }
 
 /* CLEANUP NEEDED */
 void QmitkFiberExtractionView::AddCompositeToDatastorage(mitk::PlanarFigureComposite::Pointer pfcomp, mitk::DataNode::Pointer parentDataNode )
 {
     mitk::DataNode::Pointer newPFCNode;
     newPFCNode = mitk::DataNode::New();
     newPFCNode->SetName( pfcomp->getDisplayName() );
     newPFCNode->SetData(pfcomp);
     newPFCNode->SetVisibility(true);
 
     switch (pfcomp->getOperationType()) {
     case 0:
     {
         if (!parentDataNode.IsNull()) {
             GetDataStorage()->Add(newPFCNode, parentDataNode);
 
         } else {
             GetDataStorage()->Add(newPFCNode);
         }
 
         //iterate through its childs
         for(int i=0; i<pfcomp->getNumberOfChildren(); ++i)
         {
             mitk::PlanarFigure::Pointer tmpPFchild = pfcomp->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfcomp->getDataNodeAt(i);
 
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( !pfcompcast.IsNull() )
             {
                 // child is of type planar Figure composite
                 // make new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName(  savedPFchildNode->GetName()  ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfcomp->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
                 // without having its parent anymore
                 //GetDataStorage()->Remove(savedPFchildNode);
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
 
                 }else{
                     MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
                 }
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
                 }
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfcomp->replaceDataNodeAt(i, newPFchildNode);
 
 
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
 
                 }
                 else
                 {
                     MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
                 }
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 if ( GetDataStorage()->Exists(savedPFchildNode))
                 {
                     MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
                 }
 
                 MITK_DEBUG << "adding " << newPFchildNode->GetName() << " to " << newPFCNode->GetName();
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         GetDataStorage()->Modified();
         break;
     }
     case 1:
     {
         if (!parentDataNode.IsNull()) {
             MITK_DEBUG << "adding " << newPFCNode->GetName() << " to " << parentDataNode->GetName() ;
             GetDataStorage()->Add(newPFCNode, parentDataNode);
 
         } else {
             MITK_DEBUG << "adding " << newPFCNode->GetName();
             GetDataStorage()->Add(newPFCNode);
 
         }
 
         for(int i=0; i<pfcomp->getNumberOfChildren(); ++i)
         {
             mitk::PlanarFigure::Pointer tmpPFchild = pfcomp->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfcomp->getDataNodeAt(i);
 
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( !pfcompcast.IsNull() )
             { // child is of type planar Figure composite
                 // make new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName(  savedPFchildNode->GetName()  ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfcomp->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
 
                 // remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
                 // without having its parent anymore
                 //GetDataStorage()->Remove(savedPFchildNode);
 
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
 
                 }else{
                     MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
 
                 }
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
 
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
                 }
             } else {
 
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfcomp->replaceDataNodeAt(i, newPFchildNode);
 
 
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
 
                 }else{
                     MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
 
                 }
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
 
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
                 }
 
                 MITK_DEBUG << "adding " << newPFchildNode->GetName() << " to " << newPFCNode->GetName();
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         GetDataStorage()->Modified();
         break;
     }
     case 2:
     {
         if (!parentDataNode.IsNull()) {
             MITK_DEBUG << "adding " << newPFCNode->GetName() << " to " << parentDataNode->GetName() ;
             GetDataStorage()->Add(newPFCNode, parentDataNode);
         }
         else
         {
             MITK_DEBUG << "adding " << newPFCNode->GetName();
             GetDataStorage()->Add(newPFCNode);
         }
 
 
         //iterate through its childs
 
         for(int i=0; i<pfcomp->getNumberOfChildren(); ++i)
         {
             mitk::PlanarFigure::Pointer tmpPFchild = pfcomp->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfcomp->getDataNodeAt(i);
 
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( !pfcompcast.IsNull() )
             { // child is of type planar Figure composite
                 // makeRemoveBundle new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName(  savedPFchildNode->GetName()  ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfcomp->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
 
                 // remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
                 // without having its parent anymore
                 //GetDataStorage()->Remove(savedPFchildNode);
 
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
 
                 }else{
                     MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
                 }
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
 
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
                 }
 
 
             } else {
 
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfcomp->replaceDataNodeAt(i, newPFchildNode);
 
 
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " exists in DS...trying to remove it";
 
                 }else{
                     MITK_DEBUG << "[ERROR] does NOT exist, but can I read its Name? " << savedPFchildNode->GetName();
 
                 }
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
 
                 if ( GetDataStorage()->Exists(savedPFchildNode)) {
                     MITK_DEBUG << savedPFchildNode->GetName() << " still exists";
                 }
 
                 MITK_DEBUG << "adding " << newPFchildNode->GetName() << " to " << newPFCNode->GetName();
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         GetDataStorage()->Modified();
         break;
     }
     default:
         MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
         break;
     }
 }
 
 
 void QmitkFiberExtractionView::JoinBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberExtractionView") << "Select at least two fiber bundles!";
         return;
     }
 
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (int i=1; i<m_SelectedFB.size(); i++)
     {
         newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
         name += "+"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
 }
 
 void QmitkFiberExtractionView::SubstractBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberExtractionView") << "Select at least two fiber bundles!";
         return;
     }
 
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (int i=1; i<m_SelectedFB.size(); i++)
     {
         newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
         if (newBundle.IsNull())
             break;
         name += "-"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
     if (newBundle.IsNull())
     {
         QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers. Did you select the fiber bundles in the correct order? X-Y is not equal to Y-X!");
         return;
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
 }
 
 void QmitkFiberExtractionView::GenerateStats()
 {
     if ( m_SelectedFB.empty() )
         return;
 
     QString stats("");
 
     for( int i=0; i<m_SelectedFB.size(); i++ )
     {
         mitk::DataNode::Pointer node = m_SelectedFB[i];
         if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
         {
             if (i>0)
                 stats += "\n-----------------------------\n";
             stats += QString(node->GetName().c_str()) + "\n";
             mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
             stats += "Number of fibers: "+ QString::number(fib->GetNumFibers()) + "\n";
             stats += "Min. length:         "+ QString::number(fib->GetMinFiberLength(),'f',1) + " mm\n";
             stats += "Max. length:         "+ QString::number(fib->GetMaxFiberLength(),'f',1) + " mm\n";
             stats += "Mean length:         "+ QString::number(fib->GetMeanFiberLength(),'f',1) + " mm\n";
             stats += "Median length:       "+ QString::number(fib->GetMedianFiberLength(),'f',1) + " mm\n";
             stats += "Standard deviation:  "+ QString::number(fib->GetLengthStDev(),'f',1) + " mm\n";
         }
     }
     this->m_Controls->m_StatsTextEdit->setText(stats);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
index ea8633da4e..0f670aa990 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,1991 +1,1991 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberfoxView.h"
 
 // MITK
 #include <mitkImage.h>
 #include <mitkDiffusionImage.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkDataStorage.h>
 #include <itkFibersFromPlanarFiguresFilter.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkTensorImage.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageGenerator.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
 #include <QFileDialog>
 #include <QMessageBox>
 #include "mitkModuleRegistry.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
 
 QmitkFiberfoxView::QmitkFiberfoxView()
     : QmitkAbstractView()
     , m_Controls( 0 )
     , m_SelectedImage( NULL )
 {
 
 }
 
 // Destructor
 QmitkFiberfoxView::~QmitkFiberfoxView()
 {
 
 }
 
 void QmitkFiberfoxView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberfoxViewControls;
         m_Controls->setupUi( parent );
 
         m_Controls->m_StickWidget1->setVisible(true);
         m_Controls->m_StickWidget2->setVisible(false);
         m_Controls->m_ZeppelinWidget1->setVisible(false);
         m_Controls->m_ZeppelinWidget2->setVisible(false);
         m_Controls->m_TensorWidget1->setVisible(false);
         m_Controls->m_TensorWidget2->setVisible(false);
 
         m_Controls->m_BallWidget1->setVisible(true);
         m_Controls->m_BallWidget2->setVisible(false);
         m_Controls->m_AstrosticksWidget1->setVisible(false);
         m_Controls->m_AstrosticksWidget2->setVisible(false);
         m_Controls->m_DotWidget1->setVisible(false);
         m_Controls->m_DotWidget2->setVisible(false);
 
         m_Controls->m_Comp4FractionFrame->setVisible(false);
         m_Controls->m_DiffusionPropsMessage->setVisible(false);
         m_Controls->m_GeometryMessage->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_VarianceBox->setVisible(false);
         m_Controls->m_GibbsRingingFrame->setVisible(false);
         m_Controls->m_NoiseFrame->setVisible(false);
         m_Controls->m_GhostFrame->setVisible(false);
         m_Controls->m_DistortionsFrame->setVisible(false);
         m_Controls->m_EddyFrame->setVisible(false);
 
         m_Controls->m_FrequencyMapBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         m_Controls->m_FrequencyMapBox->SetPredicate(finalPredicate);
 
         connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
         connect((QObject*) m_Controls->m_GenerateFibersButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFibers()));
         connect((QObject*) m_Controls->m_CircleButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnDrawROI()));
         connect((QObject*) m_Controls->m_FlipButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnFlipButton()));
         connect((QObject*) m_Controls->m_JoinBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(JoinBundles()));
         connect((QObject*) m_Controls->m_VarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
         connect((QObject*) m_Controls->m_DistributionBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnDistributionChanged(int)));
         connect((QObject*) m_Controls->m_FiberDensityBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberDensityChanged(int)));
         connect((QObject*) m_Controls->m_FiberSamplingBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnFiberSamplingChanged(double)));
         connect((QObject*) m_Controls->m_TensionBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnTensionChanged(double)));
         connect((QObject*) m_Controls->m_ContinuityBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnContinuityChanged(double)));
         connect((QObject*) m_Controls->m_BiasBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnBiasChanged(double)));
         connect((QObject*) m_Controls->m_AddGibbsRinging, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGibbsRinging(int)));
         connect((QObject*) m_Controls->m_AddNoise, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddNoise(int)));
         connect((QObject*) m_Controls->m_AddGhosts, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGhosts(int)));
         connect((QObject*) m_Controls->m_AddDistortions, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddDistortions(int)));
         connect((QObject*) m_Controls->m_AddEddy, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddEddy(int)));
 
         connect((QObject*) m_Controls->m_ConstantRadiusBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnConstantRadius(int)));
         connect((QObject*) m_Controls->m_CopyBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(CopyBundles()));
         connect((QObject*) m_Controls->m_TransformBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(ApplyTransform()));
         connect((QObject*) m_Controls->m_AlignOnGrid, SIGNAL(clicked()), (QObject*) this, SLOT(AlignOnGrid()));
 
         connect((QObject*) m_Controls->m_Compartment1Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp1ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment2Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp2ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment3Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp3ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment4Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp4ModelFrameVisibility(int)));
 
         connect((QObject*) m_Controls->m_AdvancedOptionsBox, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
         connect((QObject*) m_Controls->m_AdvancedOptionsBox_2, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
 
         connect((QObject*) m_Controls->m_SaveParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(SaveParameters()));
         connect((QObject*) m_Controls->m_LoadParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(LoadParameters()));
     }
 }
 
 void QmitkFiberfoxView::UpdateImageParameters()
 {
     m_ImageGenParameters.artifactList.clear();
     m_ImageGenParameters.nonFiberModelList.clear();
     m_ImageGenParameters.fiberModelList.clear();
     m_ImageGenParameters.signalModelString = "";
     m_ImageGenParameters.artifactModelString = "";
     m_ImageGenParameters.resultNode = mitk::DataNode::New();
     m_ImageGenParameters.tissueMaskImage = NULL;
     m_ImageGenParameters.frequencyMap = NULL;
     m_ImageGenParameters.gradientDirections.clear();
 
     if (m_SelectedDWI.IsNotNull())  // use parameters of selected DWI
     {
         mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedDWI->GetData());
         m_ImageGenParameters.imageRegion = dwi->GetVectorImage()->GetLargestPossibleRegion();
         m_ImageGenParameters.imageSpacing = dwi->GetVectorImage()->GetSpacing();
         m_ImageGenParameters.imageOrigin = dwi->GetVectorImage()->GetOrigin();
         m_ImageGenParameters.imageDirection = dwi->GetVectorImage()->GetDirection();
         m_ImageGenParameters.b_value = dwi->GetB_Value();
         mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer dirs = dwi->GetDirections();
 
         m_ImageGenParameters.numGradients = 0;
         for (int i=0; i<dirs->Size(); i++)
         {
             DiffusionSignalModel<double>::GradientType g;
             g[0] = dirs->at(i)[0];
             g[1] = dirs->at(i)[1];
             g[2] = dirs->at(i)[2];
             m_ImageGenParameters.gradientDirections.push_back(g);
             if (dirs->at(i).magnitude()>0.0001)
                 m_ImageGenParameters.numGradients++;
         }
     }
     else if (m_SelectedImage.IsNotNull())   // use geometry of selected image
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImage->GetData());
         itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
         CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
 
         m_ImageGenParameters.imageRegion = itkImg->GetLargestPossibleRegion();
         m_ImageGenParameters.imageSpacing = itkImg->GetSpacing();
         m_ImageGenParameters.imageOrigin = itkImg->GetOrigin();
         m_ImageGenParameters.imageDirection = itkImg->GetDirection();
 
         m_ImageGenParameters.numGradients = m_Controls->m_NumGradientsBox->value();
         m_ImageGenParameters.gradientDirections = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());
         m_ImageGenParameters.b_value = m_Controls->m_BvalueBox->value();
     }
     else    // use GUI parameters
     {
         m_ImageGenParameters.imageRegion.SetSize(0, m_Controls->m_SizeX->value());
         m_ImageGenParameters.imageRegion.SetSize(1, m_Controls->m_SizeY->value());
         m_ImageGenParameters.imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
         m_ImageGenParameters.imageSpacing[0] = m_Controls->m_SpacingX->value();
         m_ImageGenParameters.imageSpacing[1] = m_Controls->m_SpacingY->value();
         m_ImageGenParameters.imageSpacing[2] = m_Controls->m_SpacingZ->value();
         m_ImageGenParameters.imageOrigin[0] = m_ImageGenParameters.imageSpacing[0]/2;
         m_ImageGenParameters.imageOrigin[1] = m_ImageGenParameters.imageSpacing[1]/2;
         m_ImageGenParameters.imageOrigin[2] = m_ImageGenParameters.imageSpacing[2]/2;
         m_ImageGenParameters.imageDirection.SetIdentity();
 
         m_ImageGenParameters.numGradients = m_Controls->m_NumGradientsBox->value();
         m_ImageGenParameters.gradientDirections = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());;
         m_ImageGenParameters.b_value = m_Controls->m_BvalueBox->value();
     }
 
     // signal relaxation
     m_ImageGenParameters.doSimulateRelaxation = m_Controls->m_RelaxationBox->isChecked();
     if (m_ImageGenParameters.doSimulateRelaxation)
         m_ImageGenParameters.artifactModelString += "_RELAX";
 
     // N/2 ghosts
     if (m_Controls->m_AddGhosts->isChecked())
     {
         m_ImageGenParameters.artifactModelString += "_GHOST";
         m_ImageGenParameters.kspaceLineOffset = m_Controls->m_kOffsetBox->value();
     }
     else
         m_ImageGenParameters.kspaceLineOffset = 0;
 
     m_ImageGenParameters.tLine = m_Controls->m_LineReadoutTimeBox->value();
     m_ImageGenParameters.tInhom = m_Controls->m_T2starBox->value();
     m_ImageGenParameters.tEcho = m_Controls->m_TEbox->value();
     m_ImageGenParameters.repetitions = m_Controls->m_RepetitionsBox->value();
     m_ImageGenParameters.doDisablePartialVolume = m_Controls->m_EnforcePureFiberVoxelsBox->isChecked();
     m_ImageGenParameters.interpolationShrink = m_Controls->m_InterpolationShrink->value();
     m_ImageGenParameters.axonRadius = m_Controls->m_FiberRadius->value();
     m_ImageGenParameters.signalScale = m_Controls->m_SignalScaleBox->value();
 
     // adjust echo time if needed
     if ( m_ImageGenParameters.tEcho < m_ImageGenParameters.imageRegion.GetSize(1)*m_ImageGenParameters.tLine )
     {
         this->m_Controls->m_TEbox->setValue( m_ImageGenParameters.imageRegion.GetSize(1)*m_ImageGenParameters.tLine );
         m_ImageGenParameters.tEcho = m_Controls->m_TEbox->value();
         QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(m_ImageGenParameters.tEcho)+" ms");
     }
 
     // check tissue mask
     if (m_TissueMask.IsNotNull())
     {
         m_ImageGenParameters.tissueMaskImage = ItkUcharImgType::New();
         mitk::CastToItkImage<ItkUcharImgType>(m_TissueMask, m_ImageGenParameters.tissueMaskImage);
     }
 
     // rician noise
     if (m_Controls->m_AddNoise->isChecked())
     {
         double noiseVariance = m_Controls->m_NoiseLevel->value();
         m_ImageGenParameters.ricianNoiseModel.SetNoiseVariance(noiseVariance);
         m_ImageGenParameters.artifactModelString += "_NOISE";
         m_ImageGenParameters.artifactModelString += QString::number(noiseVariance);
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
     }
     else
         m_ImageGenParameters.ricianNoiseModel.SetNoiseVariance(0);
 
     // gibbs ringing
     m_ImageGenParameters.upsampling = 1;
     if (m_Controls->m_AddGibbsRinging->isChecked())
     {
         m_ImageGenParameters.artifactModelString += "_RINGING";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Ringing-Upsampling", DoubleProperty::New(m_Controls->m_ImageUpsamplingBox->value()));
         m_ImageGenParameters.upsampling = m_Controls->m_ImageUpsamplingBox->value();
     }
 
     // adjusting line readout time to the adapted image size needed for the DFT
     int y = m_ImageGenParameters.imageRegion.GetSize(1);
     if ( y%2 == 1 )
         y += 1;
     if ( y>m_ImageGenParameters.imageRegion.GetSize(1) )
         m_ImageGenParameters.tLine *= (double)m_ImageGenParameters.imageRegion.GetSize(1)/y;
 
     // add distortions
     if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
     {
         mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
         mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
         ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
         CastToItkImage< ItkDoubleImgType >(img, itkImg);
 
         if (m_ImageGenParameters.imageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
                 m_ImageGenParameters.imageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
                 m_ImageGenParameters.imageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
         {
             m_ImageGenParameters.frequencyMap = itkImg;
             m_ImageGenParameters.artifactModelString += "_DISTORTED";
         }
     }
 
     m_ImageGenParameters.doSimulateEddyCurrents = m_Controls->m_AddEddy->isChecked();
     m_ImageGenParameters.eddyStrength = 0;
     if (m_Controls->m_AddEddy->isChecked())
     {
         m_ImageGenParameters.eddyStrength = m_Controls->m_EddyGradientStrength->value();
         m_ImageGenParameters.artifactModelString += "_EDDY";
     }
 
     // signal models
     m_ImageGenParameters.comp3Weight = 1;
     m_ImageGenParameters.comp4Weight = 0;
     if (m_Controls->m_Compartment4Box->currentIndex()>0)
     {
         m_ImageGenParameters.comp4Weight = m_Controls->m_Comp4FractionBox->value();
         m_ImageGenParameters.comp3Weight -= m_ImageGenParameters.comp4Weight;
     }
 
     // compartment 1
     switch (m_Controls->m_Compartment1Box->currentIndex())
     {
     case 0:
         m_StickModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_StickModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_StickModel1.SetDiffusivity(m_Controls->m_StickWidget1->GetD());
         m_StickModel1.SetT2(m_Controls->m_StickWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_StickModel1);
         m_ImageGenParameters.signalModelString += "Stick";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_StickModel1.GetT2()) );
         break;
     case 1:
         m_ZeppelinModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_ZeppelinModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_ZeppelinModel1.SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
         m_ZeppelinModel1.SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
         m_ZeppelinModel1.SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
         m_ZeppelinModel1.SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_ZeppelinModel1);
         m_ImageGenParameters.signalModelString += "Zeppelin";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_ZeppelinModel1.GetT2()) );
         break;
     case 2:
         m_TensorModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_TensorModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_TensorModel1.SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
         m_TensorModel1.SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
         m_TensorModel1.SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
         m_TensorModel1.SetT2(m_Controls->m_TensorWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_TensorModel1);
         m_ImageGenParameters.signalModelString += "Tensor";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_ZeppelinModel1.GetT2()) );
         break;
     }
 
     // compartment 2
     switch (m_Controls->m_Compartment2Box->currentIndex())
     {
     case 0:
         break;
     case 1:
         m_StickModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_StickModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_StickModel2.SetDiffusivity(m_Controls->m_StickWidget2->GetD());
         m_StickModel2.SetT2(m_Controls->m_StickWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_StickModel2);
         m_ImageGenParameters.signalModelString += "Stick";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_StickModel2.GetT2()) );
         break;
     case 2:
         m_ZeppelinModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_ZeppelinModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_ZeppelinModel2.SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
         m_ZeppelinModel2.SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
         m_ZeppelinModel2.SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
         m_ZeppelinModel2.SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_ZeppelinModel2);
         m_ImageGenParameters.signalModelString += "Zeppelin";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_ZeppelinModel2.GetT2()) );
         break;
     case 3:
         m_TensorModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_TensorModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_TensorModel2.SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
         m_TensorModel2.SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
         m_TensorModel2.SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
         m_TensorModel2.SetT2(m_Controls->m_TensorWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_TensorModel2);
         m_ImageGenParameters.signalModelString += "Tensor";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_ZeppelinModel2.GetT2()) );
         break;
     }
 
     // compartment 3
     switch (m_Controls->m_Compartment3Box->currentIndex())
     {
     case 0:
         m_BallModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_BallModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_BallModel1.SetDiffusivity(m_Controls->m_BallWidget1->GetD());
         m_BallModel1.SetT2(m_Controls->m_BallWidget1->GetT2());
         m_BallModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_BallModel1);
         m_ImageGenParameters.signalModelString += "Ball";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_BallModel1.GetT2()) );
         break;
     case 1:
         m_AstrosticksModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_AstrosticksModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_AstrosticksModel1.SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
         m_AstrosticksModel1.SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
         m_AstrosticksModel1.SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
         m_AstrosticksModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_AstrosticksModel1);
         m_ImageGenParameters.signalModelString += "Astrosticks";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_AstrosticksModel1.GetT2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
         break;
     case 2:
         m_DotModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_DotModel1.SetT2(m_Controls->m_DotWidget1->GetT2());
         m_DotModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_DotModel1);
         m_ImageGenParameters.signalModelString += "Dot";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_DotModel1.GetT2()) );
         break;
     }
 
     // compartment 4
     switch (m_Controls->m_Compartment4Box->currentIndex())
     {
     case 0:
         break;
     case 1:
         m_BallModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_BallModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_BallModel2.SetDiffusivity(m_Controls->m_BallWidget2->GetD());
         m_BallModel2.SetT2(m_Controls->m_BallWidget2->GetT2());
         m_BallModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_BallModel2);
         m_ImageGenParameters.signalModelString += "Ball";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_BallModel2.GetT2()) );
         break;
     case 2:
         m_AstrosticksModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_AstrosticksModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_AstrosticksModel2.SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
         m_AstrosticksModel2.SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
         m_AstrosticksModel2.SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
         m_AstrosticksModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_AstrosticksModel2);
         m_ImageGenParameters.signalModelString += "Astrosticks";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_AstrosticksModel2.GetT2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
         break;
     case 3:
         m_DotModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_DotModel2.SetT2(m_Controls->m_DotWidget2->GetT2());
         m_DotModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_DotModel2);
         m_ImageGenParameters.signalModelString += "Dot";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_DotModel2.GetT2()) );
         break;
     }
 
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.InterpolationShrink", IntProperty::New(m_ImageGenParameters.interpolationShrink));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(m_ImageGenParameters.signalScale));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(m_ImageGenParameters.axonRadius));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Tinhom", IntProperty::New(m_ImageGenParameters.tInhom));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Repetitions", IntProperty::New(m_ImageGenParameters.repetitions));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(m_ImageGenParameters.b_value));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Model", StringProperty::New(m_ImageGenParameters.signalModelString.toStdString()));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.PureFiberVoxels", BoolProperty::New(m_ImageGenParameters.doDisablePartialVolume));
     m_ImageGenParameters.resultNode->AddProperty("binary", BoolProperty::New(false));
 }
 
 void QmitkFiberfoxView::SaveParameters()
 {
     UpdateImageParameters();
 
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 QDir::currentPath()+"/param.ffp",
                 tr("Fiberfox Parameters (*.ffp)") );
 
     if(filename.isEmpty() || filename.isNull())
         return;
     if(!filename.endsWith(".ffp"))
         filename += ".ffp";
 
     boost::property_tree::ptree parameters;
 
     // fiber generation parameters
     parameters.put("fiberfox.fibers.realtime", m_Controls->m_RealTimeFibers->isChecked());
     parameters.put("fiberfox.fibers.showadvanced", m_Controls->m_AdvancedOptionsBox->isChecked());
     parameters.put("fiberfox.fibers.distribution", m_Controls->m_DistributionBox->currentIndex());
     parameters.put("fiberfox.fibers.variance", m_Controls->m_VarianceBox->value());
     parameters.put("fiberfox.fibers.density", m_Controls->m_FiberDensityBox->value());
     parameters.put("fiberfox.fibers.spline.sampling", m_Controls->m_FiberSamplingBox->value());
     parameters.put("fiberfox.fibers.spline.tension", m_Controls->m_TensionBox->value());
     parameters.put("fiberfox.fibers.spline.continuity", m_Controls->m_ContinuityBox->value());
     parameters.put("fiberfox.fibers.spline.bias", m_Controls->m_BiasBox->value());
     parameters.put("fiberfox.fibers.constantradius", m_Controls->m_ConstantRadiusBox->isChecked());
     parameters.put("fiberfox.fibers.rotation.x", m_Controls->m_XrotBox->value());
     parameters.put("fiberfox.fibers.rotation.y", m_Controls->m_YrotBox->value());
     parameters.put("fiberfox.fibers.rotation.z", m_Controls->m_ZrotBox->value());
     parameters.put("fiberfox.fibers.translation.x", m_Controls->m_XtransBox->value());
     parameters.put("fiberfox.fibers.translation.y", m_Controls->m_YtransBox->value());
     parameters.put("fiberfox.fibers.translation.z", m_Controls->m_ZtransBox->value());
     parameters.put("fiberfox.fibers.scale.x", m_Controls->m_XscaleBox->value());
     parameters.put("fiberfox.fibers.scale.y", m_Controls->m_YscaleBox->value());
     parameters.put("fiberfox.fibers.scale.z", m_Controls->m_ZscaleBox->value());
     parameters.put("fiberfox.fibers.includeFiducials", m_Controls->m_IncludeFiducials->isChecked());
     parameters.put("fiberfox.fibers.includeFiducials", m_Controls->m_IncludeFiducials->isChecked());
 
     // image generation parameters
     parameters.put("fiberfox.image.basic.size.x", m_ImageGenParameters.imageRegion.GetSize(0));
     parameters.put("fiberfox.image.basic.size.y", m_ImageGenParameters.imageRegion.GetSize(1));
     parameters.put("fiberfox.image.basic.size.z", m_ImageGenParameters.imageRegion.GetSize(2));
     parameters.put("fiberfox.image.basic.spacing.x", m_ImageGenParameters.imageSpacing[0]);
     parameters.put("fiberfox.image.basic.spacing.y", m_ImageGenParameters.imageSpacing[1]);
     parameters.put("fiberfox.image.basic.spacing.z", m_ImageGenParameters.imageSpacing[2]);
     parameters.put("fiberfox.image.basic.numgradients", m_ImageGenParameters.numGradients);
     parameters.put("fiberfox.image.basic.bvalue", m_ImageGenParameters.b_value);
     parameters.put("fiberfox.image.showadvanced", m_Controls->m_AdvancedOptionsBox_2->isChecked());
     parameters.put("fiberfox.image.repetitions", m_ImageGenParameters.repetitions);
     parameters.put("fiberfox.image.signalScale", m_ImageGenParameters.signalScale);
     parameters.put("fiberfox.image.tEcho", m_ImageGenParameters.tEcho);
     parameters.put("fiberfox.image.tLine", m_Controls->m_LineReadoutTimeBox->value());
     parameters.put("fiberfox.image.tInhom", m_ImageGenParameters.tInhom);
     parameters.put("fiberfox.image.axonRadius", m_ImageGenParameters.axonRadius);
     parameters.put("fiberfox.image.interpolationShrink", m_ImageGenParameters.interpolationShrink);
     parameters.put("fiberfox.image.doSimulateRelaxation", m_ImageGenParameters.doSimulateRelaxation);
     parameters.put("fiberfox.image.doDisablePartialVolume", m_ImageGenParameters.doDisablePartialVolume);
     parameters.put("fiberfox.image.outputvolumefractions", m_Controls->m_VolumeFractionsBox->isChecked());
 
     parameters.put("fiberfox.image.artifacts.addnoise", m_Controls->m_AddNoise->isChecked());
     parameters.put("fiberfox.image.artifacts.noisevariance", m_Controls->m_NoiseLevel->value());
     parameters.put("fiberfox.image.artifacts.addghost", m_Controls->m_AddGhosts->isChecked());
     parameters.put("fiberfox.image.artifacts.kspaceLineOffset", m_Controls->m_kOffsetBox->value());
     parameters.put("fiberfox.image.artifacts.distortions", m_Controls->m_AddDistortions->isChecked());
     parameters.put("fiberfox.image.artifacts.addeddy", m_Controls->m_AddEddy->isChecked());
     parameters.put("fiberfox.image.artifacts.eddyStrength", m_Controls->m_EddyGradientStrength->value());
     parameters.put("fiberfox.image.artifacts.addringing", m_Controls->m_AddGibbsRinging->isChecked());
     parameters.put("fiberfox.image.artifacts.ringingupsampling", m_Controls->m_ImageUpsamplingBox->value());
 
     parameters.put("fiberfox.image.compartment1.index", m_Controls->m_Compartment1Box->currentIndex());
     parameters.put("fiberfox.image.compartment2.index", m_Controls->m_Compartment2Box->currentIndex());
     parameters.put("fiberfox.image.compartment3.index", m_Controls->m_Compartment3Box->currentIndex());
     parameters.put("fiberfox.image.compartment4.index", m_Controls->m_Compartment4Box->currentIndex());
 
     parameters.put("fiberfox.image.compartment1.stick.d", m_Controls->m_StickWidget1->GetD());
     parameters.put("fiberfox.image.compartment1.stick.t2", m_Controls->m_StickWidget1->GetT2());
     parameters.put("fiberfox.image.compartment1.zeppelin.d1", m_Controls->m_ZeppelinWidget1->GetD1());
     parameters.put("fiberfox.image.compartment1.zeppelin.d2", m_Controls->m_ZeppelinWidget1->GetD2());
     parameters.put("fiberfox.image.compartment1.zeppelin.t2", m_Controls->m_ZeppelinWidget1->GetT2());
     parameters.put("fiberfox.image.compartment1.tensor.d1", m_Controls->m_TensorWidget1->GetD1());
     parameters.put("fiberfox.image.compartment1.tensor.d2", m_Controls->m_TensorWidget1->GetD2());
     parameters.put("fiberfox.image.compartment1.tensor.d3", m_Controls->m_TensorWidget1->GetD3());
     parameters.put("fiberfox.image.compartment1.tensor.t2", m_Controls->m_TensorWidget1->GetT2());
 
     parameters.put("fiberfox.image.compartment2.stick.d", m_Controls->m_StickWidget2->GetD());
     parameters.put("fiberfox.image.compartment2.stick.t2", m_Controls->m_StickWidget2->GetT2());
     parameters.put("fiberfox.image.compartment2.zeppelin.d1", m_Controls->m_ZeppelinWidget2->GetD1());
     parameters.put("fiberfox.image.compartment2.zeppelin.d2", m_Controls->m_ZeppelinWidget2->GetD2());
     parameters.put("fiberfox.image.compartment2.zeppelin.t2", m_Controls->m_ZeppelinWidget2->GetT2());
     parameters.put("fiberfox.image.compartment2.tensor.d1", m_Controls->m_TensorWidget2->GetD1());
     parameters.put("fiberfox.image.compartment2.tensor.d2", m_Controls->m_TensorWidget2->GetD2());
     parameters.put("fiberfox.image.compartment2.tensor.d3", m_Controls->m_TensorWidget2->GetD3());
     parameters.put("fiberfox.image.compartment2.tensor.t2", m_Controls->m_TensorWidget2->GetT2());
 
     parameters.put("fiberfox.image.compartment3.ball.d", m_Controls->m_BallWidget1->GetD());
     parameters.put("fiberfox.image.compartment3.ball.t2", m_Controls->m_BallWidget1->GetT2());
     parameters.put("fiberfox.image.compartment3.astrosticks.d", m_Controls->m_AstrosticksWidget1->GetD());
     parameters.put("fiberfox.image.compartment3.astrosticks.t2", m_Controls->m_AstrosticksWidget1->GetT2());
     parameters.put("fiberfox.image.compartment3.astrosticks.randomize", m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
     parameters.put("fiberfox.image.compartment3.dot.t2", m_Controls->m_DotWidget1->GetT2());
 
     parameters.put("fiberfox.image.compartment4.ball.d", m_Controls->m_BallWidget2->GetD());
     parameters.put("fiberfox.image.compartment4.ball.t2", m_Controls->m_BallWidget2->GetT2());
     parameters.put("fiberfox.image.compartment4.astrosticks.d", m_Controls->m_AstrosticksWidget2->GetD());
     parameters.put("fiberfox.image.compartment4.astrosticks.t2", m_Controls->m_AstrosticksWidget2->GetT2());
     parameters.put("fiberfox.image.compartment4.astrosticks.randomize", m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
     parameters.put("fiberfox.image.compartment4.dot.t2", m_Controls->m_DotWidget2->GetT2());
 
     parameters.put("fiberfox.image.compartment4.weight", m_Controls->m_Comp4FractionBox->value());
 
     boost::property_tree::xml_parser::write_xml(filename.toStdString(), parameters);
 }
 
 void QmitkFiberfoxView::LoadParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QDir::currentPath(), tr("Fiberfox Parameters (*.ffp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     boost::property_tree::ptree parameters;
     boost::property_tree::xml_parser::read_xml(filename.toStdString(), parameters);
 
     BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameters.get_child("fiberfox") )
     {
         if( v1.first == "fibers" )
         {
             m_Controls->m_RealTimeFibers->setChecked(v1.second.get<bool>("realtime"));
             m_Controls->m_AdvancedOptionsBox->setChecked(v1.second.get<bool>("showadvanced"));
             m_Controls->m_DistributionBox->setCurrentIndex(v1.second.get<int>("distribution"));
             m_Controls->m_VarianceBox->setValue(v1.second.get<double>("variance"));
             m_Controls->m_FiberDensityBox->setValue(v1.second.get<int>("density"));
             m_Controls->m_IncludeFiducials->setChecked(v1.second.get<bool>("includeFiducials"));
             m_Controls->m_ConstantRadiusBox->setChecked(v1.second.get<bool>("constantradius"));
 
             BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second )
             {
                 if( v2.first == "spline" )
                 {
                     m_Controls->m_FiberSamplingBox->setValue(v2.second.get<double>("sampling"));
                     m_Controls->m_TensionBox->setValue(v2.second.get<double>("tension"));
                     m_Controls->m_ContinuityBox->setValue(v2.second.get<double>("continuity"));
                     m_Controls->m_BiasBox->setValue(v2.second.get<double>("bias"));
                 }
                 if( v2.first == "rotation" )
                 {
                     m_Controls->m_XrotBox->setValue(v2.second.get<double>("x"));
                     m_Controls->m_YrotBox->setValue(v2.second.get<double>("y"));
                     m_Controls->m_ZrotBox->setValue(v2.second.get<double>("z"));
                 }
                 if( v2.first == "translation" )
                 {
                     m_Controls->m_XtransBox->setValue(v2.second.get<double>("x"));
                     m_Controls->m_YtransBox->setValue(v2.second.get<double>("y"));
                     m_Controls->m_ZtransBox->setValue(v2.second.get<double>("z"));
                 }
                 if( v2.first == "scale" )
                 {
                     m_Controls->m_XscaleBox->setValue(v2.second.get<double>("x"));
                     m_Controls->m_YscaleBox->setValue(v2.second.get<double>("y"));
                     m_Controls->m_ZscaleBox->setValue(v2.second.get<double>("z"));
                 }
             }
         }
         if( v1.first == "image" )
         {
             m_Controls->m_SizeX->setValue(v1.second.get<int>("basic.size.x"));
             m_Controls->m_SizeY->setValue(v1.second.get<int>("basic.size.y"));
             m_Controls->m_SizeZ->setValue(v1.second.get<int>("basic.size.z"));
             m_Controls->m_SpacingX->setValue(v1.second.get<double>("basic.spacing.x"));
             m_Controls->m_SpacingY->setValue(v1.second.get<double>("basic.spacing.y"));
             m_Controls->m_SpacingZ->setValue(v1.second.get<double>("basic.spacing.z"));
             m_Controls->m_NumGradientsBox->setValue(v1.second.get<int>("basic.numgradients"));
             m_Controls->m_BvalueBox->setValue(v1.second.get<int>("basic.bvalue"));
             m_Controls->m_AdvancedOptionsBox_2->setChecked(v1.second.get<bool>("showadvanced"));
             m_Controls->m_RepetitionsBox->setValue(v1.second.get<int>("repetitions"));
             m_Controls->m_SignalScaleBox->setValue(v1.second.get<int>("signalScale"));
             m_Controls->m_TEbox->setValue(v1.second.get<double>("tEcho"));
             m_Controls->m_LineReadoutTimeBox->setValue(v1.second.get<double>("tLine"));
             m_Controls->m_T2starBox->setValue(v1.second.get<double>("tInhom"));
             m_Controls->m_FiberRadius->setValue(v1.second.get<double>("axonRadius"));
             m_Controls->m_InterpolationShrink->setValue(v1.second.get<int>("interpolationShrink"));
             m_Controls->m_RelaxationBox->setChecked(v1.second.get<bool>("doSimulateRelaxation"));
             m_Controls->m_EnforcePureFiberVoxelsBox->setChecked(v1.second.get<bool>("doDisablePartialVolume"));
             m_Controls->m_VolumeFractionsBox->setChecked(v1.second.get<bool>("outputvolumefractions"));
 
             m_Controls->m_AddNoise->setChecked(v1.second.get<bool>("artifacts.addnoise"));
             m_Controls->m_NoiseLevel->setValue(v1.second.get<double>("artifacts.noisevariance"));
             m_Controls->m_AddGhosts->setChecked(v1.second.get<bool>("artifacts.addghost"));
             m_Controls->m_kOffsetBox->setValue(v1.second.get<double>("artifacts.kspaceLineOffset"));
             m_Controls->m_AddDistortions->setChecked(v1.second.get<bool>("artifacts.distortions"));
 
             m_Controls->m_AddEddy->setChecked(v1.second.get<bool>("artifacts.addeddy"));
             m_Controls->m_EddyGradientStrength->setValue(v1.second.get<double>("artifacts.eddyStrength"));
             m_Controls->m_AddGibbsRinging->setChecked(v1.second.get<bool>("artifacts.addringing"));
             m_Controls->m_ImageUpsamplingBox->setValue(v1.second.get<double>("artifacts.ringingupsampling"));
 
             m_Controls->m_Compartment1Box->setCurrentIndex(v1.second.get<int>("compartment1.index"));
             m_Controls->m_Compartment2Box->setCurrentIndex(v1.second.get<int>("compartment2.index"));
             m_Controls->m_Compartment3Box->setCurrentIndex(v1.second.get<int>("compartment3.index"));
             m_Controls->m_Compartment4Box->setCurrentIndex(v1.second.get<int>("compartment4.index"));
 
 
             m_Controls->m_StickWidget1->SetD(v1.second.get<double>("compartment1.stick.d"));
             m_Controls->m_StickWidget1->SetT2(v1.second.get<double>("compartment1.stick.t2"));
             m_Controls->m_ZeppelinWidget1->SetD1(v1.second.get<double>("compartment1.zeppelin.d1"));
             m_Controls->m_ZeppelinWidget1->SetD2(v1.second.get<double>("compartment1.zeppelin.d2"));
             m_Controls->m_ZeppelinWidget1->SetT2(v1.second.get<double>("compartment1.zeppelin.t2"));
             m_Controls->m_TensorWidget1->SetD1(v1.second.get<double>("compartment1.tensor.d1"));
             m_Controls->m_TensorWidget1->SetD2(v1.second.get<double>("compartment1.tensor.d2"));
             m_Controls->m_TensorWidget1->SetD3(v1.second.get<double>("compartment1.tensor.d3"));
             m_Controls->m_TensorWidget1->SetT2(v1.second.get<double>("compartment1.tensor.t2"));
 
             m_Controls->m_StickWidget2->SetD(v1.second.get<double>("compartment2.stick.d"));
             m_Controls->m_StickWidget2->SetT2(v1.second.get<double>("compartment2.stick.t2"));
             m_Controls->m_ZeppelinWidget2->SetD1(v1.second.get<double>("compartment2.zeppelin.d1"));
             m_Controls->m_ZeppelinWidget2->SetD2(v1.second.get<double>("compartment2.zeppelin.d2"));
             m_Controls->m_ZeppelinWidget2->SetT2(v1.second.get<double>("compartment2.zeppelin.t2"));
             m_Controls->m_TensorWidget2->SetD1(v1.second.get<double>("compartment2.tensor.d1"));
             m_Controls->m_TensorWidget2->SetD2(v1.second.get<double>("compartment2.tensor.d2"));
             m_Controls->m_TensorWidget2->SetD3(v1.second.get<double>("compartment2.tensor.d3"));
             m_Controls->m_TensorWidget2->SetT2(v1.second.get<double>("compartment2.tensor.t2"));
 
             m_Controls->m_BallWidget1->SetD(v1.second.get<double>("compartment3.ball.d"));
             m_Controls->m_BallWidget1->SetT2(v1.second.get<double>("compartment3.ball.t2"));
             m_Controls->m_AstrosticksWidget1->SetD(v1.second.get<double>("compartment3.astrosticks.d"));
             m_Controls->m_AstrosticksWidget1->SetT2(v1.second.get<double>("compartment3.astrosticks.t2"));
             m_Controls->m_AstrosticksWidget1->SetRandomizeSticks(v1.second.get<bool>("compartment3.astrosticks.randomize"));
             m_Controls->m_DotWidget1->SetT2(v1.second.get<double>("compartment3.dot.t2"));
 
             m_Controls->m_BallWidget2->SetD(v1.second.get<double>("compartment4.ball.d"));
             m_Controls->m_BallWidget2->SetT2(v1.second.get<double>("compartment4.ball.t2"));
             m_Controls->m_AstrosticksWidget2->SetD(v1.second.get<double>("compartment4.astrosticks.d"));
             m_Controls->m_AstrosticksWidget2->SetT2(v1.second.get<double>("compartment4.astrosticks.t2"));
             m_Controls->m_AstrosticksWidget2->SetRandomizeSticks(v1.second.get<bool>("compartment4.astrosticks.randomize"));
             m_Controls->m_DotWidget2->SetT2(v1.second.get<double>("compartment4.dot.t2"));
 
             m_Controls->m_Comp4FractionBox->setValue(v1.second.get<double>("compartment4.weight"));
         }
     }
     UpdateImageParameters();
 }
 
 void QmitkFiberfoxView::ShowAdvancedOptions(int state)
 {
     if (state)
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedOptionsBox->setChecked(true);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(true);
     }
     else
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedOptionsBox->setChecked(false);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(false);
     }
 }
 
 void QmitkFiberfoxView::Comp1ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget1->setVisible(false);
     m_Controls->m_ZeppelinWidget1->setVisible(false);
     m_Controls->m_TensorWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_StickWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_ZeppelinWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_TensorWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp2ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget2->setVisible(false);
     m_Controls->m_ZeppelinWidget2->setVisible(false);
     m_Controls->m_TensorWidget2->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_StickWidget2->setVisible(true);
         break;
     case 2:
         m_Controls->m_ZeppelinWidget2->setVisible(true);
         break;
     case 3:
         m_Controls->m_TensorWidget2->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp3ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget1->setVisible(false);
     m_Controls->m_AstrosticksWidget1->setVisible(false);
     m_Controls->m_DotWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_BallWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_AstrosticksWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_DotWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp4ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget2->setVisible(false);
     m_Controls->m_AstrosticksWidget2->setVisible(false);
     m_Controls->m_DotWidget2->setVisible(false);
     m_Controls->m_Comp4FractionFrame->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_BallWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_AstrosticksWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_DotWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::OnConstantRadius(int value)
 {
     if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnAddEddy(int value)
 {
     if (value>0)
         m_Controls->m_EddyFrame->setVisible(true);
     else
         m_Controls->m_EddyFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddDistortions(int value)
 {
     if (value>0)
         m_Controls->m_DistortionsFrame->setVisible(true);
     else
         m_Controls->m_DistortionsFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGhosts(int value)
 {
     if (value>0)
         m_Controls->m_GhostFrame->setVisible(true);
     else
         m_Controls->m_GhostFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddNoise(int value)
 {
     if (value>0)
         m_Controls->m_NoiseFrame->setVisible(true);
     else
         m_Controls->m_NoiseFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGibbsRinging(int value)
 {
     if (value>0)
         m_Controls->m_GibbsRingingFrame->setVisible(true);
     else
         m_Controls->m_GibbsRingingFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnDistributionChanged(int value)
 {
     if (value==1)
         m_Controls->m_VarianceBox->setVisible(true);
     else
         m_Controls->m_VarianceBox->setVisible(false);
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnVarianceChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberDensityChanged(int value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberSamplingChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnTensionChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnContinuityChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnBiasChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::AlignOnGrid()
 {
     for (int i=0; i<m_SelectedFiducials.size(); i++)
     {
         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
         mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
         {
             mitk::DataNode::Pointer pFibNode = *it;
             if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pFibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer pImgNode = *it2;
                     if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
                     {
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
 
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
 
                         break;
                     }
                 }
                 break;
             }
         }
     }
 
     for( int i=0; i<m_SelectedBundles2.size(); i++ )
     {
         mitk::DataNode::Pointer fibNode = m_SelectedBundles2.at(i);
 
         mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(fibNode);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = sources->begin(); it != sources->end(); ++it )
         {
             mitk::DataNode::Pointer imgNode = *it;
             if ( imgNode.IsNotNull() && dynamic_cast<mitk::Image*>(imgNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(imgNode->GetData());
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
 
                 break;
             }
         }
     }
 
     for( int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
 
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
             }
         }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFlipButton()
 {
     if (m_SelectedFiducial.IsNull())
         return;
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
         data.m_Flipped += 1;
         data.m_Flipped %= 2;
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
 {
     NPoints *= 2;
     GradientListType pointshell;
 
     int numB0 = NPoints/20;
     if (numB0==0)
         numB0=1;
     GradientType g;
     g.Fill(0.0);
     for (int i=0; i<numB0; i++)
         pointshell.push_back(g);
 
     if (NPoints==0)
         return pointshell;
 
     vnl_vector<double> theta; theta.set_size(NPoints);
     vnl_vector<double> phi; phi.set_size(NPoints);
     double C = sqrt(4*M_PI);
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
             // % (2*DIST_POINTSHELL_PI);
         }
     }
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         pointshell.push_back(g);
     }
 
     return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
 {
     std::vector<itk::Vector<double,3> > retval;
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
     // Add 0 vector for B0
     int numB0 = ndirs/10;
     if (numB0==0)
         numB0=1;
     itk::Vector<double,3> v;
     v.Fill(0.0);
     for (int i=0; i<numB0; i++)
     {
         retval.push_back(v);
     }
 
     for(int i=0; i<ndirs;i++)
     {
         itk::Vector<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval.push_back(v);
     }
 
     return retval;
 }
 
 void QmitkFiberfoxView::OnAddBundle()
 {
     if (m_SelectedImage.IsNull())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
 
     mitk::FiberBundleX::Pointer bundle = mitk::FiberBundleX::New();
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( bundle );
     QString name = QString("Bundle_%1").arg(children->size());
     node->SetName(name.toStdString());
     m_SelectedBundles.push_back(node);
     UpdateGui();
 
     GetDataStorage()->Add(node, m_SelectedImage);
 }
 
 void QmitkFiberfoxView::OnDrawROI()
 {
     if (m_SelectedBundles.empty())
         OnAddBundle();
     if (m_SelectedBundles.empty())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
 
     mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( figure );
 
 
     QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
     for( int i=0; i<nodes.size(); i++)
         nodes.at(i)->SetSelected(false);
 
     m_SelectedFiducial = node;
 
     QString name = QString("Fiducial_%1").arg(children->size());
     node->SetName(name.toStdString());
     node->SetSelected(true);
     GetDataStorage()->Add(node, m_SelectedBundles.at(0));
 
     this->DisableCrosshairNavigation();
 
-    mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor());
+    mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( node );
     }
 
     UpdateGui();
 }
 
 bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
 {
     int li = -1;
     i->GetPropertyValue("layer", li);
     int lj = -1;
     j->GetPropertyValue("layer", lj);
     return li<lj;
 }
 
 void QmitkFiberfoxView::GenerateFibers()
 {
     if (m_SelectedBundles.empty())
     {
         if (m_SelectedFiducial.IsNull())
             return;
 
         mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             if(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()))
                 m_SelectedBundles.push_back(*it);
 
         if (m_SelectedBundles.empty())
             return;
     }
 
     vector< vector< mitk::PlanarEllipse::Pointer > > fiducials;
     vector< vector< unsigned int > > fliplist;
     for (int i=0; i<m_SelectedBundles.size(); i++)
     {
         mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(i));
         std::vector< mitk::DataNode::Pointer > childVector;
         for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
             childVector.push_back(*it);
         sort(childVector.begin(), childVector.end(), CompareLayer);
 
         vector< mitk::PlanarEllipse::Pointer > fib;
         vector< unsigned int > flip;
         float radius = 1;
         int count = 0;
         for( std::vector< mitk::DataNode::Pointer >::const_iterator it = childVector.begin(); it != childVector.end(); ++it )
         {
             mitk::DataNode::Pointer node = *it;
 
             if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
             {
                 mitk::PlanarEllipse* ellipse = dynamic_cast<mitk::PlanarEllipse*>(node->GetData());
                 if (m_Controls->m_ConstantRadiusBox->isChecked())
                 {
                     ellipse->SetTreatAsCircle(true);
                     mitk::Point2D c = ellipse->GetControlPoint(0);
                     mitk::Point2D p = ellipse->GetControlPoint(1);
                     mitk::Vector2D v = p-c;
                     if (count==0)
                     {
                         radius = v.GetVnlVector().magnitude();
                         ellipse->SetControlPoint(1, p);
                     }
                     else
                     {
                         v.Normalize();
                         v *= radius;
                         ellipse->SetControlPoint(1, c+v);
                     }
                 }
                 fib.push_back(ellipse);
 
                 std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(node.GetPointer());
                 if( it != m_DataNodeToPlanarFigureData.end() )
                 {
                     QmitkPlanarFigureData& data = it->second;
                     flip.push_back(data.m_Flipped);
                 }
                 else
                     flip.push_back(0);
             }
             count++;
         }
         if (fib.size()>1)
         {
             fiducials.push_back(fib);
             fliplist.push_back(flip);
         }
         else if (fib.size()>0)
             m_SelectedBundles.at(i)->SetData( mitk::FiberBundleX::New() );
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
     filter->SetFiducials(fiducials);
     filter->SetFlipList(fliplist);
 
     switch(m_Controls->m_DistributionBox->currentIndex()){
     case 0:
         filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_UNIFORM);
         break;
     case 1:
         filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_GAUSSIAN);
         filter->SetVariance(m_Controls->m_VarianceBox->value());
         break;
     }
 
     filter->SetDensity(m_Controls->m_FiberDensityBox->value());
     filter->SetTension(m_Controls->m_TensionBox->value());
     filter->SetContinuity(m_Controls->m_ContinuityBox->value());
     filter->SetBias(m_Controls->m_BiasBox->value());
     filter->SetFiberSampling(m_Controls->m_FiberSamplingBox->value());
     filter->Update();
     vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
 
     for (int i=0; i<fiberBundles.size(); i++)
     {
         m_SelectedBundles.at(i)->SetData( fiberBundles.at(i) );
         if (fiberBundles.at(i)->GetNumFibers()>50000)
             m_SelectedBundles.at(i)->SetVisibility(false);
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::GenerateImage()
 {
     UpdateImageParameters();
     if (m_SelectedBundles.empty())
     {
         if (m_SelectedDWI.IsNotNull()) // add artifacts to existing diffusion weighted image
         {
             for (int i=0; i<m_SelectedImages.size(); i++)
             {
                 if (!dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedImages.at(i)->GetData()))
                     continue;
 
                 m_SelectedDWI = m_SelectedImages.at(i);
                 UpdateImageParameters();
 
                 mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedImages.at(i)->GetData());
 
                 mitk::RicianNoiseModel<short> noiseModel;
                 noiseModel.SetNoiseVariance(m_ImageGenParameters.ricianNoiseModel.GetNoiseVariance());
 
                 itk::AddArtifactsToDwiImageFilter< short >::Pointer filter = itk::AddArtifactsToDwiImageFilter< short >::New();
                 filter->SetInput(diffImg->GetVectorImage());
                 filter->SettLine(m_ImageGenParameters.tLine);
                 filter->SetkOffset(m_ImageGenParameters.kspaceLineOffset);
                 filter->SetNoiseModel(&noiseModel);
                 filter->SetGradientList(m_ImageGenParameters.gradientDirections);
                 filter->SetTE(m_ImageGenParameters.tEcho);
                 filter->SetSimulateEddyCurrents(m_ImageGenParameters.doSimulateEddyCurrents);
                 filter->SetEddyGradientStrength(m_ImageGenParameters.eddyStrength);
                 filter->SetUpsampling(m_ImageGenParameters.upsampling);
                 filter->SetFrequencyMap(m_ImageGenParameters.frequencyMap);
                 filter->Update();
 
                 mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
                 image->SetVectorImage( filter->GetOutput() );
                 image->SetB_Value(diffImg->GetB_Value());
                 image->SetDirections(diffImg->GetDirections());
                 image->InitializeFromVectorImage();
                 m_ImageGenParameters.resultNode->SetData( image );
                 m_ImageGenParameters.resultNode->SetName(m_SelectedImages.at(i)->GetName()+m_ImageGenParameters.artifactModelString.toStdString());
                 GetDataStorage()->Add(m_ImageGenParameters.resultNode);
             }
             m_SelectedDWI = m_SelectedImages.front();
             return;
         }
 
         mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
                     m_Controls->m_SizeX->value(),
                     m_Controls->m_SizeY->value(),
                     m_Controls->m_SizeZ->value(),
                     m_Controls->m_SpacingX->value(),
                     m_Controls->m_SpacingY->value(),
                     m_Controls->m_SpacingZ->value());
 
         mitk::Geometry3D* geom = image->GetGeometry();
         geom->SetOrigin(m_ImageGenParameters.imageOrigin);
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData( image );
         node->SetName("Dummy");
         unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
         unsigned int level = window/2;
         mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
         node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
         GetDataStorage()->Add(node);
         m_SelectedImage = node;
 
         mitk::BaseData::Pointer basedata = node->GetData();
         if (basedata.IsNotNull())
         {
             mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
         UpdateGui();
 
         return;
     }
 
     for (int i=0; i<m_SelectedBundles.size(); i++)
     {
         mitk::FiberBundleX::Pointer fiberBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedBundles.at(i)->GetData());
         if (fiberBundle->GetNumFibers()<=0)
             continue;
 
         itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
 
         tractsToDwiFilter->SetSimulateEddyCurrents(m_ImageGenParameters.doSimulateEddyCurrents);
         tractsToDwiFilter->SetEddyGradientStrength(m_ImageGenParameters.eddyStrength);
         tractsToDwiFilter->SetUpsampling(m_ImageGenParameters.upsampling);
         tractsToDwiFilter->SetSimulateRelaxation(m_ImageGenParameters.doSimulateRelaxation);
         tractsToDwiFilter->SetImageRegion(m_ImageGenParameters.imageRegion);
         tractsToDwiFilter->SetSpacing(m_ImageGenParameters.imageSpacing);
         tractsToDwiFilter->SetOrigin(m_ImageGenParameters.imageOrigin);
         tractsToDwiFilter->SetDirectionMatrix(m_ImageGenParameters.imageDirection);
         tractsToDwiFilter->SetFiberBundle(fiberBundle);
         tractsToDwiFilter->SetFiberModels(m_ImageGenParameters.fiberModelList);
         tractsToDwiFilter->SetNonFiberModels(m_ImageGenParameters.nonFiberModelList);
         tractsToDwiFilter->SetNoiseModel(&m_ImageGenParameters.ricianNoiseModel);
         tractsToDwiFilter->SetKspaceArtifacts(m_ImageGenParameters.artifactList);
         tractsToDwiFilter->SetkOffset(m_ImageGenParameters.kspaceLineOffset);
         tractsToDwiFilter->SettLine(m_ImageGenParameters.tLine);
         tractsToDwiFilter->SettInhom(m_ImageGenParameters.tInhom);
         tractsToDwiFilter->SetTE(m_ImageGenParameters.tEcho);
         tractsToDwiFilter->SetNumberOfRepetitions(m_ImageGenParameters.repetitions);
         tractsToDwiFilter->SetEnforcePureFiberVoxels(m_ImageGenParameters.doDisablePartialVolume);
         tractsToDwiFilter->SetInterpolationShrink(m_ImageGenParameters.interpolationShrink);
         tractsToDwiFilter->SetFiberRadius(m_ImageGenParameters.axonRadius);
         tractsToDwiFilter->SetSignalScale(m_ImageGenParameters.signalScale);
         if (m_ImageGenParameters.interpolationShrink)
             tractsToDwiFilter->SetUseInterpolation(true);
         tractsToDwiFilter->SetTissueMask(m_ImageGenParameters.tissueMaskImage);
         tractsToDwiFilter->SetFrequencyMap(m_ImageGenParameters.frequencyMap);
 
         tractsToDwiFilter->Update();
 
         mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
         image->SetVectorImage( tractsToDwiFilter->GetOutput() );
         image->SetB_Value(m_ImageGenParameters.b_value);
         image->SetDirections(m_ImageGenParameters.gradientDirections);
         image->InitializeFromVectorImage();
         m_ImageGenParameters.resultNode->SetData( image );
         m_ImageGenParameters.resultNode->SetName(m_SelectedBundles.at(i)->GetName()
                                                  +"_D"+QString::number(m_ImageGenParameters.imageRegion.GetSize(0)).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageRegion.GetSize(1)).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageRegion.GetSize(2)).toStdString()
                                                  +"_S"+QString::number(m_ImageGenParameters.imageSpacing[0]).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageSpacing[1]).toStdString()
                                                  +"-"+QString::number(m_ImageGenParameters.imageSpacing[2]).toStdString()
                                                  +"_b"+QString::number(m_ImageGenParameters.b_value).toStdString()
                                                  +"_"+m_ImageGenParameters.signalModelString.toStdString()
                                                  +m_ImageGenParameters.artifactModelString.toStdString());
 
         GetDataStorage()->Add(m_ImageGenParameters.resultNode, m_SelectedBundles.at(i));
 
         m_ImageGenParameters.resultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(tractsToDwiFilter->GetLevelWindow()) );
 
         if (m_Controls->m_VolumeFractionsBox->isChecked())
         {
             std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = tractsToDwiFilter->GetVolumeFractions();
             for (int k=0; k<volumeFractions.size(); k++)
             {
                 mitk::Image::Pointer image = mitk::Image::New();
                 image->InitializeByItk(volumeFractions.at(k).GetPointer());
                 image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
 
                 mitk::DataNode::Pointer node = mitk::DataNode::New();
                 node->SetData( image );
                 node->SetName(m_SelectedBundles.at(i)->GetName()+"_CompartmentVolume-"+QString::number(k).toStdString());
                 GetDataStorage()->Add(node, m_SelectedBundles.at(i));
             }
         }
 
         mitk::BaseData::Pointer basedata = m_ImageGenParameters.resultNode->GetData();
         if (basedata.IsNotNull())
         {
             mitk::RenderingManager::GetInstance()->InitializeViews(
                         basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
     }
 }
 
 void QmitkFiberfoxView::ApplyTransform()
 {
     vector< mitk::DataNode::Pointer > selectedBundles;
     for( int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
                 selectedBundles.push_back(fibNode);
         }
     }
     if (selectedBundles.empty())
         selectedBundles = m_SelectedBundles2;
 
     if (!selectedBundles.empty())
     {
         std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin();
         for (it; it!=selectedBundles.end(); ++it)
         {
             mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
             fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
             fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
             fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
 
             // handle child fiducials
             if (m_Controls->m_IncludeFiducials->isChecked())
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Geometry3D* geom = pe->GetGeometry();
 
                         // translate
                         mitk::Vector3D world;
                         world[0] = m_Controls->m_XtransBox->value();
                         world[1] = m_Controls->m_YtransBox->value();
                         world[2] = m_Controls->m_ZtransBox->value();
                         geom->Translate(world);
 
                         // calculate rotation matrix
                         double x = m_Controls->m_XrotBox->value()*M_PI/180;
                         double y = m_Controls->m_YrotBox->value()*M_PI/180;
                         double z = m_Controls->m_ZrotBox->value()*M_PI/180;
 
                         itk::Matrix< float, 3, 3 > rotX; rotX.SetIdentity();
                         rotX[1][1] = cos(x);
                         rotX[2][2] = rotX[1][1];
                         rotX[1][2] = -sin(x);
                         rotX[2][1] = -rotX[1][2];
 
                         itk::Matrix< float, 3, 3 > rotY; rotY.SetIdentity();
                         rotY[0][0] = cos(y);
                         rotY[2][2] = rotY[0][0];
                         rotY[0][2] = sin(y);
                         rotY[2][0] = -rotY[0][2];
 
                         itk::Matrix< float, 3, 3 > rotZ; rotZ.SetIdentity();
                         rotZ[0][0] = cos(z);
                         rotZ[1][1] = rotZ[0][0];
                         rotZ[0][1] = -sin(z);
                         rotZ[1][0] = -rotZ[0][1];
 
                         itk::Matrix< float, 3, 3 > rot = rotZ*rotY*rotX;
 
                         // transform control point coordinate into geometry translation
                         geom->SetOrigin(pe->GetWorldControlPoint(0));
                         mitk::Point2D cp; cp.Fill(0.0);
                         pe->SetControlPoint(0, cp);
 
                         // rotate fiducial
                         geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
 
                         // implicit translation
                         mitk::Vector3D trans;
                         trans[0] = geom->GetOrigin()[0]-fib->GetGeometry()->GetCenter()[0];
                         trans[1] = geom->GetOrigin()[1]-fib->GetGeometry()->GetCenter()[1];
                         trans[2] = geom->GetOrigin()[2]-fib->GetGeometry()->GetCenter()[2];
                         mitk::Vector3D newWc = rot*trans;
                         newWc = newWc-trans;
                         geom->Translate(newWc);
                     }
                 }
             }
         }
     }
     else
     {
         for (int i=0; i<m_SelectedFiducials.size(); i++)
         {
             mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
             mitk::Geometry3D* geom = pe->GetGeometry();
 
             // translate
             mitk::Vector3D world;
             world[0] = m_Controls->m_XtransBox->value();
             world[1] = m_Controls->m_YtransBox->value();
             world[2] = m_Controls->m_ZtransBox->value();
             geom->Translate(world);
 
             // calculate rotation matrix
             double x = m_Controls->m_XrotBox->value()*M_PI/180;
             double y = m_Controls->m_YrotBox->value()*M_PI/180;
             double z = m_Controls->m_ZrotBox->value()*M_PI/180;
             itk::Matrix< float, 3, 3 > rotX; rotX.SetIdentity();
             rotX[1][1] = cos(x);
             rotX[2][2] = rotX[1][1];
             rotX[1][2] = -sin(x);
             rotX[2][1] = -rotX[1][2];
             itk::Matrix< float, 3, 3 > rotY; rotY.SetIdentity();
             rotY[0][0] = cos(y);
             rotY[2][2] = rotY[0][0];
             rotY[0][2] = sin(y);
             rotY[2][0] = -rotY[0][2];
             itk::Matrix< float, 3, 3 > rotZ; rotZ.SetIdentity();
             rotZ[0][0] = cos(z);
             rotZ[1][1] = rotZ[0][0];
             rotZ[0][1] = -sin(z);
             rotZ[1][0] = -rotZ[0][1];
             itk::Matrix< float, 3, 3 > rot = rotZ*rotY*rotX;
 
             // transform control point coordinate into geometry translation
             geom->SetOrigin(pe->GetWorldControlPoint(0));
             mitk::Point2D cp; cp.Fill(0.0);
             pe->SetControlPoint(0, cp);
 
             // rotate fiducial
             geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
         }
         if (m_Controls->m_RealTimeFibers->isChecked())
             GenerateFibers();
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::CopyBundles()
 {
     if ( m_SelectedBundles.size()<1 ){
         QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least one fiber bundle!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
     for (it; it!=m_SelectedBundles.end(); ++it)
     {
         // find parent image
         mitk::DataNode::Pointer parentNode;
         mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
         {
             mitk::DataNode::Pointer pImgNode = *it2;
             if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
             {
                 parentNode = pImgNode;
                 break;
             }
         }
 
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
         mitk::FiberBundleX::Pointer newBundle = fib->GetDeepCopy();
         QString name((*it)->GetName().c_str());
         name += "_copy";
 
         mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
         fbNode->SetData(newBundle);
         fbNode->SetName(name.toStdString());
         fbNode->SetVisibility(true);
         if (parentNode.IsNotNull())
             GetDataStorage()->Add(fbNode, parentNode);
         else
             GetDataStorage()->Add(fbNode);
 
         // copy child fiducials
         if (m_Controls->m_IncludeFiducials->isChecked())
         {
             mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
             for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
             {
                 mitk::DataNode::Pointer fiducialNode = *it2;
                 if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                 {
                     mitk::PlanarEllipse::Pointer pe = mitk::PlanarEllipse::New();
                     pe->DeepCopy(dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()));
                     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
                     newNode->SetData(pe);
                     newNode->SetName(fiducialNode->GetName());
                     GetDataStorage()->Add(newNode, fbNode);
                 }
             }
         }
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::JoinBundles()
 {
     if ( m_SelectedBundles.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
     QString name("");
     name += QString((*it)->GetName().c_str());
     ++it;
     for (it; it!=m_SelectedBundles.end(); ++it)
     {
         newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()));
         name += "+"+QString((*it)->GetName().c_str());
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::UpdateGui()
 {
     m_Controls->m_FiberBundleLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_GeometryFrame->setEnabled(true);
     m_Controls->m_GeometryMessage->setVisible(false);
     m_Controls->m_DiffusionPropsMessage->setVisible(false);
     m_Controls->m_FiberGenMessage->setVisible(true);
 
     m_Controls->m_TransformBundlesButton->setEnabled(false);
     m_Controls->m_CopyBundlesButton->setEnabled(false);
     m_Controls->m_GenerateFibersButton->setEnabled(false);
     m_Controls->m_FlipButton->setEnabled(false);
     m_Controls->m_CircleButton->setEnabled(false);
     m_Controls->m_BvalueBox->setEnabled(true);
     m_Controls->m_NumGradientsBox->setEnabled(true);
     m_Controls->m_JoinBundlesButton->setEnabled(false);
     m_Controls->m_AlignOnGrid->setEnabled(false);
 
     if (m_SelectedFiducial.IsNotNull())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_FlipButton->setEnabled(true);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_SelectedImage.IsNotNull() || !m_SelectedBundles.empty())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_CircleButton->setEnabled(true);
         m_Controls->m_FiberGenMessage->setVisible(false);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_TissueMask.IsNotNull() || m_SelectedImage.IsNotNull())
     {
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (m_SelectedDWI.IsNotNull())
     {
         m_Controls->m_DiffusionPropsMessage->setVisible(true);
         m_Controls->m_BvalueBox->setEnabled(false);
         m_Controls->m_NumGradientsBox->setEnabled(false);
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (!m_SelectedBundles.empty())
     {
         m_Controls->m_CopyBundlesButton->setEnabled(true);
         m_Controls->m_GenerateFibersButton->setEnabled(true);
         m_Controls->m_FiberBundleLabel->setText(m_SelectedBundles.at(0)->GetName().c_str());
 
         if (m_SelectedBundles.size()>1)
             m_Controls->m_JoinBundlesButton->setEnabled(true);
     }
 }
 
 void QmitkFiberfoxView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
 {
     m_SelectedBundles2.clear();
     m_SelectedImages.clear();
     m_SelectedFiducials.clear();
     m_SelectedFiducial = NULL;
     m_TissueMask = NULL;
     m_SelectedBundles.clear();
     m_SelectedImage = NULL;
     m_SelectedDWI = NULL;
     m_Controls->m_TissueMaskLabel->setText("<font color='grey'>optional</font>");
 
     // iterate all selected objects, adjust warning visibility
     for( int i=0; i<nodes.size(); i++)
     {
         mitk::DataNode::Pointer node = nodes.at(i);
 
         if ( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
         {
             m_SelectedDWI = node;
             m_SelectedImage = node;
             m_SelectedImages.push_back(node);
         }
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             m_SelectedImages.push_back(node);
             m_SelectedImage = node;
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
             {
                 m_TissueMask = dynamic_cast<mitk::Image*>(node->GetData());
                 m_Controls->m_TissueMaskLabel->setText(node->GetName().c_str());
             }
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
         {
             m_SelectedBundles2.push_back(node);
             if (m_Controls->m_RealTimeFibers->isChecked())
             {
                 m_SelectedBundles.push_back(node);
                 mitk::FiberBundleX::Pointer newFib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
                 if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
                     GenerateFibers();
             }
             else
                 m_SelectedBundles.push_back(node);
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
         {
             m_SelectedFiducials.push_back(node);
             m_SelectedFiducial = node;
             m_SelectedBundles.clear();
             mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
             for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             {
                 mitk::DataNode::Pointer pNode = *it;
                 if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pNode->GetData()) )
                     m_SelectedBundles.push_back(pNode);
             }
         }
     }
     UpdateGui();
 }
 
 
 void QmitkFiberfoxView::EnableCrosshairNavigation()
 {
     MITK_DEBUG << "EnableCrosshairNavigation";
 
     // enable the crosshair navigation
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "enabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(true);
         //        linkedRenderWindow->EnableSlicingPlanes(true);
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::DisableCrosshairNavigation()
 {
     MITK_DEBUG << "DisableCrosshairNavigation";
 
     // disable the crosshair navigation during the drawing
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "disabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(false);
         //        linkedRenderWindow->EnableSlicingPlanes(false);
     }
 }
 
 void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
 {
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
 
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
 
         // remove observers
         data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
         data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
         data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
         data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
         m_DataNodeToPlanarFigureData.erase( it );
     }
 }
 
 void QmitkFiberfoxView::NodeAdded( const mitk::DataNode* node )
 {
     // add observer for selection in renderwindow
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
     bool isPositionMarker (false);
     node->GetBoolProperty("isContourMarker", isPositionMarker);
     if( figure && !isPositionMarker )
     {
         MITK_DEBUG << "figure added. will add interactor if needed.";
         mitk::PlanarFigureInteractor::Pointer figureInteractor
-                = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor());
+                = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
         mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
         if(figureInteractor.IsNull())
         {
           figureInteractor = mitk::PlanarFigureInteractor::New();
           mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
           figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
           figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
           figureInteractor->SetDataNode( nonConstNode );
         }
 
         MITK_DEBUG << "will now add observers for planarfigure";
         QmitkPlanarFigureData data;
         data.m_Figure = figure;
 
         //        // add observer for event when figure has been placed
         typedef itk::SimpleMemberCommand< QmitkFiberfoxView > SimpleCommandType;
         //        SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
         //        initializationCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureInitialized );
         //        data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
         // add observer for event when figure is picked (selected)
         typedef itk::MemberCommand< QmitkFiberfoxView > MemberCommandType;
         MemberCommandType::Pointer selectCommand = MemberCommandType::New();
         selectCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureSelected );
         data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
         startInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::DisableCrosshairNavigation);
         data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
         endInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::EnableCrosshairNavigation);
         data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
         m_DataNodeToPlanarFigureData[nonConstNode] = data;
     }
 }
 
 void QmitkFiberfoxView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
     mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPf = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer allPfs = this->GetDataStorage()->GetSubset( isPf );
     for ( mitk::DataStorage::SetOfObjects::const_iterator it = allPfs->begin(); it!=allPfs->end(); ++it)
     {
         mitk::DataNode* node = *it;
 
         if( node->GetData() == object )
         {
             node->SetSelected(true);
             m_SelectedFiducial = node;
         }
         else
             node->SetSelected(false);
     }
     UpdateGui();
     this->RequestRenderWindowUpdate();
 }
 
 void QmitkFiberfoxView::SetFocus()
 {
     m_Controls->m_CircleButton->setFocus();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
index 4392acf218..f88a5a0b15 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
@@ -1,2157 +1,2157 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkPartialVolumeAnalysisView.h"
 
 #include <limits>
 
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qlineedit.h>
 #include <qclipboard.h>
 #include <qfiledialog.h>
 
 #include <berryIEditorPart.h>
 #include <berryIWorkbenchPage.h>
 #include <berryPlatform.h>
 
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkStdMultiWidgetEditor.h"
 #include "QmitkSliderNavigatorWidget.h"
 #include <QMessageBox>
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkProperties.h"
 #include "mitkProgressBar.h"
 #include "mitkImageCast.h"
 #include "mitkImageToItk.h"
 #include "mitkITKImageImport.h"
 #include "mitkDataNodeObject.h"
 #include "mitkNodePredicateData.h"
 #include "mitkPlanarFigureInteractor.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkTensorImage.h"
 #include "mitkPlanarCircle.h"
 #include "mitkPlanarRectangle.h"
 #include "mitkPlanarPolygon.h"
 #include "mitkPartialVolumeAnalysisClusteringCalculator.h"
 #include "mitkDiffusionImage.h"
 #include "mitkModuleRegistry.h"
 
 #include <itkVectorImage.h>
 #include "itkTensorDerivedMeasurementsFilter.h"
 #include "itkDiffusionTensor3D.h"
 #include "itkCartesianToPolarVectorImageFilter.h"
 #include "itkPolarToCartesianVectorImageFilter.h"
 #include "itkBinaryThresholdImageFilter.h"
 #include "itkMaskImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkImageMomentsCalculator.h"
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 
 #include <vnl/vnl_vector.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 #define PVA_PI M_PI
 
 const std::string QmitkPartialVolumeAnalysisView::VIEW_ID =
         "org.mitk.views.partialvolumeanalysisview";
 
 class QmitkRequestStatisticsUpdateEvent : public QEvent
 {
 public:
     enum Type
     {
         StatisticsUpdateRequest = QEvent::MaxUser - 1025
     };
 
     QmitkRequestStatisticsUpdateEvent()
         : QEvent( (QEvent::Type) StatisticsUpdateRequest ) {};
 };
 
 
 
 typedef itk::Image<short, 3>                 ImageType;
 typedef itk::Image<float, 3>                 FloatImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>  VectorImageType;
 
 inline bool my_isnan(float x)
 {
     volatile float d = x;
 
     if(d!=d)
         return true;
 
     if(d==d)
         return false;
     return d != d;
 
 }
 
 QmitkPartialVolumeAnalysisView::QmitkPartialVolumeAnalysisView(QObject * /*parent*/, const char * /*name*/)
     : //QmitkFunctionality(),
       m_Controls( NULL ),
       m_TimeStepperAdapter( NULL ),
       m_MeasurementInfoRenderer(0),
       m_MeasurementInfoAnnotation(0),
       m_SelectedImageNodes(  ),
       m_SelectedImage( NULL ),
       m_SelectedMaskNode( NULL ),
       m_SelectedImageMask( NULL ),
       m_SelectedPlanarFigureNodes(0),
       m_SelectedPlanarFigure( NULL ),
       m_IsTensorImage(false),
       m_FAImage(0),
       m_RDImage(0),
       m_ADImage(0),
       m_MDImage(0),
       m_CAImage(0),
       //  m_DirectionImage(0),
       m_DirectionComp1Image(0),
       m_DirectionComp2Image(0),
       m_AngularErrorImage(0),
       m_SelectedRenderWindow(NULL),
       m_LastRenderWindow(NULL),
       m_ImageObserverTag( -1 ),
       m_ImageMaskObserverTag( -1 ),
       m_PlanarFigureObserverTag( -1 ),
       m_CurrentStatisticsValid( false ),
       m_StatisticsUpdatePending( false ),
       m_GaussianSigmaChangedSliding(false),
       m_NumberBinsSliding(false),
       m_UpsamplingChangedSliding(false),
       m_ClusteringResult(NULL),
       m_EllipseCounter(0),
       m_RectangleCounter(0),
       m_PolygonCounter(0),
       m_CurrentFigureNodeInitialized(false),
       m_QuantifyClass(2),
       m_IconTexOFF(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntOFFIcon.png")),
       m_IconTexON(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntONIcon.png")),
       m_TexIsOn(true),
       m_Visible(false)
 {
 
 }
 
 
 QmitkPartialVolumeAnalysisView::~QmitkPartialVolumeAnalysisView()
 {
     if ( m_SelectedImage.IsNotNull() )
         m_SelectedImage->RemoveObserver( m_ImageObserverTag );
     if ( m_SelectedImageMask.IsNotNull() )
         m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
     if ( m_SelectedPlanarFigure.IsNotNull() )
     {
         m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
         m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
     }
 
     this->GetDataStorage()->AddNodeEvent -= mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
             , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage );
 
     m_SelectedPlanarFigureNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                              , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedPlanarFigureNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                              , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     m_SelectedPlanarFigureNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                                  , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
     m_SelectedImageNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedImageNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     m_SelectedImageNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                           , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 }
 
 
 void QmitkPartialVolumeAnalysisView::CreateQtPartControl(QWidget *parent)
 {
     if (m_Controls == NULL)
     {
         m_Controls = new Ui::QmitkPartialVolumeAnalysisViewControls;
         m_Controls->setupUi(parent);
         this->CreateConnections();
     }
 
     SetHistogramVisibility();
 
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
 
     m_Controls->m_SimilarAnglesFrame->setVisible(false);
     m_Controls->m_SimilarAnglesLabel->setVisible(false);
 
     vtkTextProperty *textProp = vtkTextProperty::New();
     textProp->SetColor(1.0, 1.0, 1.0);
 
     m_MeasurementInfoAnnotation = vtkCornerAnnotation::New();
     m_MeasurementInfoAnnotation->SetMaximumFontSize(12);
     m_MeasurementInfoAnnotation->SetTextProperty(textProp);
 
     m_MeasurementInfoRenderer = vtkRenderer::New();
     m_MeasurementInfoRenderer->AddActor(m_MeasurementInfoAnnotation);
 
     m_SelectedPlanarFigureNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
     m_SelectedPlanarFigureNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                           , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedPlanarFigureNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                           , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     m_SelectedPlanarFigureNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                               , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
     m_SelectedImageNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
     m_SelectedImageNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                        , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
     m_SelectedImageNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                    , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedImageNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                    , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     this->GetDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage ) );
 
     Select(NULL,true,true);
 
     SetAdvancedVisibility();
 }
 
 void QmitkPartialVolumeAnalysisView::SetHistogramVisibility()
 {
     m_Controls->m_HistogramWidget->setVisible(m_Controls->m_DisplayHistogramCheckbox->isChecked());
 }
 
 void QmitkPartialVolumeAnalysisView::SetAdvancedVisibility()
 {
     m_Controls->frame_7->setVisible(m_Controls->m_AdvancedCheckbox->isChecked());
 }
 
 void QmitkPartialVolumeAnalysisView::CreateConnections()
 {
     if ( m_Controls )
     {
 
         connect( m_Controls->m_DisplayHistogramCheckbox, SIGNAL( clicked() )
                  , this, SLOT( SetHistogramVisibility() ) );
 
         connect( m_Controls->m_AdvancedCheckbox, SIGNAL( clicked() )
                  , this, SLOT( SetAdvancedVisibility() ) );
 
 
         connect( m_Controls->m_NumberBinsSlider, SIGNAL( sliderReleased () ),
                  this, SLOT( NumberBinsReleasedSlider( ) ) );
         connect( m_Controls->m_UpsamplingSlider, SIGNAL( sliderReleased(  ) ),
                  this, SLOT( UpsamplingReleasedSlider( ) ) );
         connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( sliderReleased(  ) ),
                  this, SLOT( GaussianSigmaReleasedSlider(  ) ) );
         connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( sliderReleased(  ) ),
                  this, SLOT( SimilarAnglesReleasedSlider(  ) ) );
 
         connect( m_Controls->m_NumberBinsSlider, SIGNAL( valueChanged (int) ),
                  this, SLOT( NumberBinsChangedSlider( int ) ) );
         connect( m_Controls->m_UpsamplingSlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( UpsamplingChangedSlider( int ) ) );
         connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( GaussianSigmaChangedSlider( int ) ) );
         connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( SimilarAnglesChangedSlider(int) ) );
 
         connect( m_Controls->m_OpacitySlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( OpacityChangedSlider(int) ) );
 
         connect( (QObject*)(m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ToClipBoard()));
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() )
                  , this, SLOT( ActionDrawEllipseTriggered() ) );
 
         connect( m_Controls->m_RectangleButton, SIGNAL( clicked() )
                  , this, SLOT( ActionDrawRectangleTriggered() ) );
 
         connect( m_Controls->m_PolygonButton, SIGNAL( clicked() )
                  , this, SLOT( ActionDrawPolygonTriggered() ) );
 
         connect( m_Controls->m_GreenRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( GreenRadio(bool) ) );
 
         connect( m_Controls->m_PartialVolumeRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( PartialVolumeRadio(bool) ) );
 
         connect( m_Controls->m_BlueRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( BlueRadio(bool) ) );
 
         connect( m_Controls->m_AllRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( AllRadio(bool) ) );
 
         connect( m_Controls->m_EstimateCircle, SIGNAL( clicked() )
                  , this, SLOT( EstimateCircle() ) );
 
         connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
 
         connect( m_Controls->m_ExportClusteringResultsButton, SIGNAL(clicked()), this, SLOT(ExportClusteringResults()));
     }
 }
 
 void QmitkPartialVolumeAnalysisView::ExportClusteringResults()
 {
     if (m_ClusteringResult.IsNull() || m_SelectedImage.IsNull())
         return;
 
     mitk::Geometry3D* geometry = m_SelectedImage->GetGeometry();
 
     itk::Image< short, 3>::Pointer referenceImage = itk::Image< short, 3>::New();
 
     itk::Vector<double,3> newSpacing = geometry->GetSpacing();
     mitk::Point3D newOrigin = geometry->GetOrigin();
     mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
     newOrigin[0] += bounds.GetElement(0);
     newOrigin[1] += bounds.GetElement(2);
     newOrigin[2] += bounds.GetElement(4);
     itk::Matrix<double, 3, 3> newDirection;
     itk::ImageRegion<3> imageRegion;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
             newDirection[j][i] = geometry->GetMatrixColumn(i)[j]/newSpacing[j];
     imageRegion.SetSize(0, geometry->GetExtent(0));
     imageRegion.SetSize(1, geometry->GetExtent(1));
     imageRegion.SetSize(2, geometry->GetExtent(2));
 
     // apply new image parameters
     referenceImage->SetSpacing( newSpacing );
     referenceImage->SetOrigin( newOrigin );
     referenceImage->SetDirection( newDirection );
     referenceImage->SetRegions( imageRegion );
     referenceImage->Allocate();
 
     typedef itk::Image< float, 3 > OutType;
     mitk::Image::Pointer mitkInImage = dynamic_cast<mitk::Image*>(m_ClusteringResult->GetData());
 
     typedef itk::Image< itk::RGBAPixel<unsigned char>, 3 > ItkRgbaImageType;
     typedef mitk::ImageToItk< ItkRgbaImageType > CasterType;
 
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(mitkInImage);
     caster->Update();
     ItkRgbaImageType::Pointer itkInImage = caster->GetOutput();
 
     typedef itk::ExtractChannelFromRgbaImageFilter< itk::Image< short, 3>, OutType > ExtractionFilterType;
     ExtractionFilterType::Pointer filter = ExtractionFilterType::New();
     filter->SetInput(itkInImage);
     filter->SetChannel(ExtractionFilterType::ALPHA);
     filter->SetReferenceImage(referenceImage);
     filter->Update();
     OutType::Pointer outImg = filter->GetOutput();
 
     mitk::Image::Pointer img = mitk::Image::New();  img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     node->SetName("Clustering Result");
     GetDataStorage()->Add(node);
 }
 
 void QmitkPartialVolumeAnalysisView::EstimateCircle()
 {
     typedef itk::Image<unsigned char, 3> SegImageType;
     SegImageType::Pointer mask_itk = SegImageType::New();
 
     typedef mitk::ImageToItk<SegImageType> CastType;
     CastType::Pointer caster = CastType::New();
     caster->SetInput(m_SelectedImageMask);
     caster->Update();
 
     typedef itk::ImageMomentsCalculator< SegImageType > MomentsType;
     MomentsType::Pointer momentsCalc = MomentsType::New();
     momentsCalc->SetImage(caster->GetOutput());
     momentsCalc->Compute();
     MomentsType::VectorType cog = momentsCalc->GetCenterOfGravity();
     MomentsType::MatrixType axes = momentsCalc->GetPrincipalAxes();
     MomentsType::VectorType moments = momentsCalc->GetPrincipalMoments();
 
     // moments-coord conversion
     // third coordinate min oder max?
 
     // max-min = extent
 
     MomentsType::AffineTransformPointer trafo = momentsCalc->GetPhysicalAxesToPrincipalAxesTransform();
 
     itk::ImageRegionIterator<SegImageType>
             itimage(caster->GetOutput(), caster->GetOutput()->GetLargestPossibleRegion());
     itimage = itimage.Begin();
 
     double max = -9999999999.0;
     double min =  9999999999.0;
 
     while( !itimage.IsAtEnd() )
     {
         if(itimage.Get())
         {
             ImageType::IndexType index = itimage.GetIndex();
 
             itk::Point<float,3> point;
             caster->GetOutput()->TransformIndexToPhysicalPoint(index,point);
 
             itk::Point<float,3> newPoint;
             newPoint = trafo->TransformPoint(point);
 
             if(newPoint[2]<min)
                 min = newPoint[2];
 
             if(newPoint[2]>max)
                 max = newPoint[2];
         }
         ++itimage;
     }
 
     double extent = max - min;
     MITK_DEBUG << "EXTENT = " << extent;
 
     mitk::Point3D origin;
     mitk::Vector3D right, bottom, normal;
 
     double factor = 1000.0;
     mitk::FillVector3D(origin, cog[0]-factor*axes[1][0]-factor*axes[2][0],
                        cog[1]-factor*axes[1][1]-factor*axes[2][1],
                        cog[2]-factor*axes[1][2]-factor*axes[2][2]);
     //          mitk::FillVector3D(normal, axis[0][0],axis[0][1],axis[0][2]);
     mitk::FillVector3D(bottom, 2*factor*axes[1][0], 2*factor*axes[1][1], 2*factor*axes[1][2]);
     mitk::FillVector3D(right,  2*factor*axes[2][0], 2*factor*axes[2][1], 2*factor*axes[2][2]);
 
     mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
     planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector());
     planegeometry->SetOrigin(origin);
 
     double len1 = sqrt(axes[1][0]*axes[1][0] + axes[1][1]*axes[1][1] + axes[1][2]*axes[1][2]);
     double len2 = sqrt(axes[2][0]*axes[2][0] + axes[2][1]*axes[2][1] + axes[2][2]*axes[2][2]);
 
     mitk::Point2D point1;
     point1[0] = factor*len1;
     point1[1] = factor*len2;
 
     mitk::Point2D point2;
     point2[0] = factor*len1+extent*.5;
     point2[1] = factor*len2;
 
     mitk::PlanarCircle::Pointer circle = mitk::PlanarCircle::New();
     circle->SetGeometry2D(planegeometry);
     circle->PlaceFigure( point1 );
     circle->SetControlPoint(0,point1);
     circle->SetControlPoint(1,point2);
     //circle->SetCurrentControlPoint( point2 );
 
     mitk::PlanarFigure::PolyLineType polyline = circle->GetPolyLine( 0 );
     MITK_DEBUG << "SIZE of planar figure polyline: " << polyline.size();
 
     AddFigureToDataStorage(circle, "Circle");
 
 }
 
 bool QmitkPartialVolumeAnalysisView::AssertDrawingIsPossible(bool checked)
 {
     if (m_SelectedImageNodes->GetNode().IsNull())
     {
         checked = false;
         this->HandleException("Please select an image!", dynamic_cast<QWidget *>(this->parent()), true);
         return false;
     }
 
     //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(false);
 
     return checked;
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawEllipseTriggered()
 {
     bool checked = m_Controls->m_CircleButton->isChecked();
     if(!this->AssertDrawingIsPossible(checked))
         return;
 
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     // using PV_ prefix for planar figures from this view
     // to distinguish them from that ones created throught the measurement view
     this->AddFigureToDataStorage(figure, QString("PV_Circle%1").arg(++m_EllipseCounter));
 
     MITK_DEBUG << "PlanarCircle created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawRectangleTriggered()
 {
     bool checked = m_Controls->m_RectangleButton->isChecked();
     if(!this->AssertDrawingIsPossible(checked))
         return;
 
     mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
     // using PV_ prefix for planar figures from this view
     // to distinguish them from that ones created throught the measurement view
     this->AddFigureToDataStorage(figure, QString("PV_Rectangle%1").arg(++m_RectangleCounter));
 
     MITK_DEBUG << "PlanarRectangle created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawPolygonTriggered()
 {
     bool checked = m_Controls->m_PolygonButton->isChecked();
     if(!this->AssertDrawingIsPossible(checked))
         return;
 
     mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
     figure->ClosedOn();
     // using PV_ prefix for planar figures from this view
     // to distinguish them from that ones created throught the measurement view
     this->AddFigureToDataStorage(figure, QString("PV_Polygon%1").arg(++m_PolygonCounter));
 
     MITK_DEBUG << "PlanarPolygon created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
                                                             const char *propertyKey, mitk::BaseProperty *property )
 {
 
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
 
     // Add custom property, if available
     if ( (propertyKey != NULL) && (property != NULL) )
     {
         newNode->AddProperty( propertyKey, property );
     }
 
     // figure drawn on the topmost layer / image
     this->GetDataStorage()->Add(newNode, m_SelectedImageNodes->GetNode() );
 
     QList<mitk::DataNode::Pointer> selectedNodes = this->GetDataManagerSelection();
     for(unsigned int i = 0; i < selectedNodes.size(); i++)
     {
         selectedNodes[i]->SetSelected(false);
     }
 
     std::vector<mitk::DataNode *> selectedPFNodes = m_SelectedPlanarFigureNodes->GetNodes();
     for(unsigned int i = 0; i < selectedPFNodes.size(); i++)
     {
         selectedPFNodes[i]->SetSelected(false);
     }
     newNode->SetSelected(true);
 
     Select(newNode);
 }
 
 void QmitkPartialVolumeAnalysisView::PlanarFigureInitialized()
 {
     if(m_SelectedPlanarFigureNodes->GetNode().IsNull())
         return;
 
     m_CurrentFigureNodeInitialized = true;
 
     this->Select(m_SelectedPlanarFigureNodes->GetNode());
 
     m_Controls->m_CircleButton->setChecked(false);
     m_Controls->m_RectangleButton->setChecked(false);
     m_Controls->m_PolygonButton->setChecked(false);
 
     //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(true);
     this->RequestStatisticsUpdate();
 
 }
 
 void QmitkPartialVolumeAnalysisView::PlanarFigureFocus(mitk::DataNode* node)
 {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     if (_PlanarFigure)
     {
 
         FindRenderWindow(node);
 
         const mitk::PlaneGeometry
                 * _PlaneGeometry =
                 dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
 
         // make node visible
         if (m_SelectedRenderWindow)
         {
             mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
             m_SelectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
                         centerP, _PlaneGeometry->GetNormal());
             m_SelectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
                         centerP);
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::FindRenderWindow(mitk::DataNode* node)
 {
     if (node && dynamic_cast<mitk::PlanarFigure*> (node->GetData()))
     {
         m_SelectedRenderWindow = 0;
         bool PlanarFigureInitializedWindow = false;
 
         foreach(QmitkRenderWindow * window, this->GetRenderWindowPart()->GetQmitkRenderWindows().values())
         {
             if (!m_SelectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, window->GetRenderer()))
             {
                 m_SelectedRenderWindow = window;
             }
         }
     }
 }
 
 
 void QmitkPartialVolumeAnalysisView::OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes)
 {
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
     if (!m_Visible)
         return;
 
     if ( nodes.empty() )
     {
         if (m_ClusteringResult.IsNotNull())
         {
             this->GetDataStorage()->Remove(m_ClusteringResult);
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
 
         Select(NULL, true, true);
     }
 
     for (int i=0; i<nodes.size(); i++)
         Select(nodes.at(i));
 }
 
 void QmitkPartialVolumeAnalysisView::Select( mitk::DataNode::Pointer node, bool clearMaskOnFirstArgNULL, bool clearImageOnFirstArgNULL )
 {
     // Clear any unreferenced images
     this->RemoveOrphanImages();
 
     bool somethingChanged = false;
     if(node.IsNull())
     {
         somethingChanged = true;
 
         if(clearMaskOnFirstArgNULL)
         {
             if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
             {
                 m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
                 m_ImageMaskObserverTag = -1;
             }
 
             if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
             {
                 m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
                 m_PlanarFigureObserverTag = -1;
             }
 
             if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
             {
                 m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
                 m_InitializedObserverTag = -1;
             }
 
             m_SelectedPlanarFigure = NULL;
             m_SelectedPlanarFigureNodes->RemoveAllNodes();
             m_CurrentFigureNodeInitialized = false;
             m_SelectedRenderWindow = 0;
 
             m_SelectedMaskNode = NULL;
             m_SelectedImageMask = NULL;
 
         }
 
         if(clearImageOnFirstArgNULL)
         {
             if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
             {
                 m_SelectedImage->RemoveObserver( m_ImageObserverTag );
                 m_ImageObserverTag = -1;
             }
 
             m_SelectedImageNodes->RemoveAllNodes();
             m_SelectedImage = NULL;
 
             m_IsTensorImage = false;
             m_FAImage = NULL;
             m_RDImage = NULL;
             m_ADImage = NULL;
             m_MDImage = NULL;
             m_CAImage = NULL;
             m_DirectionComp1Image = NULL;
             m_DirectionComp2Image = NULL;
             m_AngularErrorImage = NULL;
 
             m_Controls->m_SimilarAnglesFrame->setVisible(false);
             m_Controls->m_SimilarAnglesLabel->setVisible(false);
         }
     }
     else
     {
         typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
         ITKCommandType::Pointer changeListener;
         changeListener = ITKCommandType::New();
         changeListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate );
 
         // Get selected element
         mitk::TensorImage *selectedTensorImage = dynamic_cast< mitk::TensorImage * >( node->GetData() );
         mitk::Image *selectedImage = dynamic_cast< mitk::Image * >( node->GetData() );
         mitk::PlanarFigure *selectedPlanar = dynamic_cast< mitk::PlanarFigure * >( node->GetData() );
 
         bool isMask = false;
         bool isImage = false;
         bool isPlanar = false;
         bool isTensorImage = false;
 
         if (selectedTensorImage != NULL)
         {
             isTensorImage = true;
         }
         else if(selectedImage != NULL)
         {
             node->GetPropertyValue("binary", isMask);
             isImage = !isMask;
         }
         else if ( (selectedPlanar != NULL) )
         {
             isPlanar = true;
         }
 
         // image
         if(isImage && selectedImage->GetDimension()==3)
         {
             if(selectedImage != m_SelectedImage.GetPointer())
             {
                 somethingChanged = true;
 
                 if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
                 {
                     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
                     m_ImageObserverTag = -1;
                 }
 
                 *m_SelectedImageNodes = node;
                 m_SelectedImage = selectedImage;
                 m_IsTensorImage = false;
                 m_FAImage = NULL;
                 m_RDImage = NULL;
                 m_ADImage = NULL;
                 m_MDImage = NULL;
                 m_CAImage = NULL;
                 m_DirectionComp1Image = NULL;
                 m_DirectionComp2Image = NULL;
                 m_AngularErrorImage = NULL;
 
                 // Add change listeners to selected objects
                 m_ImageObserverTag = m_SelectedImage->AddObserver(
                             itk::ModifiedEvent(), changeListener );
 
                 m_Controls->m_SimilarAnglesFrame->setVisible(false);
                 m_Controls->m_SimilarAnglesLabel->setVisible(false);
 
                 m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
             }
         }
 
         //planar
         if(isPlanar)
         {
             if(selectedPlanar != m_SelectedPlanarFigure.GetPointer())
             {
                 MITK_DEBUG << "Planar selection changed";
                 somethingChanged = true;
 
                 // Possibly previous change listeners
                 if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
                 {
                     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
                     m_PlanarFigureObserverTag = -1;
                 }
 
                 if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
                 {
                     m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
                     m_InitializedObserverTag = -1;
                 }
 
                 m_SelectedPlanarFigure = selectedPlanar;
                 *m_SelectedPlanarFigureNodes = node;
                 m_CurrentFigureNodeInitialized = selectedPlanar->IsPlaced();
 
                 m_SelectedMaskNode = NULL;
                 m_SelectedImageMask = NULL;
 
                 m_PlanarFigureObserverTag = m_SelectedPlanarFigure->AddObserver(
                             mitk::EndInteractionPlanarFigureEvent(), changeListener );
 
                 if(!m_CurrentFigureNodeInitialized)
                 {
                     typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
                     ITKCommandType::Pointer initializationCommand;
                     initializationCommand = ITKCommandType::New();
 
                     // set the callback function of the member command
                     initializationCommand->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::PlanarFigureInitialized );
 
                     // add an observer
                     m_InitializedObserverTag = selectedPlanar->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
                 }
 
                 m_Controls->m_SelectedMaskLabel->setText( m_SelectedPlanarFigureNodes->GetNode()->GetName().c_str() );
                 PlanarFigureFocus(node);
             }
         }
 
         //mask
         this->m_Controls->m_EstimateCircle->setEnabled(isMask && selectedImage->GetDimension()==3);
         if(isMask && selectedImage->GetDimension()==3)
         {
             if(selectedImage != m_SelectedImage.GetPointer())
             {
                 somethingChanged = true;
 
                 if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
                 {
                     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
                     m_ImageMaskObserverTag = -1;
                 }
 
                 m_SelectedMaskNode = node;
                 m_SelectedImageMask = selectedImage;
                 m_SelectedPlanarFigure = NULL;
                 m_SelectedPlanarFigureNodes->RemoveAllNodes();
 
                 m_ImageMaskObserverTag = m_SelectedImageMask->AddObserver(
                             itk::ModifiedEvent(), changeListener );
 
                 m_Controls->m_SelectedMaskLabel->setText( m_SelectedMaskNode->GetName().c_str() );
 
             }
         }
 
         //tensor image
         if(isTensorImage && selectedTensorImage->GetDimension()==3)
         {
             if(selectedImage != m_SelectedImage.GetPointer())
             {
                 somethingChanged = true;
 
                 if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
                 {
                     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
                     m_ImageObserverTag = -1;
                 }
 
                 *m_SelectedImageNodes = node;
                 m_SelectedImage = selectedImage;
 
                 m_IsTensorImage = true;
 
                 ExtractTensorImages(selectedImage);
 
                 // Add change listeners to selected objects
                 m_ImageObserverTag = m_SelectedImage->AddObserver(
                             itk::ModifiedEvent(), changeListener );
 
                 m_Controls->m_SimilarAnglesFrame->setVisible(true);
                 m_Controls->m_SimilarAnglesLabel->setVisible(true);
 
                 m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
             }
         }
     }
 
     if(somethingChanged)
     {
         this->SetMeasurementInfoToRenderWindow("");
 
         if(m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull() )
         {
             m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
             m_Controls->m_ResampleOptionsFrame->setEnabled(false);
             m_Controls->m_HistogramWidget->setEnabled(false);
             m_Controls->m_ClassSelector->setEnabled(false);
             m_Controls->m_DisplayHistogramCheckbox->setEnabled(false);
             m_Controls->m_AdvancedCheckbox->setEnabled(false);
             m_Controls->frame_7->setEnabled(false);
         }
         else
         {
             m_Controls->m_ResampleOptionsFrame->setEnabled(true);
             m_Controls->m_HistogramWidget->setEnabled(true);
             m_Controls->m_ClassSelector->setEnabled(true);
             m_Controls->m_DisplayHistogramCheckbox->setEnabled(true);
             m_Controls->m_AdvancedCheckbox->setEnabled(true);
             m_Controls->frame_7->setEnabled(true);
         }
 
         // Clear statistics / histogram GUI if nothing is selected
         if ( m_SelectedImage.IsNull() )
         {
             m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
             m_Controls->m_OpacityFrame->setEnabled(false);
             m_Controls->m_SelectedImageLabel->setText("<font color='red'>mandatory</font>");
         }
         else
         {
             m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
             m_Controls->m_OpacityFrame->setEnabled(true);
         }
 
         if( !m_Visible || m_SelectedImage.IsNull()
                 || (m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull()) )
         {
             m_Controls->m_InputData->setTitle("Please Select Input Data");
             m_Controls->m_HistogramWidget->ClearItemModel();
             m_CurrentStatisticsValid = false;
         }
         else
         {
             m_Controls->m_InputData->setTitle("Input Data");
             this->RequestStatisticsUpdate();
         }
     }
 }
 
 
 void QmitkPartialVolumeAnalysisView::ShowClusteringResults()
 {
 
     typedef itk::Image<unsigned char, 3> MaskImageType;
     mitk::Image::Pointer mask = 0;
     MaskImageType::Pointer itkmask = 0;
 
     if(m_IsTensorImage && m_Controls->m_SimilarAnglesSlider->value() != 0)
     {
         typedef itk::Image<float, 3> AngularErrorImageType;
         typedef mitk::ImageToItk<AngularErrorImageType> CastType;
         CastType::Pointer caster = CastType::New();
         caster->SetInput(m_AngularErrorImage);
         caster->Update();
 
         typedef itk::BinaryThresholdImageFilter< AngularErrorImageType, MaskImageType > ThreshType;
         ThreshType::Pointer thresh = ThreshType::New();
         thresh->SetUpperThreshold((90-m_Controls->m_SimilarAnglesSlider->value())*(PVA_PI/180.0));
         thresh->SetInsideValue(1.0);
         thresh->SetInput(caster->GetOutput());
         thresh->Update();
         itkmask = thresh->GetOutput();
 
         mask = mitk::Image::New();
         mask->InitializeByItk(itkmask.GetPointer());
         mask->SetVolume(itkmask->GetBufferPointer());
 
         //    GetDefaultDataStorage()->Remove(m_newnode);
         //    m_newnode = mitk::DataNode::New();
         //    m_newnode->SetData(mask);
         //    m_newnode->SetName("masking node");
         //    m_newnode->SetIntProperty( "layer", 1002 );
         //    GetDefaultDataStorage()->Add(m_newnode, m_SelectedImageNodes->GetNode());
 
     }
 
     mitk::Image::Pointer clusteredImage;
     ClusteringType::Pointer clusterer = ClusteringType::New();
 
     if(m_QuantifyClass==3)
     {
 
         if(m_IsTensorImage)
         {
             double *green_fa, *green_rd, *green_ad, *green_md;
             //double *greengray_fa, *greengray_rd, *greengray_ad, *greengray_md;
             double *gray_fa, *gray_rd, *gray_ad, *gray_md;
             //double *redgray_fa, *redgray_rd, *redgray_ad, *redgray_md;
             double *red_fa, *red_rd, *red_ad, *red_md;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
             mitk::Image::ConstPointer imgToCluster = tmpImg;
 
             red_fa   = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_fa  = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
             mitk::Image::ConstPointer imgToCluster3 = tmpImg;
 
             red_rd   = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_rd  = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
             mitk::Image::ConstPointer imgToCluster4 = tmpImg;
 
             red_ad   = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_ad  = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
             mitk::Image::ConstPointer imgToCluster5 = tmpImg;
 
             red_md   = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_md  = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             // clipboard
             QString clipboardText("FA\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
             clipboardText = clipboardText
                     .arg(red_fa[0]).arg(red_fa[1])
                     .arg(gray_fa[0]).arg(gray_fa[1])
                     .arg(green_fa[0]).arg(green_fa[1]);
             QString clipboardText3("RD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
             clipboardText3 = clipboardText3
                     .arg(red_rd[0]).arg(red_rd[1])
                     .arg(gray_rd[0]).arg(gray_rd[1])
                     .arg(green_rd[0]).arg(green_rd[1]);
             QString clipboardText4("AD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
             clipboardText4 = clipboardText4
                     .arg(red_ad[0]).arg(red_ad[1])
                     .arg(gray_ad[0]).arg(gray_ad[1])
                     .arg(green_ad[0]).arg(green_ad[1]);
             QString clipboardText5("MD\t%1\t%2\t\t%3\t%4\t\t%5\t%6");
             clipboardText5 = clipboardText5
                     .arg(red_md[0]).arg(red_md[1])
                     .arg(gray_md[0]).arg(gray_md[1])
                     .arg(green_md[0]).arg(green_md[1]);
 
             QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("%1  %2  %3        \n");
             plainInfoText = plainInfoText
                     .arg("Red  ", 20)
                     .arg("Gray ", 20)
                     .arg("Green", 20);
 
             QString plainInfoText0("FA:%1 ± %2%3 ± %4%5 ± %6\n");
             plainInfoText0 = plainInfoText0
                     .arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(gray_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(gray_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(green_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(green_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText3("RDx10³:%1 ± %2%3 ± %4%5 ± %6\n");
             plainInfoText3 = plainInfoText3
                     .arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * gray_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * green_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText4("ADx10³:%1 ± %2%3 ± %4%5 ± %6\n");
             plainInfoText4 = plainInfoText4
                     .arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * gray_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * green_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText5("MDx10³:%1 ± %2%3 ± %4%5 ± %6");
             plainInfoText5 = plainInfoText5
                     .arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * gray_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * green_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
 
         }
         else
         {
             double* green;
             double* gray;
             double* red;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
             mitk::Image::ConstPointer imgToCluster = tmpImg;
 
             red = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r);
             green = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g);
             gray = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b);
 
             // clipboard
             QString clipboardText("%1\t%2\t\t%3\t%4\t\t%5\t%6");
             clipboardText = clipboardText.arg(red[0]).arg(red[1])
                     .arg(gray[0]).arg(gray[1])
                     .arg(green[0]).arg(green[1]);
             QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("Red: %1 ± %2\nGray: %3 ± %4\nGreen: %5 ± %6");
             plainInfoText = plainInfoText.arg(red[0]).arg(red[1])
                     .arg(gray[0]).arg(gray[1])
                     .arg(green[0]).arg(green[1]);
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText);
 
         }
 
 
         clusteredImage = m_CurrentRGBClusteringResults->rgb;
 
     }
     else
     {
         if(m_IsTensorImage)
         {
             double *red_fa, *red_rd, *red_ad, *red_md;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
             mitk::Image::ConstPointer imgToCluster = tmpImg;
             red_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
             mitk::Image::ConstPointer imgToCluster3 = tmpImg;
             red_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
             mitk::Image::ConstPointer imgToCluster4 = tmpImg;
             red_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
             mitk::Image::ConstPointer imgToCluster5 = tmpImg;
             red_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             // clipboard
             QString clipboardText("FA\t%1\t%2\t");
             clipboardText = clipboardText
                     .arg(red_fa[0]).arg(red_fa[1]);
             QString clipboardText3("RD\t%1\t%2\t");
             clipboardText3 = clipboardText3
                     .arg(red_rd[0]).arg(red_rd[1]);
             QString clipboardText4("AD\t%1\t%2\t");
             clipboardText4 = clipboardText4
                     .arg(red_ad[0]).arg(red_ad[1]);
             QString clipboardText5("MD\t%1\t%2\t");
             clipboardText5 = clipboardText5
                     .arg(red_md[0]).arg(red_md[1]);
 
             QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("%1        \n");
             plainInfoText = plainInfoText
                     .arg("Red  ", 20);
 
             QString plainInfoText0("FA:%1 ± %2\n");
             plainInfoText0 = plainInfoText0
                     .arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText3("RDx10³:%1 ± %2\n");
             plainInfoText3 = plainInfoText3
                     .arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText4("ADx10³:%1 ± %2\n");
             plainInfoText4 = plainInfoText4
                     .arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText5("MDx10³:%1 ± %2");
             plainInfoText5 = plainInfoText5
                     .arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
 
         }
         else
         {
             double* quant;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
             mitk::Image::ConstPointer imgToCluster = tmpImg;
             quant = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage);
 
             // clipboard
             QString clipboardText("%1\t%2");
             clipboardText = clipboardText.arg(quant[0]).arg(quant[1]);
             QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("Measurement: %1 ± %2");
             plainInfoText = plainInfoText.arg(quant[0]).arg(quant[1]);
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText);
         }
 
         clusteredImage = m_CurrentPerformClusteringResults->displayImage;
 
     }
 
     if(mask.IsNotNull())
     {
         typedef itk::Image<itk::RGBAPixel<unsigned char>,3> RGBImageType;
         typedef mitk::ImageToItk<RGBImageType> ClusterCasterType;
         ClusterCasterType::Pointer clCaster = ClusterCasterType::New();
         clCaster->SetInput(clusteredImage);
         clCaster->Update();
         clCaster->GetOutput();
 
         typedef itk::MaskImageFilter< RGBImageType, MaskImageType, RGBImageType > MaskType;
         MaskType::Pointer masker = MaskType::New();
         masker->SetInput1(clCaster->GetOutput());
         masker->SetInput2(itkmask);
         masker->Update();
 
         clusteredImage = mitk::Image::New();
         clusteredImage->InitializeByItk(masker->GetOutput());
         clusteredImage->SetVolume(masker->GetOutput()->GetBufferPointer());
     }
 
     if(m_ClusteringResult.IsNotNull())
     {
         this->GetDataStorage()->Remove(m_ClusteringResult);
     }
 
     m_ClusteringResult = mitk::DataNode::New();
     m_ClusteringResult->SetBoolProperty("helper object", true);
     m_ClusteringResult->SetIntProperty( "layer", 1000 );
     m_ClusteringResult->SetBoolProperty("texture interpolation", m_TexIsOn);
     m_ClusteringResult->SetData(clusteredImage);
     m_ClusteringResult->SetName("Clusterprobs");
     this->GetDataStorage()->Add(m_ClusteringResult, m_SelectedImageNodes->GetNode());
 
     if(m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
     {
         m_SelectedPlanarFigureNodes->GetNode()->SetIntProperty( "layer", 1001 );
     }
 
     this->RequestRenderWindowUpdate();
 
 }
 
 
 void QmitkPartialVolumeAnalysisView::UpdateStatistics()
 {
     if(!m_CurrentFigureNodeInitialized && m_SelectedPlanarFigure.IsNotNull())
     {
         MITK_DEBUG << "Selected planar figure not initialized. No stats calculation performed.";
         return;
     }
 
     // Remove any cached images that are no longer referenced elsewhere
     this->RemoveOrphanImages();
 
 
     QmitkStdMultiWidget *multiWidget = 0;
     QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
 
     multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
     if(multiWidgetEdit){
         multiWidget = multiWidgetEdit->GetStdMultiWidget();
     }
 
     if ( multiWidget == NULL )
     {
         return;
     }
 
     if ( m_SelectedImage.IsNotNull() )
     {
         // Check if a the selected image is a multi-channel image. If yes, statistics
         // cannot be calculated currently.
         if ( !m_IsTensorImage && m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
         {
             QMessageBox::information( NULL, "Warning", "Non-tensor multi-component images not supported.");
 
             m_Controls->m_HistogramWidget->ClearItemModel();
             m_CurrentStatisticsValid = false;
             return;
         }
 
         // Retrieve HistogramStatisticsCalculator from has map (or create a new one
         // for this image if non-existant)
         PartialVolumeAnalysisMapType::iterator it =
                 m_PartialVolumeAnalysisMap.find( m_SelectedImage );
 
         if ( it != m_PartialVolumeAnalysisMap.end() )
         {
             m_CurrentStatisticsCalculator = it->second;
         }
         else
         {
             m_CurrentStatisticsCalculator = mitk::PartialVolumeAnalysisHistogramCalculator::New();
             m_CurrentStatisticsCalculator->SetPlanarFigureThickness(m_Controls->m_PlanarFiguresThickness->value());
             if(m_IsTensorImage)
             {
                 m_CurrentStatisticsCalculator->SetImage( m_CAImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_FAImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp1Image );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp2Image );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_RDImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_ADImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_MDImage );
             }
             else
             {
                 m_CurrentStatisticsCalculator->SetImage( m_SelectedImage );
             }
             m_PartialVolumeAnalysisMap[m_SelectedImage] = m_CurrentStatisticsCalculator;
             MITK_DEBUG << "Creating StatisticsCalculator";
         }
 
         std::string maskName;
         std::string maskType;
         unsigned int maskDimension;
 
         if ( m_SelectedImageMask.IsNotNull() )
         {
 
             mitk::PixelType pixelType = m_SelectedImageMask->GetPixelType();
             MITK_DEBUG << pixelType.GetPixelTypeAsString();
 
             if(pixelType.GetBitsPerComponent() == 16)
             {
                 //convert from short to uchar
                 typedef itk::Image<short, 3> ShortImageType;
                 typedef itk::Image<unsigned char, 3> CharImageType;
 
                 CharImageType::Pointer charImage;
                 ShortImageType::Pointer shortImage;
                 mitk::CastToItkImage(m_SelectedImageMask, shortImage);
 
                 typedef itk::CastImageFilter<ShortImageType, CharImageType> ImageCasterType;
 
                 ImageCasterType::Pointer caster = ImageCasterType::New();
                 caster->SetInput( shortImage );
                 caster->Update();
                 charImage = caster->GetOutput();
 
 
                 mitk::CastToMitkImage(charImage, m_SelectedImageMask);
             }
 
             m_CurrentStatisticsCalculator->SetImageMask( m_SelectedImageMask );
 
 
             m_CurrentStatisticsCalculator->SetMaskingModeToImage();
 
             maskName = m_SelectedMaskNode->GetName();
             maskType = m_SelectedImageMask->GetNameOfClass();
             maskDimension = 3;
 
             std::stringstream maskLabel;
             maskLabel << maskName;
             if ( maskDimension > 0 )
             {
                 maskLabel << "  [" << maskDimension << "D " << maskType << "]";
             }
             m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
         }
         else if ( m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
         {
             m_CurrentStatisticsCalculator->SetPlanarFigure( m_SelectedPlanarFigure );
             m_CurrentStatisticsCalculator->SetMaskingModeToPlanarFigure();
 
             maskName = m_SelectedPlanarFigureNodes->GetNode()->GetName();
             maskType = m_SelectedPlanarFigure->GetNameOfClass();
             maskDimension = 2;
         }
         else
         {
             m_CurrentStatisticsCalculator->SetMaskingModeToNone();
 
             maskName = "-";
             maskType = "";
             maskDimension = 0;
         }
 
         bool statisticsChanged = false;
         bool statisticsCalculationSuccessful = false;
 
         // Initialize progress bar
         mitk::ProgressBar::GetInstance()->AddStepsToDo( 100 );
 
         // Install listener for progress events and initialize progress bar
         typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
         ITKCommandType::Pointer progressListener;
         progressListener = ITKCommandType::New();
         progressListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::UpdateProgressBar );
         unsigned long progressObserverTag = m_CurrentStatisticsCalculator
                 ->AddObserver( itk::ProgressEvent(), progressListener );
 
         ClusteringType::ParamsType *cparams = 0;
         ClusteringType::ClusterResultType *cresult = 0;
         ClusteringType::HistType *chist = 0;
 
         try
         {
             m_CurrentStatisticsCalculator->SetNumberOfBins(m_Controls->m_NumberBins->text().toInt());
             m_CurrentStatisticsCalculator->SetUpsamplingFactor(m_Controls->m_Upsampling->text().toDouble());
             m_CurrentStatisticsCalculator->SetGaussianSigma(m_Controls->m_GaussianSigma->text().toDouble());
 
             // Compute statistics
             statisticsChanged =
                     m_CurrentStatisticsCalculator->ComputeStatistics( );
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
             mitk::Image::ConstPointer imgToCluster = tmpImg;
             if(imgToCluster.IsNotNull())
             {
 
                 // perform clustering
                 const HistogramType *histogram = m_CurrentStatisticsCalculator->GetHistogram( );
 
                 if(histogram != NULL)
                 {
                     ClusteringType::Pointer clusterer = ClusteringType::New();
                     clusterer->SetStepsNumIntegration(200);
                     clusterer->SetMaxIt(1000);
 
                     mitk::Image::Pointer pFiberImg;
                     if(m_QuantifyClass==3)
                     {
                         if(m_Controls->m_Quantiles->isChecked())
                         {
                             m_CurrentRGBClusteringResults = clusterer->PerformRGBQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
                         }
                         else
                         {
                             m_CurrentRGBClusteringResults = clusterer->PerformRGBClustering(imgToCluster, histogram);
                         }
 
                         pFiberImg = m_CurrentRGBClusteringResults->rgbChannels->r;
                         cparams = m_CurrentRGBClusteringResults->params;
                         cresult = m_CurrentRGBClusteringResults->result;
                         chist = m_CurrentRGBClusteringResults->hist;
                     }
                     else
                     {
                         if(m_Controls->m_Quantiles->isChecked())
                         {
                             m_CurrentPerformClusteringResults =
                                     clusterer->PerformQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
                         }
                         else
                         {
                             m_CurrentPerformClusteringResults =
                                     clusterer->PerformClustering(imgToCluster, histogram, m_QuantifyClass);
                         }
 
                         pFiberImg = m_CurrentPerformClusteringResults->clusteredImage;
                         cparams = m_CurrentPerformClusteringResults->params;
                         cresult = m_CurrentPerformClusteringResults->result;
                         chist = m_CurrentPerformClusteringResults->hist;
                     }
 
                     if(m_IsTensorImage)
                     {
                         m_AngularErrorImage = clusterer->CaculateAngularErrorImage(
                                     m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1),
                                     m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2),
                                     pFiberImg);
 
                         //          GetDefaultDataStorage()->Remove(m_newnode2);
                         //          m_newnode2 = mitk::DataNode::New();
                         //          m_newnode2->SetData(m_AngularErrorImage);
                         //          m_newnode2->SetName(("AngularError"));
                         //          m_newnode2->SetIntProperty( "layer", 1003 );
                         //          GetDefaultDataStorage()->Add(m_newnode2, m_SelectedImageNodes->GetNode());
 
                         //          newnode = mitk::DataNode::New();
                         //          newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1));
                         //          newnode->SetName(("Comp1"));
                         //          GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
 
                         //          newnode = mitk::DataNode::New();
                         //          newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2));
                         //          newnode->SetName(("Comp2"));
                         //          GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
                     }
                     ShowClusteringResults();
                 }
 
             }
 
             statisticsCalculationSuccessful = true;
         }
         catch ( const std::runtime_error &e )
         {
             QMessageBox::information( NULL, "Warning", e.what());
         }
         catch ( const std::exception &e )
         {
             MITK_ERROR << "Caught exception: " << e.what();
 
             QMessageBox::information( NULL, "Warning", e.what());
         }
 
         m_CurrentStatisticsCalculator->RemoveObserver( progressObserverTag );
 
         // Make sure that progress bar closes
         mitk::ProgressBar::GetInstance()->Progress( 100 );
 
         if ( statisticsCalculationSuccessful )
         {
             if ( statisticsChanged )
             {
                 // Do not show any error messages
                 m_CurrentStatisticsValid = true;
             }
 
             //      m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
             m_Controls->m_HistogramWidget->SetParameters(
                         cparams, cresult, chist );
             //      m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
 
         }
         else
         {
             m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
 
             // Clear statistics and histogram
             m_Controls->m_HistogramWidget->ClearItemModel();
             m_CurrentStatisticsValid = false;
 
 
             // If a (non-closed) PlanarFigure is selected, display a line profile widget
             if ( m_SelectedPlanarFigure.IsNotNull() )
             {
                 // TODO: enable line profile widget
                 //m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 1 );
                 //m_Controls->m_LineProfileWidget->SetImage( m_SelectedImage );
                 //m_Controls->m_LineProfileWidget->SetPlanarFigure( m_SelectedPlanarFigure );
                 //m_Controls->m_LineProfileWidget->UpdateItemModelFromPath();
             }
         }
     }
 
 }
 
 void QmitkPartialVolumeAnalysisView::SetMeasurementInfoToRenderWindow(const QString& text)
 {
 
     FindRenderWindow(m_SelectedPlanarFigureNodes->GetNode());
 
     if(m_LastRenderWindow != m_SelectedRenderWindow)
     {
 
         if(m_LastRenderWindow)
         {
             QObject::disconnect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
                                  , this, SLOT( OnRenderWindowDelete(QObject*) ) );
         }
         m_LastRenderWindow = m_SelectedRenderWindow;
         if(m_LastRenderWindow)
         {
             QObject::connect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
                               , this, SLOT( OnRenderWindowDelete(QObject*) ) );
         }
     }
 
     if(m_LastRenderWindow && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
     {
         if (!text.isEmpty())
         {
             m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
             mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->InsertForegroundRenderer(
                         m_MeasurementInfoRenderer, true);
         }
         else
         {
             if (mitk::VtkLayerController::GetInstance(
                         m_LastRenderWindow->GetRenderWindow()) ->IsRendererInserted(
                         m_MeasurementInfoRenderer))
                 mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->RemoveRenderer(
                             m_MeasurementInfoRenderer);
         }
     }
     else
     {
         QmitkStdMultiWidget *multiWidget = 0;
         QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
 
         multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
         if(multiWidgetEdit){
             multiWidget = multiWidgetEdit->GetStdMultiWidget();
         }
 
         if ( multiWidget == NULL )
         {
             return;
         }
 
         if (!text.isEmpty())
         {
             m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
             mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(
                         m_MeasurementInfoRenderer, true);
         }
         else
         {
             if (mitk::VtkLayerController::GetInstance(
                         multiWidget->GetRenderWindow1()->GetRenderWindow()) ->IsRendererInserted(
                         m_MeasurementInfoRenderer))
                 mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer(
                             m_MeasurementInfoRenderer);
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::UpdateProgressBar()
 {
     mitk::ProgressBar::GetInstance()->Progress();
 }
 
 void QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate()
 {
     if ( !m_StatisticsUpdatePending )
     {
         QApplication::postEvent( this, new QmitkRequestStatisticsUpdateEvent );
         m_StatisticsUpdatePending = true;
     }
 }
 
 
 void QmitkPartialVolumeAnalysisView::RemoveOrphanImages()
 {
     PartialVolumeAnalysisMapType::iterator it = m_PartialVolumeAnalysisMap.begin();
 
     while ( it != m_PartialVolumeAnalysisMap.end() )
     {
         mitk::Image *image = it->first;
         mitk::PartialVolumeAnalysisHistogramCalculator *calculator = it->second;
         ++it;
 
         mitk::NodePredicateData::Pointer hasImage = mitk::NodePredicateData::New( image );
         if ( this->GetDataStorage()->GetNode( hasImage ) == NULL )
         {
             if ( m_SelectedImage == image )
             {
                 m_SelectedImage = NULL;
                 m_SelectedImageNodes->RemoveAllNodes();
             }
             if ( m_CurrentStatisticsCalculator == calculator )
             {
                 m_CurrentStatisticsCalculator = NULL;
             }
             m_PartialVolumeAnalysisMap.erase( image );
             it = m_PartialVolumeAnalysisMap.begin();
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::ExtractTensorImages(
         mitk::Image::Pointer tensorimage)
 {
     typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
 
     typedef mitk::ImageToItk<TensorImageType> CastType;
     CastType::Pointer caster = CastType::New();
     caster->SetInput(tensorimage);
     caster->Update();
     TensorImageType::Pointer image = caster->GetOutput();
 
     typedef itk::TensorDerivedMeasurementsFilter<float> MeasurementsType;
     MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::FA);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer fa = measurementsCalculator->GetOutput();
 
     m_FAImage = mitk::Image::New();
     m_FAImage->InitializeByItk(fa.GetPointer());
     m_FAImage->SetVolume(fa->GetBufferPointer());
 
     //  mitk::DataNode::Pointer node = mitk::DataNode::New();
     //  node->SetData(m_FAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::CA);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer ca = measurementsCalculator->GetOutput();
 
     m_CAImage = mitk::Image::New();
     m_CAImage->InitializeByItk(ca.GetPointer());
     m_CAImage->SetVolume(ca->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::RD);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer rd = measurementsCalculator->GetOutput();
 
     m_RDImage = mitk::Image::New();
     m_RDImage->InitializeByItk(rd.GetPointer());
     m_RDImage->SetVolume(rd->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::AD);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer ad = measurementsCalculator->GetOutput();
 
     m_ADImage = mitk::Image::New();
     m_ADImage->InitializeByItk(ad.GetPointer());
     m_ADImage->SetVolume(ad->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::RA);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer md = measurementsCalculator->GetOutput();
 
     m_MDImage = mitk::Image::New();
     m_MDImage->InitializeByItk(md.GetPointer());
     m_MDImage->SetVolume(md->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     typedef DirectionsFilterType::OutputImageType DirImageType;
     DirectionsFilterType::Pointer dirFilter = DirectionsFilterType::New();
     dirFilter->SetInput(image );
     dirFilter->Update();
 
     itk::ImageRegionIterator<DirImageType>
             itd(dirFilter->GetOutput(), dirFilter->GetOutput()->GetLargestPossibleRegion());
     itd = itd.Begin();
     while( !itd.IsAtEnd() )
     {
         DirImageType::PixelType direction = itd.Get();
         direction[0] = fabs(direction[0]);
         direction[1] = fabs(direction[1]);
         direction[2] = fabs(direction[2]);
         itd.Set(direction);
         ++itd;
     }
 
     typedef itk::CartesianToPolarVectorImageFilter<
             DirImageType, DirImageType, true> C2PFilterType;
     C2PFilterType::Pointer cpFilter = C2PFilterType::New();
     cpFilter->SetInput(dirFilter->GetOutput());
     cpFilter->Update();
     DirImageType::Pointer dir = cpFilter->GetOutput();
 
     typedef itk::Image<float, 3> CompImageType;
     CompImageType::Pointer comp1 = CompImageType::New();
     comp1->SetSpacing( dir->GetSpacing() );   // Set the image spacing
     comp1->SetOrigin( dir->GetOrigin() );     // Set the image origin
     comp1->SetDirection( dir->GetDirection() );  // Set the image direction
     comp1->SetRegions( dir->GetLargestPossibleRegion() );
     comp1->Allocate();
 
     CompImageType::Pointer comp2 = CompImageType::New();
     comp2->SetSpacing( dir->GetSpacing() );   // Set the image spacing
     comp2->SetOrigin( dir->GetOrigin() );     // Set the image origin
     comp2->SetDirection( dir->GetDirection() );  // Set the image direction
     comp2->SetRegions( dir->GetLargestPossibleRegion() );
     comp2->Allocate();
 
     itk::ImageRegionConstIterator<DirImageType>
             it(dir, dir->GetLargestPossibleRegion());
 
     itk::ImageRegionIterator<CompImageType>
             it1(comp1, comp1->GetLargestPossibleRegion());
 
     itk::ImageRegionIterator<CompImageType>
             it2(comp2, comp2->GetLargestPossibleRegion());
 
     it = it.Begin();
     it1 = it1.Begin();
     it2 = it2.Begin();
 
     while( !it.IsAtEnd() )
     {
         it1.Set(it.Get()[1]);
         it2.Set(it.Get()[2]);
         ++it;
         ++it1;
         ++it2;
     }
 
     m_DirectionComp1Image = mitk::Image::New();
     m_DirectionComp1Image->InitializeByItk(comp1.GetPointer());
     m_DirectionComp1Image->SetVolume(comp1->GetBufferPointer());
 
     m_DirectionComp2Image = mitk::Image::New();
     m_DirectionComp2Image->InitializeByItk(comp2.GetPointer());
     m_DirectionComp2Image->SetVolume(comp2->GetBufferPointer());
 
 }
 
 void QmitkPartialVolumeAnalysisView::OnRenderWindowDelete(QObject * obj)
 {
     if(obj == m_LastRenderWindow)
         m_LastRenderWindow = 0;
     if(obj == m_SelectedRenderWindow)
         m_SelectedRenderWindow = 0;
 }
 
 bool QmitkPartialVolumeAnalysisView::event( QEvent *event )
 {
     if ( event->type() == (QEvent::Type) QmitkRequestStatisticsUpdateEvent::StatisticsUpdateRequest )
     {
         // Update statistics
 
         m_StatisticsUpdatePending = false;
 
         this->UpdateStatistics();
         return true;
     }
 
     return false;
 }
 
 
 bool QmitkPartialVolumeAnalysisView::IsExclusiveFunctionality() const
 {
     return true;
 }
 
 void QmitkPartialVolumeAnalysisView::Activated()
 {
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigure* figure = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
 
     // finally add all nodes to the model
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figure)
         {
-          figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor());
+          figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
           if(figureInteractor.IsNull())
           {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( node );
           }
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::Deactivated()
 {
 
 }
 
 void QmitkPartialVolumeAnalysisView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer reference)
 {
     this->SetMeasurementInfoToRenderWindow("");
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigure* figure = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
 
     // finally add all nodes to the model
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figure)
         {
-            figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
+            figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
             if(figureInteractor)
-                mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
+              figureInteractor->SetDataNode( NULL );
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::Hidden()
 {
     if (m_ClusteringResult.IsNotNull())
     {
         this->GetDataStorage()->Remove(m_ClusteringResult);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     Select(NULL, true, true);
     m_Visible = false;
 }
 
 void QmitkPartialVolumeAnalysisView::Visible()
 {
     m_Visible = true;
     berry::IWorkbenchPart::Pointer bla;
     if (!this->GetCurrentSelection().empty())
     {
         this->OnSelectionChanged(bla, this->GetCurrentSelection());
     }
     else
     {
         this->OnSelectionChanged(bla, this->GetDataManagerSelection());
     }
 }
 
 void QmitkPartialVolumeAnalysisView::SetFocus()
 {
 
 }
 
 
 void QmitkPartialVolumeAnalysisView::GreenRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_PartialVolumeRadio->setChecked(false);
         m_Controls->m_BlueRadio->setChecked(false);
         m_Controls->m_AllRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
     }
 
     m_QuantifyClass = 0;
 
     RequestStatisticsUpdate();
 }
 
 
 void QmitkPartialVolumeAnalysisView::PartialVolumeRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_GreenRadio->setChecked(false);
         m_Controls->m_BlueRadio->setChecked(false);
         m_Controls->m_AllRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
     }
 
     m_QuantifyClass = 1;
 
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::BlueRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_PartialVolumeRadio->setChecked(false);
         m_Controls->m_GreenRadio->setChecked(false);
         m_Controls->m_AllRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
     }
 
     m_QuantifyClass = 2;
 
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::AllRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_BlueRadio->setChecked(false);
         m_Controls->m_PartialVolumeRadio->setChecked(false);
         m_Controls->m_GreenRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(false);
     }
 
     m_QuantifyClass = 3;
 
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::NumberBinsChangedSlider(int v )
 {
     m_Controls->m_NumberBins->setText(QString("%1").arg(m_Controls->m_NumberBinsSlider->value()*5.0));
 }
 
 void QmitkPartialVolumeAnalysisView::UpsamplingChangedSlider( int v)
 {
     m_Controls->m_Upsampling->setText(QString("%1").arg(m_Controls->m_UpsamplingSlider->value()/10.0));
 }
 
 void QmitkPartialVolumeAnalysisView::GaussianSigmaChangedSlider(int v )
 {
     m_Controls->m_GaussianSigma->setText(QString("%1").arg(m_Controls->m_GaussianSigmaSlider->value()/100.0));
 }
 
 void QmitkPartialVolumeAnalysisView::SimilarAnglesChangedSlider(int v )
 {
     m_Controls->m_SimilarAngles->setText(QString("%1°").arg(90-m_Controls->m_SimilarAnglesSlider->value()));
     ShowClusteringResults();
 }
 
 void QmitkPartialVolumeAnalysisView::OpacityChangedSlider(int v )
 {
 
     if(m_SelectedImageNodes->GetNode().IsNotNull())
     {
         float opacImag = 1.0f-(v-5)/5.0f;
         opacImag = opacImag < 0 ? 0 : opacImag;
         m_SelectedImageNodes->GetNode()->SetFloatProperty("opacity", opacImag);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     if(m_ClusteringResult.IsNotNull())
     {
         float opacClust = v/5.0f;
         opacClust = opacClust > 1 ? 1 : opacClust;
         m_ClusteringResult->SetFloatProperty("opacity", opacClust);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkPartialVolumeAnalysisView::NumberBinsReleasedSlider( )
 {
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::UpsamplingReleasedSlider( )
 {
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::GaussianSigmaReleasedSlider( )
 {
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::SimilarAnglesReleasedSlider( )
 {
 
 }
 
 void QmitkPartialVolumeAnalysisView::ToClipBoard()
 {
 
     std::vector<std::vector<double>* > vals  = m_Controls->m_HistogramWidget->m_Vals;
     QString clipboardText;
     for (std::vector<std::vector<double>* >::iterator it = vals.begin(); it
          != vals.end(); ++it)
     {
         for (std::vector<double>::iterator it2 = (**it).begin(); it2 != (**it).end(); ++it2)
         {
             clipboardText.append(QString("%1 \t").arg(*it2));
         }
         clipboardText.append(QString("\n"));
     }
 
     QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 }
 
 void QmitkPartialVolumeAnalysisView::PropertyChanged(const mitk::DataNode* /*node*/, const mitk::BaseProperty* /*prop*/)
 {
 }
 
 void QmitkPartialVolumeAnalysisView::NodeChanged(const mitk::DataNode* /*node*/)
 {
 }
 
 void QmitkPartialVolumeAnalysisView::NodeRemoved(const mitk::DataNode* node)
 {
     if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
         this->GetDataStorage()->Remove(m_ClusteringResult);
 
     if(  node == m_SelectedPlanarFigureNodes->GetNode().GetPointer()
          || node == m_SelectedMaskNode.GetPointer() )
     {
         this->Select(NULL,true,false);
         SetMeasurementInfoToRenderWindow("");
     }
 
     if(  node == m_SelectedImageNodes->GetNode().GetPointer() )
     {
         this->Select(NULL,false,true);
         SetMeasurementInfoToRenderWindow("");
     }
 }
 
 void QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage(const mitk::DataNode* node)
 {
     if(!m_Visible)
         return;
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(nonConstNode->GetData());
 
     if(figure)
     {
 
         // set interactor for new node (if not already set)
         mitk::PlanarFigureInteractor::Pointer figureInteractor
-                = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor());
+                = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
         if(figureInteractor.IsNull())
         {
           figureInteractor = mitk::PlanarFigureInteractor::New();
           mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
           figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
           figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
           figureInteractor->SetDataNode( nonConstNode );
         }
 
         // remove uninitialized old planars
         if( m_SelectedPlanarFigureNodes->GetNode().IsNotNull() && m_CurrentFigureNodeInitialized == false )
         {
             mitk::Interactor::Pointer oldInteractor = m_SelectedPlanarFigureNodes->GetNode()->GetInteractor();
             if(oldInteractor.IsNotNull())
                 mitk::GlobalInteraction::GetInstance()->RemoveInteractor(oldInteractor);
 
             this->GetDataStorage()->Remove(m_SelectedPlanarFigureNodes->GetNode());
         }
 
     }
 }
 
 void QmitkPartialVolumeAnalysisView::TextIntON()
 {
     if(m_ClusteringResult.IsNotNull())
     {
         if(m_TexIsOn)
         {
             m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
         }
         else
         {
             m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
         }
 
         m_ClusteringResult->SetBoolProperty("texture interpolation", !m_TexIsOn);
         m_TexIsOn = !m_TexIsOn;
         this->RequestRenderWindowUpdate();
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
index f639a11b33..7c98e36e71 100644
--- a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
+++ b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
@@ -1,950 +1,950 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkNavigationButtonsView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 #include "mitkModuleRegistry.h"
 
 #include "mitkDiffusionImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkFiberBundle.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 #include "mitkFiberBundleInteractor.h"
 #include "mitkPlanarFigureInteractor.h"
 
 #include "mitkGlobalInteraction.h"
 
 #include "mitkGeometry2D.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include "itkTractsToProbabilityImageFilter.h"
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 
 const std::string QmitkNavigationButtonsView::VIEW_ID = "org.mitk.views.NavigationButtonsview";
 
 using namespace berry;
 
 
 QmitkNavigationButtonsView::QmitkNavigationButtonsView()
   : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL),
 {
 }
 
 QmitkNavigationButtonsView::QmitkNavigationButtonsView(const QmitkNavigationButtonsView& other)
 {
   Q_UNUSED(other)
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkNavigationButtonsView::~QmitkNavigationButtonsView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 
 
 void QmitkNavigationButtonsView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationButtonsViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
   }
 }
 
 
 void QmitkNavigationButtonsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkNavigationButtonsView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkNavigationButtonsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
   }
 }
 
 void QmitkNavigationButtonsView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkNavigationButtonsView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 int QmitkNavigationButtonsView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkNavigationButtonsView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return m_FoundSingleOdfImage ? 120 : 80;
   }
   else
   {
     return preferredResult;
   }
 }
 
 mitk::DataStorage::SetOfObjects::Pointer
     QmitkNavigationButtonsView::ActiveSet(std::string classname)
 {
   if (m_CurrentSelection)
   {
     mitk::DataStorage::SetOfObjects::Pointer set =
         mitk::DataStorage::SetOfObjects::New();
 
     int at = 0;
     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
     i != m_CurrentSelection->End();
     ++i)
     {
 
       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
         if(QString(classname.c_str()).compare(node->GetData()->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     return set;
   }
 
   return 0;
 }
 
 void QmitkNavigationButtonsView::SetBoolProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, bool value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetBoolProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetIntProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, int value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetFloatProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, float value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetFloatProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetLevelWindowProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, mitk::LevelWindow value)
 {
   if(set.IsNotNull())
   {
 
     mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), prop);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetEnumProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, mitk::EnumerationProperty::Pointer value)
 {
   if(set.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::DisplayIndexChanged(int dispIndex)
 {
 
   QString label = "Channel %1";
   label = label.arg(dispIndex);
   m_Controls->label_channel->setText(label);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("DiffusionImage");
 
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
       ++itemiter;
     }
 
     //m_MultiWidget->RequestUpdate();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::Reinit()
 {
   if (m_CurrentSelection)
   {
     mitk::DataNodeObject::Pointer nodeObj =
         m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
     mitk::DataNode::Pointer node = nodeObj->GetDataNode();
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
       mitk::RenderingManager::GetInstance()->InitializeViews(
           basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 }
 
 void QmitkNavigationButtonsView::TextIntON()
 {
   if(m_TexIsOn)
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
   }
   else
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("DiffusionImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("QBallImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("Image");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   m_TexIsOn = !m_TexIsOn;
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON_S()
 {
   if(m_GlyIsOn_S)
   {
     m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyOFF_S);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyON_S);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
 
   m_GlyIsOn_S = !m_GlyIsOn_S;
 
   VisibleOdfsON(0);
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON_T()
 {
   if(m_GlyIsOn_T)
   {
     m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyOFF_T);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyON_T);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
 
   m_GlyIsOn_T = !m_GlyIsOn_T;
 
   VisibleOdfsON(1);
 
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON_C()
 {
   if(m_GlyIsOn_C)
   {
     m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyOFF_C);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyON_C);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
 
   m_GlyIsOn_C = !m_GlyIsOn_C;
 
   VisibleOdfsON(2);
 
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON(int view)
 {
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::ShowMaxNumberChanged()
 {
   int maxNr = m_Controls->m_ShowMaxNumber->value();
   if ( maxNr < 1 )
   {
     m_Controls->m_ShowMaxNumber->setValue( 1 );
     maxNr = 1;
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   set = ActiveSet("TensorImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::NormalizationDropdownChanged(int normDropdown)
 {
   typedef mitk::OdfNormalizationMethodProperty PropType;
   PropType::Pointer normMeth = PropType::New();
 
   switch(normDropdown)
   {
   case 0:
     normMeth->SetNormalizationToMinMax();
     break;
   case 1:
     normMeth->SetNormalizationToMax();
     break;
   case 2:
     normMeth->SetNormalizationToNone();
     break;
   case 3:
     normMeth->SetNormalizationToGlobalMax();
     break;
   default:
     normMeth->SetNormalizationToMinMax();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::ScalingFactorChanged(double scalingFactor)
 {
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::AdditionalScaling(int additionalScaling)
 {
 
   typedef mitk::OdfScaleByProperty PropType;
   PropType::Pointer scaleBy = PropType::New();
 
   switch(additionalScaling)
   {
   case 0:
     scaleBy->SetScaleByNothing();
     break;
   case 1:
     scaleBy->SetScaleByGFA();
     //m_Controls->params_frame->setVisible(true);
     break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
   case 2:
     scaleBy->SetScaleByPrincipalCurvature();
     // commented in for SPIE paper, Principle curvature scaling
     //m_Controls->params_frame->setVisible(true);
     break;
 #endif
   default:
     scaleBy->SetScaleByNothing();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::IndexParam1Changed(double param1)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkNavigationButtonsView::IndexParam2Changed(double param2)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkNavigationButtonsView::OpacityChanged(double l, double u)
 {
   mitk::LevelWindow olw;
   olw.SetRangeMinMax(l*255, u*255);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("TensorImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("Image");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::ScalingCheckbox()
 {
   m_Controls->m_ScalingFrame->setVisible(
       m_Controls->m_ScalingCheckbox->isChecked());
 }
 
 
 void QmitkNavigationButtonsView::BundleRepresentationWire()
 {
   if(m_SelectedNode)
   {
     int width = m_Controls->m_LineWidth->value();
     m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(width));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(15));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(18));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(1));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(2));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(4));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::BundleRepresentationTube()
 {
   if(m_SelectedNode)
   {
     float radius = m_Controls->m_TubeRadius->value() / 100.0;
     m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(radius));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(17));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(13));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(16));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::BundleRepresentationColor()
 {
   if(m_SelectedNode)
   {
     QColor color = QColorDialog::getColor();
 
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(color.red()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.green()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.blue()));
     styleSheet.append(")");
     m_Controls->m_Color->setStyleSheet(styleSheet);
 
     m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(14));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::PlanarFigureFocus()
 {
   if(m_SelectedNode)
   {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
 
     if (_PlanarFigure)
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       QmitkRenderWindow* RenderWindow1 =
           this->GetActiveStdMultiWidget()->GetRenderWindow1();
 
       if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
         PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow1;
       }
 
       QmitkRenderWindow* RenderWindow2 =
           this->GetActiveStdMultiWidget()->GetRenderWindow2();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
           "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
           RenderWindow2->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow2;
       }
 
       QmitkRenderWindow* RenderWindow3 =
           this->GetActiveStdMultiWidget()->GetRenderWindow3();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
           "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
           RenderWindow3->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow3;
       }
 
       QmitkRenderWindow* RenderWindow4 =
           this->GetActiveStdMultiWidget()->GetRenderWindow4();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
           "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
           RenderWindow4->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow4;
       }
 
       const mitk::PlaneGeometry
           * _PlaneGeometry =
           dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry1 =
         RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane1 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry2 =
         RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane2 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry3 =
         RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane3 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
       mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
       normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
       normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
       normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
       normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
       double ang1 = angle(normal, normal1);
       double ang2 = angle(normal, normal2);
       double ang3 = angle(normal, normal3);
 
       if(ang1 < ang2 && ang1 < ang3)
       {
         selectedRenderWindow = RenderWindow1;
       }
       else
       {
         if(ang2 < ang3)
         {
           selectedRenderWindow = RenderWindow2;
         }
         else
         {
           selectedRenderWindow = RenderWindow3;
         }
       }
 
       // make node visible
       if (selectedRenderWindow)
       {
         mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
             centerP, _PlaneGeometry->GetNormal());
         selectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
             centerP);
       }
     }
 
     // set interactor for new node (if not already set)
     mitk::PlanarFigureInteractor::Pointer figureInteractor
-        = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor());
+        = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
 
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( m_SelectedNode );
     }
 
     m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
 
   }
 }
 
 void QmitkNavigationButtonsView::SetInteractor()
 {
   typedef std::vector<mitk::DataNode*> Container;
   Container _NodeSet = this->GetDataManagerSelection();
   mitk::DataNode* node = 0;
   mitk::FiberBundle* bundle = 0;
   mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
 
   // finally add all nodes to the model
   for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
     ; it++)
     {
     node = const_cast<mitk::DataNode*>(*it);
     bundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
     if(bundle)
     {
       bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
 
       if(bundleInteractor.IsNotNull())
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
 
       if(!m_Controls->m_Crosshair->isChecked())
       {
         m_Controls->m_Crosshair->setChecked(false);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
         m_CurrentPickingNode = 0;
       }
       else
       {
         m_Controls->m_Crosshair->setChecked(true);
         bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
         mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
         m_CurrentPickingNode = node;
       }
 
     }
   }
 
 }
 
 void QmitkNavigationButtonsView::PFWidth(int w)
 {
 
   double width = w/10.0;
   m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QString label = "Width %1";
   label = label.arg(width);
   m_Controls->label_pfwidth->setText(label);
 
 }
 
 void QmitkNavigationButtonsView::PFColor()
 {
 
   QColor color = QColorDialog::getColor();
 
   m_Controls->m_PFColor->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.blue()));
   styleSheet.append(")");
   m_Controls->m_PFColor->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
 
 //  m_SelectedNode->SetProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkNavigationButtonsView::PFColor3D()
 {
 
   QColor color = QColorDialog::getColor();
 
   m_Controls->m_PFColor3D->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.blue()));
   styleSheet.append(")");
   m_Controls->m_PFColor3D->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkNavigationButtonsView::Heatmap()
 {
   if(m_SelectedNode)
   {
     mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
     if(!bundle)
       return;
 
     ///////////////////////////////
     // Generate unsigned char Image
     typedef unsigned char OutPixType2;
 
     // run generator
     typedef itk::Image< float, 3 >            WMPImageType;
     typedef itk::TractsToProbabilityImageFilter<WMPImageType,
         OutPixType2> ImageGeneratorType2;
     ImageGeneratorType2::Pointer generator = ImageGeneratorType2::New();
     //generator->SetInput(NULL);
     generator->SetFiberBundle(bundle);
     generator->SetInvertImage(false);
     generator->SetUpsamplingFactor(2);
     generator->SetBinaryEnvelope(false);
     generator->Update();
 
     // get result
     typedef itk::Image<OutPixType2,3> OutType2;
     OutType2::Pointer outImg = generator->GetOutput();
 
     mitk::Image::Pointer img2 = mitk::Image::New();
     img2->InitializeByItk(outImg.GetPointer());
     img2->SetVolume(outImg->GetBufferPointer());
 
     // to datastorage
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img2);
     QString name(m_SelectedNode->GetName().c_str());
     name += "_heatmap";
     node->SetName(name.toStdString());
     node->SetVisibility(true);
 
     GetDataStorage()->Add(node);
   }
 }
 
 void QmitkNavigationButtonsView::LineWidthChanged(int w)
 {
   m_SelectedNode->SetIntProperty("LineWidth", w);
 
   QString label = "Width %1";
   label = label.arg(w);
   m_Controls->label_linewidth->setText(label);
 }
 
 void QmitkNavigationButtonsView::TubeRadiusChanged(int r)
 {
   m_SelectedNode->SetFloatProperty("TubeRadius", (float) r / 100.0);
 
   QString label = "Radius %1";
   label = label.arg(r / 100.0);
   m_Controls->label_tuberadius->setText(label);
 }
 
 void QmitkNavigationButtonsView::Welcome()
 {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
    GetSite()->GetWorkbenchWindow(), false);
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
index 4ebc504f89..742109799e 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
@@ -1,760 +1,760 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #define MEASUREMENT_DEBUG MITK_DEBUG("QmitkMeasurementView") << __LINE__ << ": "
 
 #include "QmitkMeasurementView.h"
 
 #include <QtGui>
 
 #include <mitkVtkLayerController.h>
 #include <mitkWeakPointer.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarAngle.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarLine.h>
 #include <mitkPlanarCross.h>
 #include <mitkPlanarFourPointAngle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <QmitkRenderWindow.h>
 
 #include "mitkModuleRegistry.h"
 
 
 struct QmitkPlanarFigureData
 {
   QmitkPlanarFigureData()
     : m_Figure(0), m_EndPlacementObserverTag(0), m_SelectObserverTag(0), m_StartInteractionObserverTag(0), m_EndInteractionObserverTag(0)
   {
   }
 
   mitk::PlanarFigure* m_Figure;
   unsigned int m_EndPlacementObserverTag;
   unsigned int m_SelectObserverTag;
   unsigned int m_StartInteractionObserverTag;
   unsigned int m_EndInteractionObserverTag;
 };
 
 struct QmitkMeasurementViewData
 {
   QmitkMeasurementViewData()
     : m_LineCounter(0), m_PathCounter(0), m_AngleCounter(0),
       m_FourPointAngleCounter(0), m_EllipseCounter(0),
       m_RectangleCounter(0), m_PolygonCounter(0), m_UnintializedPlanarFigure(false)
   {
   }
 
   // internal vars
   unsigned int m_LineCounter;
   unsigned int m_PathCounter;
   unsigned int m_AngleCounter;
   unsigned int m_FourPointAngleCounter;
   unsigned int m_EllipseCounter;
   unsigned int m_RectangleCounter;
   unsigned int m_PolygonCounter;
   QList<mitk::DataNode::Pointer> m_CurrentSelection;
   std::map<mitk::DataNode*, QmitkPlanarFigureData> m_DataNodeToPlanarFigureData;
   mitk::WeakPointer<mitk::DataNode> m_SelectedImageNode;
   bool m_UnintializedPlanarFigure;
 
   // WIDGETS
   QWidget* m_Parent;
   QLabel* m_SelectedImageLabel;
   QAction* m_DrawLine;
   QAction* m_DrawPath;
   QAction* m_DrawAngle;
   QAction* m_DrawFourPointAngle;
   QAction* m_DrawEllipse;
   QAction* m_DrawRectangle;
   QAction* m_DrawPolygon;
   QToolBar* m_DrawActionsToolBar;
   QActionGroup* m_DrawActionsGroup;
   QTextBrowser* m_SelectedPlanarFiguresText;
   QPushButton* m_CopyToClipboard;
   QGridLayout* m_Layout;
 };
 
 const std::string QmitkMeasurementView::VIEW_ID = "org.mitk.views.measurement";
 
 QmitkMeasurementView::QmitkMeasurementView()
 : d( new QmitkMeasurementViewData )
 {
 }
 QmitkMeasurementView::~QmitkMeasurementView()
 {
   this->RemoveAllInteractors();
   delete d;
 }
 void QmitkMeasurementView::CreateQtPartControl(QWidget* parent)
 {
   d->m_Parent = parent;
 
   // image label
   QLabel* selectedImageLabel = new QLabel("Reference Image: ");
   d->m_SelectedImageLabel = new QLabel;
   d->m_SelectedImageLabel->setStyleSheet("font-weight: bold;");
 
   d->m_DrawActionsToolBar = new QToolBar;
   d->m_DrawActionsGroup = new QActionGroup(this);
   d->m_DrawActionsGroup->setExclusive(true);
 
   //# add actions
   MEASUREMENT_DEBUG << "Draw Line";
   QAction* currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/line.png"), "Draw Line");
   currentAction->setCheckable(true);
   d->m_DrawLine = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Path";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/path.png"), "Draw Path");
   currentAction->setCheckable(true);
   d->m_DrawPath = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/angle.png"), "Draw Angle");
   currentAction->setCheckable(true);
   d->m_DrawAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Four Point Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/four-point-angle.png"), "Draw Four Point Angle");
   currentAction->setCheckable(true);
   d->m_DrawFourPointAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Circle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/circle.png"), "Draw Circle");
   currentAction->setCheckable(true);
   d->m_DrawEllipse = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Rectangle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/rectangle.png"), "Draw Rectangle");
   currentAction->setCheckable(true);
   d->m_DrawRectangle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Polygon";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(
     ":/measurement/polygon.png"), "Draw Polygon");
   currentAction->setCheckable(true);
   d->m_DrawPolygon = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   // planar figure details text
   d->m_SelectedPlanarFiguresText = new QTextBrowser;
 
   // copy to clipboard button
   d->m_CopyToClipboard = new QPushButton("Copy to Clipboard");
 
   d->m_Layout = new QGridLayout;
   d->m_Layout->addWidget(selectedImageLabel, 0, 0, 1, 1);
   d->m_Layout->addWidget(d->m_SelectedImageLabel, 0, 1, 1, 1);
   d->m_Layout->addWidget(d->m_DrawActionsToolBar, 1, 0, 1, 2);
   d->m_Layout->addWidget(d->m_SelectedPlanarFiguresText, 2, 0, 1, 2);
   d->m_Layout->addWidget(d->m_CopyToClipboard, 3, 0, 1, 2);
 
   d->m_Parent->setLayout(d->m_Layout);
 
   // create connections
   this->CreateConnections();
 
   // readd interactors and observers
   this->AddAllInteractors();
 }
 void QmitkMeasurementView::CreateConnections()
 {
   QObject::connect( d->m_DrawLine, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawLineTriggered(bool) ) );
   QObject::connect( d->m_DrawPath, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawPathTriggered(bool) ) );
   QObject::connect( d->m_DrawAngle, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawFourPointAngle, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawFourPointAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawEllipse, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawEllipseTriggered(bool) ) );
   QObject::connect( d->m_DrawRectangle, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawRectangleTriggered(bool) ) );
   QObject::connect( d->m_DrawPolygon, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawPolygonTriggered(bool) ) );
   QObject::connect( d->m_CopyToClipboard, SIGNAL( clicked(bool) )
     , this, SLOT( CopyToClipboard(bool) ) );
 }
 
 void QmitkMeasurementView::NodeAdded( const mitk::DataNode* node )
 {
   // add observer for selection in renderwindow
   mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
   bool isPositionMarker (false);
   node->GetBoolProperty("isContourMarker", isPositionMarker);
   if( figure && !isPositionMarker )
   {
     MEASUREMENT_DEBUG << "figure added. will add interactor if needed.";
     mitk::PlanarFigureInteractor::Pointer figureInteractor
-        = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor());
+        = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer() );
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "PlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( nonConstNode );
 
       nonConstNode->SetBoolProperty( "planarfigure.isextendable", true );
     }
     else
     {
       // just to be sure that the interactor is not added twice
   //    mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
     }
 
     MEASUREMENT_DEBUG << "adding interactor to globalinteraction";
   //  mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
 
     MEASUREMENT_DEBUG << "will now add observers for planarfigure";
     QmitkPlanarFigureData data;
     data.m_Figure = figure;
 
     // add observer for event when figure has been placed
     typedef itk::SimpleMemberCommand< QmitkMeasurementView > SimpleCommandType;
     SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
     initializationCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureInitialized );
     data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
     // add observer for event when figure is picked (selected)
     typedef itk::MemberCommand< QmitkMeasurementView > MemberCommandType;
     MemberCommandType::Pointer selectCommand = MemberCommandType::New();
     selectCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureSelected );
     data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
     startInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::DisableCrosshairNavigation);
     data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
     endInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::EnableCrosshairNavigation);
     data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
     // adding to the map of tracked planarfigures
     d->m_DataNodeToPlanarFigureData[nonConstNode] = data;
   }
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::NodeChanged(const mitk::DataNode* node)
 {
   // DETERMINE IF WE HAVE TO RENEW OUR DETAILS TEXT (ANY NODE CHANGED IN OUR SELECTION?)
   bool renewText = false;
   for( int i=0; i < d->m_CurrentSelection.size(); ++i )
   {
     if( node == d->m_CurrentSelection.at(i) )
     {
       renewText = true;
       break;
     }
   }
 
   if(renewText)
   {
     MEASUREMENT_DEBUG << "Selected nodes changed. Refreshing text.";
     this->UpdateMeasurementText();
   }
 
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::CheckForTopMostVisibleImage(mitk::DataNode* _NodeToNeglect)
 {
   d->m_SelectedImageNode = this->DetectTopMostVisibleImage().GetPointer();
   if( d->m_SelectedImageNode.GetPointer() == _NodeToNeglect )
     d->m_SelectedImageNode = 0;
 
   if( d->m_SelectedImageNode.IsNotNull() && d->m_UnintializedPlanarFigure == false )
   {
     MEASUREMENT_DEBUG << "Reference image found";
     d->m_SelectedImageLabel->setText( QString::fromStdString( d->m_SelectedImageNode->GetName() ) );
     d->m_DrawActionsToolBar->setEnabled(true);
     MEASUREMENT_DEBUG << "Updating Measurement text";
   }
   else
   {
     MEASUREMENT_DEBUG << "No reference image available. Will disable actions for creating new planarfigures";
     if( d->m_UnintializedPlanarFigure == false )
       d->m_SelectedImageLabel->setText( "No visible image available." );
 
     d->m_DrawActionsToolBar->setEnabled(false);
   }
 }
 
 void QmitkMeasurementView::NodeRemoved(const mitk::DataNode* node)
 {
   MEASUREMENT_DEBUG << "node removed from data storage";
 
   mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.find(nonConstNode);
 
   bool isFigureFinished = false;
   bool isPlaced = false;
 
   if( it != d->m_DataNodeToPlanarFigureData.end() )
   {
     QmitkPlanarFigureData& data = it->second;
     // remove observers
     data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
     data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
     data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
     data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
     MEASUREMENT_DEBUG << "removing from the list of tracked planar figures";
 
     isFigureFinished = data.m_Figure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
     if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
       PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
     }
     d->m_DataNodeToPlanarFigureData.erase( it );
   }
 
   mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes =
    GetDataStorage()->GetDerivations(node,isPlanarFigure);
 
   for (unsigned int x = 0; x < nodes->size(); x++)
   {
     mitk::PlanarFigure* planarFigure  = dynamic_cast<mitk::PlanarFigure*>  (nodes->at(x)->GetData());
     if (planarFigure != NULL) {
 
       isFigureFinished = planarFigure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
       if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
         GetDataStorage()->Remove(nodes->at(x));
         if( !d->m_DataNodeToPlanarFigureData.empty() )
         {
           std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it2 =
             d->m_DataNodeToPlanarFigureData.find(nodes->at(x));
           //check if returned it2 valid
           if( it2 != d->m_DataNodeToPlanarFigureData.end() )
           {
             d->m_DataNodeToPlanarFigureData.erase( it2 );// removing planar figure from tracked figure list
             PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
             EnableCrosshairNavigation();
           }
         }
       }
     }
   }
   this->CheckForTopMostVisibleImage(nonConstNode);
 }
 
 
 void QmitkMeasurementView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
   MEASUREMENT_DEBUG << "planar figure " << object << " selected";
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.begin();
 
   d->m_CurrentSelection.clear();
   while( it != d->m_DataNodeToPlanarFigureData.end())
   {
     mitk::DataNode* node = it->first;
     QmitkPlanarFigureData& data = it->second;
 
     if( data.m_Figure == object )
     {
       MITK_DEBUG << "selected node found. enabling selection";
       node->SetSelected(true);
       d->m_CurrentSelection.push_back( node );
     }
     else
     {
       node->SetSelected(false);
     }
 
     ++it;
   }
   this->UpdateMeasurementText();
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::PlanarFigureInitialized()
 {
   MEASUREMENT_DEBUG << "planar figure initialized";
   d->m_UnintializedPlanarFigure = false;
   d->m_DrawActionsToolBar->setEnabled(true);
 
   d->m_DrawLine->setChecked(false);
   d->m_DrawPath->setChecked(false);
   d->m_DrawAngle->setChecked(false);
   d->m_DrawFourPointAngle->setChecked(false);
   d->m_DrawEllipse->setChecked(false);
   d->m_DrawRectangle->setChecked(false);
   d->m_DrawPolygon->setChecked(false);
 }
 
 void QmitkMeasurementView::SetFocus()
 {
   d->m_SelectedImageLabel->setFocus();
 }
 
 void QmitkMeasurementView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
                                               const QList<mitk::DataNode::Pointer> &nodes)
 {
   MEASUREMENT_DEBUG << "Determine the top most visible image";
   MEASUREMENT_DEBUG << "The PlanarFigure interactor will take the currently visible PlaneGeometry from the slice navigation controller";
 
   this->CheckForTopMostVisibleImage();
 
   MEASUREMENT_DEBUG << "refreshing selection and detailed text";
   d->m_CurrentSelection = nodes;
   this->UpdateMeasurementText();
 
   for( int i=d->m_CurrentSelection.size()-1; i>= 0; --i)
   {
     mitk::DataNode* node = d->m_CurrentSelection.at(i);
 
     mitk::PlanarFigure* _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     // the last selected planar figure
     if( _PlanarFigure )
     {
       mitk::ILinkedRenderWindowPart* linkedRenderWindow =
           dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
       if( linkedRenderWindow )
       {
         mitk::Point3D centerP = _PlanarFigure->GetGeometry()->GetOrigin();
         linkedRenderWindow->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(centerP);
       }
       break;
     }
   }
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::ActionDrawLineTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarLine::Pointer figure = mitk::PlanarLine::New();
   QString qString = QString("Line%1").arg(++d->m_LineCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarLine initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPathTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOff();
   QString qString = QString("Path%1").arg(++d->m_PathCounter);
   mitk::DataNode::Pointer node = this->AddFigureToDataStorage(figure, qString);
   mitk::BoolProperty::Pointer closedProperty = mitk::BoolProperty::New( false );
   node->SetProperty("ClosedPlanarPolygon", closedProperty);
 
   MEASUREMENT_DEBUG << "PlanarPath initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarAngle::Pointer figure = mitk::PlanarAngle::New();
   QString qString = QString("Angle%1").arg(++d->m_AngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawFourPointAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarFourPointAngle::Pointer figure =
     mitk::PlanarFourPointAngle::New();
   QString qString = QString("Four Point Angle%1").arg(++d->m_FourPointAngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarFourPointAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawEllipseTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
   QString qString = QString("Circle%1").arg(++d->m_EllipseCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarCircle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawRectangleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
   QString qString = QString("Rectangle%1").arg(++d->m_RectangleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarRectangle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPolygonTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOn();
   QString qString = QString("Polygon%1").arg(++d->m_PolygonCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarPolygon initialized...";
 }
 
 void QmitkMeasurementView::CopyToClipboard( bool checked )
 {
   Q_UNUSED(checked)
 
   MEASUREMENT_DEBUG << "Copying current Text to clipboard...";
   QString clipboardText = d->m_SelectedPlanarFiguresText->toPlainText();
   QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::AddFigureToDataStorage(
   mitk::PlanarFigure* figure, const QString& name)
 {
   // add as
   MEASUREMENT_DEBUG << "Adding new figure to datastorage...";
   if( d->m_SelectedImageNode.IsNull() )
   {
     MITK_ERROR << "No reference image available";
     return 0;
   }
 
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName(name.toStdString());
   newNode->SetData(figure);
   // set as selected
   newNode->SetSelected( true );
   this->GetDataStorage()->Add(newNode, d->m_SelectedImageNode);
 
   // set all others in selection as deselected
   for( int i=0; i<d->m_CurrentSelection.size(); ++i)
     d->m_CurrentSelection.at(i)->SetSelected(false);
   d->m_CurrentSelection.clear();
   d->m_CurrentSelection.push_back( newNode );
   this->UpdateMeasurementText();
   this->DisableCrosshairNavigation();
   d->m_DrawActionsToolBar->setEnabled(false);
   d->m_UnintializedPlanarFigure = true;
   return newNode;
 }
 
 void QmitkMeasurementView::UpdateMeasurementText()
 {
   d->m_SelectedPlanarFiguresText->clear();
 
   QString infoText;
   QString plainInfoText;
   int j = 1;
   mitk::PlanarFigure* _PlanarFigure = 0;
   mitk::PlanarAngle* planarAngle = 0;
   mitk::PlanarFourPointAngle* planarFourPointAngle = 0;
   mitk::DataNode::Pointer node = 0;
 
   for (int i=0; i<d->m_CurrentSelection.size(); ++i, ++j)
   {
     plainInfoText.clear();
     node = d->m_CurrentSelection.at(i);
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     if( !_PlanarFigure )
       continue;
 
     if(j>1)
       infoText.append("<br />");
 
     infoText.append(QString("<b>%1</b><hr />").arg(QString::fromStdString(
       node->GetName())));
     plainInfoText.append(QString("%1").arg(QString::fromStdString(
       node->GetName())));
 
     planarAngle = dynamic_cast<mitk::PlanarAngle*> (_PlanarFigure);
     if(!planarAngle)
     {
       planarFourPointAngle = dynamic_cast<mitk::PlanarFourPointAngle*> (_PlanarFigure);
     }
 
     double featureQuantity = 0.0;
     for (unsigned int k = 0; k < _PlanarFigure->GetNumberOfFeatures(); ++k)
     {
       if ( !_PlanarFigure->IsFeatureActive( k ) ) continue;
 
       featureQuantity = _PlanarFigure->GetQuantity(k);
       if ((planarAngle && k == planarAngle->FEATURE_ID_ANGLE)
         || (planarFourPointAngle && k == planarFourPointAngle->FEATURE_ID_ANGLE))
         featureQuantity = featureQuantity * 180 / vnl_math::pi;
 
       infoText.append(
         QString("<i>%1</i>: %2 %3") .arg(QString(
         _PlanarFigure->GetFeatureName(k))) .arg(featureQuantity, 0, 'f',
         2) .arg(QString(_PlanarFigure->GetFeatureUnit(k))));
 
       plainInfoText.append(
         QString("\n%1: %2 %3") .arg(QString(_PlanarFigure->GetFeatureName(k))) .arg(
         featureQuantity, 0, 'f', 2) .arg(QString(
         _PlanarFigure->GetFeatureUnit(k))));
 
       if(k+1 != _PlanarFigure->GetNumberOfFeatures())
         infoText.append("<br />");
     }
 
     if (j != d->m_CurrentSelection.size())
       infoText.append("<br />");
   }
 
   d->m_SelectedPlanarFiguresText->setHtml(infoText);
 }
 
 void QmitkMeasurementView::AddAllInteractors()
 {
   MEASUREMENT_DEBUG << "Adding interactors to all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
   const mitk::DataNode* node = 0;
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
     ; it++)
   {
     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
     this->NodeAdded( node );
   }
 }
 
 void QmitkMeasurementView::RemoveAllInteractors()
 {
   MEASUREMENT_DEBUG << "Removing interactors and observers from all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
   const mitk::DataNode* node = 0;
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
     ; it++)
   {
     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
     this->NodeRemoved( node );
   }
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::DetectTopMostVisibleImage()
 {
   // get all images from the data storage which are not a segmentation
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
   mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
 
   mitk::DataStorage::SetOfObjects::ConstPointer Images
       = this->GetDataStorage()->GetSubset( isNormalImage );
 
 
   mitk::DataNode::Pointer currentNode;
   int maxLayer = itk::NumericTraits<int>::min();
 
   // iterate over selection
   for (mitk::DataStorage::SetOfObjects::ConstIterator sofIt = Images->Begin(); sofIt != Images->End(); ++sofIt)
   {
     mitk::DataNode::Pointer node = sofIt->Value();
     if ( node.IsNull() )
       continue;
     if (node->IsVisible(NULL) == false)
       continue;
     // we also do not want to assign planar figures to helper objects ( even if they are of type image )
     if (node->GetProperty("helper object"))
       continue;
 
     int layer = 0;
     node->GetIntProperty("layer", layer);
     if ( layer < maxLayer )
     {
       continue;
     }
     else
     {
       maxLayer = layer;
       currentNode = node;
     }
   }
 
   return currentNode;
 }
 
 void QmitkMeasurementView::EnableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "EnableCrosshairNavigation";
 
   // enable the crosshair navigation
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "enabling linked navigation";
     linkedRenderWindow->EnableLinkedNavigation(true);
     linkedRenderWindow->EnableSlicingPlanes(true);
   }
 }
 
 void QmitkMeasurementView::DisableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "DisableCrosshairNavigation";
 
   // disable the crosshair navigation during the drawing
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "disabling linked navigation";
     linkedRenderWindow->EnableLinkedNavigation(false);
     linkedRenderWindow->EnableSlicingPlanes(false);
   }
 }