common/clitkImageCommon.cxx

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