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 49d122fbd9..bb54e99cbd 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,1622 +1,1646 @@
 /*=========================================================================
 
 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 "mitkTbssImage.h"
+#include "mitkTbssGradientImage.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"
 #include <mitkQBallImage.h>
 #include <mitkTensorImage.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 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();
 
         if(dynamic_cast<mitk::PlanarFigure*>(node->GetData()) != 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->m_Controls->m_PFColor3D->setAutoFillBackground(true);
           m_View->m_Controls->m_PFColor3D->setStyleSheet(styleSheet);
 
           m_View->PlanarFigureFocus();
         }
 
         if(dynamic_cast<mitk::FiberBundle*>(node->GetData()) != 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);
 
 //          mitk::ColorProperty* nodecolor= mitk::ColorProperty::New();
 //          node->GetProperty<mitk::ColorProperty>(nodecolor,"color");
 //          m_View->m_Controls->m_Color->setAutoFillBackground(true);
 //          QString styleSheet = "background-color:rgb(";
 //          styleSheet.append(QString::number(nodecolor->GetColor().GetRed()*255.0));
 //          styleSheet.append(",");
 //          styleSheet.append(QString::number(nodecolor->GetColor().GetGreen()*255.0));
 //          styleSheet.append(",");
 //          styleSheet.append(QString::number(nodecolor->GetColor().GetBlue()*255.0));
 //          styleSheet.append(")");
 //          m_View->m_Controls->m_Color->setStyleSheet(styleSheet);
 
 
         }
       }
     }
 
     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();
 
             // 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);
 
               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);
             }
 
             if(QString("TbssImage").compare(node->GetData()->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);
 
               QString label = "Channel %1";
               label = label.arg(val);
               m_View->m_Controls->label_channel->setText(label);
 
               int maxVal = (dynamic_cast<mitk::TbssImage* >(node->GetData()))->GetImage()->GetVectorLength();
               m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
             }
 
+            if(QString("TbssGradientImage").compare(node->GetData()->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);
+
+              QString label = "Channel %1";
+              label = label.arg(val);
+              m_View->m_Controls->label_channel->setText(label);
+
+              int maxVal = (dynamic_cast<mitk::TbssGradientImage* >(node->GetData()))->GetImage()->GetVectorLength();
+              m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
+
+            }
             else if(QString("QBallImage").compare(node->GetData()->GetNameOfClass())==0)
             {
               foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
               foundQBIVolume = true;
               ApplySettings(node);
             }
 
             else if(QString("TensorImage").compare(node->GetData()->GetNameOfClass())==0)
             {
               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;
               }
             }
           }
         }
       }
 
 
       if(foundDiffusionImage || foundTbssImage)
       {
         m_View->m_Controls->m_DisplayIndex->setVisible(true);
         m_View->m_Controls->label_channel->setVisible(true);
       }
 
 
       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);
 
       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);
 
       }
     }
   }
 
   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)
 {
   currentThickSlicesMode = 1;
   m_MyMenu = NULL;
 }
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other)
 {
   Q_UNUSED(other)
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 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_Focus->setIcon(icon5);
 
     QIcon iconColor(":/QmitkDiffusionImaging/color24.gif");
     m_Controls->m_PFColor->setIcon(iconColor);
     m_Controls->m_PFColor3D->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);
     m_Controls->m_PFColor3D->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
 
     QIcon iconCrosshair(":/QmitkDiffusionImaging/crosshair.png");
     m_Controls->m_Crosshair->setIcon(iconCrosshair);
 
     QIcon iconPaint(":/QmitkDiffusionImaging/paint2.png");
     m_Controls->m_2DHeatmap->setIcon(iconPaint);
 
     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_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_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
     connect((QObject*) m_Controls->m_Focus, SIGNAL(clicked()), (QObject*) this, SLOT(PlanarFigureFocus()));
 
     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_PFColor3D, SIGNAL(clicked()), (QObject*) this, SLOT(PFColor3D()));
 
     connect((QObject*) m_Controls->m_2DHeatmap, SIGNAL(clicked()), (QObject*) this, SLOT(Heatmap()));
 
     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)));
 
     connect((QObject*) m_Controls->m_Welcome, SIGNAL(clicked()), (QObject*) this, SLOT(Welcome()));
 
   }
 }
 
 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;
   }
 }
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
  implement SelectionService Listener explicitly */
 void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
   if ( !this->IsVisible() )
   {
     // do nothing if nobody wants to see me :-(
     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::QBallImage*>(node->GetData()) || dynamic_cast<mitk::TensorImage*>(node->GetData())) )
     {
       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();
       break;
     }
   }
 }
 
 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");
+  std::vector<std::string> sets;
+  sets.push_back("DiffusionImage");
+  sets.push_back("TbssImage");
+  sets.push_back("TbssGradientImage");
 
