diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.h
index 29d7d33ac4..0537068569 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.h
@@ -1,101 +1,93 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef ITKDISTANCEMAPFILTER_H_
 #define ITKDISTANCEMAPFILTER_H_
 
 #include "itkImageToImageFilter.h"
 #include "itkImage.h"
 #include "mitkImage.h"
 
 
 namespace itk
 {
 template < class TInputImage, class TOutputImage >
 class DistanceMapFilter : public ImageToImageFilter<TInputImage, TOutputImage>
 {
-  /*!
-  \brief itkDistanceMapFilter
-
-  \brief Creates a distance map from a FA skeleton image.
-
-  \sa itkImageToImageFilter
-
-
-  \verbatim
-  Last contributor: $Author: vanbrugg $
-  \endverbatim
-  */
+    /**
+      * \brief This filter creates a map of the distance to the nearest point on a binary mask.
+      *
+      */
 
 public:
 
   /** Typedef for input ImageType. */
   typedef TInputImage  InputImageType;
 
   /** Typedef for input imageType Pointer. */
   typedef typename InputImageType::Pointer InputImagePointer;
 
   /** Typedef for output ImageType. */
   typedef TOutputImage OutputImageType;
 
   /** Typedef for input imageType Pointer. */
   typedef typename OutputImageType::Pointer OutputImagePointer;
 
 public:
 
   /** */
   typedef DistanceMapFilter Self;
 
   /** Superclass */
   typedef ImageToImageFilter<InputImageType, OutputImageType> Superclass;
 
   /** Smart Pointer */
   typedef SmartPointer<Self> Pointer;
 
   /** Smart Pointer */
   typedef SmartPointer<const Self> ConstPointer;
 
   /** */
   itkNewMacro( Self)
 
   /** Generate Data. The image will be divided into a number of pieces, a number of threads
   will be spawned and Threaded GenerateData() will be called in each thread. */
   virtual void GenerateData();
 
 
 protected:
 
   /** Constructor */
   DistanceMapFilter();
 
   /** Destructor */
   virtual ~DistanceMapFilter();
 
 
 
 protected:
 
 
 
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkDistanceMapFilter.txx"
 #endif
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.txx
index 446a3be133..f80ce05286 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDistanceMapFilter.txx
@@ -1,85 +1,79 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef _itkDistanceMapFilter_txx
 #define _itkDistanceMapFilter_txx
 
 #include "itkDistanceMapFilter.h"
 
-#include "mitkProgressBar.h"
 #include <itkSignedMaurerDistanceMapImageFilter.h>
 
 
 namespace itk
 {
 
   template< class TInputImage, class TOutputImage >
   DistanceMapFilter<TInputImage, TOutputImage>::DistanceMapFilter()
   {
 
   }
 
   template< class TInputImage, class TOutputImage >
   DistanceMapFilter<TInputImage, TOutputImage>::~DistanceMapFilter()
   {
 
 
   }
 
 
 
 
   template< class TInputImage, class TOutputImage >
   void DistanceMapFilter<TInputImage, TOutputImage>::GenerateData()
   {
-    //----------------------------------------------------------------------//
-    //  Progress bar                                                        //
-    //----------------------------------------------------------------------//
-    //mitk::ProgressBar::GetInstance()->AddStepsToDo( 3 );
-
 
 
     typedef itk::SignedMaurerDistanceMapImageFilter<InputImageType, OutputImageType> DistanceFilterType;
     typename DistanceFilterType::Pointer dFilter = DistanceFilterType::New();
     dFilter->SetInput(this->GetInput());
     dFilter->SetUseImageSpacing(true);
     dFilter->SetSquaredDistance(false);
     dFilter->SetInsideIsPositive(true);
     dFilter->Update();
 
     typename OutputImageType::Pointer outputImg = dFilter->GetOutput();
 
     typedef itk::ImageRegionIterator<OutputImageType> ImageIteratorType;
 
     ImageIteratorType outIt(outputImg, outputImg->GetRequestedRegion());
     outIt.GoToBegin();
     while(!outIt.IsAtEnd())
     {
       typename OutputImageType::PixelType p = outIt.Get();
       p *= -1;
       outIt.Set(p);
       ++outIt;
     }
 
     Superclass::SetNthOutput( 0, outputImg );
 
   }
 
 
 
 
 
 }
 #endif // _itkDistanceMapFilter_txx
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssMetaTableModel.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssMetaTableModel.h
index b13712592e..739891fd75 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssMetaTableModel.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssMetaTableModel.h
@@ -1,54 +1,54 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 
 #ifndef QmitkTbssMetaTableModel_h
 #define QmitkTbssMetaTableModel_h
 
 
 #include <QAbstractTableModel>
 
 #include <QPair>
 #include <QList>
 #include <QObject>
 #include <QString>
 
 
 class QmitkTbssMetaTableModel : public QAbstractTableModel
 {
 
-  //Q_OBJECT
+  // TableModel to model pairs of group description and group number
 
 public:
   QmitkTbssMetaTableModel(QObject *parent=0);
   QmitkTbssMetaTableModel(QList< QPair<QString, QString> > listofPairs, QObject *parent=0);
 
   int rowCount(const QModelIndex &parent) const;
   int columnCount(const QModelIndex &parent) const;
   QVariant data(const QModelIndex &index, int role) const;
   QVariant headerData(int section, Qt::Orientation orientation, int role) const;
   Qt::ItemFlags flags(const QModelIndex &index) const;
   bool setData(const QModelIndex &index, const QVariant &value, int role=Qt::EditRole);
   bool insertRows(int position, int rows, const QModelIndex &index=QModelIndex());
   bool removeRows(int position, int rows, const QModelIndex &index=QModelIndex());
   QList< QPair<QString, QString> > getList();
 
 private:
   QList< QPair<QString, QString> > listOfPairs;
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
index 54f5ce349a..755023f702 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
@@ -1,434 +1,435 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkTbssSkeletonizationView.h"
 
+
 #include <itkSkeletonizationFilter.h>
 #include <itkProjectionFilter.h>
 #include <itkDistanceMapFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 
 #include <itkImageFileReader.h>
 
 // Qt
-#include <QInputDialog>Gaimersheim
+#include <QInputDialog>
 #include <QMessageBox>
 
 //vtk
 #include <vtkLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 // Boost
 #include <boost/lexical_cast.hpp>
 
 const std::string QmitkTbssSkeletonizationView::VIEW_ID = "org.mitk.views.tbssskeletonization";
 
 using namespace berry;
 
 
 QmitkTbssSkeletonizationView::QmitkTbssSkeletonizationView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 {
 
 }
 
 QmitkTbssSkeletonizationView::~QmitkTbssSkeletonizationView()
 {
 }
 
 void QmitkTbssSkeletonizationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
   //datamanager selection changed
   if (!this->IsActivated())
     return;
 
   bool found3dImage = false;
   bool found4dImage = false;
 
   // iterate selection
   for ( int i=0; i<nodes.size(); i++ )
   {
 
 
     // only look at interesting types from valid nodes
     mitk::BaseData* nodeData = nodes[i]->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
           found3dImage = true;
         }
         else if(img->GetDimension() == 4)
         {
           found4dImage = true;
         }
       }
     }
 
   }
 
   this->m_Controls->m_Skeletonize->setEnabled(found3dImage);
   this->m_Controls->m_Project->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputMask->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputDistanceMap->setEnabled(found3dImage && found4dImage);
 
 }
 
 
 
 void QmitkTbssSkeletonizationView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkTbssSkeletonizationViewControls;
     m_Controls->setupUi( parent );
     this->CreateConnections();
   }
 
 }
 
 void QmitkTbssSkeletonizationView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkTbssSkeletonizationView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkTbssSkeletonizationView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_Skeletonize), SIGNAL(clicked()), this, SLOT(Skeletonize() ));
     connect( (QObject*)(m_Controls->m_Project), SIGNAL(clicked()), this, SLOT(Project() ));
   }
 }
 
 
 
 void QmitkTbssSkeletonizationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkTbssSkeletonizationView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 
 void QmitkTbssSkeletonizationView::Skeletonize()
 {
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   std::string name = "";
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     // process only on valid nodes
     mitk::BaseData* nodeData = nodes[i]->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
           meanImage = img;
           name = nodes[i]->GetName();
         }
       }
     }
   }
 
 
   // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   name += "_skeleton";
   AddToDataStorage(mitkOutput, name);
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::Project()
 {
 
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   typedef itk::ProjectionFilter ProjectionFilterType;
   typedef itk::DistanceMapFilter<FloatImageType, FloatImageType> DistanceMapFilterType;
 
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   mitk::Image::Pointer subjects = mitk::Image::New();
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     // process only on valid nodes
     mitk::BaseData* nodeData = nodes[i]->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
           meanImage = img;
         }
         else if(img->GetDimension() == 4)
         {
           subjects = img;
         }
       }
     }
 
   }
 
   Float4DImageType::Pointer allFA = ConvertToItk(subjects);
 
 
 
 
   // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   AddToDataStorage(mitkOutput, "mean_FA_skeletonised");
 
 
 
   // Retrieve direction image needed later by the projection filter
   DirectionImageType::Pointer directionImg = skeletonizer->GetVectorImage();
 
 
   // Calculate distance image
   DistanceMapFilterType::Pointer distanceMapFilter = DistanceMapFilterType::New();
   distanceMapFilter->SetInput(output);
   distanceMapFilter->Update();
   FloatImageType::Pointer distanceMap = distanceMapFilter->GetOutput();
 
   if(m_Controls->m_OutputDistanceMap->isChecked())
   {
     mitk::Image::Pointer mitkDistance = mitk::Image::New();
     mitk::CastToMitkImage(distanceMap, mitkDistance);
     AddToDataStorage(mitkDistance, "distance map");
   }
 
   // Do projection
 
   // Ask a threshold to create a skeleton mask
   double threshold = -1.0;
   while(threshold == -1.0)
   {
     threshold = QInputDialog::getDouble(m_Controls->m_Skeletonize, tr("Specify the FA threshold"),
                                           tr("Threshold:"), QLineEdit::Normal,
                                           0.2);
 
     if(threshold < 0.0 || threshold > 1.0)
     {
       QMessageBox msgBox;
       msgBox.setText("Please choose a value between 0 and 1");
       msgBox.exec();
       threshold = -1.0;
     }
   }
 
   typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> ThresholdFilterType;
   ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New();
   thresholder->SetInput(output);
   thresholder->SetLowerThreshold(threshold);
   thresholder->SetUpperThreshold(std::numeric_limits<float>::max());
   thresholder->SetOutsideValue(0);
   thresholder->SetInsideValue(1);
   thresholder->Update();
 
 
   CharImageType::Pointer thresholdedImg = thresholder->GetOutput();
 
 
   if(m_Controls->m_OutputMask->isChecked())
   {
     mitk::Image::Pointer mitkThresholded = mitk::Image::New();
     mitk::CastToMitkImage(thresholdedImg, mitkThresholded);
     std::string maskName = "skeleton_mask_at_" + boost::lexical_cast<std::string>(threshold);
     AddToDataStorage(mitkThresholded, maskName);
   }
 
 
 
   typedef itk::ImageFileReader< CharImageType > CharReaderType;
   CharReaderType::Pointer reader = CharReaderType::New();
   reader->SetFileName("/local/testing/LowerCingulum_1mm.nii.gz");
   reader->Update();
   CharImageType::Pointer cingulum = reader->GetOutput();
 
 
 
   ProjectionFilterType::Pointer projectionFilter = ProjectionFilterType::New();
   projectionFilter->SetDistanceMap(distanceMap);
   projectionFilter->SetDirections(directionImg);
   projectionFilter->SetAllFA(allFA);
   projectionFilter->SetTube(cingulum);
   projectionFilter->SetSkeleton(thresholdedImg);
   projectionFilter->Project();
 
   Float4DImageType::Pointer projected = projectionFilter->GetProjections();
 
   mitk::Image::Pointer mitkProjections = mitk::Image::New();
   mitk::CastToMitkImage(projected, mitkProjections);
 
   AddToDataStorage(mitkProjections, "all_FA_projected");
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::AddToDataStorage(mitk::Image* img, std::string name)
 {
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "name", mitk::StringProperty::New(name) );
   result->SetData( img );
 
   // add new image to data storage and set as active to ease further processing
   GetDefaultDataStorage()->Add( result );
 }
 
 
 Float4DImageType::Pointer QmitkTbssSkeletonizationView::ConvertToItk(mitk::Image::Pointer image)
 {
   Float4DImageType::Pointer output = Float4DImageType::New();
 
   mitk::Geometry3D* geo = image->GetGeometry();
   mitk::Vector3D mitkSpacing = geo->GetSpacing();
   mitk::Point3D mitkOrigin = geo->GetOrigin();
 
   Float4DImageType::SpacingType spacing;
   spacing[0] = mitkSpacing[0];
   spacing[1] = mitkSpacing[1];
   spacing[2] = mitkSpacing[2];
   spacing[3] = 1.0; // todo: check if spacing has length 4
 
   Float4DImageType::PointType origin;
   origin[0] = mitkOrigin[0];
   origin[1] = mitkOrigin[1];
   origin[2] = mitkOrigin[2];
   origin[3] = 0;
 
   Float4DImageType::SizeType size;
   size[0] = image->GetDimension(0);
   size[1] = image->GetDimension(1);
   size[2] = image->GetDimension(2);
   size[3] = image->GetDimension(3);
 
   Float4DImageType::DirectionType dir;
   vtkLinearTransform* lin = geo->GetVtkTransform();
   vtkMatrix4x4 *m = lin->GetMatrix();
 
   dir.Fill(0.0);
   for(int x=0; x<3; x++)
   {
     for(int y=0; y<3; y++)
     {
       dir[x][y] = m->GetElement(x,y);
     }
   }
   dir[3][3] = 1;
 
 
 
   output->SetSpacing(spacing);
   output->SetOrigin(origin);
   output->SetRegions(size);
   output->SetDirection(dir);
   output->Allocate();
 
 
   if(image->GetDimension() == 4)
   {
     int timesteps = image->GetDimension(3);
 
     // iterate through the subjects and copy data to output
     for(int t=0; t<timesteps; t++)
     {
       for(int x=0; x<image->GetDimension(0); x++)
       {
         for(int y=0; y<image->GetDimension(1); y++)
         {
           for(int z=0; z<image->GetDimension(2); z++)
           {
             itk::Index<4> ix4;
             ix4[0] = x;
             ix4[1] = y;
             ix4[2] = z;
             ix4[3] = t;
 
             mitk::Index3D ix;
             ix[0] = x;
             ix[1] = y;
             ix[2] = z;
 
             output->SetPixel(ix4, image->GetPixelValueByIndex(ix, t));
 
           }
         }
       }
     }
 
   }
 
 
   return output;
 }