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 template<class ImageType>
 186 void writeImage(const typename ImageType::Pointer image, const std::string & filename, const bool verbose)
 187 {
 188   typedef itk::ImageFileWriter<ImageType> WriterType;
 189   typename WriterType::Pointer writer = WriterType::New();
 190   writer->SetFileName(filename.c_str());
 191   writer->SetInput(image);
 192   if (verbose) {
 193     std::cout << "Writing [" << filename << "] ... " << std::endl;
 194   }
 195   try {
 196     writer->Update();
 197   } catch( itk::ExceptionObject & err ) {
 198     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 199     std::cerr << err << std::endl;
 200     exit(-1);
 201   }
 202 }
 203 //--------------------------------------------------------------------
 204
 205 //--------------------------------------------------------------------
 206 template<class ImageType>
 207 void writeImage(const ImageType* image, const std::string & filename, const bool verbose)
 208 {
 209   typedef itk::ImageFileWriter<ImageType> WriterType;
 210   typename WriterType::Pointer writer = WriterType::New();
 211   writer->SetFileName(filename.c_str());
 212   writer->SetInput(image);
 213   if (verbose) {
 214     std::cout << "Writing [" << filename << "] ... " << std::endl;
 215   }
 216   try {
 217     writer->Update();
 218   } catch( itk::ExceptionObject & err ) {
 219     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 220     std::cerr << err << std::endl;
 221     exit(-1);
 222   }
 223 }
 224 // //--------------------------------------------------------------------
 225
 226 // //--------------------------------------------------------------------
 227 // template<class ImageType>
 228 // void writeImage(const typename ImageType::ConstPointer image, const std::string & filename, const bool verbose=false) {
 229 //   typedef itk::ImageFileWriter<ImageType> WriterType;
 230 //   typename WriterType::Pointer writer = WriterType::New();
 231 //   writer->SetFileName(filename.c_str());
 232 //   writer->SetInput(image);
 233 //   if (verbose) {
 234 //     std::cout << "Writing [" << filename << "] ... " << std::endl;
 235 //   }
 236 //   try {
 237 //     writer->Update();
 238 //   }
 239 //   catch( itk::ExceptionObject & err ) {
 240 //     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 241 //     std::cerr << err << std::endl;
 242 //     exit(-1);
 243 //   }
 244 // }
 245
 246 //--------------------------------------------------------------------
 247
 248 //--------------------------------------------------------------------
 249 // Compute the number of different intensities in an image
 250 template<class ImageType>
 251 int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
 252                                      std::vector<typename ImageType::PixelType> & l)
 253 {
 254   //std::set<typename ImageType::PixelType> listOfIntensities;
 255   std::map<typename ImageType::PixelType, bool> listOfIntensities;
 256   //  listOfIntensities.resize(0);
 257   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
 258   ConstIteratorType pi(image, image->GetLargestPossibleRegion());
 259   pi.Begin();
 260   while (!pi.IsAtEnd()) {
 261     if (!listOfIntensities[pi.Get()]) listOfIntensities[pi.Get()] = true;
 262     // if (std::find(listOfIntensities.begin(),
 263     //                            listOfIntensities.end(),
 264     //                            pi.Get()) == listOfIntensities.end()) {
 265     //    listOfIntensities.insert(pi.Get());
 266     //  }
 267     ++pi;
 268   }
 269
 270   //typename std::set<typename ImageType::PixelType>::const_iterator ppi = listOfIntensities.begin();
 271   typename std::map<typename ImageType::PixelType, bool>::const_iterator ppi = listOfIntensities.begin();
 272   while (ppi != listOfIntensities.end()) {
 273     l.push_back(ppi->first);
 274     ++ppi;
 275   }
 276
 277   return listOfIntensities.size();
 278 }
 279 //--------------------------------------------------------------------
 280
 281 //--------------------------------------------------------------------
 282 template<class InputImageType, class MaskImageType>
 283 void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
 284                                  const typename MaskImageType::Pointer & mask,
 285                                  const std::vector<typename MaskImageType::PixelType> & listOfIntensities,
 286                                  std::map<typename MaskImageType::PixelType,
 287                                  std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights)
 288 {
 289   // Check size
 290   if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) {
 291     itkGenericExceptionMacro(<< "Input and mask images have not the same size"
 292                              << std::endl
 293                              << "Input = " << input->GetLargestPossibleRegion()
 294                              << std::endl
 295                              << "Mask = " << mask->GetLargestPossibleRegion());
 296   }
 297
 298   // reset weights list
 299   mapOfLabelsAndWeights.clear();
 300
 301   // loop
 302   typedef itk::ImageRegionConstIterator<InputImageType> ConstInputIteratorType;
 303   ConstInputIteratorType pi(input, input->GetLargestPossibleRegion());
 304   typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
 305   ConstMaskIteratorType pm(mask, mask->GetLargestPossibleRegion());
 306   pi.Begin();
 307   pm.Begin();
 308   while (!pi.IsAtEnd()) {
 309     mapOfLabelsAndWeights[pm.Get()][pi.Get()]++;
 310     ++pi;
 311     ++pm;
 312   }
 313 }
 314 //--------------------------------------------------------------------
 315
 316 #endif /* end #define CLITKIMAGECOMMON_TXX */
 317