mitk: mitkLevelWindowTest.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002  
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision$
00007  
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011  
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015  
00016 =========================================================================*/
00017 
00018 #include "mitkLevelWindow.h"
00019 #include <mitkImage.h>
00020 
00021 int mitkLevelWindowTest(int, char* [])
00022 {
00023   std::cout << "Testing mitk::LevelWindow  "<<std::endl;
00024 
00025   std::cout << "Testing mitk::LevelWindow constructor with Level and Window ";
00026   mitk::LevelWindow* levWin = new mitk::LevelWindow(256, 500);
00027   std::cout<<"[PASSED]"<<std::endl;
00028   
00029   std::cout << "Testing mitk::LevelWindow GetDefaultWindow ";
00030   mitk::ScalarType defaultWindow = levWin->GetDefaultWindow();
00031   if (!(defaultWindow == 500))
00032   {
00033     std::cout<<(int)(defaultWindow) + "[FAILED]"<<std::endl;
00034     return EXIT_FAILURE;
00035   }
00036   std::cout<<"[PASSED]"<<std::endl;
00037 
00038   std::cout << "Testing mitk::LevelWindow GetDefaultLevel ";
00039   mitk::ScalarType defaultLevel = levWin->GetDefaultLevel();
00040   if (!(defaultLevel == 256))
00041   {
00042     std::cout<<"[FAILED]"<<std::endl;
00043     return EXIT_FAILURE;
00044   }
00045   std::cout<<"[PASSED]"<<std::endl;
00046 
00047   std::cout << "Testing mitk::LevelWindow GetWindow ";
00048   mitk::ScalarType window = levWin->GetWindow();
00049   if (!(window == 500))
00050   {
00051     std::cout<<"[FAILED]"<<std::endl;
00052     return EXIT_FAILURE;
00053   }
00054   std::cout<<"[PASSED]"<<std::endl;
00055 
00056   std::cout << "Testing mitk::LevelWindow GetMin ";
00057   if (!(levWin->GetLowerWindowBound() == 6))
00058   {
00059     std::cout<<"[FAILED]"<<std::endl;
00060     return EXIT_FAILURE;
00061   }
00062   std::cout<<"[PASSED]"<<std::endl;
00063 
00064   std::cout << "Testing mitk::LevelWindow GetMax ";
00065   if (!(levWin->GetUpperWindowBound() == 506))
00066   {
00067     std::cout<<"[FAILED]"<<std::endl;
00068     return EXIT_FAILURE;
00069   }
00070   std::cout<<"[PASSED]"<<std::endl;
00071 
00072   std::cout << "Testing mitk::LevelWindow GetLevel ";
00073   mitk::ScalarType level = levWin->GetLevel();
00074   if (!(level == 256))
00075   {
00076     std::cout<<"[FAILED]"<<std::endl;
00077     return EXIT_FAILURE;
00078   }
00079   std::cout<<"[PASSED]"<<std::endl;
00080   
00081   std::cout << "Testing mitk::LevelWindow GetWindow : GetDefaultWindow ";
00082   if (!(defaultWindow == window))
00083   {
00084     std::cout<<"[FAILED]"<<std::endl;
00085     return EXIT_FAILURE;
00086   }
00087   std::cout<<"[PASSED]"<<std::endl;
00088 
00089   std::cout << "Testing mitk::LevelWindow GetLevel : GetDefaultLevel ";
00090   if (!(defaultLevel == level))
00091   {
00092     std::cout<<"[FAILED]"<<std::endl;
00093     return EXIT_FAILURE;
00094   }
00095   std::cout<<"[PASSED]"<<std::endl;
00096 
00097   std::cout << "Testing mitk::LevelWindow SetLevelWindow ";
00098   levWin->SetLevelWindow(20, 100);
00099   if (!(levWin->GetLevel() == 20))
00100   {
00101     std::cout<<"[FAILED]"<<std::endl;
00102     return EXIT_FAILURE;
00103   }
00104   if (!(levWin->GetWindow() == 100))
00105   {
00106     std::cout<<"[FAILED]"<<std::endl;
00107     return EXIT_FAILURE;
00108   }
00109   std::cout<<"[PASSED]"<<std::endl;
00110 
00111   std::cout << "Testing mitk::LevelWindow SetLevelWindow ";
00112   levWin->SetLevelWindow(levWin->GetDefaultLevel(), levWin->GetDefaultWindow());
00113   if (!(levWin->GetLevel() == 256) && !(levWin->GetWindow() == 500))
00114   {
00115     std::cout<<"[FAILED]"<<std::endl;
00116     return EXIT_FAILURE;
00117   }
00118   std::cout<<"[PASSED]"<<std::endl;
00119 
00120   std::cout << "Testing mitk::LevelWindow SetDefaultLevelWindow ";
00121   levWin->SetDefaultLevelWindow(20, 200);
00122   if (!(levWin->GetDefaultLevel() == 20) && !(levWin->GetDefaultWindow() == 200))
00123   {
00124     std::cout<<"[FAILED]"<<std::endl;
00125     return EXIT_FAILURE;
00126   }
00127   std::cout<<"[PASSED]"<<std::endl;
00128 
00129   std::cout << "Testing mitk::LevelWindow ResetDefaultLevelWindow ";
00130   levWin->SetLevelWindow(100, 50);
00131   levWin->ResetDefaultLevelWindow();
00132   //double a = levWin->GetLevel();
00133   //double d = levWin->GetWindow();
00134 
00135   if (!((levWin->GetLevel() == 20) &&(levWin->GetWindow() == 200)))
00136   {
00137     std::cout<<"[FAILED]"<<std::endl;
00138     return EXIT_FAILURE;
00139   }
00140   std::cout<<"[PASSED]"<<std::endl;
00141 
00142   std::cout << "Testing mitk::LevelWindow SetWindowBounds ";
00143   levWin->SetWindowBounds(0, 2);
00144   if (!((levWin->GetLowerWindowBound() == 0) && (levWin->GetUpperWindowBound() == 2) && (levWin->GetLevel() == 1) && (levWin->GetWindow() == 2)))
00145   {
00146     std::cout<<"[FAILED]"<<std::endl;
00147     return EXIT_FAILURE;
00148   }
00149   levWin->ResetDefaultLevelWindow();
00150   std::cout<<"[PASSED]"<<std::endl;
00151 
00152   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with rangemin = rangemax";
00153   levWin->SetRangeMinMax(2000, 2000);
00154   if (!(levWin->GetRangeMin() == 1999 && levWin->GetRangeMax() == 2000))
00155   {
00156     std::cout<<"[FAILED]"<<std::endl;
00157     return EXIT_FAILURE;
00158   }
00159   std::cout<<"[PASSED]"<<std::endl;
00160 
00161   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with rangemin > rangemax";
00162   levWin->SetRangeMinMax(2100, 2000);
00163   if (!(levWin->GetRangeMin() == 2000 && levWin->GetRangeMax() == 2100))
00164   {
00165     std::cout<<"[FAILED]"<<std::endl;
00166     return EXIT_FAILURE;
00167   }
00168   std::cout<<"[PASSED]"<<std::endl;
00169 
00170   std::cout << "Testing mitk::LevelWindow SetRangeMinMax ";
00171   levWin->SetRangeMinMax(-1000, 2000);
00172   std::cout<<"[PASSED]"<<std::endl;
00173 
00174   std::cout << "Testing mitk::LevelWindow GetRangeMin ";
00175   if (!(levWin->GetRangeMin() == -1000))
00176   {
00177     std::cout<<"[FAILED]"<<std::endl;
00178     return EXIT_FAILURE;
00179   }
00180   std::cout<<"[PASSED]"<<std::endl;
00181 
00182   std::cout << "Testing mitk::LevelWindow GetRangeMax ";
00183   if (!(levWin->GetRangeMax() == 2000))
00184   {
00185     std::cout<<"[FAILED]"<<std::endl;
00186     return EXIT_FAILURE;
00187   }
00188   std::cout<<"[PASSED]"<<std::endl;
00189 
00190   std::cout << "Testing mitk::LevelWindow GetRange ";
00191   if (!((levWin->GetRangeMax() - levWin->GetRangeMin()) == levWin->GetRange()))
00192   {
00193     std::cout<<"[FAILED]"<<std::endl;
00194     return EXIT_FAILURE;
00195   }
00196   std::cout<<"[PASSED]"<<std::endl;
00197 
00198   std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries with rangemin = rangemax";
00199   levWin->SetDefaultBoundaries(2000, 2000);
00200   if (!(levWin->GetDefaultLowerBound() == 1999 && levWin->GetDefaultUpperBound() == 2000))
00201   {
00202     std::cout<<"[FAILED]"<<std::endl;
00203     return EXIT_FAILURE;
00204   }
00205   std::cout<<"[PASSED]"<<std::endl;
00206 
00207   std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries with rangemin > rangemax";
00208   levWin->SetDefaultBoundaries(2100, 2000);
00209   if (!(levWin->GetDefaultLowerBound() == 2000 && levWin->GetDefaultUpperBound() == 2100))
00210   {
00211     std::cout<<"[FAILED]"<<std::endl;
00212     return EXIT_FAILURE;
00213   }
00214   std::cout<<"[PASSED]"<<std::endl;
00215 
00216   std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries ";
00217   levWin->SetDefaultBoundaries(-2000, 8000);
00218   std::cout<<"[PASSED]"<<std::endl;
00219 
00220   std::cout << "Testing mitk::LevelWindow GetDefaultLowerBound ";
00221   if (!(levWin->GetDefaultLowerBound() == -2000))
00222   {
00223     std::cout<<"[FAILED]"<<std::endl;
00224     return EXIT_FAILURE;
00225   }
00226   std::cout<<"[PASSED]"<<std::endl;
00227 
00228   std::cout << "Testing mitk::LevelWindow GetDefaultUpperBound ";
00229   if (!(levWin->GetDefaultUpperBound() == 8000))
00230   {
00231     std::cout<<"[FAILED]"<<std::endl;
00232     return EXIT_FAILURE;
00233   }
00234   std::cout<<"[PASSED]"<<std::endl;
00235 
00236   std::cout << "Testing mitk::LevelWindow ResetDefaultRangeMinMax ";
00237   levWin->ResetDefaultRangeMinMax();
00238   if (!((levWin->GetRangeMin() == levWin->GetDefaultLowerBound()) && (levWin->GetRangeMax() == levWin->GetDefaultUpperBound())))
00239   {
00240     std::cout<<"[FAILED]"<<std::endl;
00241     return EXIT_FAILURE;
00242   }
00243   std::cout<<"[PASSED]"<<std::endl;
00244 
00245   std::cout << "Testing mitk::LevelWindow minRange > maxRange ";
00246   levWin->SetRangeMinMax(2000, 1000);
00247   if (!((levWin->GetRangeMin() == 1000) && (levWin->GetRangeMax() == 2000)))
00248   {
00249     std::cout<<"[FAILED]"<<std::endl;
00250     return EXIT_FAILURE;
00251   }
00252   levWin->SetRangeMinMax(2000, -1000);
00253   if (!((levWin->GetRangeMin() == -1000) && (levWin->GetRangeMax() == 2000)))
00254   {
00255     std::cout<<"[FAILED]"<<std::endl;
00256     return EXIT_FAILURE;
00257   }
00258   levWin->SetRangeMinMax(-2000, -3000);
00259   if (!((levWin->GetRangeMin() == -3000) && (levWin->GetRangeMax() == -2000)))
00260   {
00261     std::cout<<"[FAILED]"<<std::endl;
00262     return EXIT_FAILURE;
00263   }
00264   levWin->SetRangeMinMax(0, -1000);
00265   if (!((levWin->GetRangeMin() == -1000) && (levWin->GetRangeMax() == 0)))
00266   {
00267     std::cout<<"[FAILED]"<<std::endl;
00268     return EXIT_FAILURE;
00269   }
00270   levWin->SetRangeMinMax(2000, 0);
00271   if (!((levWin->GetRangeMin() == 0) && (levWin->GetRangeMax() == 2000)))
00272   {
00273     std::cout<<"[FAILED]"<<std::endl;
00274     return EXIT_FAILURE;
00275   }
00276   levWin->SetRangeMinMax(-10000, 10000);
00277   std::cout<<"[PASSED]"<<std::endl;
00278 
00279   std::cout << "Testing mitk::LevelWindow defaultMinRange > defaultMaxRange ";
00280   levWin->SetDefaultBoundaries(2000, 1000);
00281   if (!((levWin->GetDefaultLowerBound() == 1000) && (levWin->GetDefaultUpperBound() == 2000)))
00282   {
00283     std::cout<<"[FAILED]"<<std::endl;
00284     return EXIT_FAILURE;
00285   }
00286   levWin->SetDefaultBoundaries(2000, -1000);
00287   if (!((levWin->GetDefaultLowerBound() == -1000) && (levWin->GetDefaultUpperBound() == 2000)))
00288   {
00289     std::cout<<"[FAILED]"<<std::endl;
00290     return EXIT_FAILURE;
00291   }
00292   levWin->SetDefaultBoundaries(-2000, -3000);
00293   if (!((levWin->GetDefaultLowerBound() == -3000) && (levWin->GetDefaultUpperBound() == -2000)))
00294   {
00295     std::cout<<"[FAILED]"<<std::endl;
00296     return EXIT_FAILURE;
00297   }
00298   levWin->SetDefaultBoundaries(0, -1000);
00299   if (!((levWin->GetDefaultLowerBound() == -1000) && (levWin->GetDefaultUpperBound() == 0)))
00300   {
00301     std::cout<<"[FAILED]"<<std::endl;
00302     return EXIT_FAILURE;
00303   }
00304   levWin->SetDefaultBoundaries(2000, 0);
00305   if (!((levWin->GetDefaultLowerBound() == 0) && (levWin->GetDefaultUpperBound() == 2000)))
00306   {
00307     std::cout<<"[FAILED]"<<std::endl;
00308     return EXIT_FAILURE;
00309   }
00310   levWin->SetDefaultBoundaries(-10000, 10000);
00311   std::cout<<"[PASSED]"<<std::endl;
00312 
00313   std::cout << "Testing mitk::LevelWindow min > max ";
00314   levWin->SetWindowBounds(2000, 1000);
00315   if (!((levWin->GetLowerWindowBound() == 1000) && (levWin->GetUpperWindowBound() == 2000)))
00316   {
00317     std::cout<<"[FAILED]"<<std::endl;
00318     return EXIT_FAILURE;
00319   }
00320   levWin->SetWindowBounds(2000, -1000);
00321   if (!((levWin->GetLowerWindowBound() == -1000) && (levWin->GetUpperWindowBound() == 2000)))
00322   {
00323     std::cout<<"[FAILED]"<<std::endl;
00324     return EXIT_FAILURE;
00325   }
00326   levWin->SetWindowBounds(-2000, -3000);
00327   if (!((levWin->GetLowerWindowBound() == -3000) && (levWin->GetUpperWindowBound() == -2000)))
00328   {
00329     std::cout<<"[FAILED]"<<std::endl;
00330     return EXIT_FAILURE;
00331   }
00332   levWin->SetWindowBounds(0, -1000);
00333   if (!((levWin->GetLowerWindowBound() == -1000) && (levWin->GetUpperWindowBound() == 0)))
00334   {
00335     std::cout<<"[FAILED]"<<std::endl;
00336     return EXIT_FAILURE;
00337   }
00338   levWin->SetWindowBounds(2000, 0);
00339   if (!((levWin->GetLowerWindowBound() == 0) && (levWin->GetUpperWindowBound() == 2000)))
00340   {
00341     std::cout<<"[FAILED]"<<std::endl;
00342     return EXIT_FAILURE;
00343   }
00344   levWin->ResetDefaultLevelWindow();
00345   std::cout<<"[PASSED]"<<std::endl;
00346 
00347   //minmax > maxrange, minmax < minrange, min<maxrange & max >maxrange, min < minrange & max > minrange
00348   // max < minrange & min > minrange, min > maxrange & max < maxrange, min < minrange & max > maxrange
00349   // min > maxrange & max < minrange 
00350   std::cout << "Testing mitk::LevelWindow max > min > maxrange ";
00351   levWin->SetWindowBounds(11000, 12000);
00352   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
00353   {
00354     std::cout<<"[FAILED]"<<std::endl;
00355     return EXIT_FAILURE;
00356   }
00357   levWin->ResetDefaultLevelWindow();
00358   std::cout<<"[PASSED]"<<std::endl;
00359 
00360   std::cout << "Testing mitk::LevelWindow min > max > maxrange ";
00361   levWin->SetWindowBounds(12000, 11000);
00362   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
00363   {
00364     std::cout<<"[FAILED]"<<std::endl;
00365     return EXIT_FAILURE;
00366   }
00367   levWin->ResetDefaultLevelWindow();
00368   std::cout<<"[PASSED]"<<std::endl;
00369 
00370   std::cout << "Testing mitk::LevelWindow min < max < minrange ";
00371   levWin->SetWindowBounds(-12000, -11000);
00372   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
00373   {
00374     std::cout<<"[FAILED]"<<std::endl;
00375     return EXIT_FAILURE;
00376   }
00377   levWin->ResetDefaultLevelWindow();
00378   std::cout<<"[PASSED]"<<std::endl;
00379 
00380   std::cout << "Testing mitk::LevelWindow max < min < minrange ";
00381   levWin->SetWindowBounds(-11000, -12000);
00382   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
00383   {
00384     std::cout<<"[FAILED]"<<std::endl;
00385     return EXIT_FAILURE;
00386   }
00387   levWin->ResetDefaultLevelWindow();
00388   std::cout<<"[PASSED]"<<std::endl;
00389 
00390   std::cout << "Testing mitk::LevelWindow min < maxrang & max > maxrange ";
00391   levWin->SetWindowBounds(9999, 12000);
00392   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
00393   {
00394     std::cout<<"[FAILED]"<<std::endl;
00395     return EXIT_FAILURE;
00396   }
00397   levWin->ResetDefaultLevelWindow();
00398   std::cout<<"[PASSED]"<<std::endl;
00399 
00400   std::cout << "Testing mitk::LevelWindow min < minrange & max > minrange ";
00401   levWin->SetWindowBounds(-11000, -9999);
00402   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
00403   {
00404     std::cout<<"[FAILED]"<<std::endl;
00405     return EXIT_FAILURE;
00406   }
00407   levWin->ResetDefaultLevelWindow();
00408   std::cout<<"[PASSED]"<<std::endl;
00409 
00410   std::cout << "Testing mitk::LevelWindow min < minrange & max > maxrange ";
00411   levWin->SetWindowBounds(-11000, 11000);
00412   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == 10000)))
00413   {
00414     std::cout<<"[FAILED]"<<std::endl;
00415     return EXIT_FAILURE;
00416   }
00417   levWin->ResetDefaultLevelWindow();
00418   std::cout<<"[PASSED]"<<std::endl;
00419 
00420   std::cout << "Testing mitk::LevelWindow maxrange > min = max > minrange ";
00421   levWin->SetWindowBounds(5000, 5000);
00422   if (!((levWin->GetLowerWindowBound() == 4999) && (levWin->GetUpperWindowBound() == 5000)))
00423   {
00424     std::cout<<"[FAILED]"<<std::endl;
00425     return EXIT_FAILURE;
00426   }
00427   levWin->ResetDefaultLevelWindow();
00428   std::cout<<"[PASSED]"<<std::endl;
00429 
00430   std::cout << "Testing mitk::LevelWindow min = max = minrange ";
00431   levWin->SetWindowBounds(-10000, -10000);
00432   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
00433   {
00434     std::cout<<"[FAILED]"<<std::endl;
00435     return EXIT_FAILURE;
00436   }
00437   levWin->ResetDefaultLevelWindow();
00438   std::cout<<"[PASSED]"<<std::endl;
00439 
00440   std::cout << "Testing mitk::LevelWindow min = max = maxrange ";
00441   levWin->SetWindowBounds(10000, 10000);
00442   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
00443   {
00444     std::cout<<"[FAILED]"<<std::endl;
00445     return EXIT_FAILURE;
00446   }
00447   levWin->ResetDefaultLevelWindow();
00448   std::cout<<"[PASSED]"<<std::endl;
00449 
00450   std::cout << "Testing mitk::LevelWindow min = max > maxrange ";
00451   levWin->SetWindowBounds(11000, 11000);
00452   if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
00453   {
00454     std::cout<<"[FAILED]"<<std::endl;
00455     return EXIT_FAILURE;
00456   }
00457   levWin->ResetDefaultLevelWindow();
00458   std::cout<<"[PASSED]"<<std::endl;
00459 
00460   std::cout << "Testing mitk::LevelWindow min = max < minrange ";
00461   levWin->SetWindowBounds(-11000, -11000);
00462   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
00463   {
00464     std::cout<<"[FAILED]"<<std::endl;
00465     return EXIT_FAILURE;
00466   }
00467   levWin->ResetDefaultLevelWindow();
00468   std::cout<<"[PASSED]"<<std::endl;
00469 
00470   std::cout << "Testing mitk::LevelWindow maxrange > min > minrange > max ";
00471   levWin->SetWindowBounds(-9000, -11000);
00472   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9000)))
00473   {
00474     std::cout<<"[FAILED]"<<std::endl;
00475     return EXIT_FAILURE;
00476   }
00477   levWin->ResetDefaultLevelWindow();
00478   std::cout<<"[PASSED]"<<std::endl;
00479 
00480   std::cout << "Testing mitk::LevelWindow min > maxrange > minrange > max ";
00481   levWin->SetWindowBounds(11000, -11000);
00482   if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == 10000)))
00483   {
00484     std::cout<<"[FAILED]"<<std::endl;
00485     return EXIT_FAILURE;
00486   }
00487   levWin->ResetDefaultLevelWindow();
00488   std::cout<<"[PASSED]"<<std::endl;
00489 
00490   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with maxrange < min < max ";
00491   levWin->SetRangeMinMax(-20000, -15000);
00492   if (!((levWin->GetLowerWindowBound() == -15001) && (levWin->GetUpperWindowBound() == -15000)))
00493   {
00494     std::cout<<"[FAILED]"<<std::endl;
00495     return EXIT_FAILURE;
00496   }
00497   levWin->ResetDefaultRangeMinMax();
00498   levWin->ResetDefaultLevelWindow();
00499   std::cout<<"[PASSED]"<<std::endl;
00500 
00501   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange > maxrange & maxrange < min < max ";
00502   levWin->ResetDefaultLevelWindow();
00503   levWin->SetRangeMinMax(-15000, -20000);
00504   if (!((levWin->GetLowerWindowBound() == -15001) && (levWin->GetUpperWindowBound() == -15000)))
00505   {
00506     std::cout<<"[FAILED]"<<std::endl;
00507     return EXIT_FAILURE;
00508   }
00509   levWin->ResetDefaultRangeMinMax();
00510   levWin->ResetDefaultLevelWindow();
00511   std::cout<<"[PASSED]"<<std::endl;
00512 
00513   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange < min < maxrange < max ";
00514   levWin->SetRangeMinMax(-80, 1000);
00515   levWin->SetWindowBounds(-1000,110);
00516   if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 110)))
00517   {
00518     std::cout<<"[FAILED]"<<std::endl;
00519     return EXIT_FAILURE;
00520   }
00521   levWin->ResetDefaultRangeMinMax();
00522   levWin->ResetDefaultLevelWindow();
00523   std::cout<<"[PASSED]"<<std::endl;
00524 
00525   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with maxrange < minrange & minrange < min < maxrange < max ";
00526   levWin->SetRangeMinMax(1000,-80);
00527   levWin->SetWindowBounds(-1000,110);
00528   if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 110)))
00529   {
00530     std::cout<<"[FAILED]"<<std::endl;
00531     return EXIT_FAILURE;
00532   }
00533   levWin->ResetDefaultRangeMinMax();
00534   levWin->ResetDefaultLevelWindow();
00535   std::cout<<"[PASSED]"<<std::endl;
00536 
00537   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with min < minrange < maxrange <max ";
00538   levWin->SetRangeMinMax(20, 110);
00539   if (!((levWin->GetLowerWindowBound() == 20) && (levWin->GetUpperWindowBound() == 110)))
00540   {
00541     std::cout<<"[FAILED]"<<std::endl;
00542     return EXIT_FAILURE;
00543   }
00544   levWin->ResetDefaultRangeMinMax();
00545   levWin->ResetDefaultLevelWindow();
00546   std::cout<<"[PASSED]"<<std::endl;
00547 
00548   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minRange > maxRange & min < maxrange < max ";
00549   levWin->SetWindowBounds(-90,1000);
00550   levWin->SetRangeMinMax(100, -80);
00551 
00552   if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 100)))
00553   {
00554     std::cout<<"[FAILED]"<<std::endl;
00555     return EXIT_FAILURE;
00556   }
00557   levWin->ResetDefaultRangeMinMax();
00558   levWin->ResetDefaultLevelWindow();
00559   std::cout<<"[PASSED]"<<std::endl;
00560 
00561   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minRange > maxRange & min < minrange < maxrange <max ";
00562   levWin->SetRangeMinMax(20, 100);
00563   if (!((levWin->GetLowerWindowBound() == 20) && (levWin->GetUpperWindowBound() == 100)))
00564   {
00565     std::cout<<"[FAILED]"<<std::endl;
00566     return EXIT_FAILURE;
00567   }
00568   levWin->ResetDefaultRangeMinMax();
00569   levWin->ResetDefaultLevelWindow();
00570   std::cout<<"[PASSED]"<<std::endl;
00571 
00572   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with min < max < minrange ";
00573   levWin->SetRangeMinMax(20000, 15000);
00574   if (!((levWin->GetLowerWindowBound() == 15000) && (levWin->GetUpperWindowBound() == 15001)))
00575   {
00576     std::cout<<"[FAILED]"<<std::endl;
00577     return EXIT_FAILURE;
00578   }
00579   levWin->ResetDefaultRangeMinMax();
00580   levWin->ResetDefaultLevelWindow();
00581   std::cout<<"[PASSED]"<<std::endl;
00582 
00583   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange > maxrange & min < max < minrange ";
00584   levWin->SetRangeMinMax(20000, 15000);
00585   if (!((levWin->GetLowerWindowBound() == 15000) && (levWin->GetUpperWindowBound() == 15001)))
00586   {
00587     std::cout<<"[FAILED]"<<std::endl;
00588     return EXIT_FAILURE;
00589   }
00590   levWin->ResetDefaultRangeMinMax();
00591   levWin->ResetDefaultLevelWindow();
00592   std::cout<<"[PASSED]"<<std::endl;
00593 
00594   std::cout << "Testing mitk::LevelWindow SetRangeMinMax with min < minrange <max ";
00595   levWin->SetRangeMinMax(-20000, -15000);
00596   if (!((levWin->GetLowerWindowBound() == -15001) && (levWin->GetUpperWindowBound() == -15000)))
00597   {
00598     std::cout<<"[FAILED]"<<std::endl;
00599     return EXIT_FAILURE;
00600   }
00601   levWin->ResetDefaultRangeMinMax();
00602   levWin->ResetDefaultLevelWindow();
00603   std::cout<<"[PASSED]"<<std::endl;
00604 
00605   // auch f�r default levelwindow und default range
00606 
00607   //Create Image out of nowhere
00608   mitk::Image::Pointer image;
00609   mitk::PixelType pt(typeid(int));
00610   unsigned int dim[]={100,100,20};
00611 
00612   std::cout << "Creating image: ";
00613   image = mitk::Image::New();
00614   //image->DebugOn();
00615   image->Initialize(mitk::PixelType(typeid(int)), 3, dim);
00616   int *p = (int*)image->GetData();
00617 
00618   int size = dim[0]*dim[1]*dim[2];
00619   int i;
00620   for(i=0; i<size; ++i, ++p)
00621     *p=i;
00622   std::cout<<"[PASSED]"<<std::endl;
00623 
00624   std::cout << "Testing mitk::LevelWindow SetAuto ";
00625   mitk::LevelWindow levelwindow;
00626   levelwindow.SetAuto( image );
00627   std::cout<<"[PASSED]"<<std::endl;
00628 
00629   std::cout << "Testing mitk::LevelWindow constructor with mitkLevelWindow ";
00630   const mitk::LevelWindow* lw = new mitk::LevelWindow(levelwindow);
00631   if (!(lw->GetRange() == levelwindow.GetRange()))
00632   {
00633     std::cout<<"[FAILED]"<<std::endl;
00634     return EXIT_FAILURE;
00635   }
00636   std::cout<<"[PASSED]"<<std::endl;
00637   
00638   std::cout << "Testing mitk::LevelWindow destructor ";
00639   delete levWin;
00640   delete lw;
00641   std::cout<<"[PASSED]"<<std::endl;
00642   std::cout<<"[TEST DONE]"<<std::endl;
00643   return EXIT_SUCCESS;
00644 }