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