-  if(set.IsNotNull())
+  std::vector<std::string>::iterator it = sets.begin();
+  while(it != sets.end())
   {
+    std::string s = *it;
+    mitk::DataStorage::SetOfObjects::Pointer set =
+      ActiveSet(s);
 
-    mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
-    mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
-    while ( itemiter != itemiterend )
+    if(set.IsNotNull())
     {
-      (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
-      ++itemiter;
-    }
-
-    //m_MultiWidget->RequestUpdate();
-    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-  }
 
+      mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
+      mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
+      while ( itemiter != itemiterend )
+      {
+        (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
+        ++itemiter;
+      }
 
-  set = ActiveSet("TbssImage");
-
-  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();
     }
 
-    //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);
 }
 
 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());
 
   if(!m_Controls->m_ScalingCheckbox->isChecked())
   {
     m_Controls->m_AdditionalScaling->setCurrentIndex(0);
     m_Controls->m_ScalingFactor->setValue(1.0);
   }
 }
 
 
 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::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 QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
 {
     if(m_SelectedNode)
   {
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(255,255,255)";
     m_Controls->m_Color->setStyleSheet(styleSheet);
 
     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::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->GetInteractor());
 
     if(figureInteractor.IsNull())
       figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", m_SelectedNode);
 
     mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
 
     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::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 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();
 
   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 QmitkControlVisualizationPropertiesView::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 QmitkControlVisualizationPropertiesView::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 QmitkControlVisualizationPropertiesView::LineWidthChanged(int w)
 {
   m_SelectedNode->SetIntProperty("LineWidth", w);
 
   QString label = "Width %1";
   label = label.arg(w);
   m_Controls->label_linewidth->setText(label);
 }
 
 void QmitkControlVisualizationPropertiesView::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 QmitkControlVisualizationPropertiesView::Welcome()
 {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
    GetSite()->GetWorkbenchWindow(), false);
 }
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriter.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriter.cpp
new file mode 100644
index 0000000000..fdd6887633
--- /dev/null
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriter.cpp
@@ -0,0 +1,119 @@
+/*=========================================================================
+
+Program:   Medical Imaging & Interaction Toolkit
+Language:  C++
+Date:      $Date: 2008-12-10 18:05:13 +0100 (Mi, 10 Dez 2008) $
+Version:   $Revision: 15922 $
+
+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 __mitkNrrdTbssGradientImageWriter__cpp
+#define __mitkNrrdTbssGradientImageWriter__cpp
+
+#include "mitkNrrdTbssGradientImageWriter.h"
+#include "itkMetaDataDictionary.h"
+#include "itkMetaDataObject.h"
+#include "itkNrrdImageIO.h"
+//#include "itkNiftiImageIO.h"
+#include "itkImageFileWriter.h"
+#include "itksys/SystemTools.hxx"
+#include "boost/lexical_cast.hpp"
+
+#include <iostream>
+#include <fstream>
+
+
+mitk::NrrdTbssGradientImageWriter::NrrdTbssGradientImageWriter()
+  : m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
+{
+  this->SetNumberOfRequiredInputs( 1 );
+}
+
+mitk::NrrdTbssGradientImageWriter::~NrrdTbssGradientImageWriter()
+{}
+
+
+void mitk::NrrdTbssGradientImageWriter::GenerateData()
+{
+  m_Success = false;
+  InputType* input = this->GetInput();
+  if (input == NULL)
+  {
+    itkWarningMacro(<<"Sorry, input to NrrdTbssGradientImageWriter is NULL!");
+    return;
+  }
+  if ( m_FileName == "" )
+  {
+    itkWarningMacro( << "Sorry, filename has not been set!" );
+    return ;
+  }
+
+  typedef itk::VectorImage<int,3> ImageType;
+
+  ImageType::Pointer img = input->GetImage();
+
+  itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+  io->SetFileType( itk::ImageIOBase::Binary );
+  io->UseCompressionOn();
+
+
+  typedef itk::ImageFileWriter<ImageType> WriterType;
+  WriterType::Pointer nrrdWriter = WriterType::New();
+ // nrrdWriter->UseInputMetaDataDictionaryOn();
+  nrrdWriter->SetInput( img );
+  nrrdWriter->SetImageIO(io);
+  nrrdWriter->SetFileName(m_FileName);
+  nrrdWriter->UseCompressionOn();
+  nrrdWriter->SetImageIO(io);
+  try
+  {
+    nrrdWriter->Update();
+  }
+  catch (itk::ExceptionObject e)
+  {
+    std::cout << e << std::endl;
+  }
+
+  m_Success = true;
+}
+
+
+
+
+
+
+void mitk::NrrdTbssGradientImageWriter::SetInput( InputType* tbssVol )
+{
+  this->ProcessObject::SetNthInput( 0, tbssVol );
+}
+
+
+mitk::TbssGradientImage* mitk::NrrdTbssGradientImageWriter::GetInput()
+{
+  if ( this->GetNumberOfInputs() < 1 )
+  {
+    return NULL;
+  }
+  else
+  {
+    return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( 0 ) );
+  }
+}
+
+
+std::vector<std::string> mitk::NrrdTbssGradientImageWriter::GetPossibleFileExtensions()
+{
+  std::vector<std::string> possibleFileExtensions;
+  possibleFileExtensions.push_back(".tgi"); // tgi = tbss gradient image
+  return possibleFileExtensions;
+}
+
+#endif //__mitkNrrdTbssImageWriter__cpp
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriter.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriter.h
new file mode 100644
index 0000000000..270142b4f8
--- /dev/null
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriter.h
@@ -0,0 +1,141 @@
+/*=========================================================================
+ 
+Program:   Medical Imaging & Interaction Toolkit
+Language:  C++
+Date:      $Date: 2008-08-27 17:18:46 +0200 (Mi, 27 Aug 2008) $
+Version:   $Revision: 15096 $
+ 
+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 _MITK_NRRDTBSSGRADIENTVOL_WRITER__H_
+#define _MITK_NRRDTBSSGRADIENTVOL_WRITER__H_
+
+#include <itkProcessObject.h>
+#include <mitkFileWriterWithInformation.h>
+#include <mitkTbssGradientImage.h>
+#include <QString>
+#include "MitkDiffusionImagingExports.h"
+
+namespace mitk
+{
+
+/**
+ * Writes diffusion volumes to a file
+ * @ingroup Process
+ */
+
+class MitkDiffusionImaging_EXPORT NrrdTbssGradientImageWriter : public mitk::FileWriterWithInformation
+{
+public:
+
+    mitkClassMacro( NrrdTbssGradientImageWriter, mitk::FileWriterWithInformation )
+
+    mitkWriterMacro
+
+    itkNewMacro( Self )
+    
+    typedef mitk::TbssGradientImage InputType;
+    
+    /**
+     * Sets the filename of the file to write.
+     * @param FileName the nameInputType of the file to write.
+     */
+    itkSetStringMacro( FileName )
+
+    /**
+     * @returns the name of the file to be written to disk.
+     */
+    itkGetStringMacro( FileName )
+
+    /**
+     * @warning multiple write not (yet) supported
+     */
+    itkSetStringMacro( FilePrefix )
+
+    /**
+     * @warning multiple write not (yet) supported
+     */
+    itkGetStringMacro( FilePrefix )
+
+    /**
+     * @warning multiple write not (yet) supported
+     */
+    itkSetStringMacro( FilePattern )
+
+    /**
+     * @warning multiple write not (yet) supported
+     */
+    itkGetStringMacro( FilePattern )
+
+    /**image
+     * Sets the input object for the filter.
+     * @param input the diffusion volumes to write to file.
+     */
+    void SetInput( InputType* input );
+    /**itk::VectorImage<TPixelType, 3>
+     * @returns the 0'th input object of the filter.
+     */
+    InputType* GetInput();
+
+    /**
+     * Returns false if an error happened during writing
+     */
+    itkGetMacro( Success, bool )
+   
+    /**
+    * @return possible file extensions for the data type associated with the writer
+    */
+    virtual std::vector<std::string> GetPossibleFileExtensions();
+
+    // FileWriterWithInformation methods
+    virtual const char * GetDefaultFilename() { return "TbssGradientImage.tgi"; }
+    virtual const char * GetFileDialogPattern() { return "Tbss Gradient Images (*.tgi)"; }
+    virtual const char * GetDefaultExtension() { return ".tgi"; }
+    virtual bool CanWriteBaseDataType(BaseData::Pointer data)
+    {
+      return (dynamic_cast<mitk::TbssGradientImage*>(data.GetPointer()) != NULL);
+    }
+
+
+    virtual void DoWrite(BaseData::Pointer data) { 
+      if (CanWriteBaseDataType(data)) {
+        this->SetInput(dynamic_cast<mitk::TbssGradientImage*>(data.GetPointer()));
+        this->Update(); 
+      }
+    }
+
+protected:
+        
+    NrrdTbssGradientImageWriter();
+
+    virtual ~NrrdTbssGradientImageWriter();
+
+    virtual void GenerateData();
+    
+    std::string m_FileName;
+
+    std::string m_FilePrefix;
+
+    std::string m_FilePattern;
+    
+    bool m_Success;
+
+
+    //std::string RetrieveString(mitk::TbssGradientImage::MetaDataFunction meta);
+            
+};    
+       
+
+} // end of namespace mitk
+
+
+
+#endif
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriterFactory.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriterFactory.cpp
new file mode 100644
index 0000000000..6c0c158e85
--- /dev/null
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriterFactory.cpp
@@ -0,0 +1,52 @@
+/*=========================================================================
+
+Program:   Medical Imaging & Interaction Toolkit
+Language:  C++
+Date:      $Date: 2007-12-11 14:46:19 +0100 (Di, 11 Dez 2007) $
+Version:   $Revision: 11215 $
+
+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 "mitkNrrdTbssGradientImageWriterFactory.h"
+
+#include "itkCreateObjectFunction.h"
+#include "itkVersion.h"
+
+#include <mitkNrrdTbssGradientImageWriter.h>
+
+namespace mitk
+{
+
+NrrdTbssGradientImageWriterFactory::NrrdTbssGradientImageWriterFactory()
+{
+  typedef int TbssGradientPixelType;
+  this->RegisterOverride("IOWriter",
+                         "NrrdTbssGradientImageWriter",
+                         "NrrdTbssGradientImage Writer",
+                         1,
+                         itk::CreateObjectFunction< mitk::NrrdTbssGradientImageWriter >::New());
+}
+
+NrrdTbssGradientImageWriterFactory::~NrrdTbssGradientImageWriterFactory()
+{
+}
+
+const char* NrrdTbssGradientImageWriterFactory::GetITKSourceVersion() const
+{
+  return ITK_SOURCE_VERSION;
+}
+
+const char* NrrdTbssGradientImageWriterFactory::GetDescription() const
+{
+  return "NrrdTbssGradientImageWriterFactory";
+}
+
+} // end namespace mitk
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriterFactory.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriterFactory.h
new file mode 100644
index 0000000000..22ff6b4bde
--- /dev/null
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriterFactory.h
@@ -0,0 +1,69 @@
+/*=========================================================================
+
+Program:   Medical Imaging & Interaction Toolkit
+Language:  C++
+Date:      $Date: 2009-05-13 18:06:46 +0200 (Mi, 13 Mai 2009) $
+Version:   $Revision: 11215 $
+
+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 NRRDTBSSGRADIENTIMAGE_WRITERFACTORY_H_HEADER_INCLUDED
+#define NRRDTBSSGRADIENTIMAGE_WRITERFACTORY_H_HEADER_INCLUDED
+
+#include "itkObjectFactoryBase.h"
+#include "mitkBaseData.h"
+#include "MitkDiffusionImagingExports.h"
+#include "MitkDiffusionImagingExports.h"
+
+namespace mitk
+{
+
+class MitkDiffusionImaging_EXPORT NrrdTbssGradientImageWriterFactory : public itk::ObjectFactoryBase
+{
+public:
+
+  mitkClassMacro( mitk::NrrdTbssGradientImageWriterFactory, itk::ObjectFactoryBase )
+
+  /** Class methods used to interface with the registered factories. */
+  virtual const char* GetITKSourceVersion(void) const;
+  virtual const char* GetDescription(void) const;
+
+  /** Method for class instantiation. */
+  itkFactorylessNewMacro(Self);
+
+  /** Register one factory of this type  */
+  static void RegisterOneFactory(void)
+  {
+    static bool IsRegistered = false;
+    if ( !IsRegistered )
+    {
+      mitk::NrrdTbssGradientImageWriterFactory::Pointer fac = mitk::NrrdTbssGradientImageWriterFactory::New();
+      ObjectFactoryBase::RegisterFactory( fac );
+      IsRegistered = true;
+    }
+  }
+
+protected:
+  NrrdTbssGradientImageWriterFactory();
+  ~NrrdTbssGradientImageWriterFactory();
+
+private:
+  NrrdTbssGradientImageWriterFactory(const Self&); //purposely not implemented
+  void operator=(const Self&); //purposely not implemented
+
+};
+
+} // end namespace mitk
+
+#endif // NRRDTBSSGRADIENTIMAGE_WRITERFACTORY_H_HEADER_INCLUDED
+
+
+
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
index 3af436fda6..a004eec06e 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
@@ -1,346 +1,410 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 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 __mitkNrrdTbssImageReader_cpp
 #define __mitkNrrdTbssImageReader_cpp
 
 #include "mitkNrrdTbssImageReader.h"
 
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkNiftiImageIO.h"
 
 #include <itkImageFileWriter.h>
 
 #include <iostream>
 #include <fstream>
 
 #include "itksys/SystemTools.hxx"
 
 
 namespace mitk
 {
       void NrrdTbssImageReader
       ::GenerateData()
   {
 
     // Since everything is completely read in GenerateOutputInformation() it is stored
     // in a cache variable. A timestamp is associated.
     // If the timestamp of the cache variable is newer than the MTime, we only need to
     // assign the cache variable to the DataObject.
     // Otherwise, the tree must be read again from the file and OuputInformation must
     // be updated!
     if ( ( ! m_OutputCache ) || ( this->GetMTime( ) > m_CacheTime.GetMTime( ) ) )
     {
       this->GenerateOutputInformation();
       itkWarningMacro("Cache regenerated!");
     }
 
     if (!m_OutputCache)
     {
       itkWarningMacro("Tree cache is empty!")
     }
 
     int vecsize = m_OutputCache->GetImage()->GetVectorLength();
 
     static_cast<OutputType*>(this->GetOutput())
         ->SetImage(m_OutputCache->GetImage());
     static_cast<OutputType*>(this->GetOutput())
         ->SetGroupInfo(m_OutputCache->GetGroupInfo());
     static_cast<OutputType*>(this->GetOutput())
         ->SetMetaInfo(m_OutputCache->GetMetaInfo());
     static_cast<OutputType*>(this->GetOutput())
         ->SetIsMeta(m_OutputCache->GetIsMeta());
+    static_cast<OutputType*>(this->GetOutput())
+        ->SetContainsDistanceMap(m_OutputCache->GetContainsDistanceMap());
+    static_cast<OutputType*>(this->GetOutput())
+        ->SetContainsMeanSkeleton(m_OutputCache->GetContainsMeanSkeleton());
+    static_cast<OutputType*>(this->GetOutput())
+        ->SetContainsSkeletonMask(m_OutputCache->GetContainsSkeletonMask());
+    static_cast<OutputType*>(this->GetOutput())
+        ->SetContainsGradient(m_OutputCache->GetContainsGradient());
     static_cast<OutputType*>(this->GetOutput())
         ->InitializeFromVectorImage();
 
   }
 
       void NrrdTbssImageReader
       ::GenerateOutputInformation()
   {
     OutputType::Pointer outputForCache = OutputType::New();
 
     if ( m_FileName == "")
     {
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
     }
     else
     {
       try
       {
         const std::string& locale = "C";
         const std::string& currLocale = setlocale( LC_ALL, NULL );
 
         if ( locale.compare(currLocale)!=0 )
         {
           try
           {
             MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
             setlocale(LC_ALL, locale.c_str());
           }
           catch(...)
           {
             MITK_INFO << "Could not set locale " << locale;
           }
         }
 
 
         MITK_INFO << "NrrdTbssImageReader READING IMAGE INFORMATION";
         ImageType::Pointer img;
 
         std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
         ext = itksys::SystemTools::LowerCase(ext);
         if (ext == ".tbss")
         {
           typedef itk::ImageFileReader<ImageType> FileReaderType;
           FileReaderType::Pointer reader = FileReaderType::New();
           reader->SetFileName(this->m_FileName);
           itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
           reader->SetImageIO(io);
 
           reader->Update();
           img = reader->GetOutput();
 
 
           MITK_INFO << "NrrdTbssImageReader READING HEADER INFORMATION";
 
 
           itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
           std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
           std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
           std::string metaString;
 
 
           //int numberOfGradientImages = 0;
           std::string measurementInfo;
           bool isMeta = false;
+          bool containsSkeleton;
+          bool containsSkeletonMask;
+          bool containsGradient;
+          bool containsDistanceMap;
+
+
+
           std::vector<std::pair<mitk::TbssImage::MetaDataFunction, int > > metaInfo;
 
           std::vector< std::pair<std::string, int> > groups;
 
           for (; itKey != imgMetaKeys.end(); itKey ++)
           {
             itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
 
             MITK_INFO << *itKey << " ---> " << metaString;
 
             if (itKey->find("Group_index") != std::string::npos)
             {
 
               std::vector<std::string> tokens;
               this->Tokenize(metaString, tokens, " ");
 
               if(tokens.size()==2)
               {
 
                 std::cout << tokens.at(0) << " " << tokens.at(1) << std::endl;
 
                 std::pair< std::string, int > p;
                 p.first = tokens.at(0);
                 std::string s = tokens.at(1);
                 p.second = atoi(tokens.at(1).c_str());
                 groups.push_back(p);
               }
 
 
             }
 
             else if(itKey->find("Measurement info") != std::string::npos)
             {
               measurementInfo = metaString;
             }
 
 
             else if(itKey->find("meta") != std::string::npos)
             {
               if(metaString == "true")
               {
                 isMeta = true;
               }
             }
 
             else if(itKey->find("mean fa skeleton mask") != std::string::npos)
             {
               std::pair<mitk::TbssImage::MetaDataFunction, int> p;
               p.first = mitk::TbssImage::MEAN_FA_SKELETON_MASK;
               p.second = atoi(metaString.c_str());
               metaInfo.push_back(p);
+              containsSkeletonMask = true;
             }
 
             else if(itKey->find("mean fa skeleton") != std::string::npos)
             {
               std::pair<mitk::TbssImage::MetaDataFunction, int> p;
               p.first = mitk::TbssImage::MEAN_FA_SKELETON;
               p.second = atoi(metaString.c_str());
               metaInfo.push_back(p);
+              containsSkeleton = true;
+            }
+
+            else if(itKey->find("gradient_x") != std::string::npos)
+            {
+              std::pair<mitk::TbssImage::MetaDataFunction, int> p;
+              p.first = mitk::TbssImage::GRADIENT_X;
+              p.second = atoi(metaString.c_str());
+              metaInfo.push_back(p);
+              containsGradient = true;
+            }
+            else if(itKey->find("gradient_y") != std::string::npos)
+            {
+              std::pair<mitk::TbssImage::MetaDataFunction, int> p;
+              p.first = mitk::TbssImage::GRADIENT_Y;
+              p.second = atoi(metaString.c_str());
+              metaInfo.push_back(p);
+              containsGradient = true;
             }
 
+            else if(itKey->find("gradient_z") != std::string::npos)
+            {
+              std::pair<mitk::TbssImage::MetaDataFunction, int> p;
+              p.first = mitk::TbssImage::GRADIENT_Z;
+              p.second = atoi(metaString.c_str());
+              metaInfo.push_back(p);
+              containsGradient = true;
+            }
+
+
+            else if(itKey->find("tubular structure") != std::string::npos)
+            {
+              std::pair<mitk::TbssImage::MetaDataFunction, int> p;
+              p.first = mitk::TbssImage::TUBULAR_STRUCTURE;
+              p.second = atoi(metaString.c_str());
+              metaInfo.push_back(p);
+            }
+
+            else if(itKey->find("distance map") != std::string::npos)
+            {
+              std::pair<mitk::TbssImage::MetaDataFunction, int> p;
+              p.first = mitk::TbssImage::DISTANCE_MAP;
+              p.second = atoi(metaString.c_str());
+              metaInfo.push_back(p);
+              containsDistanceMap = true;
+            }
 
           }
 
           outputForCache->SetIsMeta(isMeta);
+          outputForCache->SetContainsGradient(containsGradient);
+          outputForCache->SetContainsSkeletonMask(containsSkeletonMask);
+          outputForCache->SetContainsMeanSkeleton(containsSkeleton);
+          outputForCache->SetContainsDistanceMap(containsDistanceMap);
           outputForCache->SetGroupInfo(groups);
           outputForCache->SetMeasurementInfo(measurementInfo);
           outputForCache->SetMetaInfo(metaInfo);
 
         }
 
 
 
         // This call updates the output information of the associated VesselTreeData
         outputForCache->SetImage(img);
 
       //  outputForCache->SetB_Value(m_B_Value);
         //outputForCache->SetDirections(m_DiffusionVectors);
        // outputForCache->SetOriginalDirections(m_OriginalDiffusionVectors);
        // outputForCache->SetMeasurementFrame(m_MeasurementFrame);
 
         // Since we have already read the tree, we can store it in a cache variable
         // so that it can be assigned to the DataObject in GenerateData();
         m_OutputCache = outputForCache;
         m_CacheTime.Modified();
 
         try
         {
           MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
           setlocale(LC_ALL, currLocale.c_str());
         }
         catch(...)
         {
           MITK_INFO << "Could not reset locale " << currLocale;
         }
       }
       catch(std::exception& e)
       {
         MITK_INFO << "Std::Exception while reading file!!";
         MITK_INFO << e.what();
         throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
       }
       catch(...)
       {
         MITK_INFO << "Exception while reading file!!";
         throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
       }
     }
   }
 
 
 
       const char* NrrdTbssImageReader
       ::GetFileName() const
   {
     return m_FileName.c_str();
   }
 
        void NrrdTbssImageReader
       ::SetFileName(const char* aFileName)
   {
     m_FileName = aFileName;
   }
 
       const char* NrrdTbssImageReader
       ::GetFilePrefix() const
   {
     return m_FilePrefix.c_str();
   }
 
       void NrrdTbssImageReader
       ::SetFilePrefix(const char* aFilePrefix)
   {
     m_FilePrefix = aFilePrefix;
   }
 
       const char* NrrdTbssImageReader
       ::GetFilePattern() const
   {
     return m_FilePattern.c_str();
   }
 
       void NrrdTbssImageReader
       ::SetFilePattern(const char* aFilePattern)
   {
     m_FilePattern = aFilePattern;
   }
 
       bool NrrdTbssImageReader
       ::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
   {
 
     // First check the extension
     if(  filename == "" )
       return false;
 
     // check if image is serie
     if( filePattern != "" && filePrefix != "" )
       return false;
 
 
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
     if (ext == ".tbss")
     {
       itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
 
       typedef itk::ImageFileReader<ImageType> FileReaderType;
       FileReaderType::Pointer reader = FileReaderType::New();
       reader->SetImageIO(io);
       reader->SetFileName(filename);
 
       try
       {
         reader->Update();
       }
       catch(itk::ExceptionObject e)
       {
         MITK_INFO << e.GetDescription();
         return false;
       }
 
 
 /*
       typename ImageType::Pointer img = reader->GetOutput();
       itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
       std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
       std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
       std::string metaString;
 
       for (; itKey != imgMetaKeys.end(); itKey ++)
       {
         itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
         if (itKey->find("tbss") != std::string::npos)
         {
           if (metaString.find("ROI") != std::string::npos)
           {
             return true;
           }
         }
       }
     }
 */
  //  return false;
 
       return true;
     }
     return false;
   }
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
index 1d96fab600..de8316c295 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
@@ -1,192 +1,212 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-12-10 18:05:13 +0100 (Mi, 10 Dez 2008) $
 Version:   $Revision: 15922 $
 
 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 __mitkNrrdTbssImageWriter__cpp
 #define __mitkNrrdTbssImageWriter__cpp
 
 #include "mitkNrrdTbssImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 //#include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "boost/lexical_cast.hpp"
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::NrrdTbssImageWriter::NrrdTbssImageWriter()
   : m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
 {
   this->SetNumberOfRequiredInputs( 1 );
 }
 
 mitk::NrrdTbssImageWriter::~NrrdTbssImageWriter()
 {}
 
 
 void mitk::NrrdTbssImageWriter::GenerateData()
 {
   m_Success = false;
   InputType* input = this->GetInput();
   if (input == NULL)
   {
     itkWarningMacro(<<"Sorry, input to NrrdTbssImageWriter is NULL!");
     return;
   }
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
 
 
   itk::VectorImage<float, 3>::Pointer img = input->GetImage();
 
   std::string key;
   std::string val;
 
 
   /* For the case of a tbss image containing data of the patients:
      Save info about the groups and the type of measurement */
 
   if(!input->GetIsMeta())
   {
     key = "meta";
     val = "false";
     itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
 
 
     std::vector< std::pair <std::string, int> > groups = input->GetGroupInfo();
     std::vector< std::pair <std::string, int> >::iterator it = groups.begin();
 
     int i=0;
     while(it != groups.end())
     {
       std::pair<std::string, int> p = *it;
 
       key = "Group_index_" + boost::lexical_cast<std::string>(i);
       val = " " + p.first + " " + boost::lexical_cast<std::string>(p.second);
       //sprintf( keybuffer, "Group_index_%04d", std::string(i) );
       // sprintf( valbuffer, "%1d %1d", p.first, p.second);
 
       //std::cout << valbuffer << std::endl;
 
       //itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
       itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
       it++;
       ++i;
     }
 
     key = "Measurement info";
     val = input->GetMeasurementInfo();
     itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
   }
   /* If we are dealing with metadata we need to know what index of the vector corresponds to what image.
      Metadata are the images involved in the algorithms of tbss, like the mean FA Skeleton. */
   else
   {
     key = "meta";
     val = "true";
     itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
 
     std::vector< std::pair<mitk::TbssImage::MetaDataFunction, int> > metaInfo = input->GetMetaInfo();
     std::vector< std::pair<mitk::TbssImage::MetaDataFunction, int> >::iterator it = metaInfo.begin();
     while(it != metaInfo.end())
     {
       std::pair<mitk::TbssImage::MetaDataFunction, int> p = *it;
       key = RetrieveString(p.first);
       val = " " + boost::lexical_cast<std::string>(p.second);
       itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
       it++;
     }
   }
 
   typedef itk::VectorImage<float,3> ImageType;
 
   itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
   io->SetFileType( itk::ImageIOBase::Binary );
   io->UseCompressionOn();
 
 
   typedef itk::ImageFileWriter<ImageType> WriterType;
   WriterType::Pointer nrrdWriter = WriterType::New();
   nrrdWriter->UseInputMetaDataDictionaryOn();
   nrrdWriter->SetInput( img );
   nrrdWriter->SetImageIO(io);
   nrrdWriter->SetFileName(m_FileName);
   nrrdWriter->UseCompressionOn();
   nrrdWriter->SetImageIO(io);
   try
   {
     nrrdWriter->Update();
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e << std::endl;
   }
 
   m_Success = true;
 }
 
 
 
 std::string mitk::NrrdTbssImageWriter::RetrieveString(mitk::TbssImage::MetaDataFunction meta)
 {
   if(meta == mitk::TbssImage::MEAN_FA_SKELETON)
   {
     return "mean fa skeleton";
   }
   else if(meta == mitk::TbssImage::MEAN_FA_SKELETON_MASK)
   {
     return "mean fa skeleton mask";
   }
+  else if(meta == mitk::TbssImage::GRADIENT_X)
+  {
+    return "gradient_x";
+  }
+  else if(meta == mitk::TbssImage::GRADIENT_Y)
+  {
+    return "gradient_y";
+  }
+  else if(meta == mitk::TbssImage::GRADIENT_Z)
+  {
+    return "gradient_z";
+  }
+  else if(meta == mitk::TbssImage::TUBULAR_STRUCTURE)
+  {
+    return "tubular structure";
+  }
+  else if(meta == mitk::TbssImage::DISTANCE_MAP)
+  {
+    return "distance map";
+  }
   return "";
 }
 
 
 
 void mitk::NrrdTbssImageWriter::SetInput( InputType* tbssVol )
 {
   this->ProcessObject::SetNthInput( 0, tbssVol );
 }
 
 
 mitk::TbssImage* mitk::NrrdTbssImageWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 
 std::vector<std::string> mitk::NrrdTbssImageWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".tbss");
   return possibleFileExtensions;
 }
 
 #endif //__mitkNrrdTbssImageWriter__cpp
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssGradientImage.cpp
similarity index 80%
copy from Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.cpp
copy to Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssGradientImage.cpp
index 3c8a68e4e8..345e30ec1e 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssGradientImage.cpp
@@ -1,117 +1,109 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-08 11:19:03 +0100 (Fr, 08 Feb 2008) $
 Version:   $Revision: 11989 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
