Index: mitk/Core/Code/DataManagement/mitkLevelWindow.cpp
===================================================================
--- mitk/Core/Code/DataManagement/mitkLevelWindow.cpp	(revision 21264)
+++ mitk/Core/Code/DataManagement/mitkLevelWindow.cpp	(working copy)
@@ -26,10 +26,10 @@
 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_DefaultRangeMin( -2048.0 ), m_DefaultRangeMax( 4096.0 ),
-  m_DefaultLevel( level ), m_DefaultWindow( window ),
+  m_DefaultLowerBound( -2048.0 ), m_DefaultUpperBound( 4096.0 ),
   m_Fixed( false )
 {
+  SetDefaultLevelWindow(level, window);
 }
 
 mitk::LevelWindow::LevelWindow(const mitk::LevelWindow& levWin)
@@ -53,19 +53,19 @@
 
 mitk::ScalarType mitk::LevelWindow::GetDefaultLevel() const
 {
-  return m_DefaultLevel;
+  return ((m_DefaultUpperBound+m_DefaultLowerBound)/2);
 }
 
 mitk::ScalarType mitk::LevelWindow::GetDefaultWindow() const
 {
-  return m_DefaultWindow;
+  return ((m_DefaultUpperBound-m_DefaultLowerBound));
 }
 
 void mitk::LevelWindow::ResetDefaultLevelWindow()
 {
   if ( IsFixed() )
     return;
-  SetLevelWindow(m_DefaultLevel, m_DefaultWindow);
+  SetLevelWindow(GetDefaultLevel(), GetDefaultWindow());
 }
 
 mitk::ScalarType mitk::LevelWindow::GetLowerWindowBound() const
@@ -82,9 +82,7 @@
 {
   if ( IsFixed() )
     return;
-  
-  m_DefaultLevel = level;
-  m_DefaultWindow = window;
+  SetDefaultBoundaries((level-(window/2)), (level+(window/2)));
 }
 
 void mitk::LevelWindow::SetLevelWindow(mitk::ScalarType level, mitk::ScalarType window)
@@ -148,17 +146,17 @@
   testValues();
 }
 
-void mitk::LevelWindow::SetDefaultRangeMinMax(mitk::ScalarType min, mitk::ScalarType max)
+void mitk::LevelWindow::SetDefaultBoundaries(mitk::ScalarType low, mitk::ScalarType up)
 {
   if ( IsFixed() )
     return;
   
-  if(min > max)
-    std::swap(min, max);
-  m_DefaultRangeMin = min;
-  m_DefaultRangeMax = max;
-  if ( m_DefaultRangeMin == m_DefaultRangeMax)
-    m_DefaultRangeMin = m_DefaultRangeMax - 1;
+  if(low > up)
+    std::swap(low, up);
+  m_DefaultLowerBound = low;
+  m_DefaultUpperBound = up;
+  if ( m_DefaultLowerBound == m_DefaultUpperBound)
+    m_DefaultLowerBound = m_DefaultUpperBound - 1;
 }
 
 mitk::ScalarType mitk::LevelWindow::GetRangeMin() const
@@ -176,19 +174,19 @@
   return  m_RangeMax - m_RangeMin;
 }
 
-mitk::ScalarType mitk::LevelWindow::GetDefaultRangeMax() const
+mitk::ScalarType mitk::LevelWindow::GetDefaultUpperBound() const
 {
-  return m_DefaultRangeMax;
+  return m_DefaultUpperBound;
 }
 
