diff --git a/Modules/Core/src/DataManagement/mitkImageStatisticsHolder.cpp b/Modules/Core/src/DataManagement/mitkImageStatisticsHolder.cpp
index fffc5876b3..94a091a26d 100644
--- a/Modules/Core/src/DataManagement/mitkImageStatisticsHolder.cpp
+++ b/Modules/Core/src/DataManagement/mitkImageStatisticsHolder.cpp
@@ -1,390 +1,351 @@
 /*===================================================================
 
 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 "mitkImageStatisticsHolder.h"
 
 #include "mitkHistogramGenerator.h"
-//#include "mitkImageTimeSelector.h"
 #include <mitkProperties.h>
 
 mitk::ImageStatisticsHolder::ImageStatisticsHolder(mitk::Image *image)
-  : m_Image(image) /*, m_TimeSelectorForExtremaObject(nullptr)*/
+  : m_Image(image)
 {
   m_CountOfMinValuedVoxels.resize(1, 0);
   m_CountOfMaxValuedVoxels.resize(1, 0);
   m_ScalarMin.resize(1, itk::NumericTraits<ScalarType>::max());
   m_ScalarMax.resize(1, itk::NumericTraits<ScalarType>::NonpositiveMin());
   m_Scalar2ndMin.resize(1, itk::NumericTraits<ScalarType>::max());
   m_Scalar2ndMax.resize(1, itk::NumericTraits<ScalarType>::NonpositiveMin());
 
   mitk::HistogramGenerator::Pointer generator = mitk::HistogramGenerator::New();
   m_HistogramGeneratorObject = generator;
-
-  // m_Image = image;
-
-  // create time selector
-  // this->GetTimeSelector();
 }
 
 mitk::ImageStatisticsHolder::~ImageStatisticsHolder()
 {
   m_HistogramGeneratorObject = nullptr;
-  // m_TimeSelectorForExtremaObject = nullptr;
-  // m_Image = nullptr;
 }
 
 const mitk::ImageStatisticsHolder::HistogramType *mitk::ImageStatisticsHolder::GetScalarHistogram(
   int t, unsigned int /*component*/)
 {
   mitk::ImageTimeSelector *timeSelector = this->GetTimeSelector();
   if (timeSelector != nullptr)
   {
     timeSelector->SetTimeNr(t);
     timeSelector->UpdateLargestPossibleRegion();
 
     auto *generator =
       static_cast<mitk::HistogramGenerator *>(m_HistogramGeneratorObject.GetPointer());
     generator->SetImage(timeSelector->GetOutput());
     generator->ComputeHistogram();
     return static_cast<const mitk::ImageStatisticsHolder::HistogramType *>(generator->GetHistogram());
   }
   return nullptr;
 }
 
 bool mitk::ImageStatisticsHolder::IsValidTimeStep(int t) const
 {
   return m_Image->IsValidTimeStep(t);
 }
 
 mitk::ImageTimeSelector::Pointer mitk::ImageStatisticsHolder::GetTimeSelector()
 {
-  // if(m_TimeSelectorForExtremaObject.IsNull())
-  //{
-  //  m_TimeSelectorForExtremaObject = ImageTimeSelector::New();
-
   ImageTimeSelector::Pointer timeSelector =
-    ImageTimeSelector::New(); // static_cast<mitk::ImageTimeSelector*>( m_TimeSelectorForExtremaObject.GetPointer() );
+    ImageTimeSelector::New();
   timeSelector->SetInput(m_Image);
-  //}
 
-  return timeSelector; // static_cast<ImageTimeSelector*>( m_TimeSelectorForExtremaObject.GetPointer() );
+  return timeSelector;
 }
 
 void mitk::ImageStatisticsHolder::Expand(unsigned int timeSteps)
 {
   if (!m_Image->IsValidTimeStep(timeSteps - 1))
     return;
 
   // The BaseData needs to be expanded, call the mitk::Image::Expand() method
   m_Image->Expand(timeSteps);
 
   if (timeSteps > m_ScalarMin.size())
   {
     m_ScalarMin.resize(timeSteps, itk::NumericTraits<ScalarType>::max());
     m_ScalarMax.resize(timeSteps, itk::NumericTraits<ScalarType>::NonpositiveMin());
     m_Scalar2ndMin.resize(timeSteps, itk::NumericTraits<ScalarType>::max());
     m_Scalar2ndMax.resize(timeSteps, itk::NumericTraits<ScalarType>::NonpositiveMin());
     m_CountOfMinValuedVoxels.resize(timeSteps, 0);
     m_CountOfMaxValuedVoxels.resize(timeSteps, 0);
   }
 }
 
 void mitk::ImageStatisticsHolder::ResetImageStatistics()
 {
   m_ScalarMin.assign(1, itk::NumericTraits<ScalarType>::max());
   m_ScalarMax.assign(1, itk::NumericTraits<ScalarType>::NonpositiveMin());
   m_Scalar2ndMin.assign(1, itk::NumericTraits<ScalarType>::max());
   m_Scalar2ndMax.assign(1, itk::NumericTraits<ScalarType>::NonpositiveMin());
   m_CountOfMinValuedVoxels.assign(1, 0);
   m_CountOfMaxValuedVoxels.assign(1, 0);
 }
 
 #include "mitkImageAccessByItk.h"
 
 //#define BOUNDINGOBJECT_IGNORE
 
 template <typename ItkImageType>
 void mitk::_ComputeExtremaInItkImage(const ItkImageType *itkImage, mitk::ImageStatisticsHolder *statisticsHolder, int t)
 {
   typename ItkImageType::RegionType region;
   region = itkImage->GetBufferedRegion();
   if (region.Crop(itkImage->GetRequestedRegion()) == false)
     return;
   if (region != itkImage->GetRequestedRegion())
     return;
 
   itk::ImageRegionConstIterator<ItkImageType> it(itkImage, region);
   typedef typename ItkImageType::PixelType TPixel;
   TPixel value = 0;
 
   if (statisticsHolder == nullptr || !statisticsHolder->IsValidTimeStep(t))
     return;
   statisticsHolder->Expand(t + 1); // make sure we have initialized all arrays
   statisticsHolder->m_CountOfMinValuedVoxels[t] = 0;
   statisticsHolder->m_CountOfMaxValuedVoxels[t] = 0;
 
   statisticsHolder->m_Scalar2ndMin[t] = statisticsHolder->m_ScalarMin[t] = itk::NumericTraits<ScalarType>::max();
   statisticsHolder->m_Scalar2ndMax[t] = statisticsHolder->m_ScalarMax[t] =
     itk::NumericTraits<ScalarType>::NonpositiveMin();
 
   while (!it.IsAtEnd())
   {
     value = it.Get();
-//  if ( (value > mitkImage->m_ScalarMin) && (value < mitkImage->m_Scalar2ndMin) )        mitkImage->m_Scalar2ndMin =
-//  value;
-//  else if ( (value < mitkImage->m_ScalarMax) && (value > mitkImage->m_Scalar2ndMax) )   mitkImage->m_Scalar2ndMax =
-//  value;
-//  else if (value > mitkImage->m_ScalarMax)                                              mitkImage->m_ScalarMax =
-//  value;
-//  else if (value < mitkImage->m_ScalarMin)                                              mitkImage->m_ScalarMin =
-//  value;
-
-// if numbers start with 2ndMin or 2ndMax and never have that value again, the previous above logic failed
 #ifdef BOUNDINGOBJECT_IGNORE
     if (value > -32765)
     {
 #endif
       // update min
       if (value < statisticsHolder->m_ScalarMin[t])
       {
         statisticsHolder->m_Scalar2ndMin[t] = statisticsHolder->m_ScalarMin[t];
         statisticsHolder->m_ScalarMin[t] = value;
         statisticsHolder->m_CountOfMinValuedVoxels[t] = 1;
       }
       else if (value == statisticsHolder->m_ScalarMin[t])
       {
         ++statisticsHolder->m_CountOfMinValuedVoxels[t];
       }
       else if (value < statisticsHolder->m_Scalar2ndMin[t])
       {
         statisticsHolder->m_Scalar2ndMin[t] = value;
       }
 
       // update max
       if (value > statisticsHolder->m_ScalarMax[t])
       {
         statisticsHolder->m_Scalar2ndMax[t] = statisticsHolder->m_ScalarMax[t];
         statisticsHolder->m_ScalarMax[t] = value;
         statisticsHolder->m_CountOfMaxValuedVoxels[t] = 1;
       }
       else if (value == statisticsHolder->m_ScalarMax[t])
       {
         ++statisticsHolder->m_CountOfMaxValuedVoxels[t];
       }
       else if (value > statisticsHolder->m_Scalar2ndMax[t])
       {
         statisticsHolder->m_Scalar2ndMax[t] = value;
       }
 #ifdef BOUNDINGOBJECT_IGNORE
     }
 #endif
 
     ++it;
   }
 
   //// guard for wrong 2dMin/Max on single constant value images
   if (statisticsHolder->m_ScalarMax[t] == statisticsHolder->m_ScalarMin[t])
   {
     statisticsHolder->m_Scalar2ndMax[t] = statisticsHolder->m_Scalar2ndMin[t] = statisticsHolder->m_ScalarMax[t];
   }
   statisticsHolder->m_LastRecomputeTimeStamp.Modified();
-  // MITK_DEBUG <<"extrema "<<itk::NumericTraits<TPixel>::NonpositiveMin()<<" "<<mitkImage->m_ScalarMin<<"
-  // "<<mitkImage->m_Scalar2ndMin<<" "<<mitkImage->m_Scalar2ndMax<<" "<<mitkImage->m_ScalarMax<<"
-  // "<<itk::NumericTraits<TPixel>::max();
 }
 
 template <typename ItkImageType>
 void mitk::_ComputeExtremaInItkVectorImage(const ItkImageType *itkImage,
                                            mitk::ImageStatisticsHolder *statisticsHolder,
                                            int t,
                                            unsigned int component)
 {
   typename ItkImageType::RegionType region;
   region = itkImage->GetBufferedRegion();
   if (region.Crop(itkImage->GetRequestedRegion()) == false)
     return;
   if (region != itkImage->GetRequestedRegion())
     return;
 
   itk::ImageRegionConstIterator<ItkImageType> it(itkImage, region);
 
   if (statisticsHolder == nullptr || !statisticsHolder->IsValidTimeStep(t))
     return;
   statisticsHolder->Expand(t + 1); // make sure we have initialized all arrays
   statisticsHolder->m_CountOfMinValuedVoxels[t] = 0;
   statisticsHolder->m_CountOfMaxValuedVoxels[t] = 0;
 
   statisticsHolder->m_Scalar2ndMin[t] = statisticsHolder->m_ScalarMin[t] = itk::NumericTraits<ScalarType>::max();
   statisticsHolder->m_Scalar2ndMax[t] = statisticsHolder->m_ScalarMax[t] =
     itk::NumericTraits<ScalarType>::NonpositiveMin();
 
   while (!it.IsAtEnd())
   {
     double value = it.Get()[component];
-//  if ( (value > mitkImage->m_ScalarMin) && (value < mitkImage->m_Scalar2ndMin) )        mitkImage->m_Scalar2ndMin =
-//  value;
-//  else if ( (value < mitkImage->m_ScalarMax) && (value > mitkImage->m_Scalar2ndMax) )   mitkImage->m_Scalar2ndMax =
-//  value;
-//  else if (value > mitkImage->m_ScalarMax)                                              mitkImage->m_ScalarMax =
-//  value;
-//  else if (value < mitkImage->m_ScalarMin)                                              mitkImage->m_ScalarMin =
-//  value;
-
-// if numbers start with 2ndMin or 2ndMax and never have that value again, the previous above logic failed
 #ifdef BOUNDINGOBJECT_IGNORE
     if (value > -32765)
     {
 #endif
       // update min
       if (value < statisticsHolder->m_ScalarMin[t])
       {
         statisticsHolder->m_Scalar2ndMin[t] = statisticsHolder->m_ScalarMin[t];
         statisticsHolder->m_ScalarMin[t] = value;
         statisticsHolder->m_CountOfMinValuedVoxels[t] = 1;
       }
       else if (value == statisticsHolder->m_ScalarMin[t])
       {
         ++statisticsHolder->m_CountOfMinValuedVoxels[t];
       }
       else if (value < statisticsHolder->m_Scalar2ndMin[t])
       {
         statisticsHolder->m_Scalar2ndMin[t] = value;
       }
 
       // update max
       if (value > statisticsHolder->m_ScalarMax[t])
       {
         statisticsHolder->m_Scalar2ndMax[t] = statisticsHolder->m_ScalarMax[t];
         statisticsHolder->m_ScalarMax[t] = value;
         statisticsHolder->m_CountOfMaxValuedVoxels[t] = 1;
       }
       else if (value == statisticsHolder->m_ScalarMax[t])
       {
         ++statisticsHolder->m_CountOfMaxValuedVoxels[t];
       }
       else if (value > statisticsHolder->m_Scalar2ndMax[t])
       {
         statisticsHolder->m_Scalar2ndMax[t] = value;
       }
 #ifdef BOUNDINGOBJECT_IGNORE
     }
 #endif
 
     ++it;
   }
 
   //// guard for wrong 2dMin/Max on single constant value images
   if (statisticsHolder->m_ScalarMax[t] == statisticsHolder->m_ScalarMin[t])
   {
     statisticsHolder->m_Scalar2ndMax[t] = statisticsHolder->m_Scalar2ndMin[t] = statisticsHolder->m_ScalarMax[t];
   }
   statisticsHolder->m_LastRecomputeTimeStamp.Modified();
-  // MITK_DEBUG <<"extrema "<<itk::NumericTraits<TPixel>::NonpositiveMin()<<" "<<mitkImage->m_ScalarMin<<"
-  // "<<mitkImage->m_Scalar2ndMin<<" "<<mitkImage->m_Scalar2ndMax<<" "<<mitkImage->m_ScalarMax<<"
-  // "<<itk::NumericTraits<TPixel>::max();
 }
 
 void mitk::ImageStatisticsHolder::ComputeImageStatistics(int t, unsigned int component)
 {
   // timestep valid?
   if (!m_Image->IsValidTimeStep(t))
     return;
 
   // image modified?
   if (this->m_Image->GetMTime() > m_LastRecomputeTimeStamp.GetMTime())
     this->ResetImageStatistics();
 
   Expand(t + 1);
 
   // do we have valid information already?
   if (m_ScalarMin[t] != itk::NumericTraits<ScalarType>::max() ||
       m_Scalar2ndMin[t] != itk::NumericTraits<ScalarType>::max())
     return; // Values already calculated before...
 
   // used to avoid statistics calculation on Odf images. property will be replaced as soons as bug 17928 is merged and
   // the diffusion image refactoring is complete.
   mitk::BoolProperty *isSh = dynamic_cast<mitk::BoolProperty *>(m_Image->GetProperty("IsShImage").GetPointer());
   mitk::BoolProperty *isOdf = dynamic_cast<mitk::BoolProperty *>(m_Image->GetProperty("IsOdfImage").GetPointer());
   const mitk::PixelType pType = m_Image->GetPixelType(0);
   if (pType.GetNumberOfComponents() == 1 && (pType.GetPixelType() != itk::ImageIOBase::UNKNOWNPIXELTYPE) &&
       (pType.GetPixelType() != itk::ImageIOBase::VECTOR))
   {
     // recompute
     mitk::ImageTimeSelector::Pointer timeSelector = this->GetTimeSelector();
     if (timeSelector.IsNotNull())
     {
       timeSelector->SetTimeNr(t);
       timeSelector->UpdateLargestPossibleRegion();
       const mitk::Image *image = timeSelector->GetOutput();
       AccessByItk_2(image, _ComputeExtremaInItkImage, this, t);
     }
   }
   else if (pType.GetPixelType() == itk::ImageIOBase::VECTOR &&
            (!isOdf || !isOdf->GetValue()) && (!isSh || !isSh->GetValue())) // we have a vector image
   {
     // recompute
     mitk::ImageTimeSelector::Pointer timeSelector = this->GetTimeSelector();
     if (timeSelector.IsNotNull())
     {
       timeSelector->SetTimeNr(t);
       timeSelector->UpdateLargestPossibleRegion();
       const mitk::Image *image = timeSelector->GetOutput();
       AccessVectorPixelTypeByItk_n(image, _ComputeExtremaInItkVectorImage, (this, t, component));
     }
   }
   else
   {
     m_ScalarMin[t] = 0;
     m_ScalarMax[t] = 255;
     m_Scalar2ndMin[t] = 0;
     m_Scalar2ndMax[t] = 255;
   }
 }
 
 mitk::ScalarType mitk::ImageStatisticsHolder::GetScalarValueMin(int t, unsigned int component)
 {
   ComputeImageStatistics(t, component);
   return m_ScalarMin[t];
 }
 
 mitk::ScalarType mitk::ImageStatisticsHolder::GetScalarValueMax(int t, unsigned int component)
 {
   ComputeImageStatistics(t, component);
   return m_ScalarMax[t];
 }
 
 mitk::ScalarType mitk::ImageStatisticsHolder::GetScalarValue2ndMin(int t, unsigned int component)
 {
   ComputeImageStatistics(t, component);
   return m_Scalar2ndMin[t];
 }
 
 mitk::ScalarType mitk::ImageStatisticsHolder::GetScalarValue2ndMax(int t, unsigned int component)
 {
   ComputeImageStatistics(t, component);
   return m_Scalar2ndMax[t];
 }
 
 mitk::ScalarType mitk::ImageStatisticsHolder::GetCountOfMinValuedVoxels(int t, unsigned int component)
 {
   ComputeImageStatistics(t, component);
   return m_CountOfMinValuedVoxels[t];
 }
 
 mitk::ScalarType mitk::ImageStatisticsHolder::GetCountOfMaxValuedVoxels(int t, unsigned int component)
 {
   ComputeImageStatistics(t, component);
   return m_CountOfMaxValuedVoxels[t];
 }