-#ifndef __mitkTbssImage__cpp
-#define __mitkTbssImage__cpp
+#ifndef __mitkTbssGradientImage__cpp
+#define __mitkTbssGradientImage__cpp
 
 
-#include "mitkTbssImage.h"
+#include "mitkTbssGradientImage.h"
 #include "itkImageRegionIterator.h"
 #include "itkImageRegionConstIterator.h"
 #include "mitkImageCast.h"
 
 
 
 
-mitk::TbssImage::TbssImage()
-  : m_IsMeta(false)
+mitk::TbssGradientImage::TbssGradientImage()
 {
 
 }
 
 
-void mitk::TbssImage::InitializeFromVectorImage()
+void mitk::TbssGradientImage::InitializeFromVectorImage()
 {
   if(!m_Image)
   {
-    MITK_INFO << "TBSS Image could not be initialized. Set all members first!" << std::endl;
+    MITK_INFO << "TBSS Gradient Image could not be initialized. Set all members first!" << std::endl;
     return;
   }
 
 
   typedef itk::Image<float,3> ImgType;
   ImgType::Pointer img = ImgType::New();
   img->SetSpacing( m_Image->GetSpacing() );   // Set the image spacing
   img->SetOrigin( m_Image->GetOrigin() );     // Set the image origin
   img->SetDirection( m_Image->GetDirection() );  // Set the image direction
   img->SetLargestPossibleRegion( m_Image->GetLargestPossibleRegion());
   img->SetBufferedRegion( m_Image->GetLargestPossibleRegion() );
   img->Allocate();
 
-  int vecLength = m_Image->GetVectorLength();
-  InitializeByItk( img.GetPointer(), 1, vecLength );
-
-  //for(int i=0; i<vecLength; i++)
-  //{TbssImage();
-
+  InitializeByItk( img.GetPointer(), 1, 3 );
 
   itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
   itw = itw.Begin();
 
   itk::ImageRegionConstIterator<ImageType> itr (m_Image, m_Image->GetLargestPossibleRegion() );
   itr = itr.Begin();
 
   while(!itr.IsAtEnd())
   {
     itw.Set(itr.Get().GetElement(0));
     ++itr;
     ++itw;
   }
 
-  // init
+
   SetImportVolume(img->GetBufferPointer());//, 0, 0, CopyMemory);
-    //SetVolume( img->GetBufferPointer(), i );
-  //}::
 
   m_DisplayIndex = 0;
   MITK_INFO << "Tbss-Image successfully initialized.";
 
 }
 
 
