diff --git a/Core/Code/DataManagement/mitkLevelWindow.cpp b/Core/Code/DataManagement/mitkLevelWindow.cpp
index e35ab93b6a..47e1d553dd 100644
--- a/Core/Code/DataManagement/mitkLevelWindow.cpp
+++ b/Core/Code/DataManagement/mitkLevelWindow.cpp
@@ -1,414 +1,430 @@
 /*===================================================================
 
 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 "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;
     if ( m_LowerWindowBound > m_RangeMax ) m_LowerWindowBound = m_RangeMax;
     if ( m_UpperWindowBound > m_RangeMax ) m_UpperWindowBound = m_RangeMax;
 
     if (m_LowerWindowBound == m_UpperWindowBound )  
     {
       if(m_LowerWindowBound == m_RangeMin )
         m_UpperWindowBound++;
       else    
         m_LowerWindowBound--;
     }
   }
 }
  
 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_Fixed( false )
 {
   SetDefaultLevelWindow(level, window);
 }
 
 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_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)), (level+(window/2)));
+  SetDefaultBoundaries((level-(window/2.0)), (level+(window/2.0)));
 }
 
-void mitk::LevelWindow::SetLevelWindow(mitk::ScalarType level, mitk::ScalarType window)
+void mitk::LevelWindow::SetLevelWindow(mitk::ScalarType level, mitk::ScalarType window, bool expandRangesIfNecessary)
 {
-  SetWindowBounds((level-(window/2.0)), (level+(window/2.0)));
+  SetWindowBounds( (level-(window/2.0)), (level+(window/2.0)), expandRangesIfNecessary );
 }
 
-void mitk::LevelWindow::SetWindowBounds(mitk::ScalarType lowerBound, mitk::ScalarType upperBound)
+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_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)
 {
   if ( IsFixed() )
     return;
   
   if ( image == NULL || !image->IsInitialized() ) return;
 
   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 == NULL || !image->IsInitialized() ) return;
 
     minValue    = image->GetStatistics()->GetScalarValueMin();
     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();
       maxValue    = image->GetStatistics()->GetScalarValueMaxNoRecompute();
       min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
       max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
     }
   }
   else
   {
     const_cast<Image*>(image)->Update();
     minValue    = image->GetStatistics()->GetScalarValueMin(0);
     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);
       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()== typeid(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;
   }
   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();
   float minCountFraction = minCount/float(numPixelsInDataset);
   float maxCountFraction = maxCount/float(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::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::operator==(const mitk::LevelWindow& levWin) const
 {
   if ( 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.IsFixed() ) {
 
       return true;
     }
   else {
     return false;
   }
 }
 
 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();
     return *this;
   }
 }
diff --git a/Core/Code/DataManagement/mitkLevelWindow.h b/Core/Code/DataManagement/mitkLevelWindow.h
index 0c087f73e8..9d86dc780b 100644
--- a/Core/Code/DataManagement/mitkLevelWindow.h
+++ b/Core/Code/DataManagement/mitkLevelWindow.h
@@ -1,239 +1,239 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef LEVELWINDOW_H_HEADER_INCLUDED_C1F4F02C
 #define LEVELWINDOW_H_HEADER_INCLUDED_C1F4F02C
 
 #include "mitkVector.h"
 #include <MitkExports.h>
 
 //struct mitkIpPicDescriptor;
 
 namespace mitk {
 
 class Image;
 
 //##Documentation
 //## @brief Class to store level/window values
 //##
 //## Current min and max value are stored in m_LowerWindowBound and m_UpperWindowBound.
 //## The maximum and minimum of valid value range is stored in
 //## m_RangeMin and m_RangeMax.
 //## m_DefaultLevel amd m_DefaultWindow store the initial Level/Window values for the image.
 //## m_DefaultRangeMin and m_DefaultRangeMax store the initial minrange and maxrange for the image.
 //##
 //## See documentation of SetAuto for information on how the
 //## level window is initialized from an image.
 //##
 //## @ingroup DataManagement
 class MITK_CORE_EXPORT LevelWindow
 {
 public:
   LevelWindow(ScalarType level=127.5, ScalarType window=255.0);
   LevelWindow(const mitk::LevelWindow& levWin);
   virtual ~LevelWindow();
 
   /*!
   * \brief method that returns the level value, i.e. the center of
   * the current grey value interval
   */
   ScalarType GetLevel() const;
 
   /*!
   * \brief returns the current window size, i.e the range size of the current grey value interval
   */
   ScalarType GetWindow() const;
 
   /*!
   * \brief method returns the default level value for the image
   */
   ScalarType GetDefaultLevel() const;
 
   /*!
   * \brief returns the default window size for the image
   */
   ScalarType GetDefaultWindow() const;
 
   /*!
   * \brief Resets the level and the window value to the default values 
   */
   void ResetDefaultLevelWindow();
 
   /*!
   * Returns the minimum Value of the window
   */
   ScalarType GetLowerWindowBound() const;
 
   /*!
   * Returns the upper window bound value of the window
   */
   ScalarType GetUpperWindowBound() const;
 
   /*!
   * To set the level and the window value
   */
