Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include "mitkSegmentationInterpolationController.h"
00019 #include "mitkCoreObjectFactory.h"
00020 #include "mitkStandardFileLocations.h"
00021 #include "mitkDataNodeFactory.h"
00022 #include "ipSegmentation.h"
00023 #include "mitkCompareImageSliceTestHelper.h"
00024
00025 class mitkSegmentationInterpolationTestClass
00026 {
00027 public:
00028 mitkSegmentationInterpolationTestClass() {}
00029 ~mitkSegmentationInterpolationTestClass() {}
00030
00031 bool Test()
00032 {
00033 return CreateNewInterpolator()
00034 && CreateSegmentation()
00035 && ClearSegmentation()
00036 && CreateTwoSlices(2)
00037 && TestInterpolation(2)
00038 && ClearSegmentation()
00039 && CreateTwoSlices(1)
00040 && TestInterpolation(1)
00041 && ClearSegmentation()
00042 && CreateTwoSlices(0)
00043 && TestInterpolation(0)
00044 && DeleteInterpolator()
00045 && CreateNewInterpolator()
00046 && LoadTestImages()
00047 && CompareInterpolationsToDefinedReference();
00048 }
00049
00050 protected:
00051
00052 bool CreateNewInterpolator();
00053 bool CreateSegmentation();
00054 bool ClearSegmentation();
00055 bool CreateTwoSlices(int);
00056 bool TestInterpolation(int);
00057 bool DeleteInterpolator();
00058 bool LoadTestImages();
00059 bool CompareInterpolationsToDefinedReference();
00060
00061 mitk::Image::Pointer LoadImage(const std::string& filename);
00062
00063 mitk::SegmentationInterpolationController::Pointer m_Interpolator;
00064 mitk::Image::Pointer m_Image;
00065
00066 mitk::Image::Pointer m_ManualSlices;
00067 mitk::Image::Pointer m_InterpolatedSlices;
00068
00069 unsigned int dim[3];
00070 int pad[3];
00071 };
00072
00073 bool mitkSegmentationInterpolationTestClass::CreateNewInterpolator()
00074 {
00075 std::cout << "Instantiation" << std::endl;
00076
00077
00078 m_Interpolator = mitk::SegmentationInterpolationController::New();
00079 if (m_Interpolator.IsNotNull())
00080 {
00081 std::cout << " (II) Instantiation works." << std::endl;
00082 }
00083 else
00084 {
00085 std::cout << " Instantiation test failed!" << std::endl;
00086 return false;
00087 }
00088
00089 return true;
00090 }
00091
00092 bool mitkSegmentationInterpolationTestClass::CreateSegmentation()
00093 {
00094 m_Image = mitk::Image::New();
00095 dim[0]=15;
00096 dim[1]=20;
00097 dim[2]=25;
00098 pad[0]=2;
00099 pad[1]=3;
00100 pad[2]=4;
00101
00102 m_Image->Initialize(mitk::PixelType(typeid(int)), 3, dim);
00103
00104 return true;
00105 }
00106
00107 bool mitkSegmentationInterpolationTestClass::ClearSegmentation()
00108 {
00109 int* p = (int*)m_Image->GetData();
00110 int size = dim[0]*dim[1]*dim[2];
00111 for(int i=0; i<size; ++i, ++p) *p=0;
00112
00113 return true;
00114 }
00115
00116
00120 bool mitkSegmentationInterpolationTestClass::CreateTwoSlices(int slicedim)
00121 {
00122 int* p = (int*)m_Image->GetData();
00123
00124 int size = dim[0]*dim[1]*dim[2];
00125 for(int i=0; i<size; ++i, ++p)
00126 {
00127 int x,y,z;
00128 int xdim,ydim;
00129 switch (slicedim)
00130 {
00131 case 0:
00132 z = i % dim[0];
00133 y = i / dim[0] % dim[1];
00134 x = i / (dim[1]*dim[0]);
00135 xdim = 2;
00136 ydim = 1;
00137 break;
00138 case 1:
00139 x = i % dim[0];
00140 z = i / dim[0] % dim[1];
00141 y = i / (dim[1]*dim[0]);
00142 xdim = 0;
00143 ydim = 2;
00144 break;
00145 case 2:
00146 default:
00147 x = i % dim[0];
00148 y = i / dim[0] % dim[1];
00149 z = i / (dim[1]*dim[0]);
00150 xdim = 0;
00151 ydim = 1;
00152 break;
00153 }
00154
00155 if ( ((z == 0) || (z == 2)) && (x >= pad[xdim]) && (x < ( (signed) dim[xdim]-pad[xdim])) && (y >= pad[ydim]) && (y < ( (signed) dim[ydim]-pad[ydim])) )
00156 {
00157 *p = 1;
00158 }
00159 else
00160 {
00161 *p = 0;
00162 }
00163 }
00164
00165 m_Interpolator->SetSegmentationVolume( m_Image );
00166 std::cout << " (II) SetSegmentationVolume works (slicedim " << slicedim << ")" << std::endl;
00167
00168 return true;
00169 }
00170
00174 bool mitkSegmentationInterpolationTestClass::TestInterpolation(int slicedim)
00175 {
00176 int slice = 1;
00177 mitk::Image::Pointer interpolated = m_Interpolator->Interpolate( slicedim, slice, 0 );
00178 if (interpolated.IsNull())
00179 {
00180 std::cerr << " (EE) Interpolation did not return anything for slicedim == " << slicedim << " (although it should)." << std::endl;
00181 return false;
00182 }
00183
00184 int xdim,ydim;
00185 switch (slicedim)
00186 {
00187 case 0:
00188 xdim = 1;
00189 ydim = 2;
00190 break;
00191 case 1:
00192 xdim = 0;
00193 ydim = 2;
00194 break;
00195 case 2:
00196 default:
00197 xdim = 0;
00198 ydim = 1;
00199 break;
00200 }
00201
00202 ipMITKSegmentationTYPE* p = (ipMITKSegmentationTYPE*)interpolated->GetData();
00203
00204 int size = dim[xdim]*dim[ydim];
00205 if ( (signed) interpolated->GetDimension(0) * (signed) interpolated->GetDimension(1) != size )
00206 {
00207 std::cout << " (EE) Size of interpolated image differs from original segmentation..." << std::endl;
00208 return false;
00209 }
00210
00211 for(int i=0; i<size; ++i, ++p)
00212 {
00213 int x,y;
00214 x = i % dim[xdim];
00215 y = i / dim[xdim];
00216
00217
00218
00219 ipMITKSegmentationTYPE value = *p;
00220
00221
00222
00223 if ( (x >= pad[xdim]) && (x < ((signed) dim[xdim]-pad[xdim])) && (y >= pad[ydim]) && (y < ((signed) dim[ydim]-pad[ydim])) && (value != 1) )
00224 {
00225 std::cout << " (EE) Interpolation of a square figure failed" << std::endl;
00226 std::cout << " Value at " << x << " " << y << ": " << (int)value << std::endl;
00227 return false;
00228 }
00229 }
00230
00231 std::cout << " (II) Interpolation of a square figure works like expected (slicedim " << slicedim << ")" << std::endl;
00232 return true;
00233 }
00234
00235 bool mitkSegmentationInterpolationTestClass::DeleteInterpolator()
00236 {
00237 std::cout << "Object destruction" << std::endl;
00238
00239
00240 m_Interpolator = NULL;
00241
00242 std::cout << " (II) Freeing works." << std::endl;
00243 return true;
00244 }
00245
00246 bool mitkSegmentationInterpolationTestClass::LoadTestImages()
00247 {
00248 std::string filename1 = mitk::StandardFileLocations::GetInstance()->FindFile("interpolation_test_manual.pic.gz", "../mitk/Core/Testing/Data/");
00249 if ( filename1.empty() )
00250 {
00251 filename1 = mitk::StandardFileLocations::GetInstance()->FindFile("interpolation_test_manual.pic.gz", "Testing/Data/");
00252 }
00253
00254 std::cout << "Found test image (manual slices) in '" << filename1 << "'" << std::endl;
00255
00256 std::string filename2 = mitk::StandardFileLocations::GetInstance()->FindFile("interpolation_test_result.pic.gz", "../mitk/Core/Testing/Data/");
00257 if ( filename2.empty() )
00258 {
00259 filename2 = mitk::StandardFileLocations::GetInstance()->FindFile("interpolation_test_result.pic.gz", "Testing/Data/");
00260 }
00261
00262 std::cout << "Found test image (reference for interpolation) in '" << filename2 << "'" << std::endl;
00263
00264 if ( filename1.empty() || filename2.empty() )
00265 {
00266 return false;
00267 }
00268 else
00269 {
00270 m_ManualSlices = LoadImage( filename1 );
00271 m_InterpolatedSlices = LoadImage( filename2 );
00272
00273 return ( m_ManualSlices.IsNotNull() && m_InterpolatedSlices.IsNotNull() );
00274 }
00275
00276 return true;
00277 }
00278
00279 mitk::Image::Pointer mitkSegmentationInterpolationTestClass::LoadImage(const std::string& filename)
00280 {
00281 mitk::Image::Pointer image = NULL;
00282 mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
00283 try
00284 {
00285 factory->SetFileName( filename );
00286 factory->Update();
00287
00288 if(factory->GetNumberOfOutputs()<1)
00289 {
00290 std::cerr<<"File " << filename << " could not be loaded [FAILED]"<<std::endl;
00291 return NULL;
00292 }
00293 mitk::DataNode::Pointer node = factory->GetOutput( 0 );
00294 image = dynamic_cast<mitk::Image*>(node->GetData());
00295 if(image.IsNull())
00296 {
00297 std::cout<<"File " << filename << " is not an image! [FAILED]"<<std::endl;
00298 return NULL;
00299 }
00300 }
00301 catch ( itk::ExceptionObject & ex )
00302 {
00303 std::cerr << "Exception: " << ex << "[FAILED]" << std::endl;
00304 return NULL;
00305 }
00306
00307 return image;
00308 }
00309
00310 bool mitkSegmentationInterpolationTestClass::CompareInterpolationsToDefinedReference()
00311 {
00312 std::cout << " (II) Setting segmentation volume... " << std::flush;
00313
00314 m_Interpolator->SetSegmentationVolume( m_ManualSlices );
00315
00316 std::cout << "OK" << std::endl;
00317
00318 std::cout << " (II) Testing interpolation result for slice " << std::flush;
00319
00320 for (unsigned int slice = 1; slice < 98; ++slice)
00321 {
00322 if (slice % 2 == 0) continue;
00323
00324 std::cout << slice << " " << std::flush;
00325
00326 mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( 2, slice, 0 );
00327
00328 if ( interpolation.IsNull() )
00329 {
00330 std::cerr << " (EE) Interpolated image is NULL." << std::endl;
00331 return false;
00332 }
00333
00334 if ( !CompareImageSliceTestHelper::CompareSlice( m_InterpolatedSlices, 2, slice, interpolation ) )
00335 {
00336 std::cerr << " (EE) interpolated image is not identical to reference in slice " << slice << std::endl;
00337 return false;
00338 }
00339 }
00340
00341 std::cout << std::endl;
00342 std::cout << " (II) Interpolations are the same as the saved references." << std::endl;
00343
00344 return true;
00345 }
00346
00348 int mitkSegmentationInterpolationTest(int , char* [])
00349 {
00350
00351 std::cout << "Creating CoreObjectFactory" << std::endl;
00352 itk::ObjectFactoryBase::RegisterFactory(mitk::CoreObjectFactory::New());
00353
00354 mitkSegmentationInterpolationTestClass test;
00355 if ( test.Test() )
00356 {
00357 std::cout << "[PASSED]" << std::endl;
00358 return EXIT_SUCCESS;
00359 }
00360 else
00361 {
00362 std::cout << "[FAILED]" << std::endl;
00363 return EXIT_FAILURE;
00364 }
00365 }
00366