-void mitk::TbssImage::SetDisplayIndexForRendering(int displayIndex)
+void mitk::TbssGradientImage::SetDisplayIndexForRendering(int displayIndex)
 {
   MITK_INFO << "displayindex: " << displayIndex;
   int index = displayIndex;
   int vecLength = m_Image->GetVectorLength();
   index = index > vecLength-1 ? vecLength-1 : index;
   if( m_DisplayIndex != index )
   {
     typedef itk::Image<float,3> ImgType;
     ImgType::Pointer img = ImgType::New();
     CastToItkImage<ImgType>(this, img);
 
     itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
     itw = itw.Begin();
 
     itk::ImageRegionConstIterator<ImageType> itr (m_Image, m_Image->GetLargestPossibleRegion() );
     itr = itr.Begin();
 
     while(!itr.IsAtEnd())
     {
       itw.Set(itr.Get().GetElement(index));
       ++itr;
       ++itw;
     }
   }
 
   m_DisplayIndex = index;
 }
 
 
 
-#endif /* __mitkTbssImage__cpp */
+#endif /* __mitkTbssGradientImage__cpp */
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssGradientImage.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssGradientImage.h
new file mode 100644
index 0000000000..33a847d103
--- /dev/null
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssGradientImage.h
@@ -0,0 +1,94 @@
+/*=========================================================================
+
+Program:   Medical Imaging & Interaction Toolkit
+Language:  C++
+Date:      $Date: 2008-02-07 17:17:57 +0100 (Do, 07 Feb 2008) $
+Version:   $Revision: 11989 $
+
+Copyright (c) German Cancer Research Center, Division of Medical and
+Biological Informatics. All rights reserved.
+See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+
+
+#ifndef __mitkTbssGradientImage__h
+#define __mitkTbssGradientImage__h
+
+#include "mitkImage.h"
+#include "itkVectorImage.h"
+#include "mitkImageCast.h"
+#include "MitkDiffusionImagingExports.h"
+
+namespace mitk 
+{
+
+  /**
+  * \brief this class encapsulates tbss gradient images (vectorimages not
+  * yet supported by mitkImage)
+  */
+
+  class MitkDiffusionImaging_EXPORT TbssGradientImage : public Image
+  {
+
+  public:
+
+    typedef itk::VectorImage<int, 3> ImageType;
+
+
+    typedef itk::Index<3> IndexType;
+    //typedef typename std::vector <Index<3> > RoiType;
+
+    mitkClassMacro( TbssGradientImage, Image )
+    itkNewMacro(Self)
+
+
+    //void SetRequestedRegionToLargestPossibleReg tbssRoi->SetTbssType(mitk::TbssImage<char>::ROI);ion();
+    //bool RequestedRegionIsOutsideOfTheBufferedRegion();
+    //virtual bool VerifyRequestedRegion();
+    //void SetRequestedRegion(itk::DataObject *data);
+
+    ImageType::Pointer GetImage()
+    {
+      return m_Image;
+    }
+    void SetImage(ImageType::Pointer image )
+    {
+      this->m_Image = image;
+    }
+
+
+    void InitializeFromImage()
+    {
+      MITK_INFO << "make an mitk image that can be shown by mitk";
+      this->InitializeByItk(m_Image.GetPointer(),1,1);
+    }
+
+
+    void InitializeFromVectorImage();
+
+    void SetDisplayIndexForRendering(int displayIndex);
+
+
+
+  protected:
+
+    TbssGradientImage();
+
+    virtual ~TbssGradientImage(){}
+
+    ImageType::Pointer m_Image;
+
+    int m_DisplayIndex;
+
+  };
+
+
+
+} // namespace mitk
+
+#endif /* __mitkTbssGradientImage__h */
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.cpp
index 3c8a68e4e8..553fe5171f 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.cpp
@@ -1,117 +1,119 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-08 11:19:03 +0100 (Fr, 08 Feb 2008) $
 Version:   $Revision: 11989 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __mitkTbssImage__cpp
 #define __mitkTbssImage__cpp
 
 
 #include "mitkTbssImage.h"
 #include "itkImageRegionIterator.h"
 #include "itkImageRegionConstIterator.h"
 #include "mitkImageCast.h"
 
 
 
 
 mitk::TbssImage::TbssImage()