-  void SetLevelWindow(ScalarType level, ScalarType window);
+  void SetLevelWindow(ScalarType level, ScalarType window, bool expandRangesIfNecessary = false);
 
   /*!
   * Set the lower and upper bound of the window
   */
-  void SetWindowBounds(ScalarType lowerBound, ScalarType upperBound);
+  void SetWindowBounds(ScalarType lowerBound, ScalarType upperBound, bool expandRangesIfNecessary = false);
 
   /*!
   * sets the window to its maximum Size in scaleRange
   */
   void SetToMaxWindowSize();
 
   /*!
   * Set the range minimum and maximum value
   */
   void SetRangeMinMax(ScalarType min, ScalarType max);
 
   /*!
   * Get the range minimum value
   */
   ScalarType GetRangeMin() const;
 
   /*!
   * Get the range maximum value
   */
   ScalarType GetRangeMax() const;
 
   /*!
   * Get the default range minimum value
   */
   ScalarType GetDefaultLowerBound() const;
 
   /*!
   * Get the default range maximum value
   */
   ScalarType GetDefaultUpperBound() const;
 
   /*!
   * \brief the default min and max range for image will be reset
   */
   void ResetDefaultRangeMinMax();
 
   /**!
   * \brief returns the size of the grey value range
   */
   ScalarType GetRange() const;
 
   /*!
   * set the default level and window value
   */
   void SetDefaultLevelWindow(ScalarType level, ScalarType window);
 
   /*!
   * set the default Bounderies
   */
   void SetDefaultBoundaries(ScalarType low, ScalarType up);
 
   /**!
   * \brief sets level/window to the min/max greyvalues of the given Image
   */
   void SetAuto(const mitk::Image* image, bool tryPicTags = true, bool guessByCentralSlice = true);
   
   /**
    * If a level window is set to fixed, the set and get methods won't accept
    * modifications to the level window settings anymore. This behaviour can
    * be turned of by setting fixed to false;
    */
   void SetFixed( bool fixed );
   
   /** 
    * Returns whether the level window settings are fixed (@see SetFixed(bool)) or not
    */
   bool GetFixed() const;
   
   /** 
    * Returns whether the level window settings are fixed (@see SetFixed(bool)) or not
    */
   bool IsFixed() const;
 
   /*!
   * \brief equality operator implementation that allows to compare two level windows
   */
   virtual bool operator==(const LevelWindow& levWin) const;
 
   /*!
   * \brief non equality operator implementation that allows to compare two level windows
   */
   virtual bool operator!=(const LevelWindow& levWin) const;
 
   /*!
   * \brief implementation necessary because operator made
   *  private in itk::Object
   */
   virtual LevelWindow& operator=(const LevelWindow& levWin);
 
 protected:
 
   /*!
   * lower bound of current window
   */
   ScalarType m_LowerWindowBound;
 
   /*!
   * upper bound of current window
   */
   ScalarType m_UpperWindowBound;
 
   /*!
   * minimum gray value of the window
   */
   ScalarType m_RangeMin;
 
   /*!
   * maximum gray value of the window
   */
   ScalarType m_RangeMax;
 
   /*!
   * default minimum gray value of the window
   */
   ScalarType m_DefaultLowerBound;
 
   /*!
   * default maximum gray value of the window
   */
   ScalarType m_DefaultUpperBound;
 
 
   /*!
    * Defines whether the level window settings may be changed after
    * initialization or not.
    */
   bool m_Fixed;
 
 
   /*!
   * confidence tests
   *
   * if m_LowerWindowBound > m_UpperWindowBound, then the values for m_LowerWindowBound and m_UpperWindowBound will be exchanged
   *
   * if m_LowerWindowBound < m_RangeMin, m_LowerWindowBound will be set to m_RangeMin. m_UpperWindowBound will be decreased the same as m_LowerWindowBound will be increased, but minimum value for m_UpperWindowBound is also m_RangeMin.
   * 
   * if m_UpperWindowBound > m_RangeMax, m_UpperWindowBound will be set to m_RangeMax. m_LowerWindowBound will be increased the same as m_UpperWindowBound will be decreased, but maximum value for m_LowerWindowBound is also m_RangeMax.
   *
   */
   inline void EnsureConsistency();
   
 };
 
 } // namespace mitk
 #endif /* LEVELWINDOW_H_HEADER_INCLUDED_C1F4F02C */
