mitk: mitkImageToItkTest.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 
00019 #include "mitkImage.h"
00020 #include "mitkImageAccessByItk.h"
00021 #include "mitkITKImageImport.h"
00022 #include "mitkReferenceCountWatcher.h"
00023 #include "itkDiffusionTensor3D.h"
00024 #include "itkConfidenceDiffusionTensor3D.h"
00025 #include <mitkImageCast.h>
00026 
00027 #include <fstream>
00028 
00029 int compareGeometries(mitk::Geometry3D* geometry1, mitk::Geometry3D* geometry2)
00030 {
00031   std::cout << "Testing transfer of GetGeometry()->GetOrigin(): " << std::flush;
00032   if(mitk::Equal(geometry1->GetOrigin(), geometry2->GetOrigin()) == false)
00033   {
00034     std::cout<<"[FAILED]"<<std::endl;
00035     return EXIT_FAILURE;
00036   }
00037   std::cout<<"[PASSED]"<<std::endl;
00038 
00039   std::cout << "Testing transfer of GetGeometry()->GetSpacing(): " << std::flush;
00040   if(mitk::Equal(geometry1->GetSpacing(), geometry2->GetSpacing()) == false)
00041   {
00042     std::cout<<"[FAILED]"<<std::endl;
00043     return EXIT_FAILURE;
00044   }
00045   std::cout<<"[PASSED]"<<std::endl;
00046 
00047   int i;
00048   for(i=0; i<3; ++i)
00049   {
00050     std::cout << "Testing transfer of GetGeometry()->GetAxisVector(" << i << "): " << std::flush;
00051     if(mitk::Equal(geometry1->GetAxisVector(i), geometry2->GetAxisVector(i)) == false)
00052     {
00053       std::cout<<"[FAILED]"<<std::endl;
00054       return EXIT_FAILURE;
00055     }
00056     std::cout<<"[PASSED]"<<std::endl;
00057   }
00058   return EXIT_SUCCESS;
00059 }
00060 
00061 template <class ImageType>
00062 int testBackCasting(mitk::Image* imgMem, typename ImageType::Pointer & itkImage, bool disconnectAfterImport)
00063 {
00064   int result;
00065 
00066   if(itkImage.IsNull())
00067   {
00068     std::cout<<"[FAILED]"<<std::endl;
00069     return EXIT_FAILURE;
00070   }
00071   int *p = (int*)itkImage->GetBufferPointer();
00072   if(p==NULL)
00073   {
00074     std::cout<<"[FAILED]"<<std::endl;
00075     return EXIT_FAILURE;
00076   }
00077   std::cout<<"[PASSED]"<<std::endl;
00078 
00079   std::cout << "Testing mitk::CastToMitkImage: " << std::flush;
00080   mitk::Image::Pointer mitkImage = mitk::Image::New();
00081   mitk::CastToMitkImage( itkImage, mitkImage );
00082   std::cout<<"[PASSED]"<<std::endl;
00083 
00084   result = compareGeometries(imgMem->GetGeometry(), mitkImage->GetGeometry());
00085   if(result != EXIT_SUCCESS)
00086     return result;
00087 
00088   std::cout << "Testing whether data after mitk::CastToMitkImage is available: " << std::flush;
00089   if(mitkImage->IsChannelSet()==false)
00090   {
00091     std::cout<<"[FAILED]"<<std::endl;
00092     return EXIT_FAILURE;
00093   }
00094   std::cout<<"[PASSED]"<<std::endl;
00095 
00096   std::cout << "Testing mitk::ImportItkImage: " << std::flush;
00097   mitkImage = mitk::ImportItkImage(itkImage);
00098   std::cout<<"[PASSED]"<<std::endl;
00099 
00100   if(disconnectAfterImport)
00101   {
00102     std::cout << "Testing DisconnectPipeline() on mitk::Image into which was imported : " << std::flush;
00103     mitkImage->DisconnectPipeline();
00104     std::cout<<"[PASSED]"<<std::endl;
00105   }
00106 
00107   result = compareGeometries(imgMem->GetGeometry(), mitkImage->GetGeometry());
00108   if(result != EXIT_SUCCESS)
00109     return result;
00110 
00111   std::cout << "Testing whether data after mitk::ImportItkImage is available: " << std::flush;
00112   if(mitkImage->IsChannelSet()==false)
00113   {
00114     std::cout<<"[FAILED]"<<std::endl;
00115     return EXIT_FAILURE;
00116   }
00117   std::cout<<"[PASSED]"<<std::endl;
00118 
00119   return EXIT_SUCCESS;
00120 }
00121 
00122 
00123 template <unsigned int dim>
00124 int testImageToItkAndBack(mitk::Image* imgMem)
00125 {
00126   int result;
00127 
00128   int *p = (int*)imgMem->GetData();
00129   if(p==NULL)
00130   {
00131     std::cout<<"[FAILED]"<<std::endl;
00132     return EXIT_FAILURE;
00133   }
00134   std::cout<<"[PASSED]"<<std::endl;
00135 
00136   std::cout << "Testing for dimension " << dim << ": " << std::flush;
00137   std::cout << "Testing mitk::ImageToItk: " << std::flush;
00138   typedef itk::Image<int,dim> ImageType;
00139 
00140   typename mitk::ImageToItk<ImageType>::Pointer toItkFilter = mitk::ImageToItk<ImageType>::New();
00141   toItkFilter->SetInput(imgMem);
00142   toItkFilter->Update();
00143   typename ImageType::Pointer itkImage = toItkFilter->GetOutput();
00144 
00145   result = testBackCasting<ImageType>(imgMem, itkImage, false);
00146   if(result != EXIT_SUCCESS)
00147     return result;
00148 
00149   std::cout << "Testing mitk::ImageToItk (with subsequent DisconnectPipeline, see below): " << std::flush;
00150   result = testBackCasting<ImageType>(imgMem, itkImage, true);
00151   if(result != EXIT_SUCCESS)
00152     return result;
00153 
00154   return EXIT_SUCCESS;
00155 }
00156 
00157 int mitkImageToItkTest(int /*argc*/, char* /*argv*/[])
00158 {
00159   int result;
00160 
00161   //Create Image out of nowhere
00162   mitk::Image::Pointer imgMem;
00163   mitk::PixelType pt(typeid(int));
00164 
00165   std::cout << "Testing creation of Image: ";
00166   imgMem=mitk::Image::New();
00167   if(imgMem.IsNull())
00168   {
00169     std::cout<<"[FAILED]"<<std::endl;
00170     return EXIT_FAILURE;
00171   }
00172   std::cout<<"[PASSED]"<<std::endl;
00173 
00174   // geometry information for image
00175   mitk::Point3D origin;
00176   mitk::Vector3D right, bottom;
00177   mitk::Vector3D spacing;
00178   mitk::FillVector3D(origin, 17.0, 19.92, 7.83);
00179   mitk::FillVector3D(right, 1.0, 2.0, 3.0);
00180   mitk::FillVector3D(bottom, 0.0, -3.0, 2.0);
00181   mitk::FillVector3D(spacing, 0.78, 0.91, 2.23);
00182 
00183   std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing): " << std::flush;
00184   mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
00185   planegeometry->InitializeStandardPlane(100, 100, right, bottom, &spacing);
00186   planegeometry->SetOrigin(origin);
00187   std::cout << "done" << std::endl;
00188 
00189   std::cout << "Testing Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry) and GetData(): ";
00190   imgMem->Initialize(mitk::PixelType(typeid(int)), 40, *planegeometry); //XXXXXXXXXXXXXXXXXXXXXCHANGE!
00191 
00192   result = testImageToItkAndBack<3>(imgMem);
00193   if(result != EXIT_SUCCESS)
00194     return result;
00195 
00196   std::cout << "Testing mitk::CastToItkImage with casting (mitk int to itk float): " << std::flush;
00197   typedef itk::Image<float,3> ImageType;
00198   ImageType::Pointer itkImage;
00199   mitk::CastToItkImage( imgMem, itkImage );
00200 
00201   result = testBackCasting<ImageType>(imgMem, itkImage, false);
00202   if(result != EXIT_SUCCESS)
00203     return result;
00204 
00205   result = testBackCasting<ImageType>(imgMem, itkImage, true);
00206   if(result != EXIT_SUCCESS)
00207     return result;
00208 
00209   std::cout << "Testing Initialize(const mitk::PixelType& type, int sDim, const mitk::PlaneGeometry& geometry) and GetData(): ";
00210   imgMem->Initialize(mitk::PixelType(typeid(int)), 40, *planegeometry, false, 1, 6);
00211   result = testImageToItkAndBack<4>(imgMem);
00212   if(result != EXIT_SUCCESS)
00213     return result;
00214 
00215   std::cout << "Testing mitk::CastToItkImage again (mitk float to itk float): " << std::flush;
00216   imgMem->Initialize(mitk::PixelType(typeid(float)), 40, *planegeometry);
00217   mitk::CastToItkImage( imgMem, itkImage );
00218   std::cout<<"[PASSED]"<<std::endl;
00219 
00220   mitk::ImageDataItem::Pointer imageDataItem = imgMem->GetChannelData().GetPointer();
00221   std::cout << "Testing destruction of original mitk::Image: " << std::flush;
00222   imgMem = NULL;
00223   std::cout<<"[PASSED]"<<std::endl;
00224 
00225   std::cout << "Testing reference count mitk::ImageDataItem, which is responsible for the memory still used within the itk::Image: " << std::flush;
00226   if(imageDataItem->GetReferenceCount()-1 != 1) // 1 count by imageDataItem itself
00227   {
00228     std::cout<< imageDataItem->GetReferenceCount()-1 << " != 1. [FAILED]" << std::endl;
00229     return EXIT_FAILURE;
00230   }
00231   std::cout<<"[PASSED]"<<std::endl;
00232 
00233   std::cout << "Testing destruction of itk::Image: " << std::flush;
00234   itkImage = NULL;
00235   std::cout<<"[PASSED]"<<std::endl;
00236 
00237   std::cout << "Testing reference count mitk::ImageDataItem, which should now have been freed by itk::Image: " << std::flush;
00238   if(imageDataItem->GetReferenceCount()-1 != 0) // 1 count by imageDataItem itself
00239   {
00240     std::cout<< imageDataItem->GetReferenceCount()-1 << " != 0. [FAILED]" << std::endl;
00241     return EXIT_FAILURE;
00242   }
00243   std::cout<<"[PASSED]"<<std::endl;
00244 
00245   imgMem=mitk::Image::New();
00246   itk::Image<itk::DiffusionTensor3D<float>,3>::Pointer diffImage;
00247   imgMem->Initialize(mitk::PixelType(typeid(itk::DiffusionTensor3D<float>)), 40, *planegeometry);
00248   mitk::CastToItkImage( imgMem, diffImage );
00249   imgMem->InitializeByItk(diffImage.GetPointer());
00250   std::cout<<"[PASSED]"<<std::endl;
00251 
00252   itk::Image<itk::DiffusionTensor3D<double>,3>::Pointer diffImage2;
00253   imgMem->Initialize(mitk::PixelType(typeid(itk::DiffusionTensor3D<double>)), 40, *planegeometry);
00254   mitk::CastToItkImage( imgMem, diffImage2 );
00255   imgMem->InitializeByItk(diffImage2.GetPointer());
00256   std::cout<<"[PASSED]"<<std::endl;
00257 
00258   itk::Image<itk::ConfidenceDiffusionTensor3D<float>,3>::Pointer confDiffImage;
00259   imgMem->Initialize(mitk::PixelType(typeid(itk::ConfidenceDiffusionTensor3D<float>)), 40, *planegeometry);
00260   mitk::CastToItkImage( imgMem, confDiffImage );
00261   imgMem->InitializeByItk(confDiffImage.GetPointer());
00262   std::cout<<"[PASSED]"<<std::endl;
00263 
00264   itk::Image<itk::ConfidenceDiffusionTensor3D<double>,3>::Pointer confDiffImage2;
00265   imgMem->Initialize(mitk::PixelType(typeid(itk::ConfidenceDiffusionTensor3D<double>)), 40, *planegeometry);
00266   mitk::CastToItkImage( imgMem, confDiffImage2 );
00267   imgMem->InitializeByItk(confDiffImage2.GetPointer());
00268   std::cout<<"[PASSED]"<<std::endl;
00269 
00270   std::cout<<"[TEST DONE]"<<std::endl;
00271   return EXIT_SUCCESS;
00272 }