-  : m_IsMeta(false)
+  : m_IsMeta(false),
+  m_ContainsGradient(false),
+  m_ContainsMeanSkeleton(false),
+  m_ContainsSkeletonMask(false)
 {
 
 }
 
 
 void mitk::TbssImage::InitializeFromVectorImage()
 {
   if(!m_Image)
   {
     MITK_INFO << "TBSS Image could not be initialized. Set all members first!" << std::endl;
     return;
   }
 
 
   typedef itk::Image<float,3> ImgType;
   ImgType::Pointer img = ImgType::New();
   img->SetSpacing( m_Image->GetSpacing() );   // Set the image spacing
   img->SetOrigin( m_Image->GetOrigin() );     // Set the image origin
   img->SetDirection( m_Image->GetDirection() );  // Set the image direction
   img->SetLargestPossibleRegion( m_Image->GetLargestPossibleRegion());
   img->SetBufferedRegion( m_Image->GetLargestPossibleRegion() );
   img->Allocate();
 
   int vecLength = m_Image->GetVectorLength();
   InitializeByItk( img.GetPointer(), 1, vecLength );
 
   //for(int i=0; i<vecLength; i++)
   //{TbssImage();
 
 
   itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
   itw = itw.Begin();
 
   itk::ImageRegionConstIterator<ImageType> itr (m_Image, m_Image->GetLargestPossibleRegion() );
   itr = itr.Begin();
 
   while(!itr.IsAtEnd())
   {
     itw.Set(itr.Get().GetElement(0));
     ++itr;
     ++itw;
   }
 
   // init
   SetImportVolume(img->GetBufferPointer());//, 0, 0, CopyMemory);
     //SetVolume( img->GetBufferPointer(), i );
   //}::
 
   m_DisplayIndex = 0;
   MITK_INFO << "Tbss-Image successfully initialized.";
 
 }
 
-
 void mitk::TbssImage::SetDisplayIndexForRendering(int displayIndex)
 {
   MITK_INFO << "displayindex: " << displayIndex;
   int index = displayIndex;
   int vecLength = m_Image->GetVectorLength();
   index = index > vecLength-1 ? vecLength-1 : index;
   if( m_DisplayIndex != index )
   {
     typedef itk::Image<float,3> ImgType;
     ImgType::Pointer img = ImgType::New();
     CastToItkImage<ImgType>(this, img);
 
     itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
     itw = itw.Begin();
 
     itk::ImageRegionConstIterator<ImageType> itr (m_Image, m_Image->GetLargestPossibleRegion() );
     itr = itr.Begin();
 
     while(!itr.IsAtEnd())
     {
       itw.Set(itr.Get().GetElement(index));
       ++itr;
       ++itw;
     }
   }
 
   m_DisplayIndex = index;
 }
 
 
 
 #endif /* __mitkTbssImage__cpp */
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.h
index 3b5e5605bb..bee8701825 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.h
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.h
@@ -1,167 +1,185 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-07 17:17:57 +0100 (Do, 07 Feb 2008) $
 Version:   $Revision: 11989 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef __mitkTbssImage__h
 #define __mitkTbssImage__h
 
 #include "mitkImage.h"
 #include "itkVectorImage.h"
 #include "mitkImageCast.h"
 #include "MitkDiffusionImagingExports.h"
 
 namespace mitk 
 {
 
   /**
   * \brief this class encapsulates diffusion volumes (vectorimages not
   * yet supported by mitkImage)
   */
 
   class MitkDiffusionImaging_EXPORT TbssImage : public Image
   {
 
   public:
 
     typedef itk::VectorImage<float, 3> ImageType;
 
 
     typedef itk::Index<3> IndexType;
     //typedef typename std::vector <Index<3> > RoiType;
 
     mitkClassMacro( TbssImage, Image )
     itkNewMacro(Self)
 
 
     enum MetaDataFunction
     {
       MEAN_FA_SKELETON,
       MEAN_FA_SKELETON_MASK,
+      GRADIENT_X,
+      GRADIENT_Y,
+      GRADIENT_Z,
+      TUBULAR_STRUCTURE,
+      DISTANCE_MAP,
       MISC
     };
 
 
     //void SetRequestedRegionToLargestPossibleReg tbssRoi->SetTbssType(mitk::TbssImage<char>::ROI);ion();
     //bool RequestedRegionIsOutsideOfTheBufferedRegion();
     //virtual bool VerifyRequestedRegion();
     //void SetRequestedRegion(itk::DataObject *data);
 
     ImageType::Pointer GetImage()
     {
       return m_Image;
     }
     void SetImage(ImageType::Pointer image )
     {
       this->m_Image = image;
     }
 
 
     void InitializeFromImage()
     {
       MITK_INFO << "make an mitk image that can be shown by mitk";
       this->InitializeByItk(m_Image.GetPointer(),1,1);
     }
 
     void SetGroupInfo( std::vector< std::pair<std::string, int> > info)
     {
       m_GroupInfo = info;
     }
 
     std::vector< std::pair<std::string, int> > GetGroupInfo()
     {
       return m_GroupInfo;
     }
 
     void SetMetaInfo( std::vector< std::pair<MetaDataFunction, int> > info)
     {
       m_MetaInfo = info;
     }
 
     std::vector< std::pair<MetaDataFunction, int> > GetMetaInfo()
     {
       return m_MetaInfo;
     }
 
     void SetMeasurementInfo(std::string s)
     {
       m_MeasurementInfo = s;
     }
 
     std::string GetMeasurementInfo()
     {
       return m_MeasurementInfo;
     }
 
     void InitializeFromVectorImage();
 
     void SetDisplayIndexForRendering(int displayIndex);
 
-    void SetIsMeta(bool b)
-    {
-      m_IsMeta = b;
-    }
 
-    bool GetIsMeta()
-    {
-      return m_IsMeta;
-    }
 
 
 
+    itkGetMacro(IsMeta, bool)
+    itkGetMacro(ContainsGradient, bool)
+    itkGetMacro(ContainsMeanSkeleton, bool)
+    itkGetMacro(ContainsSkeletonMask, bool)
+    itkGetMacro(ContainsDistanceMap, bool)
+    itkSetMacro(IsMeta, bool)
+    itkSetMacro(ContainsGradient, bool)
+    itkSetMacro(ContainsMeanSkeleton, bool)
+    itkSetMacro(ContainsSkeletonMask, bool)
+    itkSetMacro(ContainsDistanceMap, bool)
+
+
   protected:
 
     TbssImage();
 
     virtual ~TbssImage(){}
 
     ImageType::Pointer m_Image;
 
 
     std::vector< std::pair<std::string, int> > m_GroupInfo;
 
     std::vector< std::pair<MetaDataFunction, int> > m_MetaInfo;
 
     int m_DisplayIndex;
 
     std::string m_MeasurementInfo;
 
     bool m_IsMeta;
 
+    bool m_ContainsGradient;
+
+    bool m_ContainsMeanSkeleton;
+
+    bool m_ContainsSkeletonMask;
+
+    bool m_ContainsDistanceMap;
+
+
 
   };
 
 /*
   // Does the same es the normal CastToMitkImage, but needed to reimplemented due to the templatet pixeltype
   template <typename ItkOutputImageType>
   void CastToTbssImage(const ItkOutputImageType* itkimage, itk::SmartPointer< mitk::TbssImage >& tbssoutputimage)
   {
     if(tbssoutputimage.IsNull())
     {
       tbssoutputimage = mitk::TbssImage::New();
     }
     tbssoutputimage->InitializeByItk(itkimage);
     tbssoutputimage->SetChannel(itkimage->GetBufferPointer());
   }
 
 
 */
 
 
 
 } // namespace mitk
 //#include "mitkTbssImage.cpp"
 #endif /* __mitkTbssImage__h */
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.cpp
index 2aff58ce42..405d92b4c1 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.cpp
@@ -1,248 +1,355 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 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 __mitkTbssImporter_cpp
 #define __mitkTbssImporter_cpp
 
 #include "mitkTbssImporter.h"
 #include <QDir>
 #include <QStringList>
