diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
index 8a914c05a1..d80421fc4d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
@@ -1,762 +1,751 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkGibbsTrackingView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QDir>
 
 // MITK
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkProgressBar.h>
 #include <mitkFiberBundleXWriter.h>
 
 // ITK
 #include <itkGibbsTrackingFilter.h>
 #include <itkResampleImageFilter.h>
 #include <itksys/SystemTools.hxx>
 
 // MISC
 #include <tinyxml.h>
 
 
 QmitkTrackingWorker::QmitkTrackingWorker(QmitkGibbsTrackingView* view)
     : m_View(view)
 {
 
 }
 
 void QmitkTrackingWorker::run()
 {
     m_View->m_GlobalTracker = QmitkGibbsTrackingView::GibbsTrackingFilterType::New();
 
     m_View->m_GlobalTracker->SetQBallImage(m_View->m_ItkQBallImage);
     m_View->m_GlobalTracker->SetTensorImage(m_View->m_ItkTensorImage);
     m_View->m_GlobalTracker->SetMaskImage(m_View->m_MaskImage);
     m_View->m_GlobalTracker->SetStartTemperature((float)m_View->m_Controls->m_StartTempSlider->value()/100);
     m_View->m_GlobalTracker->SetEndTemperature((float)m_View->m_Controls->m_EndTempSlider->value()/10000);
     m_View->m_GlobalTracker->SetIterations(m_View->m_Iterations);
     m_View->m_GlobalTracker->SetParticleWeight((float)m_View->m_Controls->m_ParticleWeightSlider->value()/10000);
     m_View->m_GlobalTracker->SetParticleWidth((float)(m_View->m_Controls->m_ParticleWidthSlider->value())/10);
     m_View->m_GlobalTracker->SetParticleLength((float)(m_View->m_Controls->m_ParticleLengthSlider->value())/10);
     m_View->m_GlobalTracker->SetInexBalance((float)m_View->m_Controls->m_InExBalanceSlider->value()/10);
     m_View->m_GlobalTracker->SetMinFiberLength(m_View->m_Controls->m_FiberLengthSlider->value());
     m_View->m_GlobalTracker->SetCurvatureThreshold(cos((float)m_View->m_Controls->m_CurvatureThresholdSlider->value()*M_PI/180));
     m_View->m_GlobalTracker->SetRandomSeed(m_View->m_Controls->m_RandomSeedSlider->value());
     try{
       m_View->m_GlobalTracker->Update();
     }
     catch( mitk::Exception e )
     {
       MITK_ERROR << "Internal error occured: " <<  e.what() << "\nAborting";
     }
     m_View->m_TrackingThread.quit();
 }
 
 const std::string QmitkGibbsTrackingView::VIEW_ID =
         "org.mitk.views.gibbstracking";
 
 QmitkGibbsTrackingView::QmitkGibbsTrackingView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_ThreadIsRunning(false)
     , m_GlobalTracker(NULL)
     , m_QBallImage(NULL)
     , m_MaskImage(NULL)
     , m_ImageNode(NULL)
     , m_ItkQBallImage(NULL)
     , m_ItkTensorImage(NULL)
     , m_FiberBundleNode(NULL)
     , m_MaskImageNode(NULL)
     , m_TrackingWorker(this)
     , m_Iterations(10000000)
     , m_LastStep(0)
 {
     m_TrackingWorker.moveToThread(&m_TrackingThread);
     connect(&m_TrackingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
     connect(&m_TrackingThread, SIGNAL(started()), &m_TrackingWorker, SLOT(run()));
     connect(&m_TrackingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
     connect(&m_TrackingThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
     m_TrackingTimer = new QTimer(this);
 }
 
 QmitkGibbsTrackingView::~QmitkGibbsTrackingView()
 {
     delete m_TrackingTimer;
 }
 
 // update tracking status and generate fiber bundle
 void QmitkGibbsTrackingView::TimerUpdate()
 {
   int currentStep = m_GlobalTracker->GetCurrentStep();
 
   mitk::ProgressBar::GetInstance()->Progress(currentStep-m_LastStep);
   UpdateTrackingStatus();
   GenerateFiberBundle();
   m_LastStep = currentStep;
 }
 
 // tell global tractography filter to stop after current step
 void QmitkGibbsTrackingView::StopGibbsTracking()
 {
     if (m_GlobalTracker.IsNull())
         return;
 
     //mitk::ProgressBar::GetInstance()->Progress(m_GlobalTracker->GetSteps()-m_LastStep+1);
     m_GlobalTracker->SetAbortTracking(true);
     m_Controls->m_TrackingStop->setEnabled(false);
     m_Controls->m_TrackingStop->setText("Stopping Tractography ...");
 }
 
 // update gui elements and generate fiber bundle after tracking is finished
 void QmitkGibbsTrackingView::AfterThread()
 {
     m_ThreadIsRunning = false;
     m_TrackingTimer->stop();
 
     mitk::ProgressBar::GetInstance()->Progress(m_GlobalTracker->GetSteps()-m_LastStep+1);
     UpdateGUI();
 
     if( !m_GlobalTracker->GetIsInValidState() )
     {
       QMessageBox::critical( NULL, "Gibbs Tracking", "An internal error occured. Tracking aborted.\n Please check the log for details." );
       m_FiberBundleNode = NULL;
       return;
     }
     UpdateTrackingStatus();
 
     if(m_Controls->m_ParticleWeightSlider->value()==0)
     {
         m_Controls->m_ParticleWeightLabel->setText(QString::number(m_GlobalTracker->GetParticleWeight()));
         m_Controls->m_ParticleWeightSlider->setValue(m_GlobalTracker->GetParticleWeight()*10000);
     }
     if(m_Controls->m_ParticleWidthSlider->value()==0)
     {
         m_Controls->m_ParticleWidthLabel->setText(QString::number(m_GlobalTracker->GetParticleWidth()));
         m_Controls->m_ParticleWidthSlider->setValue(m_GlobalTracker->GetParticleWidth()*10);
     }
     if(m_Controls->m_ParticleLengthSlider->value()==0)
     {
         m_Controls->m_ParticleLengthLabel->setText(QString::number(m_GlobalTracker->GetParticleLength()));
         m_Controls->m_ParticleLengthSlider->setValue(m_GlobalTracker->GetParticleLength()*10);
     }
 
     GenerateFiberBundle();
     m_FiberBundleNode = NULL;
 }
 
 // start tracking timer and update gui elements before tracking is started
 void QmitkGibbsTrackingView::BeforeThread()
 {
     m_ThreadIsRunning = true;
     m_TrackingTime = QTime::currentTime();
     m_ElapsedTime = 0;
     m_TrackingTimer->start(1000);
     m_LastStep = 0;
 
     UpdateGUI();
 }
 
 // setup gui elements and signal/slot connections
 void QmitkGibbsTrackingView::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::QmitkGibbsTrackingViewControls;
         m_Controls->setupUi( parent );
 
         AdvancedSettings();
 
         connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
         connect( m_Controls->m_TrackingStop, SIGNAL(clicked()), this, SLOT(StopGibbsTracking()) );
         connect( m_Controls->m_TrackingStart, SIGNAL(clicked()), this, SLOT(StartGibbsTracking()) );
         connect( m_Controls->m_AdvancedSettingsCheckbox, SIGNAL(clicked()), this, SLOT(AdvancedSettings()) );
         connect( m_Controls->m_SaveTrackingParameters, SIGNAL(clicked()), this, SLOT(SaveTrackingParameters()) );
         connect( m_Controls->m_LoadTrackingParameters, SIGNAL(clicked()), this, SLOT(LoadTrackingParameters()) );
         connect( m_Controls->m_IterationsSlider, SIGNAL(valueChanged(int)), this, SLOT(SetIterations(int)) );
         connect( m_Controls->m_ParticleWidthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWidth(int)) );
         connect( m_Controls->m_ParticleLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleLength(int)) );
         connect( m_Controls->m_InExBalanceSlider, SIGNAL(valueChanged(int)), this, SLOT(SetInExBalance(int)) );
         connect( m_Controls->m_FiberLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetFiberLength(int)) );
         connect( m_Controls->m_ParticleWeightSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWeight(int)) );
         connect( m_Controls->m_StartTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetStartTemp(int)) );
         connect( m_Controls->m_EndTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetEndTemp(int)) );
         connect( m_Controls->m_CurvatureThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(SetCurvatureThreshold(int)) );
         connect( m_Controls->m_RandomSeedSlider, SIGNAL(valueChanged(int)), this, SLOT(SetRandomSeed(int)) );
         connect( m_Controls->m_OutputFileButton, SIGNAL(clicked()), this, SLOT(SetOutputFile()) );
     }
 }
 
 void QmitkGibbsTrackingView::SetInExBalance(int value)
 {
     m_Controls->m_InExBalanceLabel->setText(QString::number((float)value/10));
 }
 
 void QmitkGibbsTrackingView::SetFiberLength(int value)
 {
     m_Controls->m_FiberLengthLabel->setText(QString::number(value)+"mm");
 }
 
 void QmitkGibbsTrackingView::SetRandomSeed(int value)
 {
     if (value>=0)
         m_Controls->m_RandomSeedLabel->setText(QString::number(value));
     else
         m_Controls->m_RandomSeedLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetParticleWeight(int value)
 {
     if (value>0)
         m_Controls->m_ParticleWeightLabel->setText(QString::number((float)value/10000));
     else
         m_Controls->m_ParticleWeightLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetStartTemp(int value)
 {
     m_Controls->m_StartTempLabel->setText(QString::number((float)value/100));
 }
 
 void QmitkGibbsTrackingView::SetEndTemp(int value)
 {
     m_Controls->m_EndTempLabel->setText(QString::number((float)value/10000));
 }
 
 void QmitkGibbsTrackingView::SetParticleWidth(int value)
 {
     if (value>0)
         m_Controls->m_ParticleWidthLabel->setText(QString::number((float)value/10)+" mm");
     else
         m_Controls->m_ParticleWidthLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetParticleLength(int value)
 {
     if (value>0)
         m_Controls->m_ParticleLengthLabel->setText(QString::number((float)value/10)+" mm");
     else
         m_Controls->m_ParticleLengthLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetCurvatureThreshold(int value)
 {
     m_Controls->m_CurvatureThresholdLabel->setText(QString::number(value)+"°");
 }
 
 void QmitkGibbsTrackingView::SetIterations(int value)
 {
     switch(value)
     {
     case 0:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^4");
         m_Iterations = 10000;
         break;
     case 1:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^4");
         m_Iterations = 50000;
         break;
     case 2:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^5");
         m_Iterations = 100000;
         break;
     case 3:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^5");
         m_Iterations = 500000;
         break;
     case 4:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^6");
         m_Iterations = 1000000;
         break;
     case 5:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^6");
         m_Iterations = 5000000;
         break;
     case 6:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^7");
         m_Iterations = 10000000;
         break;
     case 7:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^7");
         m_Iterations = 50000000;
         break;
     case 8:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^8");
         m_Iterations = 100000000;
         break;
     case 9:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^8");
         m_Iterations = 500000000;
         break;
     }
 
 }
 
 void QmitkGibbsTrackingView::StdMultiWidgetAvailable(QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkGibbsTrackingView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 // called if datamanager selection changes
 void QmitkGibbsTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     if (m_ThreadIsRunning)
         return;
 
     m_ImageNode = NULL;
     m_MaskImageNode = NULL;
 
     // iterate all selected objects
     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()) )
             m_ImageNode = node;
         else if( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
             m_ImageNode = node;
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_MaskImageNode = node;
         }
     }
 
     UpdateGUI();
 }
 
 // update gui elements displaying trackings status
 void QmitkGibbsTrackingView::UpdateTrackingStatus()
 {
     if (m_GlobalTracker.IsNull())
         return;
 
     m_ElapsedTime += m_TrackingTime.elapsed()/1000;
     m_TrackingTime.restart();
     unsigned long hours = m_ElapsedTime/3600;
     unsigned long minutes = (m_ElapsedTime%3600)/60;
     unsigned long seconds = m_ElapsedTime%60;
 
     m_Controls->m_ProposalAcceptance->setText(QString::number(m_GlobalTracker->GetProposalAcceptance()*100)+"%");
 
     m_Controls->m_TrackingTimeLabel->setText( QString::number(hours)+QString("h ")+QString::number(minutes)+QString("m ")+QString::number(seconds)+QString("s") );
     m_Controls->m_NumConnectionsLabel->setText( QString::number(m_GlobalTracker->GetNumConnections()) );
     m_Controls->m_NumParticlesLabel->setText( QString::number(m_GlobalTracker->GetNumParticles()) );
     m_Controls->m_CurrentStepLabel->setText( QString::number(100*(float)(m_GlobalTracker->GetCurrentStep()-1)/m_GlobalTracker->GetSteps())+"%" );
     m_Controls->m_AcceptedFibersLabel->setText( QString::number(m_GlobalTracker->GetNumAcceptedFibers()) );
 }
 
 // update gui elements (enable/disable elements and set tooltips)
 void QmitkGibbsTrackingView::UpdateGUI()
 {
     if (m_ImageNode.IsNotNull())
     {
         m_Controls->m_QballImageLabel->setText(m_ImageNode->GetName().c_str());
         m_Controls->m_DataFrame->setTitle("Input Data");
     }
     else
     {
         m_Controls->m_QballImageLabel->setText("<font color='red'>mandatory</font>");
         m_Controls->m_DataFrame->setTitle("Please Select Input Data");
     }
     if (m_MaskImageNode.IsNotNull())
         m_Controls->m_MaskImageLabel->setText(m_MaskImageNode->GetName().c_str());
     else
         m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
 
     if (!m_ThreadIsRunning && m_ImageNode.IsNotNull())
     {
         m_Controls->m_TrackingStop->setEnabled(false);
         m_Controls->m_TrackingStart->setEnabled(true);
         m_Controls->m_LoadTrackingParameters->setEnabled(true);
         m_Controls->m_IterationsSlider->setEnabled(true);
         m_Controls->m_AdvancedFrame->setEnabled(true);
         m_Controls->m_TrackingStop->setText("Stop Tractography");
         m_Controls->m_TrackingStart->setToolTip("Start tractography. No further change of parameters possible.");
         m_Controls->m_TrackingStop->setToolTip("");
     }
     else if (!m_ThreadIsRunning)
     {
         m_Controls->m_TrackingStop->setEnabled(false);
         m_Controls->m_TrackingStart->setEnabled(false);
         m_Controls->m_LoadTrackingParameters->setEnabled(true);
         m_Controls->m_IterationsSlider->setEnabled(true);
         m_Controls->m_AdvancedFrame->setEnabled(true);
         m_Controls->m_TrackingStop->setText("Stop Tractography");
         m_Controls->m_TrackingStart->setToolTip("No Q-Ball image selected.");
         m_Controls->m_TrackingStop->setToolTip("");
     }
     else
     {
         m_Controls->m_TrackingStop->setEnabled(true);
         m_Controls->m_TrackingStart->setEnabled(false);
         m_Controls->m_LoadTrackingParameters->setEnabled(false);
         m_Controls->m_IterationsSlider->setEnabled(false);
         m_Controls->m_AdvancedFrame->setEnabled(false);
         m_Controls->m_AdvancedFrame->setVisible(false);
         m_Controls->m_AdvancedSettingsCheckbox->setChecked(false);
         m_Controls->m_TrackingStart->setToolTip("Tracking in progress.");
         m_Controls->m_TrackingStop->setToolTip("Stop tracking and display results.");
     }
 }
 
 // show/hide advanced settings frame
 void QmitkGibbsTrackingView::AdvancedSettings()
 {
     m_Controls->m_AdvancedFrame->setVisible(m_Controls->m_AdvancedSettingsCheckbox->isChecked());
 }
 
 // set mask image data node
 void QmitkGibbsTrackingView::SetMask()
 {
     std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
     if (nodes.empty())
     {
         m_MaskImageNode = NULL;
         m_Controls->m_MaskImageLabel->setText("-");
         return;
     }
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
          it != nodes.end();
          ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
         {
             m_MaskImageNode = node;
             m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
             return;
         }
     }
 }
 
