diff --git a/Modules/DICOMQI/autoload/IO/mitkDICOMQIIOMimeTypes.cpp b/Modules/DICOMQI/autoload/IO/mitkDICOMQIIOMimeTypes.cpp
index 49d8bfcea3..a0d495f7cd 100644
--- a/Modules/DICOMQI/autoload/IO/mitkDICOMQIIOMimeTypes.cpp
+++ b/Modules/DICOMQI/autoload/IO/mitkDICOMQIIOMimeTypes.cpp
@@ -1,115 +1,128 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkDICOMQIIOMimeTypes.h"
 #include "mitkIOMimeTypes.h"
 #include <mitkDICOMDCMTKTagScanner.h>
 #include <mitkDICOMFileReaderSelector.h>
 
 #include <mitkLogMacros.h>
 
 #include <itkGDCMImageIO.h>
 
 #include <itksys/SystemTools.hxx>
 
 // dcmqi
 #include <dcmqi/ImageSEGConverter.h>
 #include <dcmqi/JSONSegmentationMetaInformationHandler.h>
 
 namespace mitk
 {
   std::vector<CustomMimeType *> MitkDICOMQIIOMimeTypes::Get()
   {
     std::vector<CustomMimeType *> mimeTypes;
 
     // order matters here (descending rank for mime types)
 
     mimeTypes.push_back(DICOMQI_MIMETYPE().Clone());
 
     return mimeTypes;
   }
 
   // Mime Types
 
   MitkDICOMQIIOMimeTypes::MitkDICOMQIMimeType::MitkDICOMQIMimeType() : CustomMimeType(DICOMQI_MIMETYPE_NAME())
   {
     this->AddExtension("dcm");
     this->SetCategory(IOMimeTypes::CATEGORY_IMAGES());
     this->SetComment("DICOM SEG");
   }
 
   bool MitkDICOMQIIOMimeTypes::MitkDICOMQIMimeType::AppliesTo(const std::string &path) const
   {
+    std::ifstream myfile;
+    myfile.open (path, std::ios::binary);
+//    myfile.seekg (128);
+    char *buffer = new char [128];
+    myfile.read (buffer,128);
+    myfile.read (buffer,4);
+    if (std::string(buffer).compare("DICM")!=0)
+    {
+      delete[] buffer;
+      return false;
+    }
+    delete[] buffer;
+
     bool canRead(CustomMimeType::AppliesTo(path));
 
     // fix for bug 18572
     // Currently this function is called for writing as well as reading, in that case
     // the image information can of course not be read
     // This is a bug, this function should only be called for reading.
     if (!itksys::SystemTools::FileExists(path.c_str()))
     {
       return canRead;
     }
     // end fix for bug 18572
     DcmFileFormat dcmFileFormat;
     OFCondition status = dcmFileFormat.loadFile(path.c_str());
 
     if (status.bad())
     {
       canRead = false;
     }
 
     if (!canRead)
     {
       return canRead;
     }
 
 
 
     OFString modality;
     if (dcmFileFormat.getDataset()->findAndGetOFString(DCM_Modality, modality).good())
     {
       if (modality.compare("SEG") == 0)
       {
         canRead = true;
       }
       else
       {
         canRead = false;
       }
     }
 
     return canRead;
   }
 
   MitkDICOMQIIOMimeTypes::MitkDICOMQIMimeType *MitkDICOMQIIOMimeTypes::MitkDICOMQIMimeType::Clone() const
   {
     return new MitkDICOMQIMimeType(*this);
   }
 
   MitkDICOMQIIOMimeTypes::MitkDICOMQIMimeType MitkDICOMQIIOMimeTypes::DICOMQI_MIMETYPE()
   {
     return MitkDICOMQIMimeType();
   }
 
   // Names
   std::string MitkDICOMQIIOMimeTypes::DICOMQI_MIMETYPE_NAME()
   {
     // create a unique and sensible name for this mime type
     static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".image.dicom.seg";
     return name;
   }
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberClustering.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberClustering.cpp
index f645349ce5..bee4bedf2e 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberClustering.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberClustering.cpp
@@ -1,228 +1,228 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkFiberBundle.h>
 #include <mitkCommandLineParser.h>
 #include <boost/lexical_cast.hpp>
 #include <mitkIOUtil.h>
 #include <itkTractClusteringFilter.h>
 #include <mitkClusteringMetricEuclideanMean.h>
 #include <mitkClusteringMetricEuclideanMax.h>
 #include <mitkClusteringMetricEuclideanStd.h>
 #include <mitkClusteringMetricAnatomic.h>
 #include <mitkClusteringMetricScalarMap.h>
 #include <mitkClusteringMetricInnerAngles.h>
 
 mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
   std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
   if( fibInfile.empty() )
     std::cout << "File " << filename << " could not be read!";
   mitk::BaseData::Pointer baseData = fibInfile.at(0);
   return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
 /*!
 \brief Spatially cluster fibers
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Fiber Clustering");
   parser.setCategory("Fiber Processing");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib, .trk, .tck)", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
 
   parser.addArgument("cluster_size", "", mitkCommandLineParser::Int, "Cluster size:", "", 10);
   parser.addArgument("fiber_points", "", mitkCommandLineParser::Int, "Fiber points:", "", 12);
   parser.addArgument("min_fibers", "", mitkCommandLineParser::Int, "Min. fibers per cluster:", "", 1);
   parser.addArgument("max_clusters", "", mitkCommandLineParser::Int, "Max. clusters:", "");
   parser.addArgument("merge_clusters", "", mitkCommandLineParser::Float, "Merge clusters:", "", -1.0);
   parser.addArgument("output_centroids", "", mitkCommandLineParser::Bool, "Output centroids:", "");
   parser.addArgument("metrics", "", mitkCommandLineParser::StringList, "Metrics:", "EU_MEAN, EU_STD, EU_MAX, ANAT, MAP, ANGLES");
   parser.addArgument("input_centroids", "", mitkCommandLineParser::String, "Input centroids:", "");
   parser.addArgument("scalar_map", "", mitkCommandLineParser::String, "Scalar map:", "");
   parser.addArgument("parcellation", "", mitkCommandLineParser::String, "Parcellation:", "");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string inFileName = us::any_cast<std::string>(parsedArgs["i"]);
   std::string out_root = us::any_cast<std::string>(parsedArgs["o"]);
 
   int cluster_size = 10;
   if (parsedArgs.count("cluster_size"))
     cluster_size = us::any_cast<int>(parsedArgs["cluster_size"]);
 
   int fiber_points = 12;
   if (parsedArgs.count("fiber_points"))
     fiber_points = us::any_cast<int>(parsedArgs["fiber_points"]);
 
   int min_fibers = 1;
   if (parsedArgs.count("min_fibers"))
     min_fibers = us::any_cast<int>(parsedArgs["min_fibers"]);
 
   int max_clusters = 0;
   if (parsedArgs.count("max_clusters"))
     max_clusters = us::any_cast<int>(parsedArgs["max_clusters"]);
 
   float merge_clusters = -1.0;
   if (parsedArgs.count("merge_clusters"))
     merge_clusters = us::any_cast<float>(parsedArgs["merge_clusters"]);
 
   bool output_centroids = false;
   if (parsedArgs.count("output_centroids"))
     output_centroids = us::any_cast<bool>(parsedArgs["output_centroids"]);
 
-  std::vector< std::string > metric_strings = {"EUCL"};
+  std::vector< std::string > metric_strings = {"EU_MEAN"};
   if (parsedArgs.count("metrics"))
     metric_strings = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["metrics"]);
 
   std::string input_centroids = "";
   if (parsedArgs.count("input_centroids"))
     input_centroids = us::any_cast<std::string>(parsedArgs["input_centroids"]);
 
   std::string scalar_map = "";
   if (parsedArgs.count("scalar_map"))
     scalar_map = us::any_cast<std::string>(parsedArgs["scalar_map"]);
 
   std::string parcellation = "";
   if (parsedArgs.count("parcellation"))
     parcellation = us::any_cast<std::string>(parsedArgs["parcellation"]);
 
   try
   {
     typedef itk::Image< float, 3 > FloatImageType;
     typedef itk::Image< short, 3 > ShortImageType;
 
     mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
 
     float max_d = 0;
     int i=1;
     std::vector< float > distances;
     while (max_d < fib->GetGeometry()->GetDiagonalLength()/2)
     {
       distances.push_back(cluster_size*i);
       max_d = cluster_size*i;
       ++i;
     }
 
     itk::TractClusteringFilter::Pointer clusterer = itk::TractClusteringFilter::New();
     clusterer->SetDistances(distances);
     clusterer->SetTractogram(fib);
 
     if (input_centroids!="")
     {
 
       mitk::FiberBundle::Pointer in_centroids = LoadFib(input_centroids);
       clusterer->SetInCentroids(in_centroids);
     }
 
     std::vector< mitk::ClusteringMetric* > metrics;
 
     for (auto m : metric_strings)
     {
       MITK_INFO << "Metric: " << m;
       if (m=="EU_MEAN")
         metrics.push_back({new mitk::ClusteringMetricEuclideanMean()});
       else if (m=="EU_STD")
         metrics.push_back({new mitk::ClusteringMetricEuclideanStd()});
       else if (m=="EU_MAX")
         metrics.push_back({new mitk::ClusteringMetricEuclideanMax()});
       else if (m=="ANGLES")
         metrics.push_back({new mitk::ClusteringMetricInnerAngles()});
       else if (m=="MAP" && scalar_map!="")
       {
         mitk::Image::Pointer mitk_map = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(scalar_map)[0].GetPointer());
         if (mitk_map->GetDimension()==3)
         {
           FloatImageType::Pointer itk_map = FloatImageType::New();
           mitk::CastToItkImage(mitk_map, itk_map);
 
           mitk::ClusteringMetricScalarMap* metric = new mitk::ClusteringMetricScalarMap();
           metric->SetImages({itk_map});
           metric->SetScale(distances.at(0));
           metrics.push_back(metric);
         }
       }
       else if (m=="ANAT" && parcellation!="")
       {
         mitk::Image::Pointer mitk_map = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(parcellation)[0].GetPointer());
         if (mitk_map->GetDimension()==3)
         {
           ShortImageType::Pointer itk_map = ShortImageType::New();
           mitk::CastToItkImage(mitk_map, itk_map);
 
           mitk::ClusteringMetricAnatomic* metric = new mitk::ClusteringMetricAnatomic();
           metric->SetParcellations({itk_map});
           metrics.push_back(metric);
         }
       }
     }
 
     if (metrics.empty())
     {
       MITK_INFO << "No metric selected!";
       return EXIT_FAILURE;
     }
 
     clusterer->SetMetrics(metrics);
     clusterer->SetMergeDuplicateThreshold(merge_clusters);
     clusterer->SetNumPoints(fiber_points);
     clusterer->SetMaxClusters(max_clusters);
     clusterer->SetMinClusterSize(min_fibers);
     clusterer->Update();
     std::vector<mitk::FiberBundle::Pointer> tracts = clusterer->GetOutTractograms();
     std::vector<mitk::FiberBundle::Pointer> centroids = clusterer->GetOutCentroids();
 
     MITK_INFO << "Saving clusters";
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
     unsigned int c = 0;
     for (auto f : tracts)
     {
       mitk::IOUtil::Save(f, out_root + "Cluster_" + boost::lexical_cast<std::string>(c) + ".fib");
 
       if (output_centroids)
         mitk::IOUtil::Save(centroids.at(c), out_root + "Centroid_" + boost::lexical_cast<std::string>(c) + ".fib");
       ++c;
     }
     std::cout.rdbuf (old);              // <-- restore
 
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp
index 139138250a..baf223d57c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp
@@ -1,311 +1,310 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 #include "QmitkTractometryView.h"
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImage.h>
 #include <mitkFiberBundle.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkITKImageImport.h>
 #include <QmitkChartWidget.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <berryIPreferences.h>
 #include <berryWorkbenchPlugin.h>
 #include <berryQtPreferences.h>
 #include <vtkLookupTable.h>
 #include <QClipboard>
 #include <boost/lexical_cast.hpp>
 
 const std::string QmitkTractometryView::VIEW_ID = "org.mitk.views.tractometry";
 using namespace mitk;
 
 QmitkTractometryView::QmitkTractometryView()
   : QmitkAbstractView()
   , m_Controls( nullptr )
 {
 
 }
 
 // Destructor
 QmitkTractometryView::~QmitkTractometryView()
 {
 
 }
 
 void QmitkTractometryView::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::QmitkTractometryViewControls;
     m_Controls->setupUi( parent );
 
     connect( m_Controls->m_SamplingPointsBox, SIGNAL(valueChanged(int)), this, SLOT(UpdateGui()) );
     connect( m_Controls->m_StDevBox, SIGNAL(stateChanged(int)), this, SLOT(UpdateGui()) );
 
     mitk::TNodePredicateDataType<mitk::Image>::Pointer imageP = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateDimension::Pointer dimP = mitk::NodePredicateDimension::New(3);
 
     m_Controls->m_ImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ImageBox->SetPredicate(mitk::NodePredicateAnd::New(imageP, dimP));
 
     this->m_Controls->m_ChartWidget->SetXAxisLabel("Tract position");
     this->m_Controls->m_ChartWidget->SetYAxisLabel("Image Value");
   }
 }
 
 void QmitkTractometryView::OnPageSuccessfullyLoaded()
 {
   berry::IPreferencesService* prefService = berry::WorkbenchPlugin::GetDefault()->GetPreferencesService();
   berry::IPreferences::Pointer m_StylePref = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
 
   QString styleName = m_StylePref->Get(berry::QtPreferences::QT_STYLE_NAME, "");
 
   if (styleName == ":/org.blueberry.ui.qt/darkstyle.qss")
   {
     this->m_Controls->m_ChartWidget->SetTheme(QmitkChartWidget::ChartStyle::darkstyle);
   }
   else
   {
     this->m_Controls->m_ChartWidget->SetTheme(QmitkChartWidget::ChartStyle::lightstyle);
   }
 }
 
 void QmitkTractometryView::SetFocus()
 {
 }
 
 void QmitkTractometryView::UpdateGui()
 {
   berry::IWorkbenchPart::Pointer nullPart;
   OnSelectionChanged(nullPart, QList<mitk::DataNode::Pointer>(m_CurrentSelection));
 }
 
 bool QmitkTractometryView::Flip(vtkSmartPointer< vtkPolyData > polydata1, int i, vtkSmartPointer< vtkPolyData > ref_poly)
 {
   float d_direct = 0;
   float d_flipped = 0;
 
   vtkCell* cell1 = polydata1->GetCell(0);
   if (ref_poly!=nullptr)
     cell1 = ref_poly->GetCell(0);
   int numPoints1 = cell1->GetNumberOfPoints();
   vtkPoints* points1 = cell1->GetPoints();
 
   vtkCell* cell2 = polydata1->GetCell(i);
   vtkPoints* points2 = cell2->GetPoints();
 
   for (int j=0; j<numPoints1; ++j)
   {
     double* p1 = points1->GetPoint(j);
     double* p2 = points2->GetPoint(j);
     d_direct = (p1[0]-p2[0])*(p1[0]-p2[0]) + (p1[1]-p2[1])*(p1[1]-p2[1]) + (p1[2]-p2[2])*(p1[2]-p2[2]);
 
     double* p3 = points2->GetPoint(numPoints1-j-1);
     d_flipped = (p1[0]-p3[0])*(p1[0]-p3[0]) + (p1[1]-p3[1])*(p1[1]-p3[1]) + (p1[2]-p3[2])*(p1[2]-p3[2]);
   }
 
   if (d_direct>d_flipped)
     return true;
   return false;
 }
 
 template <typename TPixel>
 void QmitkTractometryView::ImageValuesAlongTract(const mitk::PixelType, mitk::Image::Pointer image, mitk::FiberBundle::Pointer fib, std::vector<std::vector<double> > &data, std::string& clipboard_string)
 {
   int num_points = m_Controls->m_SamplingPointsBox->value();
   mitk::ImagePixelReadAccessor<TPixel,3> readimage(image, image->GetVolumeData(0));
   mitk::FiberBundle::Pointer working_fib = fib->GetDeepCopy();
   working_fib->ResampleToNumPoints(num_points);
   vtkSmartPointer< vtkPolyData > polydata = working_fib->GetFiberPolyData();
 
   std::vector<std::vector<double> > all_values;
   std::vector< double > mean_values;
   for (int i=0; i<num_points; ++i)
     mean_values.push_back(0);
 
   double min = 100000;
   double max = 0;
   double mean = 0;
   for (int i=0; i<working_fib->GetNumFibers(); ++i)
   {
     vtkCell* cell = polydata->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     std::vector< double > fib_vals;
 
     bool flip = false;
     if (i>0)
       flip = Flip(polydata, i);
     else if (m_ReferencePolyData!=nullptr)
       flip = Flip(polydata, 0, m_ReferencePolyData);
 
     for (int j=0; j<numPoints; j++)
     {
       double* p;
       if (flip)
         p = points->GetPoint(numPoints - j - 1);
       else
         p = points->GetPoint(j);
 
       Point3D px;
       px[0] = p[0];
       px[1] = p[1];
       px[2] = p[2];
       double pixelValue = readimage.GetPixelByWorldCoordinates(px);
       fib_vals.push_back(pixelValue);
       mean += pixelValue;
       if (pixelValue<min)
         min = pixelValue;
       else if (pixelValue>max)
         max = pixelValue;
 
       mean_values.at(j) += pixelValue;
     }
 
     all_values.push_back(fib_vals);
   }
 
   if (m_ReferencePolyData==nullptr)
     m_ReferencePolyData = polydata;
 
   std::vector< double > std_values1;
   std::vector< double > std_values2;
   for (int i=0; i<num_points; ++i)
   {
     mean_values.at(i) /= working_fib->GetNumFibers();
     double stdev = 0;
 
     for (unsigned int j=0; j<all_values.size(); ++j)
     {
       double diff = mean_values.at(i) - all_values.at(j).at(i);
       diff *= diff;
       stdev += diff;
     }
     stdev /= all_values.size();
     stdev = std::sqrt(stdev);
     std_values1.push_back(mean_values.at(i) + stdev/2);
     std_values2.push_back(mean_values.at(i) - stdev/2);
 
     clipboard_string += boost::lexical_cast<std::string>(mean_values.at(i));
     clipboard_string += " ";
     clipboard_string += boost::lexical_cast<std::string>(stdev);
     clipboard_string += "\n";
   }
   clipboard_string += "\n";
 
   data.push_back(mean_values);
   data.push_back(std_values1);
   data.push_back(std_values2);
 
   MITK_INFO << "Min: " << min;
   MITK_INFO << "Max: " << max;
   MITK_INFO << "Mean: " << mean/working_fib->GetNumberOfPoints();
 }
 
 std::string QmitkTractometryView::RGBToHexString(double *rgb)
 {
   std::ostringstream os;
   for (int i = 0; i < 3; ++i)
     {
     os << std::setw(2) << std::setfill('0') << std::hex
        << static_cast<int>(rgb[i] * 255);
     }
   return os.str();
 }
 
 void QmitkTractometryView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
-  MITK_INFO << nodes.size();
   m_CurrentSelection.clear();
   if(m_Controls->m_ImageBox->GetSelectedNode().IsNull())
     return;
 
   std::string clipboardString = "";
   m_ReferencePolyData = nullptr;
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_Controls->m_ImageBox->GetSelectedNode()->GetData());
 
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetTableRange(0.0, 1.0);
   lookupTable->Build();
 
   int num_tracts = 0;
   for (auto node: nodes)
     if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
       num_tracts++;
 
   int c = 1;
   this->m_Controls->m_ChartWidget->Clear();
   for (auto node: nodes)
   {
     if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
     {
       clipboardString += node->GetName() + "\n";
       clipboardString += "mean stdev\n";
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
       m_CurrentSelection.push_back(node);
 
       std::vector< std::vector< double > > data;
       mitkPixelTypeMultiplex4( ImageValuesAlongTract, image->GetPixelType(), image, fib, data, clipboardString );
 
       m_Controls->m_ChartWidget->AddData1D(data.at(0), node->GetName() + " Mean", QmitkChartWidget::ChartType::line);
       if (m_Controls->m_StDevBox->isChecked())
       {
         this->m_Controls->m_ChartWidget->AddData1D(data.at(1), node->GetName() + " +STDEV", QmitkChartWidget::ChartType::line);
         this->m_Controls->m_ChartWidget->AddData1D(data.at(2), node->GetName() + " -STDEV", QmitkChartWidget::ChartType::line);
       }
 
       double color[3];
       if (num_tracts>1)
       {
         float scalar_color = ( (float)c/num_tracts - 1.0/num_tracts )/(1.0-1.0/num_tracts);
         lookupTable->GetColor(1.0 - scalar_color, color);
       }
       else
         lookupTable->GetColor(0, color);
 
       this->m_Controls->m_ChartWidget->SetColor(node->GetName() + " Mean", RGBToHexString(color));
 
       if (m_Controls->m_StDevBox->isChecked())
       {
         color[0] *= 0.8;
         color[1] *= 0.8;
         color[2] *= 0.8;
         this->m_Controls->m_ChartWidget->SetColor(node->GetName() + " +STDEV", RGBToHexString(color));
         this->m_Controls->m_ChartWidget->SetColor(node->GetName() + " -STDEV", RGBToHexString(color));
       }
 
       this->m_Controls->m_ChartWidget->Show(true);
       this->m_Controls->m_ChartWidget->SetShowDataPoints(false);
       ++c;
     }
   }
 
   QApplication::clipboard()->setText(clipboardString.c_str(), QClipboard::Clipboard);
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.preprocessing/src/internal/QmitkBrainExtractionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.preprocessing/src/internal/QmitkBrainExtractionView.cpp
index 4a1788a57a..0f3b2340ac 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.preprocessing/src/internal/QmitkBrainExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.preprocessing/src/internal/QmitkBrainExtractionView.cpp
@@ -1,184 +1,203 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkBrainExtractionView.h"
 
 // MITK
 #include <mitkNodePredicateDataType.h>
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QDir>
 #include <QDirIterator>
 #include <QTimer>
 
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateAnd.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <mitkIOUtil.h>
 #include <mitkIPythonService.h>
 #include <itkResampleImageFilter.h>
 #include <mitkImageCast.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkLinearInterpolateImageFunction.h>
 #include <itkThresholdImageFilter.h>
 #include <itksys/SystemTools.hxx>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 
 FileDownloader::FileDownloader(QObject *parent) : QObject(parent)
 {
 
 }
 
 void FileDownloader::download(QUrl url)
 {
   connect(&m_WebCtrl, SIGNAL (finished(QNetworkReply*)), SLOT (Downloaded(QNetworkReply*)));
 
   QNetworkRequest request(url);
   m_WebCtrl.get(request);
 }
 
 void FileDownloader::Downloaded(QNetworkReply *reply)
 {
   MITK_INFO << "FileDownloader::Downloaded TESTTEST";
   QFile localFile("/home/neher/test_download.tar.gz");
   if (!localFile.open(QIODevice::WriteOnly))
     return;
   localFile.write(reply->readAll());
   localFile.close();
   delete reply;
 
   QMessageBox::information(nullptr, "FILE DOWNLOADED", "BLABL");
 }
 
 FileDownloader::~FileDownloader()
 {
 
 }
 
 const std::string QmitkBrainExtractionView::VIEW_ID = "org.mitk.views.brainextraction";
 
 QmitkBrainExtractionView::QmitkBrainExtractionView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_DiffusionImage( nullptr )
 {
 
 }
 
 // Destructor
 QmitkBrainExtractionView::~QmitkBrainExtractionView()
 {
 }
 
 void QmitkBrainExtractionView::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::QmitkBrainExtractionViewControls;
     m_Controls->setupUi( parent );
     connect( m_Controls->m_ImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGUI()) );
     connect( m_Controls->m_StartButton, SIGNAL(clicked()), this, SLOT(StartBrainExtraction()) );
     this->m_Parent = parent;
 
     m_Controls->m_ImageBox->SetDataStorage(this->GetDataStorage());
     mitk::NodePredicateDimension::Pointer dimPred = mitk::NodePredicateDimension::New(3);
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImagePredicate = mitk::TNodePredicateDataType<mitk::Image>::New();
     m_Controls->m_ImageBox->SetPredicate(mitk::NodePredicateAnd::New(isImagePredicate,dimPred));
 
     UpdateGUI();
 
     std::string module_library_full_path = us::GetModuleContext()->GetModule()->GetLocation();
     std::string library_file;
     itksys::SystemTools::SplitProgramPath(module_library_full_path, m_ModulePath, library_file);
   }
 }
 
 void QmitkBrainExtractionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& )
 {
 }
 
 void QmitkBrainExtractionView::UpdateGUI()
 {
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
     m_Controls->m_StartButton->setEnabled(true);
   else
     m_Controls->m_StartButton->setEnabled(false);
 }
 
 void QmitkBrainExtractionView::SetFocus()
 {
   UpdateGUI();
   m_Controls->m_StartButton->setFocus();
 }
 
 void QmitkBrainExtractionView::StartBrainExtraction()
 {
 //  FileDownloader dl;
 //  dl.download(QUrl("http://mitk.org/download/releases/MITK-2012.06/MITK-2012.06.0-src.tar.gz"));
 
   mitk::DataNode::Pointer node = m_Controls->m_ImageBox->GetSelectedNode();
   mitk::Image::Pointer mitk_image = dynamic_cast<mitk::Image*>(node->GetData());
 
-  us::ModuleContext* context = us::GetModuleContext();
-  us::ServiceReference<mitk::IPythonService> m_PythonServiceRef = context->GetServiceReference<mitk::IPythonService>();
-  mitk::IPythonService* m_PythonService = dynamic_cast<mitk::IPythonService*> ( context->GetService<mitk::IPythonService>(m_PythonServiceRef) );
-  mitk::IPythonService::ForceLoadModule();
-
-  m_PythonService->Execute("import SimpleITK as sitk");
-  m_PythonService->Execute("import SimpleITK._SimpleITK as _SimpleITK");
-  m_PythonService->Execute("import numpy");
-  m_PythonService->CopyToPythonAsSimpleItkImage( mitk_image, "in_image");
-  m_PythonService->Execute("model=\""+m_ModulePath+"/brain_extraction_model.model\"");
-  m_PythonService->ExecuteScript(m_ModulePath + "/brain_extraction_script.py");
+  if ( !itksys::SystemTools::FileExists(m_ModulePath + "/brain_extraction_script.py") )
+  {
+    QMessageBox::warning(nullptr, "Error", ("Brain extraction script file missing:\n" + m_ModulePath + "/brain_extraction_script.py").c_str(), QMessageBox::Ok);
+    return;
+  }
 
+  if ( !itksys::SystemTools::FileExists(m_ModulePath + "/brain_extraction_model.model") )
   {
-    mitk::Image::Pointer image = m_PythonService->CopySimpleItkImageFromPython("brain_mask");
-    mitk::DataNode::Pointer corrected_node = mitk::DataNode::New();
-    corrected_node->SetData( image );
-    QString name(node->GetName().c_str());
-    name += "_BrainMask";
-    corrected_node->SetName(name.toStdString());
-    GetDataStorage()->Add(corrected_node, node);
+    QMessageBox::warning(nullptr, "Error", ("Brain extraction model file missing:\n" + m_ModulePath + "/brain_extraction_model.model").c_str(), QMessageBox::Ok);
+    return;
   }
 
+  try
+  {
+    us::ModuleContext* context = us::GetModuleContext();
+    us::ServiceReference<mitk::IPythonService> m_PythonServiceRef = context->GetServiceReference<mitk::IPythonService>();
+    mitk::IPythonService* m_PythonService = dynamic_cast<mitk::IPythonService*> ( context->GetService<mitk::IPythonService>(m_PythonServiceRef) );
+    mitk::IPythonService::ForceLoadModule();
+
+    m_PythonService->Execute("import SimpleITK as sitk");
+    m_PythonService->Execute("import SimpleITK._SimpleITK as _SimpleITK");
+    m_PythonService->Execute("import numpy");
+    m_PythonService->CopyToPythonAsSimpleItkImage( mitk_image, "in_image");
+    m_PythonService->Execute("model=\""+m_ModulePath+"/brain_extraction_model.model\"");
+    m_PythonService->ExecuteScript(m_ModulePath + "/brain_extraction_script.py");
+
+    {
+      mitk::Image::Pointer image = m_PythonService->CopySimpleItkImageFromPython("brain_mask");
+      mitk::DataNode::Pointer corrected_node = mitk::DataNode::New();
+      corrected_node->SetData( image );
+      QString name(node->GetName().c_str());
+      name += "_BrainMask";
+      corrected_node->SetName(name.toStdString());
+      GetDataStorage()->Add(corrected_node, node);
+    }
+
+    {
+      mitk::Image::Pointer image = m_PythonService->CopySimpleItkImageFromPython("brain_extracted");
+      mitk::DataNode::Pointer corrected_node = mitk::DataNode::New();
+      corrected_node->SetData( image );
+      QString name(node->GetName().c_str());
+      name += "_SkullStripped";
+      corrected_node->SetName(name.toStdString());
+      GetDataStorage()->Add(corrected_node, node);
+    }
+  }
+  catch(...)
   {
-    mitk::Image::Pointer image = m_PythonService->CopySimpleItkImageFromPython("brain_extracted");
-    mitk::DataNode::Pointer corrected_node = mitk::DataNode::New();
-    corrected_node->SetData( image );
-    QString name(node->GetName().c_str());
-    name += "_SkullStripped";
-    corrected_node->SetName(name.toStdString());
-    GetDataStorage()->Add(corrected_node, node);
+    QMessageBox::warning(nullptr, "Error", "File could not be processed.\nIs pytorch installed on your system?\nDoes your script use the correct input and output variable names (in: in_image & model, out: brain_mask & brain_extracted)?", QMessageBox::Ok);
   }
 }