-
+#include "itkNrrdImageIO.h"
 
 
 namespace mitk
 {
 
   mitk::TbssImporter::TbssImporter()
   {
 
   }
 
 
   mitk::TbssImporter::TbssImporter(std::string path) : m_File(path)
   {
 
   }
 
 
 
   mitk::TbssImage::Pointer mitk::TbssImporter::Import()
   {
     // read all images with all_*.nii.gz
     mitk::TbssImage::Pointer tbssImg = mitk::TbssImage::New();
 
     FileReaderType4D::Pointer reader = FileReaderType4D::New();
     reader->SetFileName(m_File);
     reader->Update();
 
     FloatImage4DType::Pointer img = FloatImage4DType::New();
     img = reader->GetOutput();
 
 
 
     m_Data = DataImageType::New();
 
     FloatImage4DType::SizeType size = img->GetLargestPossibleRegion().GetSize();
     FloatImage4DType::SpacingType spacing = img->GetSpacing();
 
 
     DataImageType::SizeType dataSize;
     dataSize[0] = size[0];
     dataSize[1] = size[1];
     dataSize[2] = size[2];
 
     m_Data->SetRegions(dataSize);
 
 
     DataImageType::SpacingType dataSpacing;
     dataSpacing[0] = spacing[0];
     dataSpacing[1] = spacing[1];
     dataSpacing[2] = spacing[2];
 
     m_Data->SetSpacing(dataSpacing);
 
     FloatImage4DType::PointType origin = img->GetOrigin();
 
     DataImageType::PointType dataOrigin;
     dataOrigin[0] = origin[0];
     dataOrigin[1] = origin[1];
     dataOrigin[2] = origin[2];
 
     m_Data->SetOrigin(dataOrigin);
 
 
     FloatImage4DType::DirectionType dir = img->GetDirection();
 
     DataImageType::DirectionType dataDir;
     for(int i=0; i<=2; i++)
     {
       for(int j=0; j<=2; j++)
       {
         dataDir[i][j] = dir[i][j];
       }
     }
 
     m_Data->SetDirection(dataDir);
 
 
 
     // Set the length to one because otherwise allocate fails. Should be changed when groups/measurements are added
     m_Data->SetVectorLength(size[3]);
     m_Data->Allocate();
 
 
     for(int i=0; i<size[0]; i++)
     {
       for(int j=0; j<size[1]; j++)
       {
         for(int k=0; k<size[2]; k++)
         {
           itk::Index<3> ix;
           ix[0] = i;
           ix[1] = j;
           ix[2] = k;
           itk::VariableLengthVector<float> pixel = m_Data->GetPixel(ix);
           int vecSize = pixel.Size();
 
           for(int z=0; z<size[3]; z++)
           {
             itk::Index<4> ix4;
             ix4[0] = i;
             ix4[1] = j;
             ix4[2] = k;
             ix4[3] = z;
             float value = img->GetPixel(ix4);
 
 
             pixel.SetElement(z, value);
           }
           m_Data->SetPixel(ix, pixel);
         }
       }
     }
 
 
 //    mitk::CastToTbssImage(m_Data.GetPointer(), tbssImg);
 
   tbssImg->SetGroupInfo(m_Groups);
   tbssImg->SetMeasurementInfo(m_MeasurementInfo);
   tbssImg->SetImage(m_Data);
 
 
   tbssImg->InitializeFromVectorImage();
 
   return tbssImg;
 
 
 
   }
 
   mitk::TbssImage::Pointer mitk::TbssImporter::ImportMeta()
   {
     mitk::TbssImage::Pointer tbssImg = mitk::TbssImage::New();
 
 
     m_Data = DataImageType::New();
 
     std::vector< std::pair<mitk::TbssImage::MetaDataFunction, int> > metaInfo;
 
-    for(int i=0; i<m_MetaFiles.size(); i++)
+    // Gradient images are vector images, so they will add more dimensions to the vector
+    int vecLength = m_MetaFiles.size();
+    //Check if there is a gradient image
+
+    for(int i=0; i < m_MetaFiles.size(); i++)
+    {
+      std::pair<std::string, std::string> p = m_MetaFiles.at(i);
+      if(RetrieveTbssFunction(p.first) == mitk::TbssImage::GRADIENT_X)
+      {
+        vecLength += 2;
+      }
+    }
+
+
+    int currIndex = 0;
+
+
+    for(int i=0; i < m_MetaFiles.size(); i++)
     {
       std::pair<std::string, std::string> p = m_MetaFiles.at(i);
       std::string function = p.first;
       std::string file = p.second;
 
       // Add to metainfo to give the tbss image a function-index pair
       std::pair<mitk::TbssImage::MetaDataFunction, int> pair;
 
 
       pair.first = RetrieveTbssFunction(function);
       pair.second = i;
 
+      if(pair.first == mitk::TbssImage::GRADIENT_X)
+      {
+        metaInfo.push_back(std::pair<mitk::TbssImage::MetaDataFunction, int>(mitk::TbssImage::GRADIENT_X, i));
+        metaInfo.push_back(std::pair<mitk::TbssImage::MetaDataFunction, int>(mitk::TbssImage::GRADIENT_Y, i+1));
+        metaInfo.push_back(std::pair<mitk::TbssImage::MetaDataFunction, int>(mitk::TbssImage::GRADIENT_Z, i+2));
+
 
-      metaInfo.push_back(pair);
+        VectorReaderType::Pointer fileReader = VectorReaderType::New();
+        fileReader->SetFileName(file);
+        itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+        fileReader->SetImageIO(io);
+        fileReader->Update();
 
-      FileReaderType3D::Pointer fileReader = FileReaderType3D::New();
-      fileReader->SetFileName(file);
-      fileReader->Update();
+        VectorImageType::Pointer img = fileReader->GetOutput();
 
-      FloatImage3DType::Pointer img = fileReader->GetOutput();
+        VectorImageType::SizeType size = img->GetLargestPossibleRegion().GetSize();
 
-      FloatImage3DType::SizeType size = img->GetLargestPossibleRegion().GetSize();
+        if(i==0)
+        {
+          // First image in serie. Properties should be used to initialize m_Data
+          m_Data->SetRegions(img->GetLargestPossibleRegion().GetSize());
+          m_Data->SetSpacing(img->GetSpacing());
+          m_Data->SetOrigin(img->GetOrigin());
+          m_Data->SetDirection(img->GetDirection());
+          m_Data->SetVectorLength(vecLength);
+          m_Data->Allocate();
+        }
 
-      if(i==0)
-      {
-        // First image in serie. Properties should be used to initialize m_Data
-        m_Data->SetRegions(img->GetLargestPossibleRegion().GetSize());
-        m_Data->SetSpacing(img->GetSpacing());
-        m_Data->SetOrigin(img->GetOrigin());
-        m_Data->SetDirection(img->GetDirection());
-        m_Data->SetVectorLength(m_MetaFiles.size());
-        m_Data->Allocate();
-      }
 
-      for(int x=0; x<size[0]; x++)
-      {
-        for(int y=0; y<size[1]; y++)
+        /* Dealing with a gradient image, so the size of the vector need to be increased by 2
+            since this image contains 3 volumes. Old data should not be deleted*/
+
+
+
+        for(int x=0; x<size[0]; x++)
         {
-          for(int z=0; z<size[2]; z++)
+          for(int y=0; y<size[1]; y++)
           {
-            itk::Index<3> ix;
-            ix[0] = x;
-            ix[1] = y;
-            ix[2] = z;
+            for(int z=0; z<size[2]; z++)
+            {
+              itk::Index<3> ix;
+              ix[0] = x;
+              ix[1] = y;
+              ix[2] = z;
+
+              itk::VariableLengthVector<int> vec = img->GetPixel(ix);
+              itk::VariableLengthVector<float> pixel = m_Data->GetPixel(ix);
+              for(int j=0; j<vec.Size(); j++)
+              {
+                int pos = currIndex+j;
+                float f = vec.GetElement(j);
+                pixel.SetElement(pos, f);
+
+              }
+              m_Data->SetPixel(ix, pixel);
+            }
+          }
+        }
 
-            float f = img->GetPixel(ix);
-            itk::VariableLengthVector<float> pixel = m_Data->GetPixel(ix);
-            pixel.SetElement(i, f);
-            m_Data->SetPixel(ix, pixel);
+        currIndex += img->GetVectorLength();
+        tbssImg->SetContainsGradient(true);
+        // Read vector image and add to m_Data
+      }
 
+      else {
+
+        metaInfo.push_back(pair);
+        FileReaderType3D::Pointer fileReader = FileReaderType3D::New();
+        fileReader->SetFileName(file);
+        fileReader->Update();
+
+        FloatImage3DType::Pointer img = fileReader->GetOutput();
+
+        FloatImage3DType::SizeType size = img->GetLargestPossibleRegion().GetSize();
+
+        if(i==0)
+        {
+          // First image in serie. Properties should be used to initialize m_Data
+          m_Data->SetRegions(img->GetLargestPossibleRegion().GetSize());
+          m_Data->SetSpacing(img->GetSpacing());
+          m_Data->SetOrigin(img->GetOrigin());
+          m_Data->SetDirection(img->GetDirection());
+          m_Data->SetVectorLength(vecLength);         
+          m_Data->Allocate();
+        }
+
+        for(int x=0; x<size[0]; x++)
+        {
+          for(int y=0; y<size[1]; y++)
+          {
+            for(int z=0; z<size[2]; z++)
+            {
+              itk::Index<3> ix;
+              ix[0] = x;
+              ix[1] = y;
+              ix[2] = z;
+
+              float f = img->GetPixel(ix);
+              itk::VariableLengthVector<float> pixel = m_Data->GetPixel(ix);
+              pixel.SetElement(currIndex, f);
+              m_Data->SetPixel(ix, pixel);
+
+            }
           }
         }
       }
 
+      if(pair.first == mitk::TbssImage::MEAN_FA_SKELETON)
+      {
+        tbssImg->SetContainsMeanSkeleton(true);
+      }
+      else if(pair.first == mitk::TbssImage::MEAN_FA_SKELETON_MASK)
+      {
+        tbssImg->SetContainsSkeletonMask(true);
+      }
+      else if(pair.first == mitk::TbssImage::DISTANCE_MAP)
+      {
+        tbssImg->SetContainsDistanceMap(true);
+      }
+
+      currIndex++;
 
     }
 
     tbssImg->SetIsMeta(true);
     tbssImg->SetImage(m_Data);
     tbssImg->SetMetaInfo(metaInfo);
     tbssImg->InitializeFromVectorImage();
 
     return tbssImg;
   }
 
 
   mitk::TbssImage::MetaDataFunction mitk::TbssImporter::RetrieveTbssFunction(std::string s)
   {
     if(s == "skeleton mask")
     {
       return mitk::TbssImage::MEAN_FA_SKELETON_MASK;
     }
     else if(s == "mean fa skeleton")
     {
       return mitk::TbssImage::MEAN_FA_SKELETON;
     }
-
+    else if(s == "gradient image")
+    {
+      return mitk::TbssImage::GRADIENT_X;
+    }
+    else if(s == "tubular structure")
+    {
+      return mitk::TbssImage::TUBULAR_STRUCTURE;
+    }
+    else if(s == "distance map")
+    {
+      return mitk::TbssImage::DISTANCE_MAP;
+    }
     return mitk::TbssImage::MISC;
   }
 
 }
 
 
 
 #endif // __mitkTbssImporter_cpp
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.h
index 7a84f42829..e72fd5d49f 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.h
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.h
@@ -1,113 +1,115 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 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 __mitkTbssImporter_h
 #define __mitkTbssImporter_h
 
 #include "mitkCommon.h"
 #include "mitkFileReader.h"
 
 #include "itkImage.h"
 #include "itkVectorImage.h"
 #include "itkImageFileReader.h"
 #include "mitkTbssImage.h"
 
 
 namespace mitk
 {
   //template<class TPixelType>
   class TbssImporter : public itk::Object {
 
   public:
    // typedef TPixelType PixelType;
     typedef itk::VectorImage<float,3> DataImageType; // type of the 3d vector image containing the skeletonized images
+    typedef itk::VectorImage<int,3> VectorImageType; // Datatype of the tbss gradient images
     typedef itk::Image<float, 4> FloatImage4DType;
     typedef itk::ImageFileReader<FloatImage4DType> FileReaderType4D;
+    typedef itk::ImageFileReader<VectorImageType> VectorReaderType;
 
     typedef itk::Image<float, 3> FloatImage3DType;
     typedef itk::ImageFileReader<FloatImage3DType> FileReaderType3D;
 
     TbssImporter();
 
     mitkClassMacro( TbssImporter, Object )
     itkNewMacro(Self)
 
 
 
     TbssImporter(std::string path);
 
     void SetInputFile(std::string f)
     {
       m_File = f;
     }
 
     mitk::TbssImage::Pointer Import();
 
     mitk::TbssImage::Pointer ImportMeta();
 
 
     void SetGroupInfo(std::vector< std::pair<std::string, int> > groups)
     {
       m_Groups = groups;
     }
 
     std::vector< std::pair<std::string, int> > GetGroupInfo()
     {
       return m_Groups;
     }
 
     void SetTbssDatasets(std::vector< std::pair<std::string, std::string> > files)
     {
       m_MetaFiles = files;
     }
 
     void SetMeasurementInfo(std::string s)
     {
       m_MeasurementInfo = s;
     }
 
     std::string GetMeasurementInfo()
     {
       return m_MeasurementInfo;
     }
 
 
   protected:
 
 
 
     virtual ~TbssImporter(){}
 
     std::string m_File;
 
     DataImageType::Pointer m_Data;
     std::vector< std::pair<std::string, int> > m_Groups;
     std::vector< std::pair<std::string, std::string> > m_MetaFiles;
 
     std::string m_MeasurementInfo;
 
 
 
     mitk::TbssImage::MetaDataFunction RetrieveTbssFunction(std::string s);
 
 
   };
 
 }
 
 #include "mitkTbssImporter.cpp"
 #endif // __mitkTbssImporter_h
diff --git a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
index 4e20e28697..1cb9568fdf 100644
--- a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
@@ -1,370 +1,401 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-06-18 15:59:04 +0200 (Do, 18 Jun 2009) $
 Version:   $Revision: 16916 $
 
 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 "mitkDiffusionImagingObjectFactory.h"
 
 #include "mitkProperties.h"
 #include "mitkBaseRenderer.h"
 #include "mitkDataNode.h"
 
 #include "mitkNrrdDiffusionImageIOFactory.h"
 #include "mitkNrrdDiffusionImageWriterFactory.h"
 #include "mitkNrrdDiffusionImageWriter.h"
 #include "mitkDiffusionImage.h"
 
 #include "mitkNrrdQBallImageIOFactory.h"
 #include "mitkNrrdQBallImageWriterFactory.h"
 #include "mitkNrrdQBallImageWriter.h"
 
 #include "mitkNrrdTensorImageIOFactory.h"
 #include "mitkNrrdTensorImageWriterFactory.h"
 #include "mitkNrrdTensorImageWriter.h"
 
 #include "mitkCompositeMapper.h"
 #include "mitkDiffusionImageMapper.h"
 #include "mitkGPUVolumeMapper3D.h"
 #include "mitkVolumeDataVtkMapper3D.h"
 #include "mitkTbssImageMapper.h"
+#include "mitkTbssGradientImageMapper.h"
 
 //====depricated fiberstructure=====
 #include "mitkFiberBundle.h"
 #include "mitkFiberBundleMapper2D.h"
 #include "mitkFiberBundleMapper3D.h"
 #include "mitkFiberBundleIOFactory.h"
 #include "mitkFiberBundleWriterFactory.h"
 #include "mitkFiberBundleWriter.h"
 //==================================
 
 //modernized fiberbundle datastrucutre
 #include "mitkFiberBundleX.h"
 #include "mitkFiberBundleXIOFactory.h"
 #include "mitkFiberBundleXWriterFactory.h"
 #include "mitkFiberBundleXWriter.h"
 #include "mitkFiberBundleXMapper3D.h"
 
 #include "mitkFiberBundleXThreadMonitorMapper3D.h"
 #include "mitkFiberBundleXThreadMonitor.h"
 
 #include "mitkNrrdTbssImageIOFactory.h"
 #include "mitkNrrdTbssImageWriterFactory.h"
 #include "mitkNrrdTbssImageWriter.h"
 
 #include "mitkNrrdTbssRoiImageIOFactory.h"
 #include "mitkNrrdTbssRoiImageWriterFactory.h"
 #include "mitkNrrdTbssRoiImageWriter.h"
 
+#include "mitkNrrdTbssGradientImageWriterFactory.h"
+#include "mitkNrrdTbssGradientImageWriter.h"
+
 
 typedef short DiffusionPixelType;
 typedef char TbssRoiPixelType;
 typedef float TbssPixelType;
+typedef int TbssGradientPixelType;
 
 
 typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageShort;
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::DiffusionImagingObjectFactory::DiffusionImagingObjectFactory(bool /*registerSelf*/)
 :CoreObjectFactoryBase()
 {
 
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "DiffusionImagingObjectFactory c'tor" << std::endl;
     RegisterIOFactories();
 
 
     mitk::NrrdDiffusionImageIOFactory::RegisterOneFactory();
     mitk::NrrdQBallImageIOFactory::RegisterOneFactory();
     mitk::NrrdTensorImageIOFactory::RegisterOneFactory();
     mitk::FiberBundleIOFactory::RegisterOneFactory();
     mitk::NrrdTbssImageIOFactory::RegisterOneFactory();
     mitk::NrrdTbssRoiImageIOFactory::RegisterOneFactory();
     mitk::FiberBundleXIOFactory::RegisterOneFactory(); //modernized
 
 
     mitk::NrrdDiffusionImageWriterFactory::RegisterOneFactory();
     mitk::NrrdQBallImageWriterFactory::RegisterOneFactory();
     mitk::NrrdTensorImageWriterFactory::RegisterOneFactory();
     mitk::FiberBundleWriterFactory::RegisterOneFactory();
     mitk::NrrdTbssImageWriterFactory::RegisterOneFactory();
     mitk::NrrdTbssRoiImageWriterFactory::RegisterOneFactory();
     mitk::FiberBundleXWriterFactory::RegisterOneFactory();//modernized
+    mitk::NrrdTbssGradientImageWriterFactory::RegisterOneFactory();
 
     m_FileWriters.push_back( NrrdDiffusionImageWriter<DiffusionPixelType>::New().GetPointer() );
     m_FileWriters.push_back( NrrdQBallImageWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTensorImageWriter::New().GetPointer() );
     m_FileWriters.push_back( mitk::FiberBundleWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTbssImageWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTbssRoiImageWriter::New().GetPointer() );
     m_FileWriters.push_back( mitk::FiberBundleXWriter::New().GetPointer() );//modernized
+    m_FileWriters.push_back( mitk::NrrdTbssGradientImageWriter::New().GetPointer() );
 
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(this);
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 mitk::Mapper::Pointer mitk::DiffusionImagingObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard2D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
 
     classname = "DiffusionImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::DiffusionImageMapper<short>::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssRoiImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::ImageVtkMapper2D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "FiberBundle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
 //      newMapper = mitk::FiberBundleMapper2D::New();
 //      newMapper->SetDataNode(node);
     }
     
     classname = "FiberBundleX";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleMapper2D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
+    classname = "TbssGradientImage";
+    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
+    {
+      newMapper = mitk::TbssGradientImageMapper::New();
+      newMapper->SetDataNode(node);
+    }
+
   }
   else if ( id == mitk::BaseRenderer::Standard3D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "DiffusionImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "FiberBundle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "FiberBundleX";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleXMapper3D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "FiberBundleXThreadMonitor";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleXThreadMonitorMapper3D::New();
       newMapper->SetDataNode(node); 
     }
 
     classname = "TbssRoiImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::VolumeDataVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {  
       newMapper = mitk::TbssImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