-// cast image to float
-template<class InputImageType>
-void QmitkGibbsTrackingView::CastToFloat(InputImageType* image, mitk::Image::Pointer outImage)
-{
-    typedef itk::CastImageFilter<InputImageType, ItkFloatImageType> ItkCastFilter;
-    typename ItkCastFilter::Pointer itkCaster = ItkCastFilter::New();
-    itkCaster->SetInput(image);
-    itkCaster->Update();
-    outImage->InitializeByItk(itkCaster->GetOutput());
-    outImage->SetVolume(itkCaster->GetOutput()->GetBufferPointer());
-}
-
 // check for mask and qbi and start tracking thread
 void QmitkGibbsTrackingView::StartGibbsTracking()
 {
     if(m_ThreadIsRunning)
     {
         MITK_WARN("QmitkGibbsTrackingView")<<"Thread already running!";
         return;
     }
+    m_GlobalTracker = NULL;
 
     if (m_ImageNode.IsNull())
     {
         QMessageBox::information( NULL, "Warning", "Please load and select a qball image before starting image processing.");
         return;
     }
 
     if (dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData()))
         m_QBallImage = dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData());
     else if (dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData()))
         m_TensorImage = dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData());
 
     if (m_QBallImage.IsNull() && m_TensorImage.IsNull())
         return;
 
     // cast qbi to itk
     m_ItkTensorImage = NULL;
     m_ItkQBallImage = NULL;
     m_MaskImage = NULL;
 
     if (m_QBallImage.IsNotNull())
     {
         m_ItkQBallImage = ItkQBallImgType::New();
         mitk::CastToItkImage<ItkQBallImgType>(m_QBallImage, m_ItkQBallImage);
     }
     else
     {
         m_ItkTensorImage = ItkTensorImage::New();
         mitk::CastToItkImage<ItkTensorImage>(m_TensorImage, m_ItkTensorImage);
     }
 
     // mask image found?
     // catch exceptions thrown by the itkAccess macros
     try{
         if(m_MaskImageNode.IsNotNull())
         {
             if (dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()))
                 mitk::CastToItkImage<ItkFloatImageType>(dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()), m_MaskImage);
         }
     }
     catch(...){};
 
     unsigned int steps = m_Iterations/10000;
     if (steps<10)
         steps = 10;
 
     m_LastStep = 1;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(steps);
 
       // start worker thread
       m_TrackingThread.start(QThread::LowestPriority);
 }
 
 // generate mitkFiberBundle from tracking filter output
 void QmitkGibbsTrackingView::GenerateFiberBundle()
 {
     if (m_GlobalTracker.IsNull() || (!(m_Controls->m_VisualizationCheckbox->isChecked() || m_Controls->m_VisualizeOnceButton->isChecked()) && m_ThreadIsRunning))
         return;
 
     if (m_Controls->m_VisualizeOnceButton->isChecked())
         m_Controls->m_VisualizeOnceButton->setChecked(false);
 
     vtkSmartPointer<vtkPolyData> fiberBundle = m_GlobalTracker->GetFiberBundle();
     if ( m_GlobalTracker->GetNumAcceptedFibers()==0 )
         return;
     m_FiberBundle = mitk::FiberBundleX::New(fiberBundle);
 
     if (m_FiberBundleNode.IsNotNull()){
         GetDefaultDataStorage()->Remove(m_FiberBundleNode);
         m_FiberBundleNode = 0;
     }
     m_FiberBundleNode = mitk::DataNode::New();
     m_FiberBundleNode->SetData(m_FiberBundle);
 
     QString name(m_ImageNode->GetName().c_str());
     name += "_Gibbs";
     m_FiberBundleNode->SetName(name.toStdString());
     m_FiberBundleNode->SetVisibility(true);
 
     if (!m_OutputFileName.isEmpty())
     {
         QString filename = m_OutputFileName;
         mitk::FiberBundleXWriter::Pointer writer = mitk::FiberBundleXWriter::New();
         writer->SetFileName(filename.toStdString());
         writer->SetInputFiberBundleX(m_FiberBundle.GetPointer());
         try
         {
             writer->Update();
             QMessageBox::information(NULL, "Fiber bundle saved to", filename);
         }
         catch (itk::ExceptionObject &ex)
         {
             QMessageBox::information(NULL, "Fiber bundle could not be saved", QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
 
             if(m_ImageNode.IsNull())
                 GetDataStorage()->Add(m_FiberBundleNode);
             else
                 GetDataStorage()->Add(m_FiberBundleNode, m_ImageNode);
         }
     }
     else {
         if(m_ImageNode.IsNull())
             GetDataStorage()->Add(m_FiberBundleNode);
         else
             GetDataStorage()->Add(m_FiberBundleNode, m_ImageNode);
     }
 }
 
 void QmitkGibbsTrackingView::SetOutputFile()
 {
     // SELECT FOLDER DIALOG
     m_OutputFileName = QFileDialog::getSaveFileName(0,
                                                     tr("Set file name"),
                                                     QDir::currentPath()+"/FiberBundle.fib",
                                                     tr("Fiber Bundle (*.fib)") );
     if (m_OutputFileName.isEmpty())
         m_Controls->m_OutputFileLabel->setText("N/A");
     else
         m_Controls->m_OutputFileLabel->setText(m_OutputFileName);
 }
 
 // save current tracking paramters as xml file (.gtp)
 void QmitkGibbsTrackingView::SaveTrackingParameters()
 {
     TiXmlDocument documentXML;
     TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" );
     documentXML.LinkEndChild( declXML );
 
     TiXmlElement* mainXML = new TiXmlElement("global_tracking_parameter_file");
     mainXML->SetAttribute("file_version",  "0.1");
     documentXML.LinkEndChild(mainXML);
 
     TiXmlElement* paramXML = new TiXmlElement("parameter_set");
     paramXML->SetAttribute("iterations", QString::number(m_Iterations).toStdString());
     paramXML->SetAttribute("particle_length", QString::number((float)m_Controls->m_ParticleLengthSlider->value()/10).toStdString());
     paramXML->SetAttribute("particle_width", QString::number((float)m_Controls->m_ParticleWidthSlider->value()/10).toStdString());
     paramXML->SetAttribute("particle_weight", QString::number((float)m_Controls->m_ParticleWeightSlider->value()/10000).toStdString());
     paramXML->SetAttribute("temp_start", QString::number((float)m_Controls->m_StartTempSlider->value()/100).toStdString());
     paramXML->SetAttribute("temp_end", QString::number((float)m_Controls->m_EndTempSlider->value()/10000).toStdString());
     paramXML->SetAttribute("inexbalance", QString::number((float)m_Controls->m_InExBalanceSlider->value()/10).toStdString());
     paramXML->SetAttribute("fiber_length", QString::number(m_Controls->m_FiberLengthSlider->value()).toStdString());
     paramXML->SetAttribute("curvature_threshold", QString::number(m_Controls->m_CurvatureThresholdSlider->value()).toStdString());
     mainXML->LinkEndChild(paramXML);
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 QDir::currentPath()+"/param.gtp",
                 tr("Global Tracking Parameters (*.gtp)") );
 
     if(filename.isEmpty() || filename.isNull())
         return;
     if(!filename.endsWith(".gtp"))
         filename += ".gtp";
     documentXML.SaveFile( filename.toStdString() );
 }
 
 void QmitkGibbsTrackingView::UpdateIteraionsGUI(unsigned long iterations)
 {
     switch(iterations)
     {
     case 10000:
         m_Controls->m_IterationsSlider->setValue(0);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^4");
         break;
     case 50000:
         m_Controls->m_IterationsSlider->setValue(1);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^4");
         break;
     case 100000:
         m_Controls->m_IterationsSlider->setValue(2);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^5");
         break;
     case 500000:
         m_Controls->m_IterationsSlider->setValue(3);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^5");
         break;
     case 1000000:
         m_Controls->m_IterationsSlider->setValue(4);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^6");
         break;
     case 5000000:
         m_Controls->m_IterationsSlider->setValue(5);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^6");
         break;
     case 10000000:
         m_Controls->m_IterationsSlider->setValue(6);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^7");
         break;
     case 50000000:
         m_Controls->m_IterationsSlider->setValue(7);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^7");
         break;
     case 100000000:
         m_Controls->m_IterationsSlider->setValue(8);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^8");
         break;
     case 500000000:
         m_Controls->m_IterationsSlider->setValue(9);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^8");
         break;
     case 1000000000:
         m_Controls->m_IterationsSlider->setValue(10);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^9");
         break;
     case 5000000000:
         m_Controls->m_IterationsSlider->setValue(11);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^9");
         break;
     }
 }
 
 // load current tracking paramters from xml file (.gtp)
 void QmitkGibbsTrackingView::LoadTrackingParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QDir::currentPath(), tr("Global Tracking Parameters (*.gtp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     TiXmlDocument doc( filename.toStdString() );
     doc.LoadFile();
 
     TiXmlHandle hDoc(&doc);
     TiXmlElement* pElem;
     TiXmlHandle hRoot(0);
 
     pElem = hDoc.FirstChildElement().Element();
     hRoot = TiXmlHandle(pElem);
     pElem = hRoot.FirstChildElement("parameter_set").Element();
 
     QString iterations(pElem->Attribute("iterations"));
     m_Iterations = iterations.toULong();
     UpdateIteraionsGUI(m_Iterations);
 
     QString particleLength(pElem->Attribute("particle_length"));
     float pLength = particleLength.toFloat();
     QString particleWidth(pElem->Attribute("particle_width"));
     float pWidth = particleWidth.toFloat();
 
     if (pLength==0)
         m_Controls->m_ParticleLengthLabel->setText("auto");
     else
         m_Controls->m_ParticleLengthLabel->setText(particleLength+" mm");
     if (pWidth==0)
         m_Controls->m_ParticleWidthLabel->setText("auto");
     else
         m_Controls->m_ParticleWidthLabel->setText(particleWidth+" mm");
 
     m_Controls->m_ParticleWidthSlider->setValue(pWidth*10);
     m_Controls->m_ParticleLengthSlider->setValue(pLength*10);
 
     QString partWeight(pElem->Attribute("particle_weight"));
     m_Controls->m_ParticleWeightSlider->setValue(partWeight.toFloat()*10000);
     m_Controls->m_ParticleWeightLabel->setText(partWeight);
 
     QString startTemp(pElem->Attribute("temp_start"));
     m_Controls->m_StartTempSlider->setValue(startTemp.toFloat()*100);
     m_Controls->m_StartTempLabel->setText(startTemp);
 
     QString endTemp(pElem->Attribute("temp_end"));
     m_Controls->m_EndTempSlider->setValue(endTemp.toFloat()*10000);
     m_Controls->m_EndTempLabel->setText(endTemp);
 
     QString inExBalance(pElem->Attribute("inexbalance"));
     m_Controls->m_InExBalanceSlider->setValue(inExBalance.toFloat()*10);
     m_Controls->m_InExBalanceLabel->setText(inExBalance);
 
     QString fiberLength(pElem->Attribute("fiber_length"));
     m_Controls->m_FiberLengthSlider->setValue(fiberLength.toInt());
     m_Controls->m_FiberLengthLabel->setText(fiberLength+"mm");
 
     QString curvThres(pElem->Attribute("curvature_threshold"));
     m_Controls->m_CurvatureThresholdSlider->setValue(curvThres.toInt());
     m_Controls->m_CurvatureThresholdLabel->setText(curvThres+"°");
 }
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
index 4a7c2935ca..92e7b2a58f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
@@ -1,168 +1,165 @@
 /*===================================================================
 
 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 QmitkGibbsTrackingView_h
 #define QmitkGibbsTrackingView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkFunctionality.h>
 
 #include "ui_QmitkGibbsTrackingViewControls.h"
 
 #include <mitkQBallImage.h>
 #include <QThread>
 #include <mitkFiberBundleX.h>
 #include <QTime>
 #include <itkImage.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <itkDiffusionTensor3D.h>
 #include <mitkTensorImage.h>
 
 class QmitkGibbsTrackingView;
 
 class QmitkTrackingWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
   QmitkTrackingWorker(QmitkGibbsTrackingView* view);
 
 public slots:
 
   void run();
 
 private:
 
   QmitkGibbsTrackingView* m_View;
 };
 
 /*!
   \brief View for global fiber tracking (Gibbs tracking)
 
   \sa QmitkFunctionality
   \ingroup Functionalities
 */
 typedef itk::Image< float, 3 >            FloatImageType;
 
 namespace itk
 {
 template<class X>
 class GibbsTrackingFilter;
 }
 
 class QmitkGibbsTrackingView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   typedef itk::Image<float,3>                               ItkFloatImageType;
   typedef itk::Vector<float, QBALL_ODFSIZE>                 OdfVectorType;
   typedef itk::Image<OdfVectorType, 3>                      ItkQBallImgType;
   typedef itk::Image< itk::DiffusionTensor3D<float>, 3 >    ItkTensorImage;
   typedef itk::GibbsTrackingFilter< ItkQBallImgType >       GibbsTrackingFilterType;
 
   static const std::string VIEW_ID;
 
   QmitkGibbsTrackingView();
   virtual ~QmitkGibbsTrackingView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
 signals:
 
 protected slots:
 
   void StartGibbsTracking();
   void StopGibbsTracking();
   void AfterThread();                       ///< update gui etc. after tracking has finished
   void BeforeThread();                      ///< start timer etc.
   void TimerUpdate();
   void SetMask();
   void AdvancedSettings();                  ///< show/hide advanced tracking options
   void SaveTrackingParameters();            ///< save tracking parameters to xml file
   void LoadTrackingParameters();            ///< load tracking parameters from xml file
 
   /** update labels if parameters have changed */
   void SetIterations(int value);
   void SetParticleWidth(int value);
   void SetParticleLength(int value);
   void SetInExBalance(int value);
   void SetFiberLength(int value);
   void SetParticleWeight(int value);
   void SetStartTemp(int value);
   void SetEndTemp(int value);
   void SetCurvatureThreshold(int value);
   void SetRandomSeed(int value);
   void SetOutputFile();
 
 private:
 
   // Visualization & GUI
   void GenerateFiberBundle();   ///< generate fiber bundle from tracking output and add to datanode
   void UpdateGUI();             ///< update button activity etc. dpending on current datamanager selection
   void UpdateTrackingStatus();  ///< update textual status display of the tracking process
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
-  template<class InputImageType>
-  void CastToFloat(InputImageType* image, typename mitk::Image::Pointer outImage);
-
   void UpdateIteraionsGUI(unsigned long iterations);    ///< update iterations label text
 
   Ui::QmitkGibbsTrackingViewControls* m_Controls;
   QmitkStdMultiWidget* m_MultiWidget;
 
   /** data objects */
   mitk::FiberBundleX::Pointer   m_FiberBundle;      ///< tracking output
   ItkFloatImageType::Pointer    m_MaskImage;        ///< used to reduce the algorithms search space. tracking only inside of the mask.
   mitk::TensorImage::Pointer    m_TensorImage;      ///< actual image that is tracked
   mitk::QBallImage::Pointer     m_QBallImage;       ///< actual image that is tracked
   ItkQBallImgType::Pointer      m_ItkQBallImage;    ///< actual image that is tracked
   ItkTensorImage::Pointer       m_ItkTensorImage;   ///< actual image that is tracked
 
   /** data nodes */
   mitk::DataNode::Pointer m_ImageNode;
   mitk::DataNode::Pointer m_MaskImageNode;
   mitk::DataNode::Pointer m_FiberBundleNode;
 
   /** flags etc. */
   bool            m_ThreadIsRunning;
   QTimer*         m_TrackingTimer;
   QTime           m_TrackingTime;
   unsigned long   m_ElapsedTime;
   unsigned long   m_Iterations;
   int             m_LastStep;
   QString         m_OutputFileName;
 
   /** global tracker and friends */
   itk::SmartPointer<GibbsTrackingFilterType> m_GlobalTracker;
   QmitkTrackingWorker m_TrackingWorker;
   QThread m_TrackingThread;
   friend class QmitkTrackingWorker;
 };
 
 #endif // _QMITKGibbsTrackingVIEW_H_INCLUDED