-mitk::ScalarType mitk::LevelWindow::GetDefaultRangeMin() const
+mitk::ScalarType mitk::LevelWindow::GetDefaultLowerBound() const
 {
-  return m_DefaultRangeMin;
+  return m_DefaultLowerBound;
 }
 
 void mitk::LevelWindow::ResetDefaultRangeMinMax()
 {
-  SetRangeMinMax(m_DefaultRangeMin, m_DefaultRangeMax);
+  SetRangeMinMax(m_DefaultLowerBound, m_DefaultUpperBound);
 }
 
 /*!
@@ -302,7 +300,7 @@
     minValue = maxValue-1;
   }
   SetRangeMinMax(minValue, maxValue);
-  SetDefaultRangeMinMax(minValue, maxValue);
+  SetDefaultBoundaries(minValue, maxValue);
 
   if ( tryPicTags ) // level and window will be set by informations provided directly by the mitkIpPicDescriptor
   {
@@ -395,7 +393,7 @@
       max = level + window/2;
     }
     SetRangeMinMax(min, max);
-    SetDefaultRangeMinMax(min, max);
+    SetDefaultBoundaries(min, max);
     SetLevelWindow( level, window );
     SetDefaultLevelWindow(level, window);
     return true;
@@ -423,8 +421,7 @@
   if ( m_RangeMin == levWin.GetRangeMin() && 
     m_RangeMax == levWin.GetRangeMax() && 
     m_LowerWindowBound == levWin.GetLowerWindowBound() && m_UpperWindowBound == levWin.GetUpperWindowBound() &&
-    m_DefaultLevel == levWin.GetDefaultLevel() && m_DefaultWindow == levWin.GetDefaultWindow() &&
-    m_DefaultRangeMin == levWin.GetDefaultRangeMin() && m_DefaultRangeMax == levWin.GetDefaultRangeMax() && m_Fixed == levWin.IsFixed() ) {
+    m_DefaultLowerBound == levWin.GetDefaultLowerBound() && m_DefaultUpperBound == levWin.GetDefaultUpperBound() && m_Fixed == levWin.IsFixed() ) {
 
       return true;
     }
@@ -448,10 +445,8 @@
     m_RangeMax = levWin.GetRangeMax();
     m_LowerWindowBound= levWin.GetLowerWindowBound();
     m_UpperWindowBound= levWin.GetUpperWindowBound();
-    m_DefaultLevel = levWin.GetDefaultLevel();
-    m_DefaultWindow = levWin.GetDefaultWindow();
-    m_DefaultRangeMin = levWin.GetDefaultRangeMin();
-    m_DefaultRangeMax = levWin.GetDefaultRangeMax();
+    m_DefaultLowerBound = levWin.GetDefaultLowerBound();
+    m_DefaultUpperBound = levWin.GetDefaultUpperBound();
     m_Fixed = levWin.GetFixed();
     return *this;
   }
Index: mitk/Core/Code/DataManagement/mitkLevelWindow.h
===================================================================
--- mitk/Core/Code/DataManagement/mitkLevelWindow.h	(revision 21264)
+++ mitk/Core/Code/DataManagement/mitkLevelWindow.h	(working copy)
@@ -117,12 +117,12 @@
   /*!
   * Get the default range minimum value
   */
-  ScalarType GetDefaultRangeMin() const;
+  ScalarType GetDefaultLowerBound() const;
 
   /*!
   * Get the default range maximum value
   */
-  ScalarType GetDefaultRangeMax() const;
+  ScalarType GetDefaultUpperBound() const;
 
   /*!
   * \brief the default min and max range for image will be reset
@@ -140,9 +140,9 @@
   void SetDefaultLevelWindow(ScalarType level, ScalarType window);
 
   /*!
-  * set the default total range maximum value
+  * set the default Bounderies
   */
-  void SetDefaultRangeMinMax(ScalarType min, ScalarType max);
+  void SetDefaultBoundaries(ScalarType low, ScalarType up);
 
   /**!
   * \brief sets level/window to the min/max greyvalues of the given Image
@@ -213,24 +213,15 @@
   /*!
   * default minimum gray value of the window
   */
-  ScalarType m_DefaultRangeMin;
+  ScalarType m_DefaultLowerBound;
 
   /*!
   * default maximum gray value of the window
   */
-  ScalarType m_DefaultRangeMax;
+  ScalarType m_DefaultUpperBound;
 
-  /*!
-  * default value of the level for image
-  */
-  ScalarType m_DefaultLevel;
 
   /*!
-  * default value of the window for image
-  */
-  ScalarType m_DefaultWindow;
-
-  /*!
    * Defines whether the level window settings may be changed after
    * initialization or not.
    */
Index: mitk/Core/Code/Testing/mitkLevelWindowTest.cpp
===================================================================
--- mitk/Core/Code/Testing/mitkLevelWindowTest.cpp	(revision 21264)
+++ mitk/Core/Code/Testing/mitkLevelWindowTest.cpp	(working copy)
@@ -129,6 +129,9 @@
   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;
@@ -192,38 +195,38 @@
   }
   std::cout<<"[PASSED]"<<std::endl;
 
-  std::cout << "Testing mitk::LevelWindow SetDefaultRangeMinMax with rangemin = rangemax";
-  levWin->SetDefaultRangeMinMax(2000, 2000);
-  if (!(levWin->GetDefaultRangeMin() == 1999 && levWin->GetDefaultRangeMax() == 2000))
+  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 SetDefaultRangeMinMax with rangemin > rangemax";
-  levWin->SetDefaultRangeMinMax(2100, 2000);
-  if (!(levWin->GetDefaultRangeMin() == 2000 && levWin->GetDefaultRangeMax() == 2100))
+  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 SetDefaultRangeMinMax ";
-  levWin->SetDefaultRangeMinMax(-2000, 8000);
+  std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries ";
+  levWin->SetDefaultBoundaries(-2000, 8000);
   std::cout<<"[PASSED]"<<std::endl;
 
