diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index a2a60b8f9f..e48e11e49b 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1052 +1,1227 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "QmitkControlVisualizationPropertiesView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkDiffusionImage.h"
-
+#include "mitkPlanarFigure.h"
+#include "mitkFiberBundle.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 
 #include "qwidgetaction.h"
+#include "qcolordialog.h"
 
 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 do_vis;
     node->GetBoolProperty("VisibleOdfs_T", do_vis);
     if(do_vis)
     {
       m_View->m_Controls->m_VisibleOdfsON_T->setIcon(*m_View->m_IconGlyON_T);
       m_View->m_Controls->m_VisibleOdfsON_T->setChecked(true);
       m_View->m_GlyIsOn_T = true;
     }
     else
     {
       m_View->m_Controls->m_VisibleOdfsON_T->setIcon(*m_View->m_IconGlyOFF_T);
       m_View->m_Controls->m_VisibleOdfsON_T->setChecked(false);
       m_View->m_GlyIsOn_T = false;
     }
 
     node->GetBoolProperty("VisibleOdfs_C", do_vis);
     if(do_vis)
     {
       m_View->m_Controls->m_VisibleOdfsON_C->setIcon(*m_View->m_IconGlyON_C);
       m_View->m_Controls->m_VisibleOdfsON_C->setChecked(true);
       m_View->m_GlyIsOn_C = true;
     }
     else
     {
       m_View->m_Controls->m_VisibleOdfsON_C->setIcon(*m_View->m_IconGlyOFF_C);
       m_View->m_Controls->m_VisibleOdfsON_C->setChecked(false);
       m_View->m_GlyIsOn_C = false;
     }
 
     node->GetBoolProperty("VisibleOdfs_S", do_vis);
     if(do_vis)
     {
       m_View->m_Controls->m_VisibleOdfsON_S->setIcon(*m_View->m_IconGlyON_S);
       m_View->m_Controls->m_VisibleOdfsON_S->setChecked(true);
       m_View->m_GlyIsOn_S = true;
     }
     else
     {
       m_View->m_Controls->m_VisibleOdfsON_S->setIcon(*m_View->m_IconGlyOFF_S);
       m_View->m_Controls->m_VisibleOdfsON_S->setChecked(false);
       m_View->m_GlyIsOn_S = false;
     }
 
     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);
 
-    bool foundDiffusionImage = false;
-    bool foundQBIVolume = false;
-    bool foundTensorVolume = false;
-    bool foundImage = false;
-    bool foundMultipleOdfImages = false;
-    bool foundRGBAImage = 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;
 
-    // do something with the selected items
-    if(m_View->m_CurrentSelection)
+    if(m_View->m_CurrentSelection->Size() == 1)
     {
-      // iterate selection
-      for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin(); 
-      i != m_View->m_CurrentSelection->End(); ++i)
+      mitk::DataNodeObject::Pointer nodeObj = m_View->m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
+      if(nodeObj.IsNotNull())
       {
+        mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
-        // extract datatree node
-        if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
+        if(dynamic_cast<mitk::PlanarFigure*>(node->GetData()) != 0)
         {
-          mitk::DataNode::Pointer node = nodeObj->GetDataNode();
+          m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(true);
+          m_View->m_SelectedNode = node;
+        }
 
-          // only look at interesting types
-          if(QString("DiffusionImage").compare(node->GetData()->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);
+        if(dynamic_cast<mitk::FiberBundle*>(node->GetData()) != 0)
+        {
+          m_View->m_Controls->m_BundleControlsFrame->setVisible(true);
+          m_View->m_SelectedNode = node;
+        }
+      }
+    }
 
-            QString label = "Channel %1";
-            label = label.arg(val);
-            m_View->m_Controls->label_channel->setText(label);
+    if(m_View->m_CurrentSelection->Size() > 0 && m_View->m_SelectedNode == 0)
+    {
+      m_View->m_Controls->m_ImageControlsFrame->setVisible(true);
 
-            int maxVal = (dynamic_cast<mitk::DiffusionImage<short>* >(node->GetData()))->GetVectorImage()->GetVectorLength();
-            m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
-          }
+      bool foundDiffusionImage = false;
+      bool foundQBIVolume = false;
+      bool foundTensorVolume = false;
+      bool foundImage = false;
+      bool foundMultipleOdfImages = false;
+      bool foundRGBAImage = false;
 
