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