diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.cpp
index 3c6a9a446d..e12d8e4708 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.cpp
@@ -1,556 +1,556 @@
 /*===================================================================
 
 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 "itkTractClusteringFilter.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <boost/progress.hpp>
 #include <vnl/vnl_sparse_matrix.h>
 
 namespace itk{
 
 TractClusteringFilter::TractClusteringFilter()
   : m_NumPoints(12)
   , m_InCentroids(nullptr)
   , m_MinClusterSize(1)
   , m_MaxClusters(0)
   , m_MergeDuplicateThreshold(-1)
   , m_DoResampling(true)
   , m_FilterMask(nullptr)
   , m_OverlapThreshold(0.0)
 {
 
 }
 
 TractClusteringFilter::~TractClusteringFilter()
 {
   for (auto m : m_Metrics)
     delete m;
 }
 
 std::vector<std::vector<long> > TractClusteringFilter::GetOutFiberIndices() const
 {
   return m_OutFiberIndices;
 }
 
 void TractClusteringFilter::SetMetrics(const std::vector<mitk::ClusteringMetric *> &Metrics)
 {
   m_Metrics = Metrics;
 }
 
 std::vector<TractClusteringFilter::Cluster> TractClusteringFilter::GetOutClusters() const
 {
   return m_OutClusters;
 }
 
 std::vector<mitk::FiberBundle::Pointer> TractClusteringFilter::GetOutCentroids() const
 {
   return m_OutCentroids;
 }
 
 std::vector<mitk::FiberBundle::Pointer> TractClusteringFilter::GetOutTractograms() const
 {
   return m_OutTractograms;
 }
 
 void TractClusteringFilter::SetDistances(const std::vector<float> &Distances)
 {
   m_Distances = Distances;
 }
 
 float TractClusteringFilter::CalcOverlap(vnl_matrix<float>& t)
 {
   float overlap = 0;
   if (m_FilterMask.IsNotNull())
   {
 
     for (unsigned int i=0; i<m_NumPoints; ++i)
     {
       vnl_vector<float> p = t.get_column(i);
       itk::Point<float,3> point;
       point[0] = p[0];
       point[1] = p[1];
       point[2] = p[2];
       itk::Index<3> idx;
       m_FilterMask->TransformPhysicalPointToIndex(point, idx);
       if (m_FilterMask->GetLargestPossibleRegion().IsInside(idx) && m_FilterMask->GetPixel(idx)>0)
         overlap += 1;
     }
     overlap /= m_NumPoints;
   }
   else
     return 1.0;
 
   return overlap;
 }
 
 std::vector<vnl_matrix<float> > TractClusteringFilter::ResampleFibers(mitk::FiberBundle::Pointer tractogram)
 {
   mitk::FiberBundle::Pointer temp_fib = tractogram->GetDeepCopy();
   if (m_DoResampling)
     temp_fib->ResampleToNumPoints(m_NumPoints);
 
   std::vector< vnl_matrix<float> > out_fib;
 
   for (int i=0; i<temp_fib->GetFiberPolyData()->GetNumberOfCells(); i++)
   {
     vtkCell* cell = temp_fib->GetFiberPolyData()->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vnl_matrix<float> streamline;
     streamline.set_size(3, m_NumPoints);
     streamline.fill(0.0);
 
     for (int j=0; j<numPoints; j++)
     {
       double cand[3];
       points->GetPoint(j, cand);
 
       vnl_vector_fixed< float, 3 > candV;
       candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
       streamline.set_column(j, candV);
     }
 
     out_fib.push_back(streamline);
   }
 
   return out_fib;
 }
 
 std::vector< TractClusteringFilter::Cluster > TractClusteringFilter::ClusterStep(std::vector< long > f_indices, std::vector<float> distances)
 {
   float dist_thres = distances.back();
   distances.pop_back();
   std::vector< Cluster > C;
 
   int N = f_indices.size();
 
   Cluster c1;
   c1.I.push_back(f_indices.at(0));
   c1.h = T[f_indices.at(0)];
   c1.n = 1;
   C.push_back(c1);
   if (f_indices.size()==1)
     return C;
 
   for (int i=1; i<N; ++i)
   {
     vnl_matrix<float> t = T.at(f_indices.at(i));
 
     int min_cluster_index = -1;
     float min_cluster_distance = 99999;
     bool flip = false;
 
     for (unsigned int k=0; k<C.size(); ++k)
     {
       vnl_matrix<float> v = C.at(k).h / C.at(k).n;
       bool f = false;
       float d = 0;
       for (auto m : m_Metrics)
         d += m->CalculateDistance(t, v, f);
       d /= m_Metrics.size();
 
       if (d<min_cluster_distance)
       {
         min_cluster_distance = d;
         min_cluster_index = k;
         flip = f;
       }
     }
 
     if (min_cluster_index>=0 && min_cluster_distance<dist_thres)
     {
       C[min_cluster_index].I.push_back(f_indices.at(i));
       if (!flip)
         C[min_cluster_index].h += t;
       else
         C[min_cluster_index].h += t.fliplr();
       C[min_cluster_index].n += 1;
     }
     else
     {
       Cluster c;
       c.I.push_back(f_indices.at(i));
       c.h = t;
       c.n = 1;
       C.push_back(c);
     }
   }
 
   if (!distances.empty())
   {
     std::vector< Cluster > outC;
 #pragma omp parallel for
     for (int c=0; c<(int)C.size(); c++)
     {
 
       std::vector< Cluster > tempC = ClusterStep(C.at(c).I, distances);
 #pragma omp critical
       AppendCluster(outC, tempC);
     }
     return outC;
   }
   else
     return C;
 }
 
 void TractClusteringFilter::AppendCluster(std::vector< Cluster >& a, std::vector< Cluster >&b)
 {
   for (auto c : b)
     a.push_back(c);
 }
 
 std::vector< TractClusteringFilter::Cluster > TractClusteringFilter::MergeDuplicateClusters2(std::vector< TractClusteringFilter::Cluster >& clusters)
 {
   if (m_MergeDuplicateThreshold<0)
     m_MergeDuplicateThreshold = m_Distances.at(0)/2;
 
   MITK_INFO << "Merging duplicate clusters with distance threshold " << m_MergeDuplicateThreshold;
 
   std::vector< TractClusteringFilter::Cluster > new_clusters;
   for (Cluster c1 : clusters)
   {
     vnl_matrix<float> t = c1.h / c1.n;
 
     int min_idx = -1;
     float min_d = 99999;
     bool flip = false;
 
 #pragma omp parallel for
-    for (unsigned int k2=0; k2<new_clusters.size(); ++k2)
+    for (int k2=0; k2<(int)new_clusters.size(); ++k2)
     {
       Cluster c2 = new_clusters.at(k2);
       vnl_matrix<float> v = c2.h / c2.n;
 
       bool f = false;
       float d = 0;
       for (auto m : m_Metrics)
         d += m->CalculateDistance(t, v, f);
       d /= m_Metrics.size();
 
 #pragma omp critical
       if (d<min_d && d<m_MergeDuplicateThreshold)
       {
         min_d = d;
         min_idx = k2;
         flip = f;
       }
     }
 
     if (min_idx<0)
       new_clusters.push_back(c1);
     else
     {
       for (int i=0; i<c1.n; ++i)
       {
         new_clusters[min_idx].I.push_back(c1.I.at(i));
         new_clusters[min_idx].n += 1;
       }
       if (!flip)
         new_clusters[min_idx].h += c1.h;
       else
         new_clusters[min_idx].h += c1.h.fliplr();
     }
   }
 
   MITK_INFO << "\nNumber of clusters after merging duplicates: " << new_clusters.size();
   return new_clusters;
 }
 
 void TractClusteringFilter::MergeDuplicateClusters(std::vector< TractClusteringFilter::Cluster >& clusters)
 {
   if (m_MergeDuplicateThreshold<0)
     m_MergeDuplicateThreshold = m_Distances.at(0)/2;
   bool found = true;
 
 
   MITK_INFO << "Merging duplicate clusters with distance threshold " << m_MergeDuplicateThreshold;
   int start = 0;
   while (found && m_MergeDuplicateThreshold>mitk::eps)
   {
     std::cout << "                                                                                                     \r";
     std::cout << "Number of clusters: " << clusters.size() << '\r';
     cout.flush();
 
     found = false;
     for (int k1=start; k1<(int)clusters.size(); ++k1)
     {
       Cluster c1 = clusters.at(k1);
       vnl_matrix<float> t = c1.h / c1.n;
 
       std::vector< int > merge_indices;
       std::vector< bool > flip_indices;
 
 #pragma omp parallel for
       for (int k2=start+1; k2<(int)clusters.size(); ++k2)
       {
         if (k1!=k2)
         {
           Cluster c2 = clusters.at(k2);
           vnl_matrix<float> v = c2.h / c2.n;
           bool f = false;
 
           float d = 0;
           for (auto m : m_Metrics)
             d += m->CalculateDistance(t, v, f);
           d /= m_Metrics.size();
 
 #pragma omp critical
           if (d<m_MergeDuplicateThreshold)
           {
             merge_indices.push_back(k2);
             flip_indices.push_back(f);
           }
         }
       }
 
       for (unsigned int i=0; i<merge_indices.size(); ++i)
       {
         Cluster c2 = clusters.at(merge_indices.at(i));
         for (int i=0; i<c2.n; ++i)
         {
           clusters[k1].I.push_back(c2.I.at(i));
           clusters[k1].n += 1;
         }
         if (!flip_indices.at(i))
           clusters[k1].h += c2.h;
         else
           clusters[k1].h += c2.h.fliplr();
       }
 
       std::sort(merge_indices.begin(), merge_indices.end());
       for (unsigned int i=0; i<merge_indices.size(); ++i)
       {
         clusters.erase (clusters.begin()+merge_indices.at(i)-i);
         found = true;
       }
       if (found)
         break;
     }
     ++start;
   }
   MITK_INFO << "\nNumber of clusters after merging duplicates: " << clusters.size();
 }
 
 std::vector<TractClusteringFilter::Cluster> TractClusteringFilter::AddToKnownClusters(std::vector< long > f_indices, std::vector<vnl_matrix<float> >& centroids)
 {
   float dist_thres = m_Distances.at(0);
   int N = f_indices.size();
 
   std::vector< Cluster > C;
   vnl_matrix<float> zero_h; zero_h.set_size(T.at(0).rows(), T.at(0).cols()); zero_h.fill(0.0);
   Cluster no_fit;
   no_fit.h = zero_h;
 
   for (unsigned int i=0; i<centroids.size(); ++i)
   {
     Cluster c;
     c.h.set_size(T.at(0).rows(), T.at(0).cols()); c.h.fill(0.0);
     c.f_id = i;
     C.push_back(c);
   }
 
 #pragma omp parallel for
   for (int i=0; i<N; ++i)
   {
     vnl_matrix<float> t = T.at(f_indices.at(i));
 
     int min_cluster_index = -1;
     float min_cluster_distance = 99999;
     bool flip = false;
 
     if (CalcOverlap(t)>=m_OverlapThreshold)
     {
       int c_idx = 0;
       for (vnl_matrix<float> centroid : centroids)
       {
         bool f = false;
         float d = 0;
         for (auto m : m_Metrics)
           d += m->CalculateDistance(t, centroid, f);
         d /= m_Metrics.size();
 
         if (d<min_cluster_distance)
         {
           min_cluster_distance = d;
           min_cluster_index = c_idx;
           flip = f;
         }
         ++c_idx;
       }
     }
 
     if (min_cluster_index>=0 && min_cluster_distance<dist_thres)
     {
 #pragma omp critical
       {
         C[min_cluster_index].I.push_back(f_indices.at(i));
         if (!flip)
           C[min_cluster_index].h += t;
         else
           C[min_cluster_index].h += t.fliplr();
         C[min_cluster_index].n += 1;
       }
     }
     else
     {
 #pragma omp critical
       {
         no_fit.I.push_back(f_indices.at(i));
         no_fit.n++;
       }
     }
   }
   C.push_back(no_fit);
   return C;
 }
 
 
 
 void TractClusteringFilter::GenerateData()
 {
   m_OutTractograms.clear();
   m_OutCentroids.clear();
   m_OutClusters.clear();
 
   if (m_Metrics.empty())
   {
     mitkThrow() << "No metric selected!";
     return;
   }
 
   T = ResampleFibers(m_Tractogram);
   if (T.empty())
   {
     MITK_INFO << "No fibers in tractogram!";
     return;
   }
 
   std::vector< long > f_indices;
   for (unsigned int i=0; i<T.size(); ++i)
     f_indices.push_back(i);
   //  std::random_shuffle(f_indices.begin(), f_indices.end());
 
   Cluster no_match;
   std::vector< Cluster > clusters;
   if (m_InCentroids.IsNull())
   {
     MITK_INFO << "Clustering fibers";
     clusters = ClusterStep(f_indices, m_Distances);
     MITK_INFO << "Number of clusters: " << clusters.size();
     clusters = MergeDuplicateClusters2(clusters);
     std::sort(clusters.begin(),clusters.end());
   }
   else
   {
     std::vector<vnl_matrix<float> > centroids = ResampleFibers(m_InCentroids);
     if (centroids.empty())
     {
       MITK_INFO << "No fibers in centroid tractogram!";
       return;
     }
     MITK_INFO << "Clustering with input centroids";
     clusters = AddToKnownClusters(f_indices, centroids);
     no_match = clusters.back();
     clusters.pop_back();
     MITK_INFO << "Number of clusters: " << clusters.size();
     clusters = MergeDuplicateClusters2(clusters);
   }
 
   MITK_INFO << "Clustering finished";
   int max = clusters.size()-1;
   if (m_MaxClusters>0 && clusters.size()-1>m_MaxClusters)
     max = m_MaxClusters;
   int skipped = 0;
   for (int i=clusters.size()-1; i>=0; --i)
   {
     Cluster c = clusters.at(i);
     if ( c.n>=(int)m_MinClusterSize && !(m_MaxClusters>0 && clusters.size()-i>m_MaxClusters) )
     {
       m_OutClusters.push_back(c);
 
       vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
       vtkSmartPointer<vtkPolyData> pTmp = m_Tractogram->GeneratePolyDataByIds(c.I, weights);
       mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
       if (max>0)
         fib->SetFiberWeights((float)i/max);
       m_OutTractograms.push_back(fib);
       m_OutFiberIndices.push_back(c.I);
 
       // create centroid
       vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
       vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       vnl_matrix<float> centroid_points = c.h / c.n;
       for (unsigned int j=0; j<centroid_points.cols(); j++)
       {
         double p[3];
         p[0] = centroid_points.get(0,j);
         p[1] = centroid_points.get(1,j);
         p[2] = centroid_points.get(2,j);
 
         vtkIdType id = vtkNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
       vtkNewCells->InsertNextCell(container);
       polyData->SetPoints(vtkNewPoints);
       polyData->SetLines(vtkNewCells);
       mitk::FiberBundle::Pointer centroid = mitk::FiberBundle::New(polyData);
       centroid->SetFiberColors(255, 255, 255);
       m_OutCentroids.push_back(centroid);
     }
     else
     {
       skipped++;
     }
   }
   MITK_INFO << "Final number of clusters: " << m_OutTractograms.size() << " (discarded " << skipped << " clusters)";
 
   int w = 0;
   for (auto fib : m_OutTractograms)
   {
     if (m_OutTractograms.size()>1)
     {
       fib->SetFiberWeights((float)w/(m_OutTractograms.size()-1));
       m_OutCentroids.at(w)->SetFiberWeights((float)w/(m_OutTractograms.size()-1));
     }
     else
     {
       fib->SetFiberWeights(1);
       m_OutCentroids.at(w)->SetFiberWeights(1);
     }
     fib->ColorFibersByFiberWeights(false, false);
     ++w;
   }
 
   if (no_match.n>0)
   {
     vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
     vtkSmartPointer<vtkPolyData> pTmp = m_Tractogram->GeneratePolyDataByIds(no_match.I, weights);
     mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
     fib->SetFiberColors(0, 0, 0);
     m_OutFiberIndices.push_back(no_match.I);
     m_OutTractograms.push_back(fib);
   }
 }
 
 }
 
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDistanceFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDistanceFilter.cpp
index a86705a7d3..f86b915e05 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDistanceFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDistanceFilter.cpp
@@ -1,189 +1,189 @@
 /*===================================================================
 
 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 "itkTractDistanceFilter.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <vnl/vnl_sparse_matrix.h>
 
 namespace itk{
 
 TractDistanceFilter::TractDistanceFilter()
   : m_NumPoints(12)
   , disp(0)
 {
 
 }
 
 TractDistanceFilter::~TractDistanceFilter()
 {
   for (auto m : m_Metrics)
     delete m;
 }
 
 vnl_matrix<float> TractDistanceFilter::GetAllDistances() const
 {
   return m_AllDistances;
 }
 
 vnl_vector<int> TractDistanceFilter::GetMinIndices() const
 {
   return m_MinIndices;
 }
 
 vnl_vector<float> TractDistanceFilter::GetMinDistances() const
 {
   return m_MinDistances;
 }
 
 void TractDistanceFilter::SetTracts2(const std::vector<FiberBundle::Pointer> &Tracts2)
 {
   m_Tracts2 = Tracts2;
 }
 
 void TractDistanceFilter::SetTracts1(const std::vector<FiberBundle::Pointer> &Tracts1)
 {
   m_Tracts1 = Tracts1;
 }
 
 void TractDistanceFilter::SetMetrics(const std::vector<mitk::ClusteringMetric *> &Metrics)
 {
   m_Metrics = Metrics;
 }
 
 std::vector<vnl_matrix<float> > TractDistanceFilter::ResampleFibers(mitk::FiberBundle::Pointer tractogram)
 {
   std::streambuf *old = cout.rdbuf(); // <-- save
   std::stringstream ss;
   std::cout.rdbuf (ss.rdbuf());       // <-- redirect
   mitk::FiberBundle::Pointer temp_fib = tractogram->GetDeepCopy();
   temp_fib->ResampleToNumPoints(m_NumPoints);
 
   std::vector< vnl_matrix<float> > out_fib;
 
   for (int i=0; i<temp_fib->GetFiberPolyData()->GetNumberOfCells(); i++)
   {
     vtkCell* cell = temp_fib->GetFiberPolyData()->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vnl_matrix<float> streamline;
     streamline.set_size(3, m_NumPoints);
     streamline.fill(0.0);
 
     for (int j=0; j<numPoints; j++)
     {
       double cand[3];
       points->GetPoint(j, cand);
 
       vnl_vector_fixed< float, 3 > candV;
       candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
       streamline.set_column(j, candV);
     }
 
     out_fib.push_back(streamline);
   }
 
   std::cout.rdbuf (old);              // <-- restore
   return out_fib;
 }
 
 float TractDistanceFilter::calc_distance(const std::vector<vnl_matrix<float> >& T1, const std::vector<vnl_matrix<float> >& T2)
 {
   float distance = 0;
   for (auto metric : m_Metrics)
   {
     unsigned int r = 0;
     for (auto f1 : T1)
     {
       unsigned int c = 0;
       float min_d = 99999;
       for (auto f2 : T2)
       {
 #pragma omp critical
         ++disp;
         bool flipped = false;
         float d = metric->CalculateDistance(f1, f2, flipped);
         if (d < min_d)
           min_d = d;
         ++c;
       }
       distance += min_d;
       ++r;
     }
   }
   distance /= (T1.size() *  m_Metrics.size());
   return distance;
 }
 
 void TractDistanceFilter::GenerateData()
 {
   if (m_Metrics.empty())
   {
     mitkThrow() << "No metric selected!";
     return;
   }
 
   m_MinIndices.clear();
   m_MinDistances.clear();
   std::vector<std::vector<vnl_matrix<float>>> T1;
   std::vector<std::vector<vnl_matrix<float>>> T2;
 
   unsigned int num_fibs1 = 0;
   unsigned int num_fibs2 = 0;
   for (auto t : m_Tracts1)
   {
     T1.push_back(ResampleFibers(t));
     num_fibs1 += T1.back().size();
   }
   for (auto t : m_Tracts2)
   {
     T2.push_back(ResampleFibers(t));
     num_fibs2 += T2.back().size();
   }
 
   disp.restart(m_Metrics.size() * num_fibs1 * num_fibs2);
 
   m_AllDistances.set_size(T1.size(), T2.size());
 
   m_MinIndices.set_size(T1.size());
   m_MinDistances.set_size(T1.size());
 
 #pragma omp parallel for
-  for (unsigned int i=0; i<T1.size(); ++i)
+  for (int i=0; i<(int)T1.size(); ++i)
   {
     auto tracto1 = T1.at(i);
     m_MinDistances[i] = 99999;
     for (unsigned int j=0; j<T2.size(); ++j)
     {
       auto tracto2 = T2.at(j);
       float d = calc_distance(tracto1, tracto2);
       m_AllDistances[i][j] = d;
 
       if (d < m_MinDistances[i])
       {
         m_MinDistances[i] = d;
         m_MinIndices[i] = j;
       }
     }
   }
 }
 
 }
 
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.odfpeaks/src/internal/QmitkOdfMaximaExtractionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.odfpeaks/src/internal/QmitkOdfMaximaExtractionView.cpp
index 6990aec704..6c91624318 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.odfpeaks/src/internal/QmitkOdfMaximaExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.odfpeaks/src/internal/QmitkOdfMaximaExtractionView.cpp
@@ -1,380 +1,382 @@
 /*===================================================================
 
 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
 #include <QFileDialog>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkOdfMaximaExtractionView.h"
 
 #include <mitkImageCast.h>
 #include <mitkFiberBundle.h>
 #include <mitkImage.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 #include <itkVectorImage.h>
 #include <itkOdfMaximaExtractionFilter.h>
 #include <itkOdfMaximaExtractionFilter.h>
 #include <itkShCoefficientImageImporter.h>
 #include <itkDiffusionTensorPrincipalDirectionImageFilter.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateIsDWI.h>
 #include <mitkPeakImage.h>
 #include <mitkShImage.h>
 
 // Qt
 #include <QMessageBox>
 
 const std::string QmitkOdfMaximaExtractionView::VIEW_ID = "org.mitk.views.odfmaximaextractionview";
 using namespace mitk;
 
 QmitkOdfMaximaExtractionView::QmitkOdfMaximaExtractionView()
   : m_Controls(nullptr)
 {
 
 }
 
 // Destructor
 QmitkOdfMaximaExtractionView::~QmitkOdfMaximaExtractionView()
 {
 
 }
 
 
 void QmitkOdfMaximaExtractionView::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::QmitkOdfMaximaExtractionViewControls;
     m_Controls->setupUi(parent);
 
     connect((QObject*)m_Controls->m_StartPeakExtractionButton, SIGNAL(clicked()), (QObject*) this, SLOT(StartPeakExtraction()));
     connect((QObject*)m_Controls->m_ImportShCoeffs, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertShCoeffs()));
 
     m_Controls->m_MaskBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ImageBox->SetDataStorage(this->GetDataStorage());
 
-    mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
+    mitk::TNodePredicateDataType<mitk::ShImage>::Pointer isShImage = mitk::TNodePredicateDataType<mitk::ShImage>::New();
+    mitk::TNodePredicateDataType<mitk::TensorImage>::Pointer isTensorImage = mitk::TNodePredicateDataType<mitk::TensorImage>::New();
+
     mitk::NodePredicateNot::Pointer isDwi = mitk::NodePredicateNot::New(mitk::NodePredicateIsDWI::New());
     mitk::NodePredicateNot::Pointer isOdf = mitk::NodePredicateNot::New(mitk::NodePredicateDataType::New("OdfImage"));
     mitk::NodePredicateAnd::Pointer unwanted = mitk::NodePredicateAnd::New(isOdf, isDwi);
     mitk::NodePredicateDimension::Pointer dim3 = mitk::NodePredicateDimension::New(3);
     mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
 
     m_Controls->m_MaskBox->SetPredicate(mitk::NodePredicateAnd::New(mitk::NodePredicateAnd::New(unwanted, dim3), isBinaryPredicate));
-    m_Controls->m_ImageBox->SetPredicate(mitk::NodePredicateAnd::New(mitk::NodePredicateAnd::New(unwanted, isMitkImage), mitk::NodePredicateNot::New(isBinaryPredicate)));
+    m_Controls->m_ImageBox->SetPredicate(mitk::NodePredicateOr::New(isTensorImage, isShImage));
     m_Controls->m_MaskBox->SetZeroEntryText("--");
 
     connect( (QObject*)(m_Controls->m_ImageBox), SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnImageSelectionChanged()) );
 
     m_Controls->m_StartPeakExtractionButton->setVisible(false);
     m_Controls->m_ImportShCoeffs->setVisible(false);
   }
 }
 
 void QmitkOdfMaximaExtractionView::SetFocus()
 {
 }
 
 void QmitkOdfMaximaExtractionView::StartPeakExtraction()
 {
   if (dynamic_cast<TensorImage*>(m_Controls->m_ImageBox->GetSelectedNode()->GetData()) != nullptr)
   {
     StartTensorPeakExtraction(dynamic_cast<TensorImage*>(m_Controls->m_ImageBox->GetSelectedNode()->GetData()));
   }
   else
   {
     StartMaximaExtraction(dynamic_cast<Image*>(m_Controls->m_ImageBox->GetSelectedNode()->GetData()));
   }
 }
 
 template<int shOrder>
 void QmitkOdfMaximaExtractionView::TemplatedConvertShCoeffs(mitk::Image* mitkImg)
 {
   typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
   typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
   CasterType::Pointer caster = CasterType::New();
   caster->SetInput(mitkImg);
   caster->Update();
 
   typename FilterType::Pointer filter = FilterType::New();
   filter->SetInputImage(caster->GetOutput());
   filter->GenerateData();
   typename FilterType::CoefficientImageType::Pointer itkCi = filter->GetCoefficientImage();
 
   {
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::ShImage::New().GetPointer());
     img->InitializeByItk(itkCi.GetPointer());
     img->SetVolume(itkCi->GetBufferPointer());
     DataNode::Pointer node = DataNode::New();
     node->SetData(img);
 
     QString name(m_Controls->m_ImageBox->GetSelectedNode()->GetName().c_str());
     name += "_ShImage_Imported";
     node->SetName(name.toStdString().c_str());
 
     GetDataStorage()->Add(node, m_Controls->m_ImageBox->GetSelectedNode());
   }
 }
 
 void QmitkOdfMaximaExtractionView::ConvertShCoeffs()
 {
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNull())
     return;
 
   Image::Pointer mitkImg = dynamic_cast<Image*>(m_Controls->m_ImageBox->GetSelectedNode()->GetData());
   if (mitkImg->GetDimension() != 4 && mitkImg->GetLargestPossibleRegion().GetSize()[3]<6)
   {
     MITK_INFO << "wrong image type (need 4 dimensions)";
     return;
   }
 
   int nrCoeffs = mitkImg->GetLargestPossibleRegion().GetSize()[3];
   switch (nrCoeffs)
   {
   case 6:
     TemplatedConvertShCoeffs<2>(mitkImg);
     break;
   case 15:
     TemplatedConvertShCoeffs<4>(mitkImg);
     break;
   case 28:
     TemplatedConvertShCoeffs<6>(mitkImg);
     break;
   case 45:
     TemplatedConvertShCoeffs<8>(mitkImg);
     break;
   case 66:
     TemplatedConvertShCoeffs<10>(mitkImg);
     break;
   case 91:
     TemplatedConvertShCoeffs<12>(mitkImg);
     break;
   default :
     QMessageBox::warning(nullptr, "Error", "Only spherical harmonics orders 2-12 are supported.", QMessageBox::Ok);
   }
 }
 
 void QmitkOdfMaximaExtractionView::StartTensorPeakExtraction(mitk::TensorImage* img)
 {
   typedef itk::DiffusionTensorPrincipalDirectionImageFilter< float > MaximaExtractionFilterType;
   MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
   filter->SetUsePolarCoordinates(false);
 
   mitk::BaseGeometry::Pointer geometry;
   try{
     ItkTensorImage::Pointer itkImage = ItkTensorImage::New();
     CastToItkImage(img, itkImage);
     filter->SetInput(itkImage);
     geometry = img->GetGeometry();
   }
   catch (itk::ExceptionObject &e)
   {
     MITK_INFO << "wrong image type: " << e.what();
     QMessageBox::warning(nullptr, "Wrong pixel type", "Could not perform Tensor Principal Direction Extraction due to Image has wrong pixel type.", QMessageBox::Ok);
     return;
   }
 
   if (m_Controls->m_MaskBox->GetSelectedNode().IsNotNull())
   {
     ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
     Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_Controls->m_MaskBox->GetSelectedNode()->GetData());
     CastToItkImage(mitkMaskImg, itkMaskImage);
     filter->SetMaskImage(itkMaskImage);
   }
 
   if (m_Controls->m_NormalizationBox->currentIndex() == 0)
     filter->SetNormalizeVectors(false);
   filter->SetFaThreshold(m_Controls->m_AbsoluteThresholdBox->value());
 
   filter->Update();
 
   MaximaExtractionFilterType::PeakImageType::Pointer itkImg = filter->GetPeakImage();
   mitk::Image::Pointer mitkPeakImage = dynamic_cast<Image*>(PeakImage::New().GetPointer());
   CastToMitkImage(itkImg, mitkPeakImage);
 
   DataNode::Pointer node = DataNode::New();
   node->SetData(mitkPeakImage);
   QString name(m_Controls->m_ImageBox->GetSelectedNode()->GetName().c_str());
   name += "_PrincipalDirection";
   node->SetName(name.toStdString().c_str());
   GetDataStorage()->Add(node, m_Controls->m_ImageBox->GetSelectedNode());
 
   if (m_Controls->m_OutputNumDirectionsBox->isChecked())
   {
     ItkUcharImgType::Pointer numDirImage = filter->GetOutput();
     mitk::Image::Pointer image2 = mitk::Image::New();
     image2->InitializeByItk(numDirImage.GetPointer());
     image2->SetVolume(numDirImage->GetBufferPointer());
     DataNode::Pointer node2 = DataNode::New();
     node2->SetData(image2);
     QString name(m_Controls->m_ImageBox->GetSelectedNode()->GetName().c_str());
     name += "_NumDirections";
     node2->SetName(name.toStdString().c_str());
     GetDataStorage()->Add(node2, m_Controls->m_ImageBox->GetSelectedNode());
   }
 }
 
 template<int shOrder>
 void QmitkOdfMaximaExtractionView::StartMaximaExtraction(Image *image)
 {
   typedef itk::OdfMaximaExtractionFilter< float, shOrder, ODF_SAMPLING_SIZE > MaximaExtractionFilterType;
   typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
   switch (m_Controls->m_ToolkitBox->currentIndex())
   {
   case 0:
     filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
     break;
   case 1:
     filter->SetToolkit(MaximaExtractionFilterType::FSL);
     break;
   default:
     filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
   }
 
   mitk::BaseGeometry::Pointer geometry;
   try{
     typedef ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
     typename CasterType::Pointer caster = CasterType::New();
     caster->SetInput(image);
     caster->Update();
     filter->SetInput(caster->GetOutput());
     geometry = image->GetGeometry();
   }
   catch (itk::ExceptionObject &e)
   {
     MITK_INFO << "wrong image type: " << e.what();
     QMessageBox::warning(nullptr, "Wrong pixel type", "Could not perform Finite Differences Extraction due to Image has wrong pixel type.", QMessageBox::Ok);
     return;
   }
 
   filter->SetAngularThreshold(cos((float)m_Controls->m_AngularThreshold->value()*itk::Math::pi / 180));
   filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
   filter->SetRelativePeakThreshold(m_Controls->m_PeakThresholdBox->value());
   filter->SetAbsolutePeakThreshold(m_Controls->m_AbsoluteThresholdBox->value());
   filter->SetScaleByGfa(m_Controls->m_ScaleByGfaBox->isChecked());
 
   if (m_Controls->m_MaskBox->GetSelectedNode().IsNotNull())
   {
     ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
     Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_Controls->m_MaskBox->GetSelectedNode()->GetData());
     CastToItkImage(mitkMaskImg, itkMaskImage);
     filter->SetMaskImage(itkMaskImage);
   }
 
   switch (m_Controls->m_NormalizationBox->currentIndex())
   {
   case 0:
     filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
     break;
   case 1:
     filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
     break;
   case 2:
     filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
     break;
   }
 
   filter->Update();
 
   typename MaximaExtractionFilterType::PeakImageType::Pointer itkImg = filter->GetPeakImage();
   mitk::Image::Pointer img = dynamic_cast<Image*>(PeakImage::New().GetPointer());
   CastToMitkImage(itkImg, img);
 
   DataNode::Pointer node = DataNode::New();
   node->SetData(img);
   QString name(m_Controls->m_ImageBox->GetSelectedNode()->GetName().c_str());
   name += "_PEAKS";
   node->SetName(name.toStdString().c_str());
   GetDataStorage()->Add(node, m_Controls->m_ImageBox->GetSelectedNode());
 
   if (m_Controls->m_OutputNumDirectionsBox->isChecked())
   {
     ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
     mitk::Image::Pointer image2 = mitk::Image::New();
     CastToMitkImage(numDirImage, image2);
 
     DataNode::Pointer node2 = DataNode::New();
     node2->SetData(image2);
     QString name(m_Controls->m_ImageBox->GetSelectedNode()->GetName().c_str());
     name += "_NUM_DIRECTIONS";
     node2->SetName(name.toStdString().c_str());
     GetDataStorage()->Add(node2, m_Controls->m_ImageBox->GetSelectedNode());
   }
 }
 
 void QmitkOdfMaximaExtractionView::StartMaximaExtraction(Image* img)
 {
   mitk::PixelType pixT = img->GetPixelType();
 
   switch (pixT.GetNumberOfComponents())
   {
   case 6:
     StartMaximaExtraction<2>(img);
     break;
   case 15:
     StartMaximaExtraction<4>(img);
     break;
   case 28:
     StartMaximaExtraction<6>(img);
     break;
   case 45:
     StartMaximaExtraction<8>(img);
     break;
   case 66:
     StartMaximaExtraction<10>(img);
     break;
   case 91:
     StartMaximaExtraction<12>(img);
     break;
   default :
     QMessageBox::warning(nullptr, "Error", "Only spherical harmonics orders 2-12 are supported.", QMessageBox::Ok);
   }
 }
 
 void QmitkOdfMaximaExtractionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer , const QList<mitk::DataNode::Pointer>& nodes)
 {
   (void) nodes;
   this->OnImageSelectionChanged();
 }
 
 void QmitkOdfMaximaExtractionView::OnImageSelectionChanged()
 {
   m_Controls->m_StartPeakExtractionButton->setVisible(false);
   m_Controls->m_ImportShCoeffs->setVisible(false);
 
   mitk::DataNode::Pointer node = m_Controls->m_ImageBox->GetSelectedNode();
   if (node.IsNull())
     return;
 
   Image::Pointer img = dynamic_cast<Image*>(node->GetData());
   if (img->GetDimension()==4)
     m_Controls->m_ImportShCoeffs->setVisible(true);
   else
     m_Controls->m_StartPeakExtractionButton->setVisible(true);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/internal/QmitkQBallReconstructionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/internal/QmitkQBallReconstructionView.cpp
index 95f0309c19..29f47ceda3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/internal/QmitkQBallReconstructionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/internal/QmitkQBallReconstructionView.cpp
@@ -1,874 +1,875 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "QmitkQBallReconstructionView.h"
 
 // qt includes
 #include <QMessageBox>
 
 // itk includes
 #include "itkTimeProbe.h"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "QmitkDataStorageComboBox.h"
 
 #include "itkDiffusionQballReconstructionImageFilter.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
 #include "itkDiffusionMultiShellQballReconstructionImageFilter.h"
 #include "itkVectorContainer.h"
 #include "itkB0ImageExtractionImageFilter.h"
 #include <itkBinaryThresholdImageFilter.h>
 
 #include "mitkOdfImage.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include <mitkImageCast.h>
 #include "mitkDiffusionImagingConfigure.h"
 #include <mitkNodePredicateIsDWI.h>
 
 #include "berryIStructuredSelection.h"
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 #include <mitkShImage.h>
 #include <boost/version.hpp>
 #include <itkShToOdfImageFilter.h>
 #include <mitkImageCast.h>
 
 const std::string QmitkQBallReconstructionView::VIEW_ID = "org.mitk.views.qballreconstruction";
 
 
 typedef float TTensorPixelType;
 
 const int QmitkQBallReconstructionView::nrconvkernels = 252;
 
 
 struct QbrShellSelection
 {
   typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
   typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
   typedef mitk::DiffusionPropertyHelper::BValueMapType                    BValueMapType;
   typedef itk::VectorImage< DiffusionPixelType, 3 >                       ITKDiffusionImageType;
 
   QmitkQBallReconstructionView* m_View;
   mitk::DataNode * m_Node;
   std::string m_NodeName;
 
   std::vector<QCheckBox *> m_CheckBoxes;
   QLabel * m_Label;
 
   mitk::Image * m_Image;
 
   QbrShellSelection(QmitkQBallReconstructionView* view, mitk::DataNode * node)
     : m_View(view),
       m_Node(node),
       m_NodeName(node->GetName())
   {
     m_Image = dynamic_cast<mitk::Image * > (node->GetData());
 
     if(!m_Image)
     {
       MITK_ERROR << "QmitkQBallReconstructionView::QbrShellSelection : no image selected";
       return;
     }
     bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_Node->GetData())) );
 
     if( !isDiffusionImage )
     {
       MITK_ERROR <<
                     "QmitkQBallReconstructionView::QbrShellSelection : selected image contains no diffusion information";
       return;
     }
 
     GenerateCheckboxes();
 
   }
 
   void GenerateCheckboxes()
   {
     BValueMapType origMap = mitk::DiffusionPropertyHelper::GetBValueMap(m_Image);
     BValueMapType::iterator itStart = origMap.begin();
     itStart++;
     BValueMapType::iterator itEnd = origMap.end();
 
     m_Label = new QLabel(m_NodeName.c_str());
     m_Label->setVisible(true);
     m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(m_Label);
 
     for(BValueMapType::iterator it = itStart ; it!= itEnd; it++)
     {
       QCheckBox * box  = new QCheckBox(QString::number(it->first));
       m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(box);
 
       box->setChecked(true);
       box->setCheckable(true);
       // box->setVisible(true);
       m_CheckBoxes.push_back(box);
     }
   }
 
   void SetVisible(bool vis)
   {
     foreach(QCheckBox * box, m_CheckBoxes)
     {
       box->setVisible(vis);
     }
   }
 
   BValueMapType GetBValueSelctionMap()
   {
     BValueMapType inputMap = mitk::DiffusionPropertyHelper::GetBValueMap(m_Image);
     BValueMapType outputMap;
 
     unsigned int val = 0;
 
     if(inputMap.find(0) == inputMap.end()){
       MITK_INFO << "QbrShellSelection: return empty BValueMap from GUI Selection";
       return outputMap;
     }else{
       outputMap[val] = inputMap[val];
       MITK_INFO << val;
     }
 
     foreach(QCheckBox * box, m_CheckBoxes)
     {
       if(box->isChecked()){
         val = box->text().toDouble();
         outputMap[val] = inputMap[val];
         MITK_INFO << val;
       }
     }
 
     return outputMap;
   }
 
   ~QbrShellSelection()
   {
     m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget(m_Label);
     delete m_Label;
 
     for(std::vector<QCheckBox *>::iterator it = m_CheckBoxes.begin() ; it!= m_CheckBoxes.end(); it++)
     {
       m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget((*it));
       delete (*it);
     }
     m_CheckBoxes.clear();
   }
 };
 
 QmitkQBallReconstructionView::QmitkQBallReconstructionView()
   : QmitkAbstractView(),
     m_Controls(nullptr)
 {
 }
 
 QmitkQBallReconstructionView::~QmitkQBallReconstructionView()
 {
 
 }
 
 void QmitkQBallReconstructionView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkQBallReconstructionViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     QStringList items;
     items << "2" << "4" << "6" << "8" << "10" << "12";
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->addItems(items);
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->setCurrentIndex(1);
     MethodChoosen(m_Controls->m_QBallReconstructionMethodComboBox->currentIndex());
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     m_Controls->m_QBallReconstructionMethodComboBox->removeItem(3);
 #endif
 
   }
 }
 
 void QmitkQBallReconstructionView::SetFocus()
 {
 }
 
 void QmitkQBallReconstructionView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_ButtonStandard), SIGNAL(clicked()), this, SLOT(ReconstructStandard()) );
     connect( (QObject*)(m_Controls->m_QBallReconstructionMethodComboBox), SIGNAL(currentIndexChanged(int)), this, SLOT(MethodChoosen(int)) );
     connect( (QObject*)(m_Controls->m_QBallReconstructionThreasholdEdit), SIGNAL(valueChanged(int)), this, SLOT(PreviewThreshold(int)) );
     connect( (QObject*)(m_Controls->m_ConvertButton), SIGNAL(clicked()), this, SLOT(ConvertShImage()) );
 
     m_Controls->m_ImageBox->SetDataStorage(this->GetDataStorage());
     mitk::NodePredicateIsDWI::Pointer isDwi = mitk::NodePredicateIsDWI::New();
     m_Controls->m_ImageBox->SetPredicate( isDwi );
 
     m_Controls->m_ShImageBox->SetDataStorage(this->GetDataStorage());
     mitk::TNodePredicateDataType<mitk::ShImage>::Pointer isSh = mitk::TNodePredicateDataType<mitk::ShImage>::New();
     m_Controls->m_ShImageBox->SetPredicate( isSh );
 
     connect( (QObject*)(m_Controls->m_ImageBox), SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
     connect( (QObject*)(m_Controls->m_ShImageBox), SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
 
     UpdateGui();
   }
 }
 
 template<int ShOrder>
 void QmitkQBallReconstructionView::TemplatedConvertShImage(mitk::ShImage::Pointer mitkImage)
 {
   typedef itk::ShToOdfImageFilter< float, ShOrder > ShConverterType;
 
   typename ShConverterType::InputImageType::Pointer itkvol = ShConverterType::InputImageType::New();
   mitk::CastToItkImage(mitkImage, itkvol);
 
   typename ShConverterType::Pointer converter = ShConverterType::New();
   converter->SetInput(itkvol);
   converter->Update();
 
   mitk::OdfImage::Pointer image = mitk::OdfImage::New();
   image->InitializeByItk( converter->GetOutput() );
   image->SetVolume( converter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   node->SetName(m_Controls->m_ShImageBox->GetSelectedNode()->GetName());
 
   GetDataStorage()->Add(node, m_Controls->m_ShImageBox->GetSelectedNode());
 }
 
 void QmitkQBallReconstructionView::ConvertShImage()
 {
   if (m_Controls->m_ShImageBox->GetSelectedNode().IsNotNull())
   {
     mitk::ShImage::Pointer mitkImg = dynamic_cast<mitk::ShImage*>(m_Controls->m_ShImageBox->GetSelectedNode()->GetData());
     switch (mitkImg->ShOrder())
     {
     case 2:
       TemplatedConvertShImage<2>(mitkImg);
       break;
     case 4:
       TemplatedConvertShImage<4>(mitkImg);
       break;
     case 6:
       TemplatedConvertShImage<6>(mitkImg);
       break;
     case 8:
       TemplatedConvertShImage<8>(mitkImg);
       break;
     case 10:
       TemplatedConvertShImage<10>(mitkImg);
       break;
     case 12:
       TemplatedConvertShImage<12>(mitkImg);
       break;
     default :
       QMessageBox::warning(nullptr, "Error", "Only spherical harmonics orders 2-12 are supported.", QMessageBox::Ok);
     }
   }
 }
 
 void QmitkQBallReconstructionView::UpdateGui()
 {
   m_Controls->m_ButtonStandard->setEnabled(false);
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
   {
     m_Controls->m_ButtonStandard->setEnabled(true);
     GenerateShellSelectionUI(m_Controls->m_ImageBox->GetSelectedNode());
   }
 
   m_Controls->m_ConvertButton->setEnabled(m_Controls->m_ShImageBox->GetSelectedNode().IsNotNull());
 }
 
 void QmitkQBallReconstructionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& /*nodes*/)
 {
   UpdateGui();
 }
 
 void QmitkQBallReconstructionView::Activated()
 {
 }
 
 void QmitkQBallReconstructionView::Deactivated()
 {
 }
 
 void QmitkQBallReconstructionView::Visible()
 {
 }
 
 void QmitkQBallReconstructionView::Hidden()
 {
 }
 
 void QmitkQBallReconstructionView::ReconstructStandard()
 {
   int index = m_Controls->m_QBallReconstructionMethodComboBox->currentIndex();
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
   if(index>=3)
   {
     index = index + 1;
   }
 #endif
 
   switch(index)
   {
   case 0:
   {
     // Numerical
     Reconstruct(0,0);
     break;
   }
   case 1:
   {
     // Standard
     Reconstruct(1,0);
     break;
   }
   case 2:
   {
     // Solid Angle
     Reconstruct(1,6);
     break;
   }
   case 3:
   {
     // Constrained Solid Angle
     Reconstruct(1,7);
     break;
   }
   case 4:
   {
     // ADC
     Reconstruct(1,4);
     break;
   }
   case 5:
   {
     // Raw Signal
     Reconstruct(1,5);
     break;
   }
   case 6:
   {
     // Q-Ball reconstruction
     Reconstruct(2,0);
     break;
   }
   }
 }
 
 void QmitkQBallReconstructionView::MethodChoosen(int method)
 {
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
   if(method>=3)
   {
     method = method + 1;
   }
 #endif
 
   m_Controls->m_QBallSelectionBox->setHidden(true);
   m_Controls->m_OutputCoeffsImage->setHidden(true);
 
   if (method==0)
     m_Controls->m_ShFrame->setVisible(false);
   else
     m_Controls->m_ShFrame->setVisible(true);
 
   switch(method)
   {
   case 0:
     m_Controls->m_Description->setText("Numerical recon. (Tuch 2004)");
     break;
   case 1:
     m_Controls->m_Description->setText("Spherical harmonics recon. (Descoteaux 2007)");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 2:
     m_Controls->m_Description->setText("SH recon. with solid angle consideration (Aganj 2009)");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 3:
     m_Controls->m_Description->setText("SH solid angle with non-neg. constraint (Goh 2009)");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 4:
     m_Controls->m_Description->setText("SH recon. of the plain ADC-profiles");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 5:
     m_Controls->m_Description->setText("SH recon. of the raw diffusion signal");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 6:
     m_Controls->m_Description->setText("SH recon. of the multi shell diffusion signal (Aganj 2010)");
     m_Controls->m_QBallSelectionBox->setHidden(false);
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   }
 }
 
 void QmitkQBallReconstructionView::Reconstruct(int method, int normalization)
 {
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
   {
     if(method == 0)
     {
       NumericalQBallReconstruction(m_Controls->m_ImageBox->GetSelectedNode(), normalization);
     }
     else if(method == 1)
     {
       AnalyticalQBallReconstruction(m_Controls->m_ImageBox->GetSelectedNode(), normalization);
     }
     else if(method == 2)
     {
       MultiQBallReconstruction(m_Controls->m_ImageBox->GetSelectedNode());
     }
   }
 }
 
 void QmitkQBallReconstructionView::NumericalQBallReconstruction(mitk::DataNode::Pointer node, int normalization)
 {
   try
   {
     mitk::Image* vols = static_cast<mitk::Image*>(node->GetData());
 
     std::string nodename = node->GetName();
 
     typedef itk::DiffusionQballReconstructionImageFilter
         <DiffusionPixelType, DiffusionPixelType, TTensorPixelType, ODF_SAMPLING_SIZE>
         QballReconstructionImageFilterType;
 
     ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
     mitk::CastToItkImage(vols, itkVectorImagePointer);
 
     QballReconstructionImageFilterType::Pointer filter = QballReconstructionImageFilterType::New();
     filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(vols));
     filter->SetGradientImage(mitk::DiffusionPropertyHelper::GetGradientContainer(vols), itkVectorImagePointer);
     filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
 
     std::string nodePostfix;
     switch(normalization)
     {
     case 0:
     {
       filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
       nodePostfix = "_Numerical_Qball";
       break;
     }
     case 1:
     {
       filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO_B_VALUE);
       nodePostfix = "_Numerical_ZeroBvalueNormalization_Qball";
       break;
     }
     case 2:
     {
       filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO);
       nodePostfix = "_NumericalQball_ZeroNormalization_Qball";
       break;
     }
     case 3:
     {
       filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_NONE);
       nodePostfix = "_NumericalQball_NoNormalization_Qball";
       break;
     }
     default:
     {
       filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
       nodePostfix = "_NumericalQball_Qball";
     }
     }
 
     filter->Update();
 
     // ODFs TO DATATREE
     mitk::OdfImage::Pointer image = mitk::OdfImage::New();
     image->InitializeByItk( filter->GetOutput() );
     image->SetVolume( filter->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer new_node = mitk::DataNode::New();
     new_node->SetData( image );
     new_node->SetName(nodename+nodePostfix);
     mitk::ProgressBar::GetInstance()->Progress();
 
     GetDataStorage()->Add(new_node, node);
 
     this->GetRenderWindowPart()->RequestUpdate();
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex ;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return ;
   }
 }
 
 void QmitkQBallReconstructionView::AnalyticalQBallReconstruction( mitk::DataNode::Pointer node, int normalization)
 {
   try
   {
     float lambda = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
     switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
     {
     case 0:
     {
       TemplatedAnalyticalQBallReconstruction<2>(node, lambda, normalization);
       break;
     }
     case 1:
     {
       TemplatedAnalyticalQBallReconstruction<4>(node, lambda, normalization);
       break;
     }
     case 2:
     {
       TemplatedAnalyticalQBallReconstruction<6>(node, lambda, normalization);
       break;
     }
     case 3:
     {
       TemplatedAnalyticalQBallReconstruction<8>(node, lambda, normalization);
       break;
     }
     case 4:
     {
       TemplatedAnalyticalQBallReconstruction<10>(node, lambda, normalization);
       break;
     }
     case 5:
     {
       TemplatedAnalyticalQBallReconstruction<12>(node, lambda, normalization);
       break;
     }
     }
 
     this->GetRenderWindowPart()->RequestUpdate();
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return;
   }
 }
 
 template<int L>
 void QmitkQBallReconstructionView::TemplatedAnalyticalQBallReconstruction(mitk::DataNode* dataNodePointer, float lambda, int normalization)
 {
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter
       <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,ODF_SAMPLING_SIZE> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
 
   mitk::Image* vols = dynamic_cast<mitk::Image*>(dataNodePointer->GetData());
 
   ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
   mitk::CastToItkImage(vols, itkVectorImagePointer);
 
   filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(vols));
   filter->SetGradientImage(mitk::DiffusionPropertyHelper::GetGradientContainer(vols), itkVectorImagePointer);
   filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
   filter->SetLambda(lambda);
 
   std::string nodePostfix;
   switch(normalization)
   {
   case 0:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
     nodePostfix = "_SH_Qball";
     break;
   }
   case 1:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO_B_VALUE);
     nodePostfix = "_SH_1_Qball";
     break;
   }
   case 2:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO);
     nodePostfix = "_SH_2_Qball";
     break;
   }
   case 3:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_NONE);
     nodePostfix = "_SH_3_Qball";
     break;
   }
   case 4:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
     nodePostfix = "_AdcProfile";
     break;
   }
   case 5:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
     nodePostfix = "_RawSignal";
     break;
   }
   case 6:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
     nodePostfix = "_SH_CSA_Qball";
     break;
   }
   case 7:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_NONNEG_SOLID_ANGLE);
     nodePostfix = "_SH_NonNegCSA_Qball";
     break;
   }
   default:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
   }
   }
 
   filter->Update();
 
   // ODFs TO DATATREE
   mitk::OdfImage::Pointer image = mitk::OdfImage::New();
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   node->SetName(dataNodePointer->GetName()+nodePostfix);
 
   GetDataStorage()->Add(node, dataNodePointer);
 
   if(m_Controls->m_OutputCoeffsImage->isChecked())
   {
     mitk::Image::Pointer coeffsImage = dynamic_cast<mitk::Image*>(mitk::ShImage::New().GetPointer());
     coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
     coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
 
     mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
     coeffsNode->SetData( coeffsImage );
     coeffsNode->SetProperty( "name", mitk::StringProperty::New(dataNodePointer->GetName()+"_SH-Coeffs") );
     GetDataStorage()->Add(coeffsNode, node);
   }
 }
 
 void QmitkQBallReconstructionView::MultiQBallReconstruction(mitk::DataNode::Pointer node)
 {
   try
   {
     float lambda  = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
     switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
     {
     case 0:
     {
       TemplatedMultiQBallReconstruction<2>(lambda, node);
       break;
     }
     case 1:
     {
       TemplatedMultiQBallReconstruction<4>(lambda, node);
       break;
     }
     case 2:
     {
       TemplatedMultiQBallReconstruction<6>(lambda, node);
       break;
     }
     case 3:
     {
       TemplatedMultiQBallReconstruction<8>(lambda, node);
       break;
     }
     case 4:
     {
       TemplatedMultiQBallReconstruction<10>(lambda, node);
       break;
     }
     case 5:
     {
       TemplatedMultiQBallReconstruction<12>(lambda, node);
       break;
     }
     }
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex ;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return ;
   }
 }
 
 template<int L>
 void QmitkQBallReconstructionView::TemplatedMultiQBallReconstruction(float lambda, mitk::DataNode* dataNodePointer)
 {
   typedef itk::DiffusionMultiShellQballReconstructionImageFilter
       <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,ODF_SAMPLING_SIZE> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
 
   std::string nodename;
   dataNodePointer->GetStringProperty("name",nodename);
 
   mitk::Image* dwi = dynamic_cast<mitk::Image*>(dataNodePointer->GetData());
   BValueMapType currSelectionMap = m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap();
 
   if(currSelectionMap.size() != 4)// || currSelectionMap.find(0) != currSelectionMap.end())
   {
     QMessageBox::information(0, "Reconstruction not possible:" ,QString("Only three equidistant shells are supported. (ImageName: " + QString(nodename.c_str()) + ")"));
     return;
   }
 
   BValueMapType::reverse_iterator it1 = currSelectionMap.rbegin();
   BValueMapType::reverse_iterator it2 = currSelectionMap.rbegin();
   ++it2;
 
   // Get average distance
   int avdistance = 0;
   for(; it2 != currSelectionMap.rend(); ++it1,++it2)
     avdistance += (int)it1->first - (int)it2->first;
   avdistance /= currSelectionMap.size()-1;
 
   // Check if all shells are using the same averae distance
   it1 = currSelectionMap.rbegin();
   it2 = currSelectionMap.rbegin();
   ++it2;
   for(; it2 != currSelectionMap.rend(); ++it1,++it2)
   {
     if(avdistance != (int)it1->first - (int)it2->first)
     {
       QMessageBox::information(0, "Reconstruction not possible:" ,QString("Selected Shells are not in a equidistant configuration. (ImageName: " + QString(nodename.c_str()) + ")"));
       return;
     }
   }
   ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
   mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
   filter->SetBValueMap(m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap());
   filter->SetGradientImage(mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer, mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
   filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
   filter->SetLambda(lambda);
   filter->Update();
 
-  if(m_Controls->m_OutputCoeffsImage->isChecked())
-  {
-    mitk::Image::Pointer coeffsImage = mitk::Image::New();
-    coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
-    coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
-    mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
-    coeffsNode->SetData( coeffsImage );
-    coeffsNode->SetProperty( "name", mitk::StringProperty::New(
-                               QString(nodename.c_str()).append("_SH-Coefficients").toStdString()) );
-    GetDataStorage()->Add(coeffsNode, dataNodePointer);
-  }
 
   // ODFs TO DATATREE
   mitk::OdfImage::Pointer image = mitk::OdfImage::New();
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   node->SetName(nodename+"_SH_MultiShell_Qball");
 
   GetDataStorage()->Add(node, dataNodePointer);
+
+  if(m_Controls->m_OutputCoeffsImage->isChecked())
+  {
+    mitk::Image::Pointer coeffsImage = dynamic_cast<mitk::Image*>(mitk::ShImage::New().GetPointer());
+    coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
+    coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
+
+    mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
+    coeffsNode->SetData( coeffsImage );
+    coeffsNode->SetProperty( "name", mitk::StringProperty::New(dataNodePointer->GetName()+"_SH-Coeffs") );
+    GetDataStorage()->Add(coeffsNode, node);
+  }
 }
 
 void QmitkQBallReconstructionView::GenerateShellSelectionUI(mitk::DataNode::Pointer node)
 {
   std::map<const mitk::DataNode * , QbrShellSelection * > tempMap;
 
   if(m_ShellSelectorMap.find(  node.GetPointer() ) != m_ShellSelectorMap.end())
   {
     tempMap[node.GetPointer()] = m_ShellSelectorMap[node.GetPointer()];
     m_ShellSelectorMap.erase(node.GetPointer());
   }
   else
   {
     tempMap[node.GetPointer()] = new QbrShellSelection(this, node );
     tempMap[node.GetPointer()]->SetVisible(true);
   }
 
   for(std::map<const mitk::DataNode * , QbrShellSelection * >::iterator it = m_ShellSelectorMap.begin(); it != m_ShellSelectorMap.end();it ++)
   {
     delete it->second;
   }
   m_ShellSelectorMap.clear();
   m_ShellSelectorMap = tempMap;
 }
 
 void QmitkQBallReconstructionView::PreviewThreshold(int threshold)
 {
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
   {
     mitk::Image* vols = static_cast<mitk::Image*>(m_Controls->m_ImageBox->GetSelectedNode()->GetData());
 
     // Extract b0 image
     ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
     mitk::CastToItkImage(vols, itkVectorImagePointer);
 
     typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
     FilterType::Pointer filterB0 = FilterType::New();
     filterB0->SetInput( itkVectorImagePointer );
     filterB0->SetDirections(mitk::DiffusionPropertyHelper::GetGradientContainer(vols));
     filterB0->Update();
 
     mitk::Image::Pointer mitkImage = mitk::Image::New();
 
     typedef itk::Image<short, 3> ImageType;
     typedef itk::Image<short, 3> SegmentationType;
     typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
     // apply threshold
     ThresholdFilterType::Pointer filterThreshold = ThresholdFilterType::New();
     filterThreshold->SetInput(filterB0->GetOutput());
     filterThreshold->SetLowerThreshold(threshold);
     filterThreshold->SetInsideValue(0);
     filterThreshold->SetOutsideValue(1); // mark cut off values red
     filterThreshold->Update();
 
     mitkImage->InitializeByItk( filterThreshold->GetOutput() );
     mitkImage->SetVolume( filterThreshold->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer node;
     if (this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", m_Controls->m_ImageBox->GetSelectedNode()))
     {
       node = this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", m_Controls->m_ImageBox->GetSelectedNode());
     }
     else
     {
       // create a new node, to show thresholded values
       node = mitk::DataNode::New();
       GetDataStorage()->Add( node, m_Controls->m_ImageBox->GetSelectedNode() );
       node->SetProperty( "name", mitk::StringProperty::New("ThresholdOverlay"));
       node->SetBoolProperty("helper object", true);
     }
     node->SetData( mitkImage );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/QmitkDiffusionImagingAppWorkbenchAdvisor.cpp b/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/QmitkDiffusionImagingAppWorkbenchAdvisor.cpp
index 417146690b..e1b61e6b0b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/QmitkDiffusionImagingAppWorkbenchAdvisor.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/QmitkDiffusionImagingAppWorkbenchAdvisor.cpp
@@ -1,99 +1,99 @@
 /*===================================================================
 
 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 "QmitkDiffusionImagingAppWorkbenchAdvisor.h"
 
 #include "internal/QmitkDiffusionApplicationPlugin.h"
 
 #include <berryPlatform.h>
 #include <berryIPreferencesService.h>
 #include <berryWorkbenchPreferenceConstants.h>
 #include <QmitkExtWorkbenchWindowAdvisor.h>
 
 #include <QApplication>
 #include <QPoint>
 #include <QRect>
 #include <QDesktopWidget>
 
 const QString QmitkDiffusionImagingAppWorkbenchAdvisor::WELCOME_PERSPECTIVE_ID = "org.mitk.diffusionimagingapp.perspectives.welcome";
 
 
 class QmitkDiffusionImagingAppWorkbenchWindowAdvisor : public QmitkExtWorkbenchWindowAdvisor
 {
 
 public:
 
   QmitkDiffusionImagingAppWorkbenchWindowAdvisor(berry::WorkbenchAdvisor* wbAdvisor,
                                                  berry::IWorkbenchWindowConfigurer::Pointer configurer)
     : QmitkExtWorkbenchWindowAdvisor(wbAdvisor, configurer)
   {
 
   }
 
   void PostWindowOpen() override
   {
     QmitkExtWorkbenchWindowAdvisor::PostWindowOpen();
     berry::IWorkbenchWindowConfigurer::Pointer configurer = GetWindowConfigurer();
     configurer->GetWindow()->GetWorkbench()->GetIntroManager()->ShowIntro(configurer->GetWindow(), false);
   }
 
 };
 
 void
 QmitkDiffusionImagingAppWorkbenchAdvisor::Initialize(berry::IWorkbenchConfigurer::Pointer configurer)
 {
   berry::QtWorkbenchAdvisor::Initialize(configurer);
 
   configurer->SetSaveAndRestore(true);
 
 }
 
 berry::WorkbenchWindowAdvisor*
 QmitkDiffusionImagingAppWorkbenchAdvisor::CreateWorkbenchWindowAdvisor(
     berry::IWorkbenchWindowConfigurer::Pointer configurer)
 {
   QList<QString> perspExcludeList;
   perspExcludeList.push_back( "org.blueberry.uitest.util.EmptyPerspective" );
   perspExcludeList.push_back( "org.blueberry.uitest.util.EmptyPerspective2" );
   perspExcludeList.push_back("org.blueberry.perspectives.help");
 
   QList<QString> viewExcludeList;
   viewExcludeList.push_back( "org.mitk.views.controlvisualizationpropertiesview" );
   viewExcludeList.push_back( "org.mitk.views.modules" );
 
   //QRect rec = QApplication::desktop()->screenGeometry();
   //configurer->SetInitialSize(QPoint(rec.width(),rec.height()));
 
   QmitkDiffusionImagingAppWorkbenchWindowAdvisor* advisor = new QmitkDiffusionImagingAppWorkbenchWindowAdvisor(this, configurer);
   advisor->ShowViewMenuItem(true);
   advisor->ShowNewWindowMenuItem(true);
   advisor->ShowClosePerspectiveMenuItem(true);
   advisor->SetPerspectiveExcludeList(perspExcludeList);
   advisor->SetViewExcludeList(viewExcludeList);
   advisor->ShowViewToolbar(false);
   advisor->ShowPerspectiveToolbar(true);
   advisor->ShowVersionInfo(false);
-  advisor->ShowMitkVersionInfo(false);
+  advisor->ShowMitkVersionInfo(true);
   advisor->ShowMemoryIndicator(false);
   advisor->SetProductName("MITK Diffusion");
   advisor->SetWindowIcon(":/org.mitk.gui.qt.diffusionimagingapp/app-icon.png");
   return advisor;
 }
 
 QString QmitkDiffusionImagingAppWorkbenchAdvisor::GetInitialWindowPerspectiveId()
 {
   return WELCOME_PERSPECTIVE_ID;
 }