-          else if(QString("QBallImage").compare(node->GetData()->GetNameOfClass())==0)
-          {
-            foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
-            foundQBIVolume = true;
-            ApplySettings(node);
-          }
+      // 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)
+        {
 
-          else if(QString("TensorImage").compare(node->GetData()->GetNameOfClass())==0)
+          // extract datatree node
+          if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
           {
-            foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
-            foundTensorVolume = true;
-            ApplySettings(node);
-          }
+            mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
-          else if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
-          {
-            foundImage = true;
-            mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(node->GetData());
-            if(img.IsNotNull() && img->GetPixelType().GetItkTypeId() == &typeid(itk::RGBAPixel<unsigned char>) )
+            // only look at interesting types
+            if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
             {
-              foundRGBAImage = true;
+              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);
+
+              QString label = "Channel %1";
+              label = label.arg(val);
+              m_View->m_Controls->label_channel->setText(label);
+
+              int maxVal = (dynamic_cast<mitk::DiffusionImage<short>* >(node->GetData()))->GetVectorImage()->GetVectorLength();
+              m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
             }
 
-            bool tex_int;
-            node->GetBoolProperty("texture interpolation", tex_int);
-            if(tex_int)
+            else if(QString("QBallImage").compare(node->GetData()->GetNameOfClass())==0)
             {
-              m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
-              m_View->m_Controls->m_TextureIntON->setChecked(true);
-              m_View->m_TexIsOn = true;
+              foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
+              foundQBIVolume = true;
+              ApplySettings(node);
             }
-            else
+
+            else if(QString("TensorImage").compare(node->GetData()->GetNameOfClass())==0)
             {
-              m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
-              m_View->m_Controls->m_TextureIntON->setChecked(false);
-              m_View->m_TexIsOn = false;
+              foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
+              foundTensorVolume = true;
+              ApplySettings(node);
+            }
+
+            else if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
+            {
+              foundImage = true;
+              mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(node->GetData());
+              if(img.IsNotNull() && img->GetPixelType().GetItkTypeId() == &typeid(itk::RGBAPixel<unsigned char>) )
+              {
+                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;
+              }
             }
           }
         }
       }
-    }
 
-    m_View->m_Controls->m_DisplayIndex->setVisible(foundDiffusionImage);
-    m_View->m_Controls->label_channel->setVisible(foundDiffusionImage);
+      m_View->m_Controls->m_DisplayIndex->setVisible(foundDiffusionImage);
+      m_View->m_Controls->label_channel->setVisible(foundDiffusionImage);
 
-    m_View->m_FoundSingleOdfImage = (foundQBIVolume || foundTensorVolume)
-                                    && !foundMultipleOdfImages;
-    m_View->m_Controls->m_NumberGlyphsFrame->setVisible(m_View->m_FoundSingleOdfImage);
+      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->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);
+      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);
+      // 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);
+      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;
+      bool foundAnyImage = foundDiffusionImage ||
+                           foundQBIVolume || foundTensorVolume || foundImage;
 
-    m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
-    m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
-    m_View->m_Controls->m_TSMenu->setVisible(foundAnyImage);
+      m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
+      m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
+      m_View->m_Controls->m_TSMenu->setVisible(foundAnyImage);
 
-    if(m_View->m_IsInitialized)
-    {
-      //m_View->GetSite()->GetWorkbenchWindow()->GetActivePage()
-      //  ->HideView(IViewPart::Pointer(m_View));
+      if(m_View->m_IsInitialized)
+      {
+        //m_View->GetSite()->GetWorkbenchWindow()->GetActivePage()
+        //  ->HideView(IViewPart::Pointer(m_View));
 
-      //berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()
-      //  ->ShowView(QmitkControlVisualizationPropertiesView::VIEW_ID,
-      //  "", berry::IWorkbenchPage::VIEW_VISIBLE);
+        //berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()
+        //  ->ShowView(QmitkControlVisualizationPropertiesView::VIEW_ID,
+        //  "", berry::IWorkbenchPage::VIEW_VISIBLE);
 
+      }
     }
   }
 
   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_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_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")),