diff --git a/Modules/Core/src/DataManagement/mitkLevelWindow.cpp b/Modules/Core/src/DataManagement/mitkLevelWindow.cpp
index 96566b2d9c..8e9ac8a779 100644
--- a/Modules/Core/src/DataManagement/mitkLevelWindow.cpp
+++ b/Modules/Core/src/DataManagement/mitkLevelWindow.cpp
@@ -1,520 +1,511 @@
 /*===================================================================
 
 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 "mitkLevelWindow.h"
 #include "mitkImage.h"
 #include "mitkImageSliceSelector.h"
 #include "mitkImageStatisticsHolder.h"
 
 #include <algorithm>
 
 void mitk::LevelWindow::EnsureConsistency()
 {
   // Check if total range is ok
   {
     if (m_RangeMin > m_RangeMax)
       std::swap(m_RangeMin, m_RangeMax);
     if (m_RangeMin == m_RangeMax)
       m_RangeMin = m_RangeMax - 1;
   }
 
   // Check if current window is ok
   {
     if (m_LowerWindowBound > m_UpperWindowBound)
       std::swap(m_LowerWindowBound, m_UpperWindowBound);
 
     if (m_LowerWindowBound <= m_RangeMin)
       m_LowerWindowBound = m_RangeMin;
     if (m_UpperWindowBound <= m_RangeMin)
       m_UpperWindowBound = m_RangeMin + 1;
     if (m_LowerWindowBound >= m_RangeMax)
       m_LowerWindowBound = m_RangeMax - 1;
     if (m_UpperWindowBound >= m_RangeMax)
       m_UpperWindowBound = m_RangeMax;
 
     if (m_LowerWindowBound == m_UpperWindowBound)
     {
       m_UpperWindowBound += 0.5;
       m_LowerWindowBound -= 0.5;
 
       m_UpperWindowBound = std::min(m_UpperWindowBound, m_RangeMax);
       m_LowerWindowBound = std::max(m_LowerWindowBound, m_RangeMin);
     }
   }
 }
 
 mitk::LevelWindow::LevelWindow(mitk::ScalarType level, mitk::ScalarType window)
   : m_LowerWindowBound(level - window / 2.0),
     m_UpperWindowBound(level + window / 2.0),
     m_RangeMin(-2048.0),
     m_RangeMax(4096.0),
     m_DefaultLowerBound(-2048.0),
     m_DefaultUpperBound(4096.0),
     m_IsFloatingImage(false),
     m_Fixed(false)
 {
   SetDefaultLevelWindow(level, window);
   SetLevelWindow(level, window, true);
 }
 
 mitk::LevelWindow::LevelWindow(const mitk::LevelWindow &levWin)
   : m_LowerWindowBound(levWin.GetLowerWindowBound()),
     m_UpperWindowBound(levWin.GetUpperWindowBound()),
     m_RangeMin(levWin.GetRangeMin()),
     m_RangeMax(levWin.GetRangeMax()),
     m_DefaultLowerBound(levWin.GetDefaultLowerBound()),
     m_DefaultUpperBound(levWin.GetDefaultUpperBound()),
     m_IsFloatingImage(levWin.IsFloatingValues()),
     m_Fixed(levWin.GetFixed())
 {
 }
 
 mitk::LevelWindow::~LevelWindow()
 {
 }
 
 mitk::ScalarType mitk::LevelWindow::GetLevel() const
 {
   return (m_UpperWindowBound - m_LowerWindowBound) / 2.0 + m_LowerWindowBound;
 }
 
 mitk::ScalarType mitk::LevelWindow::GetWindow() const
 {
   return (m_UpperWindowBound - m_LowerWindowBound);
 }
 
 mitk::ScalarType mitk::LevelWindow::GetDefaultLevel() const
 {
   return ((m_DefaultUpperBound + m_DefaultLowerBound) / 2.0);
 }
 
 mitk::ScalarType mitk::LevelWindow::GetDefaultWindow() const
 {
   return ((m_DefaultUpperBound - m_DefaultLowerBound));
 }
 
 void mitk::LevelWindow::ResetDefaultLevelWindow()
 {
   SetLevelWindow(GetDefaultLevel(), GetDefaultWindow());
 }
 
 mitk::ScalarType mitk::LevelWindow::GetLowerWindowBound() const
 {
   return m_LowerWindowBound;
 }
 
 mitk::ScalarType mitk::LevelWindow::GetUpperWindowBound() const
 {
   return m_UpperWindowBound;
 }
 
 void mitk::LevelWindow::SetDefaultLevelWindow(mitk::ScalarType level, mitk::ScalarType window)
 {
   SetDefaultBoundaries((level - (window / 2.0)), (level + (window / 2.0)));
 }
 
 void mitk::LevelWindow::SetLevelWindow(mitk::ScalarType level, mitk::ScalarType window, bool expandRangesIfNecessary)
 {
   SetWindowBounds((level - (window / 2.0)), (level + (window / 2.0)), expandRangesIfNecessary);
 }
 
 void mitk::LevelWindow::SetWindowBounds(mitk::ScalarType lowerBound,
                                         mitk::ScalarType upperBound,
                                         bool expandRangesIfNecessary)
 {
   if (IsFixed())
     return;
 
   m_LowerWindowBound = lowerBound;
   m_UpperWindowBound = upperBound;
 
   if (expandRangesIfNecessary)
   {
     /* if caller is sure he wants exactly that level/window, we make sure the limits match */
     if (m_LowerWindowBound > m_UpperWindowBound)
       std::swap(m_LowerWindowBound, m_UpperWindowBound);
     if (m_LowerWindowBound < m_RangeMin)
     {
       m_RangeMin = m_LowerWindowBound;
     }
 
     if (m_UpperWindowBound > m_RangeMax)
     {
       m_RangeMax = m_UpperWindowBound;
     }
   }
 
   EnsureConsistency();
 }
 
 void mitk::LevelWindow::SetRangeMinMax(mitk::ScalarType min, mitk::ScalarType max)
 {
   if (IsFixed())
     return;
   m_RangeMin = min;
   m_RangeMax = max;
   EnsureConsistency();
 }
 
 void mitk::LevelWindow::SetDefaultBoundaries(mitk::ScalarType low, mitk::ScalarType up)
 {
   if (IsFixed())
     return;
   m_DefaultLowerBound = low;
   m_DefaultUpperBound = up;
   // Check if default window is ok
   {
     if (m_DefaultLowerBound > m_DefaultUpperBound)
       std::swap(m_DefaultLowerBound, m_DefaultUpperBound);
 
     if (m_DefaultLowerBound == m_DefaultUpperBound)
       m_DefaultLowerBound--;
   }
   EnsureConsistency();
 }
 
 void mitk::LevelWindow::SetToMaxWindowSize()
 {
   SetWindowBounds(m_RangeMin, m_RangeMax);
 }
 
 mitk::ScalarType mitk::LevelWindow::GetRangeMin() const
 {
   return m_RangeMin;
 }
 
 mitk::ScalarType mitk::LevelWindow::GetRangeMax() const
 {
   return m_RangeMax;
 }
 
 mitk::ScalarType mitk::LevelWindow::GetRange() const
 {
   return m_RangeMax - m_RangeMin;
 }
 
 mitk::ScalarType mitk::LevelWindow::GetDefaultUpperBound() const
 {
   return m_DefaultUpperBound;
 }
 
 mitk::ScalarType mitk::LevelWindow::GetDefaultLowerBound() const
 {
   return m_DefaultLowerBound;
 }
 
 void mitk::LevelWindow::ResetDefaultRangeMinMax()
 {
   SetRangeMinMax(m_DefaultLowerBound, m_DefaultUpperBound);
 }
 
 /*!
 This method initializes a mitk::LevelWindow from an mitk::Image. The algorithm is as follows:
 
 Default to taking the central image slice for quick analysis.
 
 Compute the smallest (minValue), second smallest (min2ndValue), second largest (max2ndValue), and
 largest (maxValue) data value by traversing the pixel values only once. In the
 same scan it also computes the count of minValue values and maxValue values.
 After that a basic histogram with specific information about the
 extrems is complete.
 
 If minValue == maxValue, the center slice is uniform and the above scan is repeated for
 the complete image, not just one slice
 
 Next, special cases of images with only 1, 2 or 3 distinct data values
 have hand assigned level window ranges.
 
 Next the level window is set relative to the inner range IR = lengthOf([min2ndValue, max2ndValue])
 
 For count(minValue) > 20% the smallest values are frequent and should be
 distinct from the min2ndValue and larger values (minValue may be std:min, may signify
 something special) hence the lower end of the level window is set to min2ndValue - 0.5 * IR
 
 For count(minValue) <= 20% the smallest values are not so important and can
 blend with the next ones => min(level window) = min2ndValue
 
 And analog for max(level window):
 count(max2ndValue) > 20%:  max(level window) = max2ndValue + 0.5 * IR
 count(max2ndValue) < 20%:  max(level window) = max2ndValue
 
 In both 20%+ cases the level window bounds are clamped to the [minValue, maxValue] range
 
 In consequence the level window maximizes contrast with minimal amount of
 computation and does do useful things if the data contains std::min or
 std:max values or has only 1 or 2 or 3 data values.
 */
 void mitk::LevelWindow::SetAuto(const mitk::Image *image,
                                 bool /*tryPicTags*/,
                                 bool guessByCentralSlice,
                                 unsigned selectedComponent)
 {
   if (IsFixed())
     return;
 
   if (image == nullptr || !image->IsInitialized())
     return;
 
   if ((image->GetPixelType().GetComponentType() == 9) || (image->GetPixelType().GetComponentType() == 10))
   {
     // Floating image
     m_IsFloatingImage = true;
   }
   else
   {
     m_IsFloatingImage = false;
   }
 
   const mitk::Image *wholeImage = image;
   ScalarType minValue = 0.0;
   ScalarType maxValue = 0.0;
   ScalarType min2ndValue = 0.0;
   ScalarType max2ndValue = 0.0;
   mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
   if (guessByCentralSlice)
   {
     sliceSelector->SetInput(image);
     sliceSelector->SetSliceNr(image->GetDimension(2) / 2);
     sliceSelector->SetTimeNr(image->GetDimension(3) / 2);
     sliceSelector->SetChannelNr(image->GetDimension(4) / 2);
     sliceSelector->Update();
     image = sliceSelector->GetOutput();
     if (image == nullptr || !image->IsInitialized())
       return;
 
     minValue = image->GetStatistics()->GetScalarValueMin(0, selectedComponent);
     maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute();
     min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
     max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
     if (minValue == maxValue)
     {
       // guessByCentralSlice seems to have failed, lets look at all data
       image = wholeImage;
       minValue = image->GetStatistics()->GetScalarValueMin(0, selectedComponent);
       maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute();
       min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
       max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
     }
   }
   else
   {
     const_cast<Image *>(image)->Update();
     minValue = image->GetStatistics()->GetScalarValueMin(0, selectedComponent);
     maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute(0);
     min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute(0);
     max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute(0);
     for (unsigned int i = 1; i < image->GetDimension(3); ++i)
     {
       ScalarType minValueTemp = image->GetStatistics()->GetScalarValueMin(i, selectedComponent);
       if (minValue > minValueTemp)
         minValue = minValueTemp;
       ScalarType maxValueTemp = image->GetStatistics()->GetScalarValueMaxNoRecompute(i);
       if (maxValue < maxValueTemp)
         maxValue = maxValueTemp;
       ScalarType min2ndValueTemp = image->GetStatistics()->GetScalarValue2ndMinNoRecompute(i);
       if (min2ndValue > min2ndValueTemp)
         min2ndValue = min2ndValueTemp;
       ScalarType max2ndValueTemp = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute(i);
       if (max2ndValue > max2ndValueTemp)
         max2ndValue = max2ndValueTemp;
     }
   }
 
   // Fix for bug# 344 Level Window wird bei Eris Cut bildern nicht richtig gesetzt
   if (image->GetPixelType().GetPixelType() == itk::ImageIOBase::SCALAR &&
       image->GetPixelType().GetComponentType() == itk::ImageIOBase::INT && image->GetPixelType().GetBpe() >= 8)
   {
     // the windows compiler complains about ambiguos 'pow' call, therefore static casting to (double, int)
     if (minValue == -(pow((double)2.0, static_cast<int>(image->GetPixelType().GetBpe() / 2))))
     {
       minValue = min2ndValue;
     }
   }
   // End fix
 
   //// uniform image
   if (minValue == maxValue)
   {
     minValue = maxValue - 1;
   }
   else
   {
     // Due to bug #8690 level window now is no longer of fixed range by default but the range adapts according to
     // levelwindow interaction
     // This is done because the range should be a little bit larger from the beginning so that the scale doesn't start
     // to resize right from the beginning
     double additionalRange = 0.15 * (maxValue - minValue);
     minValue -= additionalRange;
     maxValue += additionalRange;
   }
 
   if (!std::isfinite(minValue))
   {
     minValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute(0);
   }
   if (!std::isfinite(maxValue))
   {
     maxValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute(0);
   }
 
   SetRangeMinMax(minValue, maxValue);
   SetDefaultBoundaries(minValue, maxValue);
-  /*
-  if ( tryPicTags ) // level and window will be set by informations provided directly by the mitkIpPicDescriptor
-  {
-  if ( SetAutoByPicTags(const_cast<Image*>(image)->GetPic()) )
-  {
-  return;
-  }
-  }
-  */
 
   unsigned int numPixelsInDataset = image->GetDimensions()[0];
   for (unsigned int k = 0; k < image->GetDimension(); ++k)
     numPixelsInDataset *= image->GetDimensions()[k];
   unsigned int minCount = image->GetStatistics()->GetCountOfMinValuedVoxelsNoRecompute();
   unsigned int maxCount = image->GetStatistics()->GetCountOfMaxValuedVoxelsNoRecompute();
   ScalarType minCountFraction = minCount / ScalarType(numPixelsInDataset);
   ScalarType maxCountFraction = maxCount / ScalarType(numPixelsInDataset);
 
   //// binary image
   if (min2ndValue == maxValue)
   {
     // noop; full range is fine
   }
 
   //// triple value image, put middle value in center of gray level ramp
   else if (min2ndValue == max2ndValue)
   {
     ScalarType minDelta = std::min(min2ndValue - minValue, maxValue - min2ndValue);
     minValue = min2ndValue - minDelta;
     maxValue = min2ndValue + minDelta;
   }
 
   // now we can assume more than three distict scalar values
   else
   {
     ScalarType innerRange = max2ndValue - min2ndValue;
 
     if (minCountFraction > 0.2) //// lots of min values -> make different from rest, but not miles away
     {
       ScalarType halfInnerRangeGapMinValue = min2ndValue - innerRange / 2.0;
       minValue = std::max(minValue, halfInnerRangeGapMinValue);
     }
     else //// few min values -> focus on innerRange
     {
       minValue = min2ndValue;
     }
 
     if (maxCountFraction > 0.2) //// lots of max values -> make different from rest
     {
       ScalarType halfInnerRangeGapMaxValue = max2ndValue + innerRange / 2.0;
       maxValue = std::min(maxValue, halfInnerRangeGapMaxValue);
     }
     else //// few max values -> focus on innerRange
     {
       maxValue = max2ndValue;
     }
   }
   SetWindowBounds(minValue, maxValue);
   SetDefaultLevelWindow((maxValue - minValue) / 2 + minValue, maxValue - minValue);
 }
 
 void mitk::LevelWindow::SetToImageRange(const mitk::Image *image)
 {
   if (IsFixed())
     return;
 
   if (image == nullptr || !image->IsInitialized())
     return;
 
   ScalarType minValue = image->GetStatistics()->GetScalarValueMin(0);
   if (!std::isfinite(minValue))
   {
     minValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute(0);
   }
   ScalarType maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute(0);
   if (!std::isfinite(maxValue))
   {
     maxValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute(0);
   }
 
   SetRangeMinMax(minValue, maxValue);
   SetDefaultBoundaries(minValue, maxValue);
   SetWindowBounds(minValue, maxValue);
   SetDefaultLevelWindow((maxValue - minValue) / 2 + minValue, maxValue - minValue);
 }
 
 void mitk::LevelWindow::SetFixed(bool fixed)
 {
   m_Fixed = fixed;
 }
 
 bool mitk::LevelWindow::GetFixed() const
 {
   return m_Fixed;
 }
 
 bool mitk::LevelWindow::IsFixed() const
 {
   return m_Fixed;
 }
 
 bool mitk::LevelWindow::IsFloatingValues() const
 {
   return m_IsFloatingImage;
 }
 
 void mitk::LevelWindow::SetFloatingValues(bool value)
 {
   m_IsFloatingImage = value;
 }
 
 bool mitk::LevelWindow::operator==(const mitk::LevelWindow &levWin) const
 {
   return mitk::Equal(this->m_RangeMin, levWin.m_RangeMin, mitk::sqrteps) &&
          mitk::Equal(this->m_RangeMax, levWin.m_RangeMax, mitk::sqrteps) &&
          mitk::Equal(this->m_DefaultLowerBound, levWin.m_DefaultLowerBound, mitk::sqrteps) &&
          mitk::Equal(this->m_DefaultUpperBound, levWin.m_DefaultUpperBound, mitk::sqrteps) &&
          mitk::Equal(this->m_LowerWindowBound, levWin.m_LowerWindowBound, mitk::sqrteps) &&
          mitk::Equal(this->m_UpperWindowBound, levWin.m_UpperWindowBound, mitk::sqrteps) &&
          m_Fixed == levWin.IsFixed() && m_IsFloatingImage == levWin.IsFloatingValues();
 }
 
 bool mitk::LevelWindow::operator!=(const mitk::LevelWindow &levWin) const
 {
   return !((*this) == levWin);
 }
 
 mitk::LevelWindow &mitk::LevelWindow::operator=(const mitk::LevelWindow &levWin)
 {
   if (this == &levWin)
   {
     return *this;
   }
   else
   {
     m_RangeMin = levWin.GetRangeMin();
     m_RangeMax = levWin.GetRangeMax();
     m_LowerWindowBound = levWin.GetLowerWindowBound();
     m_UpperWindowBound = levWin.GetUpperWindowBound();
     m_DefaultLowerBound = levWin.GetDefaultLowerBound();
     m_DefaultUpperBound = levWin.GetDefaultUpperBound();
     m_Fixed = levWin.GetFixed();
     m_IsFloatingImage = levWin.IsFloatingValues();
     return *this;
   }
 }