diff --git a/Core/Code/Testing/mitkLevelWindowTest.cpp b/Core/Code/Testing/mitkLevelWindowTest.cpp
index 2efbdfe166..3d6aae2415 100644
--- a/Core/Code/Testing/mitkLevelWindowTest.cpp
+++ b/Core/Code/Testing/mitkLevelWindowTest.cpp
@@ -1,644 +1,709 @@
 /*===================================================================
 
 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>
 
 int mitkLevelWindowTest(int, char* [])
 {
   std::cout << "Testing mitk::LevelWindow  "<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow constructor with Level and Window ";
   mitk::LevelWindow* levWin = new mitk::LevelWindow(256, 500);
   std::cout<<"[PASSED]"<<std::endl;
   
   std::cout << "Testing mitk::LevelWindow GetDefaultWindow ";
   mitk::ScalarType defaultWindow = levWin->GetDefaultWindow();
   if (!(defaultWindow == 500))
   {
     std::cout<<(int)(defaultWindow) + "[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetDefaultLevel ";
   mitk::ScalarType defaultLevel = levWin->GetDefaultLevel();
   if (!(defaultLevel == 256))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetWindow ";
   mitk::ScalarType window = levWin->GetWindow();
   if (!(window == 500))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetMin ";
   if (!(levWin->GetLowerWindowBound() == 6))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetMax ";
   if (!(levWin->GetUpperWindowBound() == 506))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetLevel ";
   mitk::ScalarType level = levWin->GetLevel();
   if (!(level == 256))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
   
   std::cout << "Testing mitk::LevelWindow GetWindow : GetDefaultWindow ";
   if (!(defaultWindow == window))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetLevel : GetDefaultLevel ";
   if (!(defaultLevel == level))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetLevelWindow ";
   levWin->SetLevelWindow(20, 100);
   if (!(levWin->GetLevel() == 20))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   if (!(levWin->GetWindow() == 100))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetLevelWindow ";
   levWin->SetLevelWindow(levWin->GetDefaultLevel(), levWin->GetDefaultWindow());
   if (!(levWin->GetLevel() == 256) && !(levWin->GetWindow() == 500))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetDefaultLevelWindow ";
   levWin->SetDefaultLevelWindow(20, 200);
   if (!(levWin->GetDefaultLevel() == 20) && !(levWin->GetDefaultWindow() == 200))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow ResetDefaultLevelWindow ";
   levWin->SetLevelWindow(100, 50);
   levWin->ResetDefaultLevelWindow();
   //double a = levWin->GetLevel();
   //double d = levWin->GetWindow();
 
   if (!((levWin->GetLevel() == 20) &&(levWin->GetWindow() == 200)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetWindowBounds ";
   levWin->SetWindowBounds(0, 2);
   if (!((levWin->GetLowerWindowBound() == 0) && (levWin->GetUpperWindowBound() == 2) && (levWin->GetLevel() == 1) && (levWin->GetWindow() == 2)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with rangemin = rangemax";
   levWin->SetRangeMinMax(2000, 2000);
   if (!(levWin->GetRangeMin() == 1999 && levWin->GetRangeMax() == 2000))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with rangemin > rangemax";
   levWin->SetRangeMinMax(2100, 2000);
   if (!(levWin->GetRangeMin() == 2000 && levWin->GetRangeMax() == 2100))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax ";
   levWin->SetRangeMinMax(-1000, 2000);
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetRangeMin ";
   if (!(levWin->GetRangeMin() == -1000))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetRangeMax ";
   if (!(levWin->GetRangeMax() == 2000))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetRange ";
   if (!((levWin->GetRangeMax() - levWin->GetRangeMin()) == levWin->GetRange()))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries with rangemin = rangemax";
   levWin->SetDefaultBoundaries(2000, 2000);
   if (!(levWin->GetDefaultLowerBound() == 1999 && levWin->GetDefaultUpperBound() == 2000))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries with rangemin > rangemax";
   levWin->SetDefaultBoundaries(2100, 2000);
   if (!(levWin->GetDefaultLowerBound() == 2000 && levWin->GetDefaultUpperBound() == 2100))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries ";
   levWin->SetDefaultBoundaries(-2000, 8000);
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetDefaultLowerBound ";
   if (!(levWin->GetDefaultLowerBound() == -2000))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow GetDefaultUpperBound ";
   if (!(levWin->GetDefaultUpperBound() == 8000))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow ResetDefaultRangeMinMax ";
   levWin->ResetDefaultRangeMinMax();
   if (!((levWin->GetRangeMin() == levWin->GetDefaultLowerBound()) && (levWin->GetRangeMax() == levWin->GetDefaultUpperBound())))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow minRange > maxRange ";
   levWin->SetRangeMinMax(2000, 1000);
   if (!((levWin->GetRangeMin() == 1000) && (levWin->GetRangeMax() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetRangeMinMax(2000, -1000);
   if (!((levWin->GetRangeMin() == -1000) && (levWin->GetRangeMax() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetRangeMinMax(-2000, -3000);
   if (!((levWin->GetRangeMin() == -3000) && (levWin->GetRangeMax() == -2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetRangeMinMax(0, -1000);
   if (!((levWin->GetRangeMin() == -1000) && (levWin->GetRangeMax() == 0)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetRangeMinMax(2000, 0);
   if (!((levWin->GetRangeMin() == 0) && (levWin->GetRangeMax() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetRangeMinMax(-10000, 10000);
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow defaultMinRange > defaultMaxRange ";
   levWin->SetDefaultBoundaries(2000, 1000);
   if (!((levWin->GetDefaultLowerBound() == 1000) && (levWin->GetDefaultUpperBound() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetDefaultBoundaries(2000, -1000);
   if (!((levWin->GetDefaultLowerBound() == -1000) && (levWin->GetDefaultUpperBound() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetDefaultBoundaries(-2000, -3000);
   if (!((levWin->GetDefaultLowerBound() == -3000) && (levWin->GetDefaultUpperBound() == -2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetDefaultBoundaries(0, -1000);
   if (!((levWin->GetDefaultLowerBound() == -1000) && (levWin->GetDefaultUpperBound() == 0)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetDefaultBoundaries(2000, 0);
   if (!((levWin->GetDefaultLowerBound() == 0) && (levWin->GetDefaultUpperBound() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetDefaultBoundaries(-10000, 10000);
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min > max ";
   levWin->SetWindowBounds(2000, 1000);
   if (!((levWin->GetLowerWindowBound() == 1000) && (levWin->GetUpperWindowBound() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetWindowBounds(2000, -1000);
   if (!((levWin->GetLowerWindowBound() == -1000) && (levWin->GetUpperWindowBound() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetWindowBounds(-2000, -3000);
   if (!((levWin->GetLowerWindowBound() == -3000) && (levWin->GetUpperWindowBound() == -2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetWindowBounds(0, -1000);
   if (!((levWin->GetLowerWindowBound() == -1000) && (levWin->GetUpperWindowBound() == 0)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->SetWindowBounds(2000, 0);
   if (!((levWin->GetLowerWindowBound() == 0) && (levWin->GetUpperWindowBound() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   //minmax > maxrange, minmax < minrange, min<maxrange & max >maxrange, min < minrange & max > minrange
   // max < minrange & min > minrange, min > maxrange & max < maxrange, min < minrange & max > maxrange
   // min > maxrange & max < minrange 
   std::cout << "Testing mitk::LevelWindow max > min > maxrange ";
   levWin->SetWindowBounds(11000, 12000);
   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min > max > maxrange ";
   levWin->SetWindowBounds(12000, 11000);
   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min < max < minrange ";
   levWin->SetWindowBounds(-12000, -11000);
   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow max < min < minrange ";
   levWin->SetWindowBounds(-11000, -12000);
   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min < maxrang & max > maxrange ";
   levWin->SetWindowBounds(9999, 12000);
   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min < minrange & max > minrange ";
   levWin->SetWindowBounds(-11000, -9999);
   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min < minrange & max > maxrange ";
   levWin->SetWindowBounds(-11000, 11000);
   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == 10000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow maxrange > min = max > minrange ";
   levWin->SetWindowBounds(5000, 5000);
   if (!((levWin->GetLowerWindowBound() == 4999) && (levWin->GetUpperWindowBound() == 5000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min = max = minrange ";
   levWin->SetWindowBounds(-10000, -10000);
   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min = max = maxrange ";
   levWin->SetWindowBounds(10000, 10000);
   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min = max > maxrange ";
   levWin->SetWindowBounds(11000, 11000);
   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min = max < minrange ";
   levWin->SetWindowBounds(-11000, -11000);
   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow maxrange > min > minrange > max ";
   levWin->SetWindowBounds(-9000, -11000);
   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min > maxrange > minrange > max ";
   levWin->SetWindowBounds(11000, -11000);
   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == 10000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with maxrange < min < max ";
   levWin->SetRangeMinMax(-20000, -15000);
   if (!((levWin->GetLowerWindowBound() == -15001) && (levWin->GetUpperWindowBound() == -15000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange > maxrange & maxrange < min < max ";
   levWin->ResetDefaultLevelWindow();
   levWin->SetRangeMinMax(-15000, -20000);
   if (!((levWin->GetLowerWindowBound() == -15001) && (levWin->GetUpperWindowBound() == -15000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange < min < maxrange < max ";
   levWin->SetRangeMinMax(-80, 1000);
   levWin->SetWindowBounds(-1000,110);
   if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 110)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with maxrange < minrange & minrange < min < maxrange < max ";
   levWin->SetRangeMinMax(1000,-80);
   levWin->SetWindowBounds(-1000,110);
   if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 110)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with min < minrange < maxrange <max ";
   levWin->SetRangeMinMax(20, 110);
   if (!((levWin->GetLowerWindowBound() == 20) && (levWin->GetUpperWindowBound() == 110)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minRange > maxRange & min < maxrange < max ";
   levWin->SetWindowBounds(-90,1000);
   levWin->SetRangeMinMax(100, -80);
 
   if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 100)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minRange > maxRange & min < minrange < maxrange <max ";
   levWin->SetRangeMinMax(20, 100);
   if (!((levWin->GetLowerWindowBound() == 20) && (levWin->GetUpperWindowBound() == 100)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with min < max < minrange ";
   levWin->SetRangeMinMax(20000, 15000);
   if (!((levWin->GetLowerWindowBound() == 15000) && (levWin->GetUpperWindowBound() == 15001)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange > maxrange & min < max < minrange ";
   levWin->SetRangeMinMax(20000, 15000);
   if (!((levWin->GetLowerWindowBound() == 15000) && (levWin->GetUpperWindowBound() == 15001)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with min < minrange <max ";
   levWin->SetRangeMinMax(-20000, -15000);
   if (!((levWin->GetLowerWindowBound() == -15001) && (levWin->GetUpperWindowBound() == -15000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   levWin->ResetDefaultRangeMinMax();
   levWin->ResetDefaultLevelWindow();
   std::cout<<"[PASSED]"<<std::endl;
 
   // auch für default levelwindow und default range
 
   //Create Image out of nowhere
   mitk::Image::Pointer image;
   //mitk::PixelType pt(typeid(int));
   unsigned int dim[]={100,100,20};
 
   std::cout << "Creating image: ";
   image = mitk::Image::New();
   //image->DebugOn();
 
   image->Initialize( mitk::MakePixelType<int, int, 1>(), 3, dim);
   int *p = (int*)image->GetData();
 
   int size = dim[0]*dim[1]*dim[2];
   int i;
   for(i=0; i<size; ++i, ++p)
     *p=i;
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetAuto ";
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( image );
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow constructor with mitkLevelWindow ";
   const mitk::LevelWindow* lw = new mitk::LevelWindow(levelwindow);
   if (!(lw->GetRange() == levelwindow.GetRange()))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
   std::cout<<"[PASSED]"<<std::endl;
   
   std::cout << "Testing mitk::LevelWindow destructor ";
   delete levWin;
   delete lw;
+
+  mitk::LevelWindow levelWindow(50,100);
+  levelWindow.SetRangeMinMax(0,100);
+  // test range restriction/adaption for SetLevelWindow and SetWindowBounds
+  std::cout << "Testing range restriction of mitk::LevelWindow::SetWindowBounds()";
+  mitk::ScalarType initialUpperBound = levelWindow.GetUpperWindowBound();
+  mitk::ScalarType initialLowerBound = levelWindow.GetLowerWindowBound();
+  levelWindow.SetWindowBounds( -10, 110 );
+  if ( levelWindow.GetUpperWindowBound() != initialUpperBound ||
+       levelWindow.GetLowerWindowBound() != initialLowerBound )
+  {
+    std::cout<<"[FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing range restriction of mitk::LevelWindow::SetLevelWindow()";
+  levelWindow.SetLevelWindow( 60, 100 );
+  if ( levelWindow.GetUpperWindowBound() != initialUpperBound )
+  {
+    std::cout<<"[FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing range restriction of mitk::LevelWindow::SetLevelWindow()";
+  levelWindow.SetLevelWindow( 40, 100 );
+  if ( levelWindow.GetLowerWindowBound() != initialLowerBound )
+  {
+    std::cout<<"[FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing range adaption of mitk::LevelWindow::SetWindowBounds()";
+  levelWindow.SetWindowBounds(-10,90,true); // ture == force
+  if ( levelWindow.GetUpperWindowBound() != 90.0 ||
+       levelWindow.GetLowerWindowBound() != -10.0 )
+  {
+    std::cout<<"[FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+
+  std::cout << "Testing range adaption of mitk::LevelWindow::SetWindowBounds()";
+  levelWindow.SetWindowBounds(-20,110,true); // ture == force
+  if ( levelWindow.GetUpperWindowBound() != 110.0 ||
+       levelWindow.GetLowerWindowBound() != -20.0 )
+  {
+    std::cout<<"[FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+  
+  std::cout << "Testing range adaption of mitk::LevelWindow::SetLevelWindow()";
+  levelWindow.SetLevelWindow(50,140,true); // ture == force
+  if ( levelWindow.GetUpperWindowBound() != 120.0 ||
+       levelWindow.GetLowerWindowBound() != -20.0 )
+  {
+    std::cout<<"[FAILED]"<<std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout<<"[PASSED]"<<std::endl;
+ 
+
   std::cout<<"[PASSED]"<<std::endl;
   std::cout<<"[TEST DONE]"<<std::endl;
   return EXIT_SUCCESS;
 }