+  m_CurrentSelection(0)
 {
   currentThickSlicesMode = 1;
   m_MyMenu = NULL;
 }
 
 QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
 {
   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 = GetDataStorage()->GetNamedNode("widget1Plane"); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
   n = GetDataStorage()->GetNamedNode("widget2Plane"); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
   n = GetDataStorage()->GetNamedNode("widget3Plane"); 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 = GetDataStorage()->GetNamedNode("widget1Plane"); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
     n = GetDataStorage()->GetNamedNode("widget2Plane"); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
     n = GetDataStorage()->GetNamedNode("widget3Plane"); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
   }
   else
   {
     mitk::DataNode* n;
     n = GetDataStorage()->GetNamedNode("widget1Plane"); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     n = GetDataStorage()->GetNamedNode("widget2Plane"); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     n = GetDataStorage()->GetNamedNode("widget3Plane"); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 
     n = GetDataStorage()->GetNamedNode("widget1Plane"); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     n = GetDataStorage()->GetNamedNode("widget2Plane"); if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     n = GetDataStorage()->GetNamedNode("widget3Plane"); 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();
 
     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_TextureIntON->setCheckable(true);
     m_Controls->m_VisibleOdfsON_T->setCheckable(true);
     m_Controls->m_VisibleOdfsON_S->setCheckable(true);
     m_Controls->m_VisibleOdfsON_C->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_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;
 }
 
 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_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_Focus, SIGNAL(clicked()), (QObject*) this, SLOT(PlanarFigureFocus()));
+
   }
 }
 
 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;
   }
 }
 
 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();
         if(QString(classname.c_str()).compare(node->GetData()->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)
 {
 
   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 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()
 {
   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);
+  VisibleOdfsON(0);
 }
 
 void QmitkControlVisualizationPropertiesView::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 QmitkControlVisualizationPropertiesView::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 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();
 
 }
 
 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());
 }
