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, bool exit_on_error) {
  82   itk::ImageIOBase::Pointer reader =
  83     itk::ImageIOFactory::CreateImageIO(filename.c_str(), itk::ImageIOFactory::ReadMode);
  84   if (!reader) {
  85       if (exit_on_error) //default behavior for tools who don't handle the problem
  86       {
  87           std::cerr << "Error reading file " << filename << ", exiting immediately" << std::endl;
  88           std::exit(-1);
  89       }
  90       else
  91           return NULL;
  92   }
  93   reader->SetFileName(filename);
  94   reader->ReadImageInformation();
  95   return reader;
  96 }
  97 //--------------------------------------------------------------------
  98
  99 //--------------------------------------------------------------------
 100 void clitk::printImageHeader(itk::ImageIOBase::Pointer header, std::ostream & os, const int level) {
 101   unsigned int dim = header->GetNumberOfDimensions();
 102   std::string pixelTypeName = header->GetComponentTypeAsString(header->GetComponentType());
 103   std::vector<int> inputSize;
 104   std::vector<double> inputSpacing;
 105   std::vector<double> inputOrigin;
 106   inputSize.resize(dim);
 107   inputSpacing.resize(dim);
 108   inputOrigin.resize(dim);
 109   for(unsigned int i=0; i<dim; i++) {
 110     inputSpacing[i] = header->GetSpacing(i);
 111     inputSize[i] = header->GetDimensions(i);
 112     inputOrigin[i] = header->GetOrigin(i);
 113   }
 114   int pixelSize =
 115     clitk::GetTypeSizeFromString(header->GetComponentTypeAsString(header->GetComponentType()));
 116   unsigned int nbOfComponents = header->GetNumberOfComponents();
 117   if (level == 0) {
 118     os << dim << "D ";
 119     if (nbOfComponents !=1) os << nbOfComponents << "x" << pixelTypeName;
 120     else os << pixelTypeName;
 121     os << " ";
 122     for(unsigned int i=0; i< dim-1; i++)
 123       os << inputSize[i] << "x";
 124     os << inputSize[dim-1]
 125        << "  ";
 126     for(unsigned int i=0; i< dim-1; i++)
 127       os << inputSpacing[i] << "x";
 128     os << inputSpacing[dim-1];
 129   }
 130   else {
 131     os << "Dim       = " << dim << "D" << std::endl;
 132     os << "PixelType = " << pixelTypeName << std::endl;
 133     if (nbOfComponents > 1)
 134       os << "Vector    = " << nbOfComponents << std::endl;
 135     os << "Size      = ";
 136     for(unsigned int i=0; i< dim; i++) {
 137       os << inputSize[i] << " ";
 138     }
 139     os << std::endl;
 140     os << "Spacing   = ";
 141     for(unsigned int i=0; i< dim; i++) {
 142       os << inputSpacing[i] << " ";
 143     }
 144     os << std::endl;
 145     if (level > 1) {
 146       os << "# voxels  = " << header->GetImageSizeInPixels() << std::endl;
 147       os << "Size (mm) = ";
 148       for(unsigned int i=0; i< dim; i++) {
 149         os << inputSize[i]*inputSpacing[i] << " ";
 150       }
 151       os << "mm" << std::endl;
 152       os << "Origin (mm)= ";
 153       for(unsigned int i=0; i< dim; i++) {
 154         os << inputOrigin[i] << " ";
 155       }
 156       os << "mm" << std::endl;
 157
 158       os << "Volume    = ";
 159       double vol=1.0;
 160       for(unsigned int i=0; i< dim; i++) {
 161         vol *= inputSize[i]*inputSpacing[i]/10.0;
 162       }
 163       os << vol << " cc" << std::endl;
 164       int mem = header->GetImageSizeInPixels()*pixelSize*nbOfComponents;
 165       double memKb = (double)mem/1024.0;
 166       double memMb = (double)mem/1024.0/1024.0;
 167       double memGb = (double)mem/1024.0/1024.0/1024.0;
 168       if (lrint(memKb) <= 0)
 169         os << "Memory    = " << mem << " bytes" << std::endl;
 170       else {
 171         if (lrint(memMb) <= 0)
 172           os << "Memory    = " << memKb << " Kb (" << mem << " bytes)" << std::endl;
 173         else {
 174           if (lrint(memGb) <= 0)
 175             os << "Memory    = " << memMb << " Mb (" << mem << " bytes)" << std::endl;
 176           else
 177             os << "Memory     = " << memGb << " Gb (" << mem << " bytes)" << std::endl;
 178         }
 179       }
 180     }
 181   }
 182 }
 183 //--------------------------------------------------------------------
 184
 185 #endif /* end #define CLITKIMAGECOMMON_CXX */
 186