-  std::cout << "Testing mitk::LevelWindow GetDefaultRangeMin ";
-  if (!(levWin->GetDefaultRangeMin() == -2000))
+  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 GetDefaultRangeMax ";
-  if (!(levWin->GetDefaultRangeMax() == 8000))
+  std::cout << "Testing mitk::LevelWindow GetDefaultUpperBound ";
+  if (!(levWin->GetDefaultUpperBound() == 8000))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
@@ -232,7 +235,7 @@
 
   std::cout << "Testing mitk::LevelWindow ResetDefaultRangeMinMax ";
   levWin->ResetDefaultRangeMinMax();
-  if (!((levWin->GetRangeMin() == levWin->GetDefaultRangeMin()) && (levWin->GetRangeMax() == levWin->GetDefaultRangeMax())))
+  if (!((levWin->GetRangeMin() == levWin->GetDefaultLowerBound()) && (levWin->GetRangeMax() == levWin->GetDefaultUpperBound())))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
@@ -274,37 +277,37 @@
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow defaultMinRange > defaultMaxRange ";
-  levWin->SetDefaultRangeMinMax(2000, 1000);
-  if (!((levWin->GetDefaultRangeMin() == 1000) && (levWin->GetDefaultRangeMax() == 2000)))
+  levWin->SetDefaultBoundaries(2000, 1000);
+  if (!((levWin->GetDefaultLowerBound() == 1000) && (levWin->GetDefaultUpperBound() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
-  levWin->SetDefaultRangeMinMax(2000, -1000);
-  if (!((levWin->GetDefaultRangeMin() == -1000) && (levWin->GetDefaultRangeMax() == 2000)))
+  levWin->SetDefaultBoundaries(2000, -1000);
+  if (!((levWin->GetDefaultLowerBound() == -1000) && (levWin->GetDefaultUpperBound() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
-  levWin->SetDefaultRangeMinMax(-2000, -3000);
-  if (!((levWin->GetDefaultRangeMin() == -3000) && (levWin->GetDefaultRangeMax() == -2000)))
+  levWin->SetDefaultBoundaries(-2000, -3000);
+  if (!((levWin->GetDefaultLowerBound() == -3000) && (levWin->GetDefaultUpperBound() == -2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
-  levWin->SetDefaultRangeMinMax(0, -1000);
-  if (!((levWin->GetDefaultRangeMin() == -1000) && (levWin->GetDefaultRangeMax() == 0)))
+  levWin->SetDefaultBoundaries(0, -1000);
+  if (!((levWin->GetDefaultLowerBound() == -1000) && (levWin->GetDefaultUpperBound() == 0)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
-  levWin->SetDefaultRangeMinMax(2000, 0);
-  if (!((levWin->GetDefaultRangeMin() == 0) && (levWin->GetDefaultRangeMax() == 2000)))
+  levWin->SetDefaultBoundaries(2000, 0);
+  if (!((levWin->GetDefaultLowerBound() == 0) && (levWin->GetDefaultUpperBound() == 2000)))
   {
     std::cout<<"[FAILED]"<<std::endl;
     return EXIT_FAILURE;
   }
-  levWin->SetDefaultRangeMinMax(-10000, 10000);
+  levWin->SetDefaultBoundaries(-10000, 10000);
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow min > max ";
@@ -508,7 +511,8 @@
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange < min < maxrange < max ";
-  levWin->SetRangeMinMax(-1000, 110);
+  levWin->SetRangeMinMax(-80, 1000);
+  levWin->SetWindowBounds(-1000,110);
   if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 110)))
   {
     std::cout<<"[FAILED]"<<std::endl;
@@ -519,7 +523,8 @@
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with maxrange < minrange & minrange < min < maxrange < max ";
-  levWin->SetRangeMinMax(110, -1000);
+  levWin->SetRangeMinMax(1000,-80);
+  levWin->SetWindowBounds(-1000,110);
   if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 110)))
   {
     std::cout<<"[FAILED]"<<std::endl;
@@ -541,7 +546,9 @@
   std::cout<<"[PASSED]"<<std::endl;
 
   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minRange > maxRange & min < maxrange < max ";
-  levWin->SetRangeMinMax(-1000, 100);
+  levWin->SetWindowBounds(-90,1000);
+  levWin->SetRangeMinMax(100, -80);
+
   if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 100)))
   {
     std::cout<<"[FAILED]"<<std::endl;