common/clitkImageCommon.txx

   1 /*=========================================================================
   2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
   3
   4   Authors belong to:
   5   - University of LYON              http://www.universite-lyon.fr/
   6   - Léon Bérard cancer center       http://oncora1.lyon.fnclcc.fr
   7   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
   8
   9   This software is distributed WITHOUT ANY WARRANTY; without even
  10   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11   PURPOSE.  See the copyright notices for more information.
  12
  13   It is distributed under dual licence
  14
  15   - BSD        See included LICENSE.txt file
  16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  17 ======================================================================-====*/
  18 #ifndef CLITKIMAGECOMMON_TXX
  19 #define CLITKIMAGECOMMON_TXX
  20
  21
  22 //--------------------------------------------------------------------
  23 template<class PixelType>
  24 typename itk::Image<PixelType,1>::Pointer
  25 NewImage1D(int vsize, double vspacing)
  26 {
  27   typedef itk::Image<PixelType,1> ImageType;
  28   typename ImageType::Pointer g = ImageType::New();
  29   typename ImageType::SizeType size;
  30   size[0] = vsize;
  31   typename ImageType::RegionType region;
  32   region.SetSize(size);
  33   g->SetRegions(region);
  34   typename ImageType::SpacingType spacing;
  35   spacing[0] = vspacing;
  36   g->SetSpacing(spacing);
  37   return g;
  38 }
  39 //--------------------------------------------------------------------
  40
  41 //--------------------------------------------------------------------
  42 template<class PixelType>
  43 typename itk::Image<PixelType,2>::Pointer
  44 NewImage2D(int sx, int sy, double dx, double dy)
  45 {
  46   typedef itk::Image<PixelType,2> ImageType;
  47   typename ImageType::Pointer g = ImageType::New();
  48   typename ImageType::SizeType size;
  49   size[0] = sx;
  50   size[1] = sy;
  51   typename ImageType::RegionType region;
  52   region.SetSize(size);
  53   g->SetRegions(region);
  54   typename ImageType::SpacingType spacing;
  55   spacing[0] = dx;
  56   spacing[1] = dy;
  57   g->SetSpacing(spacing);
  58   return g;
  59 }
  60 //--------------------------------------------------------------------
  61
  62
  63 //--------------------------------------------------------------------
  64 template<class PixelType>
  65 typename itk::Image<PixelType,3>::Pointer
  66 NewImage3D(int sx, int sy, int sz, double dx, double dy, double dz)
  67 {
  68   typedef itk::Image<PixelType,3> ImageType;
  69   typename ImageType::Pointer g = ImageType::New();
  70   typename ImageType::SizeType size;
  71   size[0] = sx;
  72   size[1] = sy;
  73   size[2] = sz;
  74   typename ImageType::RegionType region;
  75   region.SetSize(size);
  76   g->SetRegions(region);
  77   typename ImageType::SpacingType spacing;
  78   spacing[0] = dx;
  79   spacing[1] = dy;
  80   spacing[2] = dz;
  81   g->SetSpacing(spacing);
  82   return g;
  83 }
  84 //--------------------------------------------------------------------
  85
  86 //--------------------------------------------------------------------
  87 template<class PixelType>
  88 typename itk::Image<PixelType,4>::Pointer NewImage4D(int sx, int sy, int sz, int st, double dx, double dy, double dz, double dt)
  89 {
  90   typedef itk::Image<PixelType,3> ImageType;
  91   typename ImageType::Pointer g = ImageType::New();
  92   typename ImageType::SizeType size;
  93   size[0] = sx;
  94   size[1] = sy;
  95   size[2] = sz;
  96   size[3] = st;
  97   typename ImageType::RegionType region;
  98   region.SetSize(size);
  99   g->SetRegions(region);
 100   typename ImageType::SpacingType spacing;
 101   spacing[0] = dx;
 102   spacing[1] = dy;
 103   spacing[2] = dz;
 104   spacing[3] = dt;
 105   g->SetSpacing(spacing);
 106   return g;
 107 }
 108 //--------------------------------------------------------------------
 109
 110
 111 //--------------------------------------------------------------------
 112 template<class ImageType>
 113 typename ImageType::Pointer NewImageLike(const typename ImageType::Pointer input, bool allocate)
 114 {
 115   typename ImageType::Pointer output = ImageType::New();
 116   output->CopyInformation(input);
 117   output->SetRegions(input->GetLargestPossibleRegion());
 118   if (allocate) output->Allocate();
 119   return output;
 120 }
 121 //--------------------------------------------------------------------
 122
 123
 124 //--------------------------------------------------------------------
 125 template<class ImageType>
 126 void CopyValues(const typename ImageType::Pointer input,
 127                 typename ImageType::Pointer output)
 128 {
 129   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
 130   ConstIteratorType pi(input,input->GetLargestPossibleRegion());
 131   pi.GoToBegin();
 132   typedef itk::ImageRegionIterator<ImageType> IteratorType;
 133   IteratorType po(output,input->GetLargestPossibleRegion());
 134   po.GoToBegin();
 135   while (!pi.IsAtEnd()) {
 136     po.Set(pi.Get());
 137     ++pi;
 138     ++po;
 139   }
 140 }
 141 //--------------------------------------------------------------------
 142
 143
 144 //--------------------------------------------------------------------
 145 template<class ImageType>
 146 typename ImageType::Pointer readImage(const std::string & filename, const bool verbose)
 147 {
 148   typedef itk::ImageFileReader<ImageType> ReaderType;
 149   typename ReaderType::Pointer reader = ReaderType::New();
 150   reader->SetFileName(filename.c_str());
 151   if (verbose) {
 152     std::cout << "Reading [" << filename << "] ... " << std::endl;
 153   }
 154   try {
 155     reader->Update();
 156   } catch(itk::ExceptionObject & err) {
 157     std::cerr << "Exception while reading image [" << filename << "]" << std::endl;
 158     std::cerr << err << std::endl;
 159     exit(0);
 160   }
 161   return reader->GetOutput();
 162 }
 163 //--------------------------------------------------------------------
 164
 165 //--------------------------------------------------------------------
 166 template<typename ImageType>
 167 typename ImageType::Pointer readImage(const std::vector<std::string> & filenames,
 168                                       const bool verbose)
 169 {
 170   if (filenames.size() == 1) return readImage<ImageType>(filenames[0], verbose);
 171   typedef itk::ImageSeriesReader<ImageType> ReaderType;
 172   typename ReaderType::Pointer reader = ReaderType::New();
 173   reader->SetFileNames(filenames);
 174   if (verbose) {
 175     std::cout << "Reading " << filenames[0] << " and others ..." << std::endl;
 176   }
 177   try {
 178     reader->Update();
 179   } catch( itk::ExceptionObject & err ) {
 180     std::cerr << "Error while reading " << filenames[0]
 181               << " or other files ..." << err << std::endl;
 182     exit(0);
 183   }
 184   return reader->GetOutput();
 185 }
 186 //--------------------------------------------------------------------
 187
 188
 189 //--------------------------------------------------------------------
 190 template<class ImageType>
 191 void writeImage(const typename ImageType::Pointer image, const std::string & filename, const bool verbose)
 192 {
 193   typedef itk::ImageFileWriter<ImageType> WriterType;
 194   typename WriterType::Pointer writer = WriterType::New();
 195   writer->SetFileName(filename.c_str());
 196   writer->SetInput(image);
 197   if (verbose) {
 198     std::cout << "Writing [" << filename << "] ... " << std::endl;
 199   }
 200   try {
 201     writer->Update();
 202   } catch( itk::ExceptionObject & err ) {
 203     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 204     std::cerr << err << std::endl;
 205     exit(-1);
 206   }
 207 }
 208 //--------------------------------------------------------------------
 209
 210
 211 //--------------------------------------------------------------------
 212 template<class ImageType>
 213 void writeImage(const ImageType* image, const std::string & filename, const bool verbose)
 214 {
 215   typedef itk::ImageFileWriter<ImageType> WriterType;
 216   typename WriterType::Pointer writer = WriterType::New();
 217   writer->SetFileName(filename.c_str());
 218   writer->SetInput(image);
 219   if (verbose) {
 220     std::cout << "Writing [" << filename << "] ... " << std::endl;
 221   }
 222   try {
 223     writer->Update();
 224   } catch( itk::ExceptionObject & err ) {
 225     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 226     std::cerr << err << std::endl;
 227     exit(-1);
 228   }
 229 }
 230 // //--------------------------------------------------------------------
 231
 232 // //--------------------------------------------------------------------
 233 // template<class ImageType>
 234 // void writeImage(const typename ImageType::ConstPointer image, const std::string & filename, const bool verbose=false) {
 235 //   typedef itk::ImageFileWriter<ImageType> WriterType;
 236 //   typename WriterType::Pointer writer = WriterType::New();
 237 //   writer->SetFileName(filename.c_str());
 238 //   writer->SetInput(image);
 239 //   if (verbose) {
 240 //     std::cout << "Writing [" << filename << "] ... " << std::endl;
 241 //   }
 242 //   try {
 243 //     writer->Update();
 244 //   }
 245 //   catch( itk::ExceptionObject & err ) {
 246 //     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 247 //     std::cerr << err << std::endl;
 248 //     exit(-1);
 249 //   }
 250 // }
 251
 252 //--------------------------------------------------------------------
 253
 254 //--------------------------------------------------------------------
 255 // Compute the number of different intensities in an image
 256 template<class ImageType>
 257 int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
 258                                      std::vector<typename ImageType::PixelType> & l)
 259 {
 260   //std::set<typename ImageType::PixelType> listOfIntensities;
 261   std::map<typename ImageType::PixelType, bool> listOfIntensities;
 262   //  listOfIntensities.resize(0);
 263   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
 264   ConstIteratorType pi(image, image->GetLargestPossibleRegion());
 265   pi.Begin();
 266   while (!pi.IsAtEnd()) {
 267     if (!listOfIntensities[pi.Get()]) listOfIntensities[pi.Get()] = true;
 268     // if (std::find(listOfIntensities.begin(),
 269     //                            listOfIntensities.end(),
 270     //                            pi.Get()) == listOfIntensities.end()) {
 271     //    listOfIntensities.insert(pi.Get());
 272     //  }
 273     ++pi;
 274   }
 275
 276   //typename std::set<typename ImageType::PixelType>::const_iterator ppi = listOfIntensities.begin();
 277   typename std::map<typename ImageType::PixelType, bool>::const_iterator ppi = listOfIntensities.begin();
 278   while (ppi != listOfIntensities.end()) {
 279     l.push_back(ppi->first);
 280     ++ppi;
 281   }
 282
 283   return listOfIntensities.size();
 284 }
 285 //--------------------------------------------------------------------
 286
 287
 288 //--------------------------------------------------------------------
 289 template<class InputImageType, class MaskImageType>
 290 void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
 291                                  const typename MaskImageType::Pointer & mask,
 292                                  const std::vector<typename MaskImageType::PixelType> & listOfIntensities,
 293                                  std::map<typename MaskImageType::PixelType,
 294                                  std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights)
 295 {
 296   // Check size
 297   if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) {
 298     itkGenericExceptionMacro(<< "Input and mask images have not the same size"
 299                              << std::endl
 300                              << "Input = " << input->GetLargestPossibleRegion()
 301                              << std::endl
 302                              << "Mask = " << mask->GetLargestPossibleRegion());
 303   }
 304
 305   // reset weights list
 306   mapOfLabelsAndWeights.clear();
 307
 308   // loop
 309   typedef itk::ImageRegionConstIterator<InputImageType> ConstInputIteratorType;
 310   ConstInputIteratorType pi(input, input->GetLargestPossibleRegion());
 311   typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
 312   ConstMaskIteratorType pm(mask, mask->GetLargestPossibleRegion());
 313   pi.Begin();
 314   pm.Begin();
 315   while (!pi.IsAtEnd()) {
 316     mapOfLabelsAndWeights[pm.Get()][pi.Get()]++;
 317     ++pi;
 318     ++pm;
 319   }
 320 }
 321 //--------------------------------------------------------------------
 322
 323
 324 //--------------------------------------------------------------------
 325 template<class ImageType1, class ImageType2>
 326 bool HaveSameSizeAndSpacing(typename ImageType1::ConstPointer A,
 327                            typename ImageType2::ConstPointer B)
 328 {
 329   if (A->GetImageDimension() != B->GetImageDimension()) return false;
 330   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
 331     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
 332     if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
 333   }
 334   return true;
 335 }
 336 //--------------------------------------------------------------------
 337
 338 //--------------------------------------------------------------------
 339 template<class ImageType1, class ImageType2>
 340 bool HaveSameSizeAndSpacing(typename ImageType1::Pointer A,
 341                            typename ImageType2::Pointer B)
 342 {
 343   if (A->GetImageDimension() != B->GetImageDimension()) return false;
 344   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
 345     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
 346     if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
 347   }
 348   return true;
 349 }
 350 //--------------------------------------------------------------------
 351
 352 //--------------------------------------------------------------------
 353 template<class ImageType1, class ImageType2>
 354 bool HaveSameSpacing(typename ImageType1::ConstPointer A,
 355                      typename ImageType2::ConstPointer B)
 356 {
 357   if (A->GetImageDimension() != B->GetImageDimension()) return false;
 358   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
 359     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
 360   }
 361   return true;
 362 }
 363 //--------------------------------------------------------------------
 364
 365 //--------------------------------------------------------------------
 366 template<class ImageType1, class ImageType2>
 367 bool HaveSameSpacing(typename ImageType1::Pointer A,
 368                            typename ImageType2::Pointer B)
 369 {
 370   if (A->GetImageDimension() != B->GetImageDimension()) return false;
 371   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
 372     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
 373   }
 374   return true;
 375 }
 376 //--------------------------------------------------------------------
 377
 378 #endif /* end #define CLITKIMAGECOMMON_TXX */
 379