common/clitkImageCommon.txx

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