common/clitkImageCommon.txx

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