common/clitkImageCommon.cxx

   1 #ifndef CLITKIMAGECOMMON_CXX
   2 #define CLITKIMAGECOMMON_CXX
   3 /**
   4    ------------------------------------------------=
   5    * @file   clitkImageCommon.cxx
   6    * @author David Sarrut <david.sarrut@creatis.insa-lyon.fr>
   7    * @date   02 Oct 2007 14:30:47
   8    *
   9    * @brief
  10    *
  11    *
  12    ------------------------------------------------=*/
  13
  14 #include "clitkImageCommon.h"
  15
  16 //--------------------------------------------------------------------
  17 void clitk::ReadImageDimensionAndPixelType(const std::string & filename,
  18                                            int & dimension,
  19                                            std::string & pixeType) {
  20   itk::ImageIOBase::Pointer genericReader =
  21     itk::ImageIOFactory::CreateImageIO(filename.c_str(), itk::ImageIOFactory::ReadMode);
  22   if (!genericReader) {
  23     std::cerr << "Image file format unknown while reading " << filename << std::endl;
  24     exit(0);
  25   }
  26   genericReader->SetFileName(filename.c_str());
  27   genericReader->ReadImageInformation();
  28   pixeType = genericReader->GetComponentTypeAsString(genericReader->GetComponentType());
  29   dimension = genericReader->GetNumberOfDimensions();
  30 }
  31 //--------------------------------------------------------------------
  32
  33
  34 //--------------------------------------------------------------------
  35 void clitk::ReadImageDimensionAndPixelType(const std::string & filename,
  36                                            int & dimension,
  37                                            std::string & pixeType, int & components) {
  38   itk::ImageIOBase::Pointer genericReader =
  39     itk::ImageIOFactory::CreateImageIO(filename.c_str(), itk::ImageIOFactory::ReadMode);
  40   if (!genericReader) {
  41     std::cerr << "Image file format unknown while reading " << filename << std::endl;
  42     exit(0);
  43   }
  44   genericReader->SetFileName(filename.c_str());
  45   genericReader->ReadImageInformation();
  46   pixeType = genericReader->GetComponentTypeAsString(genericReader->GetComponentType());
  47   dimension = genericReader->GetNumberOfDimensions();
  48   components= genericReader->GetNumberOfComponents();
  49 }
  50 //--------------------------------------------------------------------
  51
  52 //--------------------------------------------------------------------
  53 // Read a dicom header
  54 gdcm::File * clitk::readDicomHeader(const std::string & filename,
  55                                     const bool verbose) {
  56   if (verbose) {
  57     std::cout << "Reading DICOM <" << filename << ">" << std::endl;
  58   }
  59   gdcm::File *header = new gdcm::File();
  60   header->SetFileName(filename);
  61   header->SetMaxSizeLoadEntry(16384); // required ?
  62   header->Load();
  63   return header;
  64 }
  65 //--------------------------------------------------------------------
  66
  67 //--------------------------------------------------------------------
  68 itk::ImageIOBase::Pointer clitk::readImageHeader(const std::string & filename, bool exit_on_error) {
  69   itk::ImageIOBase::Pointer reader =
  70     itk::ImageIOFactory::CreateImageIO(filename.c_str(), itk::ImageIOFactory::ReadMode);
  71   if (!reader) {
  72       if (exit_on_error) //default behavior for tools who don't handle the problem
  73       {
  74           std::cerr << "Error reading file " << filename << ", exiting immediately" << std::endl;
  75           std::exit(-1);
  76       }
  77       else
  78           return NULL;
  79   }
  80   reader->SetFileName(filename);
  81   reader->ReadImageInformation();
  82   return reader;
  83 }
  84 //--------------------------------------------------------------------
  85
  86 //--------------------------------------------------------------------
  87 void clitk::printImageHeader(itk::ImageIOBase::Pointer header, std::ostream & os, const int level) {
  88   unsigned int dim = header->GetNumberOfDimensions();
  89   std::string pixelTypeName = header->GetComponentTypeAsString(header->GetComponentType());
  90   std::vector<int> inputSize;
  91   std::vector<double> inputSpacing;
  92   std::vector<double> inputOrigin;
  93   inputSize.resize(dim);
  94   inputSpacing.resize(dim);
  95   inputOrigin.resize(dim);
  96   for(unsigned int i=0; i<dim; i++) {
  97     inputSpacing[i] = header->GetSpacing(i);
  98     inputSize[i] = header->GetDimensions(i);
  99     inputOrigin[i] = header->GetOrigin(i);
 100   }
 101   int pixelSize =
 102     clitk::GetTypeSizeFromString(header->GetComponentTypeAsString(header->GetComponentType()));
 103   unsigned int nbOfComponents = header->GetNumberOfComponents();
 104   if (level == 0) {
 105     os << dim << "D ";
 106     if (nbOfComponents !=1) os << nbOfComponents << "x" << pixelTypeName;
 107     else os << pixelTypeName;
 108     os << " ";
 109     for(unsigned int i=0; i< dim-1; i++)
 110       os << inputSize[i] << "x";
 111     os << inputSize[dim-1]
 112        << "  ";
 113     for(unsigned int i=0; i< dim-1; i++)
 114       os << inputSpacing[i] << "x";
 115     os << inputSpacing[dim-1];
 116   }
 117   else {
 118     os << "Dim       = " << dim << "D" << std::endl;
 119     os << "PixelType = " << pixelTypeName << std::endl;
 120     if (nbOfComponents > 1)
 121       os << "Vector    = " << nbOfComponents << std::endl;
 122     os << "Size      = ";
 123     for(unsigned int i=0; i< dim; i++) {
 124       os << inputSize[i] << " ";
 125     }
 126     os << std::endl;
 127     os << "Spacing   = ";
 128     for(unsigned int i=0; i< dim; i++) {
 129       os << inputSpacing[i] << " ";
 130     }
 131     os << std::endl;
 132     if (level > 1) {
 133       os << "# voxels  = " << header->GetImageSizeInPixels() << std::endl;
 134       os << "Size (mm) = ";
 135       for(unsigned int i=0; i< dim; i++) {
 136         os << inputSize[i]*inputSpacing[i] << " ";
 137       }
 138       os << "mm" << std::endl;
 139       os << "Origin (mm)= ";
 140       for(unsigned int i=0; i< dim; i++) {
 141         os << inputOrigin[i] << " ";
 142       }
 143       os << "mm" << std::endl;
 144
 145       os << "Volume    = ";
 146       double vol=1.0;
 147       for(unsigned int i=0; i< dim; i++) {
 148         vol *= inputSize[i]*inputSpacing[i]/10.0;
 149       }
 150       os << vol << " cc" << std::endl;
 151       int mem = header->GetImageSizeInPixels()*pixelSize*nbOfComponents;
 152       double memKb = (double)mem/1024.0;
 153       double memMb = (double)mem/1024.0/1024.0;
 154       double memGb = (double)mem/1024.0/1024.0/1024.0;
 155       if (lrint(memKb) <= 0)
 156         os << "Memory    = " << mem << " bytes" << std::endl;
 157       else {
 158         if (lrint(memMb) <= 0)
 159           os << "Memory    = " << memKb << " Kb (" << mem << " bytes)" << std::endl;
 160         else {
 161           if (lrint(memGb) <= 0)
 162             os << "Memory    = " << memMb << " Mb (" << mem << " bytes)" << std::endl;
 163           else
 164             os << "Memory     = " << memGb << " Gb (" << mem << " bytes)" << std::endl;
 165         }
 166       }
 167     }
 168   }
 169 }
 170 //--------------------------------------------------------------------
 171
 172 #endif /* end #define CLITKIMAGECOMMON_CXX */
 173