common/clitkImageCommon.cxx

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