+
+
+void QmitkControlVisualizationPropertiesView::BundleRepresentationWire()
+{
+  if(m_SelectedNode)
+  {
+    m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(m_Controls->m_LineWidth->value()));
+    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)
+  {
+    m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(m_Controls->m_TubeRadius->value()));
+    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::BundleRepresentationColor()
+{
+  if(m_SelectedNode)
+  {
+    QColor color = QColorDialog::getColor();
+    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 QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
+{
+  if(m_SelectedNode)
+  {
+    mitk::PlanarFigure* _PlanarFigure = 0;
+    _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
+
+    if (_PlanarFigure)
+    {
+
+      m_SelectedNode->SetProperty("layer",mitk::IntProperty::New(1000));
+      m_SelectedNode->SetProperty("selected",mitk::BoolProperty::New(false));
+      m_SelectedNode->SetProperty("visible",mitk::BoolProperty::New(true));
+      m_SelectedNode->SetProperty("planarfigure.default.line.color",mitk::ColorProperty::New(1,1,1));
+      m_SelectedNode->SetProperty("planarfigure.default.line.color",mitk::ColorProperty::New(1,1,1));
+      m_SelectedNode->SetProperty("planarfigure.hover.line.color",mitk::ColorProperty::New(1,1,1));
+      m_SelectedNode->SetProperty("planarfigure.hover.line.color",mitk::ColorProperty::New(1,1,1));
+      m_SelectedNode->SetProperty("planarfigure.selected.line.color",mitk::ColorProperty::New(1,1,1));
+      m_SelectedNode->SetProperty("planarfigure.selected.line.color",mitk::ColorProperty::New(1,1,1));
+
+      QmitkRenderWindow* selectedRenderWindow = 0;
+
+      QmitkRenderWindow* RenderWindow1 =
+          this->GetActiveStdMultiWidget()->GetRenderWindow1();
+      QmitkRenderWindow* RenderWindow2 =
+          this->GetActiveStdMultiWidget()->GetRenderWindow2();
+      QmitkRenderWindow* RenderWindow3 =
+          this->GetActiveStdMultiWidget()->GetRenderWindow3();
+      QmitkRenderWindow* RenderWindow4 =
+          this->GetActiveStdMultiWidget()->GetRenderWindow4();
+
+      bool PlanarFigureInitializedWindow = false;
+
+      // find initialized renderwindow
+      if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
+                                          PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
+      {
+        selectedRenderWindow = RenderWindow1;
+      }
+
+      if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
+          "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
+          RenderWindow2->GetRenderer()))
+      {
+        selectedRenderWindow = RenderWindow2;
+      }
+
+      if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
+          "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
+          RenderWindow3->GetRenderer()))
+      {
+        selectedRenderWindow = RenderWindow3;
+      }
+
+      if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
+          "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
+          RenderWindow4->GetRenderer()))
+      {
+        selectedRenderWindow = RenderWindow4;
+      }
+
+      const mitk::PlaneGeometry
+          * _PlaneGeometry =
+          dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
+
+      // make node visible
+      if (selectedRenderWindow)
+      {
+        mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
+        selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
+            centerP, _PlaneGeometry->GetNormal());
+        selectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
+            centerP);
+      }
+    }
+
+  }
+}
diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h
index 914737df7c..51114e026c 100644
--- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h
+++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h
@@ -1,141 +1,149 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
 Version:   $Revision: 17495 $ 
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef _QMITKControlVisualizationPropertiesView_H_INCLUDED
 #define _QMITKControlVisualizationPropertiesView_H_INCLUDED
 
 #include <QmitkFunctionality.h>
 
 #include <string>
 
 #include "berryISelectionListener.h"
 #include "berryIStructuredSelection.h"
 #include "berryISizeProvider.h"
 
 #include "ui_QmitkControlVisualizationPropertiesViewControls.h"
 
 #include "mitkEnumerationProperty.h"
 
 /*!
  * \ingroup org_mitk_gui_qt_diffusionquantification_internal
  *
  * \brief QmitkControlVisualizationPropertiesView
  *
  * Document your class here.
  *
  * \sa QmitkFunctionality
  */
 class QmitkControlVisualizationPropertiesView : public QObject, public QmitkFunctionality//, public berry::ISizeProvider
 {
 
   friend struct CvpSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkControlVisualizationPropertiesView();
   virtual ~QmitkControlVisualizationPropertiesView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
   /// \brief Called when the functionality is activated
   virtual void Activated();
 
   virtual void Deactivated();
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   mitk::DataStorage::SetOfObjects::Pointer ActiveSet(std::string);
 
   void SetBoolProp (mitk::DataStorage::SetOfObjects::Pointer,std::string,bool);
   void SetIntProp  (mitk::DataStorage::SetOfObjects::Pointer,std::string,int);
   void SetFloatProp(mitk::DataStorage::SetOfObjects::Pointer,std::string,float);
   void SetLevelWindowProp(mitk::DataStorage::SetOfObjects::Pointer,std::string,mitk::LevelWindow);
   void SetEnumProp (mitk::DataStorage::SetOfObjects::Pointer,std::string,mitk::EnumerationProperty::Pointer);
 
   virtual int GetSizeFlags(bool width);
   virtual int ComputePreferredSize(bool width, int availableParallel, int availablePerpendicular, int preferredResult);
 
 protected slots:
 
   void DisplayIndexChanged(int);
   void TextIntON();
   void Reinit();
 
   void VisibleOdfsON(int view);
   void VisibleOdfsON_S();
   void VisibleOdfsON_T();
   void VisibleOdfsON_C();
 
   void ShowMaxNumberChanged();
   void NormalizationDropdownChanged(int);
   void ScalingFactorChanged(double);
   void AdditionalScaling(int);
   void IndexParam1Changed(double);
   void IndexParam2Changed(double);
   void OpacityChanged(double,double);
   void ScalingCheckbox();
 
   void OnThickSlicesModeSelected( QAction* action );
   void OnTSNumChanged(int num);
   void OnMenuAboutToShow ();
 
+  void BundleRepresentationWire();
+  void BundleRepresentationTube();
+  void BundleRepresentationColor();
+  void PlanarFigureFocus();
+
 protected:
 
   Ui::QmitkControlVisualizationPropertiesViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   berry::ISelectionListener::Pointer m_SelListener;
   berry::IStructuredSelection::ConstPointer m_CurrentSelection;
 
   bool m_FoundSingleOdfImage;
   bool m_IsInitialized;
 
   QIcon* m_IconTexOFF;
   QIcon* m_IconTexON;
   QIcon* m_IconGlyOFF_T;
   QIcon* m_IconGlyON_T;
   QIcon* m_IconGlyOFF_C;
   QIcon* m_IconGlyON_C;
   QIcon* m_IconGlyOFF_S;
   QIcon* m_IconGlyON_S;
 
   bool m_TexIsOn;
   bool m_GlyIsOn_T;
   bool m_GlyIsOn_C;
   bool m_GlyIsOn_S;
 
   int currentThickSlicesMode;
   QLabel* m_TSLabel;
   QMenu* m_MyMenu;
+
+  // for planarfigure and bundle handling:
+  mitk::DataNode* m_SelectedNode;
 };
 
 
 
 
 #endif // _QMITKControlVisualizationPropertiesView_H_INCLUDED