mitk: mitkExtractImageFilterTest.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 "mitkExtractImageFilter.h"
00019 #include "mitkCoreObjectFactory.h"
00020 #include "mitkDataNodeFactory.h"
00021 #include "mitkCompareImageSliceTestHelper.h"
00022 #include "mitkImageTimeSelector.h"
00023 
00024 unsigned int CompareImageSliceTestHelper::m_Dimension0 = 0;
00025 unsigned int CompareImageSliceTestHelper::m_Dimension1 = 0;
00026 unsigned int CompareImageSliceTestHelper::m_SliceDimension = 0;
00027 unsigned int CompareImageSliceTestHelper::m_SliceIndex = 0;
00028 bool CompareImageSliceTestHelper::m_ComparisonResult = false;
00029 mitk::Image* CompareImageSliceTestHelper::m_SliceImage = NULL;
00030  
00031 
00032 
00033 class mitkExtractImageFilterTestClass
00034 {
00035 
00036   public:
00037 
00038 static void Test3D( mitk::ExtractImageFilter* filter, mitk::Image* image, unsigned int& numberFailed )
00039 {
00040   // we expect the result to be the same as the input for 2D (the only possible slice)
00041   assert(filter);
00042   assert(image);
00043 
00044   filter->SetInput( image );
00045 
00046   unsigned int initialNumberFailed = numberFailed;
00047 
00048   for ( unsigned int sliceDimension = 0; sliceDimension < 6; ++sliceDimension )
00049   {
00050     for ( unsigned int sliceIndex = 1; sliceIndex < 3; ++sliceIndex )
00051     {
00052       filter->SetSliceDimension( sliceDimension );
00053       filter->SetSliceIndex( sliceIndex ); // second slice in that direction
00054       try
00055       {
00056         filter->Update();
00057       }
00058       catch(...)
00059       {
00060         if ( sliceDimension < 3 )
00061         {
00062           ++numberFailed;
00063           std::cerr << "  (EE) Extracting produced an exception for " 
00064                     << image->GetDimension() 
00065                     << "-dimensional image, sliceDimension " 
00066                     << sliceDimension 
00067                     << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00068           continue;
00069         }
00070         else
00071         {
00072           // this was expected and is nice to see
00073           continue;
00074         }
00075       }
00076 
00077       if ( sliceDimension >= 3 )
00078       {
00079         // we would expect to get an exception earlier
00080         ++numberFailed;
00081         std::cerr << "  (EE) Extracting produced no exception (although it should) for " 
00082                   << image->GetDimension() 
00083                   << "-dimensional image, sliceDimension " 
00084                   << sliceDimension 
00085                     << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00086         continue;
00087       }
00088 
00089       mitk::Image::Pointer output = filter->GetOutput();
00090 
00091       if (output.GetPointer() == filter->GetInput())
00092       {
00093         ++numberFailed;
00094         std::cerr << "  (EE) Extracting failed with wrong result (output == input) for " 
00095                   << image->GetDimension() 
00096                   << "-dimensional image, sliceDimension " 
00097                   << sliceDimension 
00098                     << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00099        }
00100 
00101       if (output->GetDimension() == 2)
00102       {
00103         try
00104         {
00105           if (!CompareImageSliceTestHelper::CompareSlice( image, sliceDimension , sliceIndex , output ))
00106           {
00107             ++numberFailed;
00108             std::cerr << "  (EE) Extracting extracted the wrong pixels or somehow messed up with a " 
00109                       << image->GetDimension() 
00110                       << "-dimensional image, sliceDimension " 
00111                       << sliceDimension 
00112                       << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00113           }
00114           else
00115           {
00116             std::cerr << "  :-) Extracting extracted somehow correct pixels with a " 
00117                       << image->GetDimension() 
00118                       << "-dimensional image, sliceDimension " 
00119                       << sliceDimension 
00120                       << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00121           }
00122         }
00123         catch(std::exception& e)
00124         {
00125             ++numberFailed;
00126             std::cerr << "  (EE) Extracting extracted the wrong pixels or somehow SEVERELY messed up with a " 
00127                       << image->GetDimension() 
00128                       << "-dimensional image, sliceDimension " 
00129                       << sliceDimension 
00130                       << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00131             std::cerr << "Following exception was thrown: " << e.what() << std::endl;
00132         }
00133       }
00134       else
00135       {
00136         ++numberFailed;
00137         std::cerr << "  (EE) Extracting failed with wrong result (not 2D) for " 
00138                   << image->GetDimension() 
00139                   << "-dimensional image, sliceDimension " 
00140                   << sliceDimension 
00141                   << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00142        }
00143 
00144     }
00145   }
00146 
00147   if ( numberFailed == initialNumberFailed )
00148   {
00149     std::cout << "  (II) Extracting works like expected (2D result and all pixels the same) for " 
00150               << image->GetDimension() 
00151               << "-dimensional image." << "(l. " << __LINE__ << ")" << std::endl;
00152   }
00153 }
00154 
00155 
00156 static void Test2D( mitk::ExtractImageFilter* filter, mitk::Image* image, unsigned int& numberFailed )
00157 {
00158   // we expect the result to be the same as the input for 2D (the only possible slice)
00159   assert(filter);
00160   assert(image);
00161 
00162   filter->SetInput( image );
00163 
00164   unsigned int initialNumberFailed = numberFailed;
00165 
00166   for ( unsigned int sliceDimension = 0; sliceDimension < 6; ++sliceDimension )
00167   {
00168     filter->SetSliceDimension( sliceDimension );
00169     filter->SetSliceIndex( 1 ); // second slice in that direction
00170     try
00171     {
00172       filter->Update();
00173     }
00174     catch(...)
00175     {
00176       ++numberFailed;
00177       std::cerr << "  (EE) Extracting produced an exception for " 
00178                 << image->GetDimension() 
00179                 << "-dimensional image, sliceDimension " 
00180                 << sliceDimension 
00181                 << " sliceIndex 1." << "(l. " << __LINE__ << ")" << std::endl;
00182       continue;
00183     }
00184 
00185     mitk::Image::Pointer output = filter->GetOutput();
00186 
00187     if (output.GetPointer() != filter->GetInput())
00188     {
00189       ++numberFailed;
00190       std::cerr << "  (EE) Extracting failed with wrong result for " 
00191                 << image->GetDimension() 
00192                 << "-dimensional image, sliceDimension " 
00193                 << sliceDimension 
00194                 << " sliceIndex 1." << "(l. " << __LINE__ << ")" << std::endl;
00195      }
00196 
00197   }
00198 
00199   if ( numberFailed == initialNumberFailed )
00200   {
00201     std::cout << "  (II) Extracting works like expected for " 
00202               << image->GetDimension() 
00203               << "-dimensional image." << "(l. " << __LINE__ << ")" << std::endl;
00204   }
00205 }
00206 
00207 static void Test4D( mitk::ExtractImageFilter* filter, mitk::Image* image, unsigned int& numberFailed )
00208 {
00209   // we expect the result to be the same as the input for 2D (the only possible slice)
00210   assert(filter);
00211   assert(image);
00212 
00213   filter->SetInput( image );
00214 
00215   unsigned int initialNumberFailed = numberFailed;
00216 
00217   for ( unsigned int timeStep = 0; timeStep < image->GetTimeSteps(); ++timeStep )
00218   {
00219     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
00220     timeSelector->SetInput( image );
00221     timeSelector->SetTimeNr( timeStep );
00222     timeSelector->UpdateLargestPossibleRegion();
00223     mitk::Image::Pointer image3D = timeSelector->GetOutput();
00224 
00225     for ( unsigned int sliceDimension = 0; sliceDimension < 6; ++sliceDimension )
00226     {
00227       unsigned int maxSliceIndex = 3;
00228       if ( image->GetDimension( sliceDimension ) < 3 ) maxSliceIndex = 2;
00229       if ( image->GetDimension( sliceDimension ) < 2 ) maxSliceIndex = 1;
00230       for ( unsigned int sliceIndex = 1; sliceIndex < maxSliceIndex; ++sliceIndex )
00231       {
00232         filter->SetTimeStep( timeStep );
00233         filter->SetSliceDimension( sliceDimension );
00234         filter->SetSliceIndex( sliceIndex ); // second slice in that direction
00235         try
00236         {
00237           filter->Update();
00238         }
00239         catch(...)
00240         {
00241           if ( sliceDimension < 3 )
00242           {
00243             ++numberFailed;
00244             std::cerr << "  (EE) Extracting produced an exception for " 
00245                       << image->GetDimension() 
00246                       << "-dimensional image, sliceDimension " 
00247                       << sliceDimension 
00248                       << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00249             continue;
00250           }
00251           else
00252           {
00253             // this was expected and is nice to see
00254             continue;
00255           }
00256         }
00257 
00258         if ( sliceDimension >= 3 )
00259         {
00260           // we would expect to get an exception earlier
00261           ++numberFailed;
00262           std::cerr << "  (EE) Extracting produced no exception (although it should) for " 
00263                     << image->GetDimension() 
00264                     << "-dimensional image, sliceDimension " 
00265                     << sliceDimension 
00266                       << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00267           continue;
00268         }
00269 
00270         mitk::Image::Pointer output = filter->GetOutput();
00271 
00272         if (output.GetPointer() == filter->GetInput())
00273         {
00274           ++numberFailed;
00275           std::cerr << "  (EE) Extracting failed with wrong result (output == input) for " 
00276                     << image->GetDimension() 
00277                     << "-dimensional image, sliceDimension " 
00278                     << sliceDimension 
00279                       << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00280          }
00281 
00282         if (output->GetDimension() == 2)
00283         {
00284           if (!CompareImageSliceTestHelper::CompareSlice( image3D, sliceDimension , sliceIndex , output ))
00285           {
00286             ++numberFailed;
00287             std::cerr << "  (EE) Extracting extracted the wrong pixels or somehow messed up with a " 
00288                       << image->GetDimension() 
00289                       << "-dimensional image, time step " 
00290                       << timeStep 
00291                       << "sliceDimension " 
00292                       << sliceDimension 
00293                       << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00294           }
00295         }
00296         else
00297         {
00298           ++numberFailed;
00299           std::cerr << "  (EE) Extracting failed with wrong result (not 2D) for " 
00300                     << image->GetDimension() 
00301                     << "-dimensional image, sliceDimension " 
00302                     << sliceDimension 
00303                     << " sliceIndex " << sliceIndex << "." << "(l. " << __LINE__ << ")" << std::endl;
00304          }
00305 
00306       }
00307     }
00308 
00309     if ( numberFailed == initialNumberFailed )
00310     {
00311       std::cout << "  (II) Extracting works like expected (2D result and all pixels the same) for " 
00312                 << image->GetDimension() 
00313                 << "-dimensional image." << "(l. " << __LINE__ << ")" << std::endl;
00314     }
00315   }
00316 }
00317 
00318 
00319 static void TestOtherD( mitk::ExtractImageFilter* filter, mitk::Image* image, unsigned int& numberFailed )
00320 {
00321   // we expect the result to be empty for images other than 2D or 3D
00322   assert(filter);
00323   assert(image);
00324 
00325   filter->SetInput( image );
00326 
00327   unsigned int initialNumberFailed = numberFailed;
00328 
00329   for ( unsigned int sliceDimension = 0; sliceDimension < 6; ++sliceDimension )
00330   {
00331     filter->SetSliceDimension( sliceDimension );
00332     filter->SetSliceIndex( 1 ); // second slice in that direction
00333     try
00334     {
00335       filter->Update();
00336     }
00337     catch(...)
00338     {
00339      continue;
00340     }
00341 
00342     // no exception
00343     ++numberFailed;
00344     std::cerr << "  (EE) Extracting produced no exception for " 
00345               << image->GetDimension() 
00346               << "-dimensional image, sliceDimension " 
00347               << sliceDimension 
00348               << " sliceIndex 1." << "(l. " << __LINE__ << ")" << std::endl;
00349  }
00350 
00351   if ( numberFailed == initialNumberFailed )
00352   {
00353     std::cout << "  (II) Extracting works like expected for " 
00354               << image->GetDimension() 
00355               << "-dimensional image." << "(l. " << __LINE__ << ")" << std::endl;
00356   }
00357 }
00358 
00359 };
00360 
00362 int mitkExtractImageFilterTest(int argc, char* argv[])
00363 {
00364   // one big variable to tell if anything went wrong
00365     unsigned int numberFailed(0);
00366  
00367   // need one parameter (image filename)
00368     if(argc==0)
00369     {
00370       std::cerr<<"No file specified [FAILED]"<<std::endl;
00371       return EXIT_FAILURE;
00372     }
00373  
00374   // load the image
00375 
00376     mitk::Image::Pointer image = NULL;
00377     mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
00378     try
00379     {
00380       std::cout << "Testing with parameter '" << argv[1] << "'" << std::endl;
00381       factory->SetFileName( argv[1] );
00382       factory->Update();
00383 
00384       if(factory->GetNumberOfOutputs()<1)
00385       {
00386         std::cerr<<"File could not be loaded [FAILED]"<<std::endl;
00387         return EXIT_FAILURE;
00388       }
00389       mitk::DataNode::Pointer node = factory->GetOutput( 0 );
00390       image = dynamic_cast<mitk::Image*>(node->GetData());
00391       if(image.IsNull())
00392       {
00393         std::cout<<"File not an image - test will not be applied [PASSED]"<<std::endl;
00394         std::cout<<"[TEST DONE]"<<std::endl;
00395         return EXIT_SUCCESS;
00396       }
00397     }
00398     catch ( itk::ExceptionObject & ex )
00399     {
00400       ++numberFailed;
00401       std::cerr << "Exception: " << ex << "[FAILED]" << std::endl;
00402       return EXIT_FAILURE;
00403     }
00404 
00405     std::cout << "  (II) Could load image." << std::endl;
00406     std::cout << "Testing filter instantiation" << std::endl;
00407 
00408   // instantiation
00409     mitk::ExtractImageFilter::Pointer filter = mitk::ExtractImageFilter::New();
00410     if (filter.IsNotNull())
00411     {
00412       std::cout << "  (II) Instantiation works." << std::endl;
00413     }
00414     else
00415     {
00416       ++numberFailed;
00417       std::cout << "Test failed, and it's the ugliest one!" << std::endl;
00418       return EXIT_FAILURE;
00419     }
00420 
00421   // some real work
00422     if ( image->GetDimension() == 2 )
00423     {
00424       mitkExtractImageFilterTestClass::Test2D( filter, image, numberFailed );
00425     }
00426     else if ( image->GetDimension() == 3 )
00427     {
00428       mitkExtractImageFilterTestClass::Test3D( filter, image, numberFailed );
00429     }
00430     else if ( image->GetDimension() == 4 )
00431     {
00432       mitkExtractImageFilterTestClass::Test4D( filter, image, numberFailed );
00433     }
00434   
00435     std::cout << "Testing filter destruction" << std::endl;
00436 
00437   // freeing
00438     filter = NULL;
00439       
00440     std::cout << "  (II) Freeing works." << std::endl;
00441 
00442     if (numberFailed > 0)
00443     {
00444       std::cerr << numberFailed << " tests failed." << std::endl;
00445       return EXIT_FAILURE;
00446     }
00447     else
00448     {
00449       std::cout << "PASSED all tests." << std::endl;
00450       return EXIT_SUCCESS;
00451     }
00452 }
00453 
00454