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://www.centreleonberard.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, const bool compression)
 192 {
 193   return writeImage(image.GetPointer(), filename, verbose, compression);
 194 }
 195 //--------------------------------------------------------------------
 196
 197
 198 //--------------------------------------------------------------------
 199 template<class ImageType>
 200 void writeImage(const ImageType* image, const std::string & filename, const bool verbose, const bool compression)
 201 {
 202   typedef itk::ImageFileWriter<ImageType> WriterType;
 203   typename WriterType::Pointer writer = WriterType::New();
 204   writer->SetFileName(filename.c_str());
 205   writer->SetInput(image);
 206   writer->SetUseCompression(compression);
 207   if (verbose) {
 208     std::cout << "Writing [" << filename << "] ... " << std::endl;
 209   }
 210   try {
 211     writer->Update();
 212   } catch( itk::ExceptionObject & err ) {
 213     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 214     std::cerr << err << std::endl;
 215     exit(-1);
 216   }
 217 }
 218 // //--------------------------------------------------------------------
 219
 220 // //--------------------------------------------------------------------
 221 // template<class ImageType>
 222 // void writeImage(const typename ImageType::ConstPointer image, const std::string & filename, const bool verbose=false) {
 223 //   typedef itk::ImageFileWriter<ImageType> WriterType;
 224 //   typename WriterType::Pointer writer = WriterType::New();
 225 //   writer->SetFileName(filename.c_str());
 226 //   writer->SetInput(image);
 227 //   if (verbose) {
 228 //     std::cout << "Writing [" << filename << "] ... " << std::endl;
 229 //   }
 230 //   try {
 231 //     writer->Update();
 232 //   }
 233 //   catch( itk::ExceptionObject & err ) {
 234 //     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 235 //     std::cerr << err << std::endl;
 236 //     exit(-1);
 237 //   }
 238 // }
 239
 240 //--------------------------------------------------------------------
 241
 242 //--------------------------------------------------------------------
 243 // Compute the number of different intensities in an image
 244 template<class ImageType>
 245 int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
 246                                      std::vector<typename ImageType::PixelType> & l)
 247 {
 248   //std::set<typename ImageType::PixelType> listOfIntensities;
 249   std::map<typename ImageType::PixelType, bool> listOfIntensities;
 250   //  listOfIntensities.resize(0);
 251   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
 252   ConstIteratorType pi(image, image->GetLargestPossibleRegion());
 253   pi.Begin();
 254   while (!pi.IsAtEnd()) {
 255     if (!listOfIntensities[pi.Get()]) listOfIntensities[pi.Get()] = true;
 256     // if (std::find(listOfIntensities.begin(),
 257     //                            listOfIntensities.end(),
 258     //                            pi.Get()) == listOfIntensities.end()) {
 259     //    listOfIntensities.insert(pi.Get());
 260     //  }
 261     ++pi;
 262   }
 263
 264   //typename std::set<typename ImageType::PixelType>::const_iterator ppi = listOfIntensities.begin();
 265   typename std::map<typename ImageType::PixelType, bool>::const_iterator ppi = listOfIntensities.begin();
 266   while (ppi != listOfIntensities.end()) {
 267     l.push_back(ppi->first);
 268     ++ppi;
 269   }
 270
 271   return listOfIntensities.size();
 272 }
 273 //--------------------------------------------------------------------
 274
 275
 276 //--------------------------------------------------------------------
 277 template<class InputImageType, class MaskImageType>
 278 void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
 279                                  const typename MaskImageType::Pointer & mask,
 280                                  const std::vector<typename MaskImageType::PixelType> & listOfIntensities,
 281                                  std::map<typename MaskImageType::PixelType,
 282                                  std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights)
 283 {
 284   // Check size
 285   if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) {
 286     itkGenericExceptionMacro(<< "Input and mask images have not the same size"
 287                              << std::endl
 288                              << "Input = " << input->GetLargestPossibleRegion()
 289                              << std::endl
 290                              << "Mask = " << mask->GetLargestPossibleRegion());
 291   }
 292
 293   // reset weights list
 294   mapOfLabelsAndWeights.clear();
 295
 296   // loop
 297   typedef itk::ImageRegionConstIterator<InputImageType> ConstInputIteratorType;
 298   ConstInputIteratorType pi(input, input->GetLargestPossibleRegion());
 299   typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
 300   ConstMaskIteratorType pm(mask, mask->GetLargestPossibleRegion());
 301   pi.Begin();
 302   pm.Begin();
 303   while (!pi.IsAtEnd()) {
 304     mapOfLabelsAndWeights[pm.Get()][pi.Get()]++;
 305     ++pi;
 306     ++pm;
 307   }
 308 }
 309 //--------------------------------------------------------------------
 310
 311
 312 //--------------------------------------------------------------------
 313 template<class ImageType1, class ImageType2>
 314 bool HaveSameSpacing(typename ImageType1::ConstPointer A,
 315                      typename ImageType2::ConstPointer B)
 316 {
 317   if (A->GetImageDimension() != B->GetImageDimension()) return false;
 318   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
 319     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
 320   }
 321   return true;
 322 }
 323 //--------------------------------------------------------------------
 324
 325 //--------------------------------------------------------------------
 326 template<class ImageType1, class ImageType2>
 327 bool HaveSameSpacing(typename ImageType1::Pointer A,
 328                      typename ImageType2::Pointer B)
 329 {
 330   if (A->GetImageDimension() != B->GetImageDimension()) return false;
 331   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
 332     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
 333   }
 334   return true;
 335 }
 336 //--------------------------------------------------------------------
 337
 338 //--------------------------------------------------------------------
 339 template<class ImageType1, class ImageType2>
 340 bool HaveSameSize(typename ImageType1::ConstPointer A,
 341                   typename ImageType2::ConstPointer B)
 342 {
 343   if (A->GetImageDimension() != B->GetImageDimension()) return false;
 344   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
 345     if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
 346   }
 347   return true;
 348 }
 349 //--------------------------------------------------------------------
 350
 351 //--------------------------------------------------------------------
 352 template<class ImageType1, class ImageType2>
 353 bool HaveSameSize(typename ImageType1::Pointer A,
 354                   typename ImageType2::Pointer B)
 355 {
 356   if (A->GetImageDimension() != B->GetImageDimension()) return false;
 357   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
 358     if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
 359   }
 360   return true;
 361 }
 362 //--------------------------------------------------------------------
 363
 364 //--------------------------------------------------------------------
 365 template<class ImageType1, class ImageType2>
 366 bool HaveSameSizeAndSpacing(typename ImageType1::ConstPointer A,
 367                             typename ImageType2::ConstPointer B)
 368 {
 369   return ( HaveSameSize<ImageType1, ImageType2>(A, B) &&
 370            HaveSameSpacing<ImageType1, ImageType2>(A, B) );
 371 }
 372 //--------------------------------------------------------------------
 373
 374 //--------------------------------------------------------------------
 375 template<class ImageType1, class ImageType2>
 376 bool HaveSameSizeAndSpacing(typename ImageType1::Pointer A,
 377                             typename ImageType2::Pointer B)
 378 {
 379   return ( HaveSameSize<ImageType1, ImageType2>(A, B) &&
 380            HaveSameSpacing<ImageType1, ImageType2>(A, B) );
 381 }
 382 //--------------------------------------------------------------------
 383
 384 #endif /* end #define CLITKIMAGECOMMON_TXX */
 385