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    * @file   clitkImageCommon.txx
  23    * @author David Sarrut <david.sarrut@creatis.insa-lyon.fr>
  24    * @date   07 Sep 2007 11:34:19
  25    *
  26    * @brief
  27    *
  28    *
  29    -------------------------------------------------*/
  30
  31 //--------------------------------------------------------------------
  32 template<class PixelType>
  33 typename itk::Image<PixelType,1>::Pointer NewImage1D(int vsize, double vspacing) {
  34   typedef itk::Image<PixelType,1> ImageType;
  35   typename ImageType::Pointer g = ImageType::New();
  36   typename ImageType::SizeType size;
  37   size[0] = vsize;
  38   typename ImageType::RegionType region;
  39   region.SetSize(size);
  40   g->SetRegions(region);
  41   typename ImageType::SpacingType spacing;
  42   spacing[0] = vspacing;
  43   g->SetSpacing(spacing);
  44   return g;
  45 }
  46 //--------------------------------------------------------------------
  47
  48 //--------------------------------------------------------------------
  49 template<class PixelType>
  50 typename itk::Image<PixelType,2>::Pointer NewImage2D(int sx, int sy, double dx, double dy) {
  51   typedef itk::Image<PixelType,2> ImageType;
  52   typename ImageType::Pointer g = ImageType::New();
  53   typename ImageType::SizeType size;
  54   size[0] = sx; size[1] = sy;
  55   typename ImageType::RegionType region;
  56   region.SetSize(size);
  57   g->SetRegions(region);
  58   typename ImageType::SpacingType spacing;
  59   spacing[0] = dx; spacing[1] = dy;
  60   g->SetSpacing(spacing);
  61   return g;
  62 }
  63 //--------------------------------------------------------------------
  64
  65 //--------------------------------------------------------------------
  66 template<class PixelType>
  67 typename itk::Image<PixelType,3>::Pointer NewImage3D(int sx, int sy, int sz, double dx, double dy, double dz) {
  68   typedef itk::Image<PixelType,3> ImageType;
  69   typename ImageType::Pointer g = ImageType::New();
  70   typename ImageType::SizeType size;
  71   size[0] = sx; size[1] = sy; size[2] = sz;
  72   typename ImageType::RegionType region;
  73   region.SetSize(size);
  74   g->SetRegions(region);
  75   typename ImageType::SpacingType spacing;
  76   spacing[0] = dx; spacing[1] = dy; 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   typedef itk::Image<PixelType,3> ImageType;
  86   typename ImageType::Pointer g = ImageType::New();
  87   typename ImageType::SizeType size;
  88   size[0] = sx; size[1] = sy; size[2] = sz; size[3] = st;
  89   typename ImageType::RegionType region;
  90   region.SetSize(size);
  91   g->SetRegions(region);
  92   typename ImageType::SpacingType spacing;
  93   spacing[0] = dx; spacing[1] = dy; spacing[2] = dz; spacing[3] = dt;
  94   g->SetSpacing(spacing);
  95   return g;
  96 }
  97 //--------------------------------------------------------------------
  98
  99 //--------------------------------------------------------------------
 100 template<class ImageType>
 101 typename ImageType::Pointer readImage(const std::string & filename, const bool verbose) {
 102   typedef itk::ImageFileReader<ImageType> ReaderType;
 103   typename ReaderType::Pointer reader = ReaderType::New();
 104   reader->SetFileName(filename.c_str());
 105   if (verbose) {
 106     std::cout << "Reading [" << filename << "] ... " << std::endl;
 107   }
 108   try {
 109     reader->Update();
 110   }
 111   catch(itk::ExceptionObject & err) {
 112     std::cerr << "Exception while reading image [" << filename << "]" << std::endl;
 113     std::cerr << err << std::endl;
 114     exit(0);
 115   }
 116   return reader->GetOutput();
 117 }
 118 //--------------------------------------------------------------------
 119
 120 //--------------------------------------------------------------------
 121 template<typename ImageType>
 122 typename ImageType::Pointer readImage(const std::vector<std::string> & filenames,
 123                                       const bool verbose) {
 124   if (filenames.size() == 1) return readImage<ImageType>(filenames[0], verbose);
 125   typedef itk::ImageSeriesReader<ImageType> ReaderType;
 126   typename ReaderType::Pointer reader = ReaderType::New();
 127   reader->SetFileNames(filenames);
 128   if (verbose) {
 129     std::cout << "Reading " << filenames[0] << " and others ..." << std::endl;
 130   }
 131   try {
 132     reader->Update();
 133   }
 134   catch( itk::ExceptionObject & err ) {
 135     std::cerr << "Error while reading " << filenames[0]
 136               << " or other files ..." << err << std::endl;
 137     exit(0);
 138   }
 139   return reader->GetOutput();
 140 }
 141 //--------------------------------------------------------------------
 142
 143 //--------------------------------------------------------------------
 144 template<class ImageType>
 145 void writeImage(const typename ImageType::Pointer image, const std::string & filename, const bool verbose) {
 146   typedef itk::ImageFileWriter<ImageType> WriterType;
 147   typename WriterType::Pointer writer = WriterType::New();
 148   writer->SetFileName(filename.c_str());
 149   writer->SetInput(image);
 150   if (verbose) {
 151     std::cout << "Writing [" << filename << "] ... " << std::endl;
 152   }
 153   try {
 154     writer->Update();
 155   }
 156   catch( itk::ExceptionObject & err ) {
 157     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 158     std::cerr << err << std::endl;
 159     exit(-1);
 160   }
 161 }
 162 //--------------------------------------------------------------------
 163
 164 //--------------------------------------------------------------------
 165 template<class ImageType>
 166 void writeImage(const ImageType* image, const std::string & filename, const bool verbose) {
 167   typedef itk::ImageFileWriter<ImageType> WriterType;
 168   typename WriterType::Pointer writer = WriterType::New();
 169   writer->SetFileName(filename.c_str());
 170   writer->SetInput(image);
 171   if (verbose) {
 172     std::cout << "Writing [" << filename << "] ... " << std::endl;
 173   }
 174   try {
 175     writer->Update();
 176   }
 177   catch( itk::ExceptionObject & err ) {
 178     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
 179     std::cerr << err << std::endl;
 180     exit(-1);
 181   }
 182 }
 183 // //--------------------------------------------------------------------
 184
 185 // //--------------------------------------------------------------------
 186 // template<class ImageType>
 187 // void writeImage(const typename ImageType::ConstPointer image, const std::string & filename, const bool verbose=false) {
 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 //   }
 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 // Compute the number of different intensities in an image
 209 template<class ImageType>
 210 int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
 211                                      std::vector<typename ImageType::PixelType> & l)
 212 {
 213   //std::set<typename ImageType::PixelType> listOfIntensities;
 214   std::map<typename ImageType::PixelType, bool> listOfIntensities;
 215   //  listOfIntensities.resize(0);
 216   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
 217   ConstIteratorType pi(image, image->GetLargestPossibleRegion());
 218   pi.Begin();
 219   while (!pi.IsAtEnd()) {
 220     if (!listOfIntensities[pi.Get()]) listOfIntensities[pi.Get()] = true;
 221     // if (std::find(listOfIntensities.begin(),
 222     //                            listOfIntensities.end(),
 223     //                            pi.Get()) == listOfIntensities.end()) {
 224     //    listOfIntensities.insert(pi.Get());
 225     //  }
 226     ++pi;
 227   }
 228
 229   //typename std::set<typename ImageType::PixelType>::const_iterator ppi = listOfIntensities.begin();
 230   typename std::map<typename ImageType::PixelType, bool>::const_iterator ppi = listOfIntensities.begin();
 231   while (ppi != listOfIntensities.end()) {
 232     l.push_back(ppi->first);
 233     ++ppi;
 234   }
 235
 236   return listOfIntensities.size();
 237 }
 238 //--------------------------------------------------------------------
 239
 240 //--------------------------------------------------------------------
 241 template<class InputImageType, class MaskImageType>
 242 void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
 243                                  const typename MaskImageType::Pointer & mask,
 244                                  const std::vector<typename MaskImageType::PixelType> & listOfIntensities,
 245                                  std::map<typename MaskImageType::PixelType,
 246                                  std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights) {
 247   // Check size
 248   if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) {
 249     itkGenericExceptionMacro(<< "Input and mask images have not the same size"
 250                              << std::endl
 251                              << "Input = " << input->GetLargestPossibleRegion()
 252                              << std::endl
 253                              << "Mask = " << mask->GetLargestPossibleRegion());
 254   }
 255
 256   // reset weights list
 257   mapOfLabelsAndWeights.clear();
 258
 259   // loop
 260   typedef itk::ImageRegionConstIterator<InputImageType> ConstInputIteratorType;
 261   ConstInputIteratorType pi(input, input->GetLargestPossibleRegion());
 262   typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
 263   ConstMaskIteratorType pm(mask, mask->GetLargestPossibleRegion());
 264   pi.Begin();
 265   pm.Begin();
 266   while (!pi.IsAtEnd()) {
 267     mapOfLabelsAndWeights[pm.Get()][pi.Get()]++;
 268     ++pi;
 269     ++pm;
 270   }
 271 }
 272 //--------------------------------------------------------------------
 273
 274 #endif /* end #define CLITKIMAGECOMMON_TXX */
 275