+    classname = "TbssGradientImage";
+    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
+    {
+      newMapper = mitk::TbssGradientImageMapper::New();
+      newMapper->SetDataNode(node);
+    }
+
   }
 
   return newMapper;
 }
 
 void mitk::DiffusionImagingObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   std::string classname = "QBallImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TensorImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "DiffusionImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundle";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleMapper3D::SetDefaultProperties(node);
     mitk::FiberBundleMapper2D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundleX";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXMapper3D::SetDefaultProperties(node);
 //    mitk::FiberBundleXMapper2D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundleXThreadMonitor";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXThreadMonitorMapper3D::SetDefaultProperties(node);
   }
   
   classname = "TbssRoiImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
     mitk::VolumeDataVtkMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TbssImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::TbssImageMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
+
+  classname = "TbssGradientImage";
+  if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
+  {
+    mitk::TbssGradientImageMapper::SetDefaultProperties(node);
+    mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
+  }
+
 }
 
 const char* mitk::DiffusionImagingObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionImagingObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::DiffusionImagingObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionImagingObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::DiffusionImagingObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fsl", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fslgz", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fib", "Fiber Bundle"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vfib", "Fiber Bundle Polydata"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Fiber Bundle Polydata"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tbss", "TBSS data"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure File"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
+  m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tgi", "TBSS gradient image"));
 
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fsl", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fslgz", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fib", "Fiber Bundle"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vfib", "Fiber Bundle Polydata"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Fiber Bundle Polydata"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tbss", "TBSS data"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure File"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
+  m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tgi", "TBSS gradient image"));
 }
 
 void mitk::DiffusionImagingObjectFactory::RegisterIOFactories()
 {
 }
 
 void RegisterDiffusionImagingObjectFactory()
 {
   static bool oneDiffusionImagingObjectFactoryRegistered = false;
   if ( ! oneDiffusionImagingObjectFactoryRegistered ) {
     MITK_DEBUG << "Registering DiffusionImagingObjectFactory..." << std::endl;
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::DiffusionImagingObjectFactory::New());
 
     oneDiffusionImagingObjectFactoryRegistered = true;
   }
 }
diff --git a/Modules/DiffusionImaging/Rendering/mitkTbssGradientImageMapper.cpp b/Modules/DiffusionImaging/Rendering/mitkTbssGradientImageMapper.cpp
new file mode 100644
index 0000000000..c758bbaf0c
--- /dev/null
+++ b/Modules/DiffusionImaging/Rendering/mitkTbssGradientImageMapper.cpp
@@ -0,0 +1,66 @@
+/*=========================================================================
+
+Program:   Medical Imaging & Interaction Toolkit
+Language:  C++
+Date:      $Date: 2009-05-12 19:56:03 +0200 (Di, 12 Mai 2009) $
+Version:   $Revision: 17179 $
+
+Copyright (c) German Cancer Research Center, Division of Medical and
+Biological Informatics. All rights reserved.
+See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+
+
+#ifndef TbssGradientImageMapper__cpp
+#define TbssGradientImageMapper__cpp
+
+#include "mitkTbssGradientImageMapper.h"
+
+#include "mitkProperties.h"
+#include "mitkTbssGradientImage.h"
+
+
+
+mitk::TbssGradientImageMapper::TbssGradientImageMapper()
+{
+}
+
+
+mitk::TbssGradientImageMapper::~TbssGradientImageMapper()
+{
+}
+
+
+void mitk::TbssGradientImageMapper::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
+{
+  int displayIndex(0);
+
+
+  this->GetDataNode()->GetIntProperty( "DisplayChannel", displayIndex, renderer );
+  mitk::Image *input = const_cast< mitk::Image* >(
+    this->GetInput()
+    );
+  mitk::TbssGradientImage *input2 = dynamic_cast< mitk::TbssGradientImage* >(
+    input
+    );
+
+  MITK_INFO << "displayindex: " << displayIndex;
+
+
+  input2->SetDisplayIndexForRendering(displayIndex);
+  Superclass::GenerateDataForRenderer(renderer);
+}
+
+
+void mitk::TbssGradientImageMapper::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
+{
+  node->AddProperty( "DisplayChannel", mitk::IntProperty::New( 0 ), renderer, overwrite );
+  Superclass::SetDefaultProperties(node, renderer, overwrite);
+}
+
+#endif
diff --git a/Modules/DiffusionImaging/Rendering/mitkTbssGradientImageMapper.h b/Modules/DiffusionImaging/Rendering/mitkTbssGradientImageMapper.h
new file mode 100644
index 0000000000..ded598b649
--- /dev/null
+++ b/Modules/DiffusionImaging/Rendering/mitkTbssGradientImageMapper.h
@@ -0,0 +1,53 @@
+/*=========================================================================
+
+Program:   Medical Imaging & Interaction Toolkit
+Language:  C++
+Date:      $Date: 2009-05-12 19:56:03 +0200 (Di, 12 Mai 2009) $
+Version:   $Revision: 17179 $
+
+Copyright (c) German Cancer Research Center, Division of Medical and
+Biological Informatics. All rights reserved.
+See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+
+
+#ifndef TbssGradientImageMapper_H_HEADER_INCLUDED
+#define TbssGradientImageMapper_H_HEADER_INCLUDED
+
+#include "mitkImageVtkMapper2D.h"
+#include "MitkDiffusionImagingExports.h"
+
+namespace mitk {
+
+  //##Documentation
+  //## @brief Mapper for Gradient images
+  //## @ingroup Mapper
+
+  class MitkDiffusionImaging_EXPORT TbssGradientImageMapper : public ImageVtkMapper2D
+  {
+  public:
+
+    mitkClassMacro(TbssGradientImageMapper,ImageVtkMapper2D);
+    itkNewMacro(Self);
+
+    void GenerateDataForRenderer( mitk::BaseRenderer *renderer );
+
+    static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
+    
+  protected:
+
+    TbssGradientImageMapper();
+    virtual ~TbssGradientImageMapper();
+
+  };
+
+} // namespace mitk
+
+
+#endif /* TbssGradientImageMapper_H_HEADER_INCLUDED */
+
diff --git a/Modules/DiffusionImaging/files.cmake b/Modules/DiffusionImaging/files.cmake
index 3948551288..e21a1ac38e 100644
--- a/Modules/DiffusionImaging/files.cmake
+++ b/Modules/DiffusionImaging/files.cmake
@@ -1,173 +1,176 @@
 SET(CPP_FILES
 
   # DicomImport
   DicomImport/mitkDicomDiffusionImageReader.cpp
   DicomImport/mitkGroupDiffusionHeadersFilter.cpp
   DicomImport/mitkDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkGEDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkPhilipsDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensMosaicDicomDiffusionImageHeaderReader.cpp
 
   # DataStructures
   IODataStructures/mitkDiffusionImagingObjectFactory.cpp
 
   # DataStructures -> DWI
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageHeaderInformation.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageReader.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageWriter.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageIOFactory.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageWriterFactory.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSerializer.cpp
 
   # DataStructures -> QBall
   IODataStructures/QBallImages/mitkQBallImageSource.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageReader.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageWriter.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageIOFactory.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageWriterFactory.cpp
   IODataStructures/QBallImages/mitkQBallImage.cpp
   IODataStructures/QBallImages/mitkQBallImageSerializer.cpp
 
   # DataStructures -> Tensor
   IODataStructures/TensorImages/mitkTensorImageSource.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageWriter.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageIOFactory.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageWriterFactory.cpp
   IODataStructures/TensorImages/mitkTensorImage.cpp
   IODataStructures/TensorImages/mitkTensorImageSerializer.cpp
 
   # DataStructures -> FiberBundle
   IODataStructures/FiberBundle/mitkFiberBundle.cpp
   IODataStructures/FiberBundle/mitkFiberBundleWriter.cpp
   IODataStructures/FiberBundle/mitkFiberBundleReader.cpp
   IODataStructures/FiberBundle/mitkFiberBundleIOFactory.cpp
   IODataStructures/FiberBundle/mitkFiberBundleWriterFactory.cpp
   IODataStructures/FiberBundle/mitkFiberBundleSerializer.cpp
   IODataStructures/FiberBundle/mitkParticle.cpp
   IODataStructures/FiberBundle/mitkParticleGrid.cpp
 
 # DataStructures -> FiberBundleX
   IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXWriter.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXReader.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXIOFactory.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXWriterFactory.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXSerializer.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
 
 
   # DataStructures -> PlanarFigureComposite
   IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp
 
 
   # DataStructures -> Tbss
   IODataStructures/TbssImages/mitkTbssImageSource.cpp
   IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageIOFactory.cpp
   IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
   IODataStructures/TbssImages/mitkNrrdTbssRoiImageIOFactory.cpp
   IODataStructures/TbssImages/mitkTbssImage.cpp
   IODataStructures/TbssImages/mitkTbssRoiImage.cpp
+  IODataStructures/TbssImages/mitkTbssGradientImage.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageWriterFactory.cpp
+  IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriter.cpp
+  IODataStructures/TbssImages/mitkNrrdTbssGradientImageWriterFactory.cpp
   IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.cpp
   IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriterFactory.cpp
   IODataStructures/TbssImages/mitkTbssImporter.cpp
 
 
   # Rendering
   Rendering/vtkMaskedProgrammableGlyphFilter.cpp
   Rendering/mitkCompositeMapper.cpp
   Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
   Rendering/vtkOdfSource.cxx
   Rendering/vtkThickPlane.cxx
   Rendering/mitkOdfNormalizationMethodProperty.cpp
   Rendering/mitkOdfScaleByProperty.cpp
   Rendering/mitkFiberBundleMapper2D.cpp
   Rendering/mitkFiberBundleMapper3D.cpp
   Rendering/mitkFiberBundleXMapper3D.cpp
   Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
   Rendering/mitkTbssImageMapper.cpp
+  Rendering/mitkTbssGradientImageMapper.cpp
   
 # Interactions
   Interactions/mitkFiberBundleInteractor.cpp
 
   # Algorithms
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
 
  # Tractography
  Tractography/itkStochasticTractographyFilter.h
 )
 
 SET(H_FILES
   # Rendering
   Rendering/mitkDiffusionImageMapper.h
   Rendering/mitkTbssImageMapper.h
+  Rendering/mitkTbssGradientImageMapper.h
   Rendering/mitkOdfVtkMapper2D.h
   Rendering/mitkFiberBundleMapper2D.h
   Rendering/mitkFiberBundleMapper3D.h
   Rendering/mitkFiberBundleXMapper3D.h
   Rendering/mitkFiberBundleXThreadMonitorMapper3D.h
 
   # Reconstruction
   Reconstruction/itkDiffusionQballReconstructionImageFilter.h
   Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
   Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
   Reconstruction/itkPointShell.h
   Reconstruction/itkOrientationDistributionFunction.h
   Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h
   Reconstruction/itkRegularizedIVIMLocalVariationImageFilter.h
   Reconstruction/itkRegularizedIVIMReconstructionFilter.h
   Reconstruction/itkRegularizedIVIMReconstructionSingleIteration.h
 
   # IO Datastructures
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
-  IODataStructures/FiberBundle/itkSlowPolyLineParametricPath.h
-  #IODataStructures/TbssImages/mitkTbssImage.h
- # IODataStructures/TbssImages/mitkTbssRoiImage.h
+  IODataStructures/FiberBundle/itkSlowPolyLineParametricPath.h  
 
   # DataStructures -> FiberBundleX
   IODataStructures/FiberBundleX/mitkFiberBundleX.h
   IODataStructures/FiberBundleX/mitkFiberBundleXWriter.h
   IODataStructures/FiberBundleX/mitkFiberBundleXReader.h
   IODataStructures/FiberBundleX/mitkFiberBundleXIOFactory.h
   IODataStructures/FiberBundleX/mitkFiberBundleXWriterFactory.h
   IODataStructures/FiberBundleX/mitkFiberBundleXSerializer.h
   IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
 
 
 
   # Tractography
   Tractography/itkGibbsTrackingFilter.h
   Tractography/itkStochasticTractographyFilter.h
 
   # Algorithms
   Algorithms/itkDiffusionQballGeneralizedFaImageFilter.h
   Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.h
   Algorithms/itkTensorDerivedMeasurementsFilter.h
   Algorithms/itkBrainMaskExtractionImageFilter.h
   Algorithms/itkB0ImageExtractionImageFilter.h
   Algorithms/itkTensorImageToDiffusionImageFilter.h
   Algorithms/itkTensorToL2NormImageFilter.h
   Algorithms/itkTractsToProbabilityImageFilter.h
   Algorithms/itkTractsToFiberEndingsImageFilter.h
   Algorithms/itkGaussianInterpolateImageFunction.h
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.h
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
   Algorithms/itkDiffusionTensorPrincipleDirectionImageFilter.h
   Algorithms/itkCartesianToPolarVectorImageFilter.h
   Algorithms/itkPolarToCartesianVectorImageFilter.h
 )
 
 SET( TOOL_FILES
 )
 
 IF(WIN32)
 ENDIF(WIN32)
 
 #MITK_MULTIPLEX_PICTYPE( Algorithms/mitkImageRegistrationMethod-TYPE.cpp )