common/clitkVoxImageIO.cxx

   1 #ifndef CLITKVOXIMAGEIO_CXX
   2 #define CLITKVOXIMAGEIO_CXX
   3 /**
   4    -------------------------------------------------
   5    * @file   clitkVoxImageIO.cxx
   6    * @author David Sarrut <david.sarrut@creatis.insa-lyon.fr>
   7    * @date   17 May 2006 08:03:07
   8    *
   9    * @brief
  10    *
  11    *
  12    -------------------------------------------------*/
  13
  14 // clitk include
  15 #include "clitkVoxImageIO.h"
  16 #include "clitkCommon.h"
  17
  18 // itk include (for itkReadRawBytesAfterSwappingMacro)
  19 #include "itkRawImageIO.h"
  20
  21 //--------------------------------------------------------------------
  22 // Read Image Information
  23 void clitk::VoxImageIO::ReadImageInformation() {
  24   // open file
  25   std::ifstream is;
  26   clitk::openFileForReading(is, m_FileName);
  27   // read magic number
  28   std::string mn;
  29   is >> mn;
  30   //DD(mn);
  31   if (mn != "VOX") {
  32     itkExceptionMacro(<<"read magic number '" << mn << "' while expect VOX");
  33   }
  34   // read vox file version
  35   skipComment(is);
  36   is >> mn;
  37   //DD(mn);
  38   if (mn != "v2") {
  39     itkExceptionMacro(<<"read old format '" << mn << "'. TODO");
  40   }
  41
  42   // ONLY 3D IMAGES YET ...
  43
  44   // read grid size/spacing
  45   itk::Vector<unsigned int,3> dim;
  46   itk::Vector<double,3> spacing;
  47   itk::Vector<double,3> origin;
  48   origin.Fill(0.0);
  49   skipComment(is);
  50   is >> dim[0];
  51   is >> dim[1];
  52   is >> dim[2];
  53   //DD(dim);
  54   skipComment(is);
  55   is >> spacing[0];
  56   is >> spacing[1];
  57   is >> spacing[2];
  58   //DD(spacing);
  59   skipComment(is);
  60   int d;
  61   is >> d;
  62   if (d != 3 && d != 2) {
  63     itkExceptionMacro(<<"could not read no " << d << "D image (only 2D and 3D). TODO");
  64   }
  65   // read data type
  66   skipComment(is);
  67   std::string dataTypeName;
  68   is >> dataTypeName;
  69   //DD(dataTypeName);
  70
  71   // get header size
  72   m_HeaderSize = is.tellg();
  73   m_HeaderSize++;
  74   //DD(m_HeaderSize);
  75
  76   // set dimension values
  77   SetNumberOfDimensions(d);
  78   for(int i=0; i<d; i++) {
  79     SetDimensions(i,dim[i]);
  80     SetSpacing(i,spacing[i]);
  81     SetOrigin(i,origin[i]);
  82   }
  83
  84   // set other information
  85   SetByteOrderToLittleEndian();
  86   SetPixelType(itk::ImageIOBase::SCALAR);
  87   SetNumberOfComponents(1);
  88
  89   if (dataTypeName == "char") SetComponentType(itk::ImageIOBase::CHAR);
  90   else if (dataTypeName == "schar") SetComponentType(itk::ImageIOBase::CHAR);
  91   else if (dataTypeName == "uchar" || dataTypeName == "unsigned_char") SetComponentType(itk::ImageIOBase::UCHAR);
  92   else if (dataTypeName == "sshort") SetComponentType(itk::ImageIOBase::SHORT);
  93   else if (dataTypeName == "ushort") SetComponentType(itk::ImageIOBase::USHORT);
  94   else if (dataTypeName == "int") SetComponentType(itk::ImageIOBase::INT);
  95   else if (dataTypeName == "sint") SetComponentType(itk::ImageIOBase::INT);
  96   else if (dataTypeName == "uint") SetComponentType(itk::ImageIOBase::UINT);
  97   else if (dataTypeName == "float") SetComponentType(itk::ImageIOBase::FLOAT);
  98   else if (dataTypeName == "double") SetComponentType(itk::ImageIOBase::DOUBLE);
  99   else {
 100     itkExceptionMacro(<<"Read failed: Wanted pixel type "
 101                       << "(char, uchar, short, ushort, int, uint, float, double)"
 102                       << " but read " << dataTypeName);
 103   }
 104
 105 } ////
 106
 107 //--------------------------------------------------------------------
 108 // Read Image Information
 109 bool clitk::VoxImageIO::CanReadFile(const char* FileNameToRead)
 110 {
 111   std::string filename(FileNameToRead);
 112   std::string filenameext = GetExtension(filename);
 113   if (filenameext != std::string("vox")) return false;
 114   return true;
 115 } ////
 116
 117 //--------------------------------------------------------------------
 118 // Read Image Content
 119 void clitk::VoxImageIO::Read(void * buffer)
 120 {
 121   // Adapted from itkRawImageIO
 122
 123   std::ifstream file;
 124   openFileForReading(file, m_FileName);
 125
 126   // Offset into file
 127   unsigned long streamStart = m_HeaderSize;
 128   file.seekg((long)streamStart, std::ios::beg);
 129   if ( file.fail() ) {
 130     itkExceptionMacro(<<"File seek failed (Vox Read)");
 131   }
 132
 133   unsigned long numberOfBytesToBeRead = GetComponentSize();
 134   for(unsigned int i=0; i<GetNumberOfDimensions(); i++) numberOfBytesToBeRead *= GetDimensions(i);
 135
 136   //DD(numberOfBytesToBeRead);
 137
 138   if(!this->ReadBufferAsBinary(file, buffer, numberOfBytesToBeRead)) {
 139     itkExceptionMacro(<<"Read failed: Wanted "
 140                       << numberOfBytesToBeRead
 141                       << " bytes, but read "
 142                       << file.gcount() << " bytes.");
 143   }
 144   itkDebugMacro(<< "Reading Done");
 145
 146   {
 147     using namespace itk;
 148     // Swap bytes if necessary
 149     if itkReadRawBytesAfterSwappingMacro( unsigned short, USHORT )
 150       else if itkReadRawBytesAfterSwappingMacro( short, SHORT )
 151         else if itkReadRawBytesAfterSwappingMacro( char, CHAR )
 152           else if itkReadRawBytesAfterSwappingMacro( unsigned char, UCHAR )
 153             else if itkReadRawBytesAfterSwappingMacro( unsigned int, UINT )
 154               else if itkReadRawBytesAfterSwappingMacro( int, INT )
 155                 else if itkReadRawBytesAfterSwappingMacro( float, FLOAT )
 156                   else if itkReadRawBytesAfterSwappingMacro( double, DOUBLE );
 157   }
 158 }
 159
 160 //--------------------------------------------------------------------
 161 // Write Image Information
 162 void clitk::VoxImageIO::WriteImageInformation(bool keepOfStream)
 163 {
 164   // Check dimension
 165   if (GetNumberOfDimensions() != 3 &&  GetNumberOfDimensions() != 2) {
 166     itkExceptionMacro(<<"Write failed: only 3D and 2D image for Vox file format yet.");
 167   }
 168
 169   // Open the file
 170   clitk::openFileForWriting(file, m_FileName);
 171   // write magic number
 172   file << "VOX v2" << std::endl;
 173   // write grid size/spacing
 174   file << "# Size" << std::endl;
 175   file << GetDimensions(0) << " "
 176        << GetDimensions(1) << " "
 177        << GetDimensions(2) << std::endl;
 178   file << "# Spacing" << std::endl;
 179   file.precision(40);
 180   file << GetSpacing(0) << " "
 181        << GetSpacing(1) << " "
 182        << GetSpacing(2) << std::endl;
 183   file << "# Image dim" << std::endl << "3" << std::endl;
 184   file << "# Image type" << std::endl;
 185
 186   std::string dataTypeName;
 187   if (GetComponentType() == itk::ImageIOBase::CHAR) dataTypeName = "schar";
 188   else if (GetComponentType() == itk::ImageIOBase::UCHAR) dataTypeName = "uchar";
 189   else if (GetComponentType() == itk::ImageIOBase::SHORT) dataTypeName = "sshort";
 190   else if (GetComponentType() == itk::ImageIOBase::USHORT) dataTypeName = "ushort";
 191   else if (GetComponentType() == itk::ImageIOBase::INT) dataTypeName = "int";
 192   else if (GetComponentType() == itk::ImageIOBase::UINT) dataTypeName = "uint";
 193   else if (GetComponentType() == itk::ImageIOBase::FLOAT) dataTypeName = "float";
 194   else if (GetComponentType() == itk::ImageIOBase::DOUBLE) dataTypeName = "double";
 195   else {
 196     itkExceptionMacro(<<"Write failed: Wanted pixel type "
 197                       << "(char, uchar, short, ushort, int, uint, float, double)"
 198                       << " but Vox is : " << dataTypeName);
 199   }
 200   file << dataTypeName << std::endl;
 201
 202   // close file
 203   if (!keepOfStream) file.close();
 204 }
 205
 206 //--------------------------------------------------------------------
 207 // Write Image Information
 208 bool clitk::VoxImageIO::CanWriteFile(const char* FileNameToWrite)
 209 {
 210   std::string filename(FileNameToWrite);
 211   std::string filenameext = GetExtension(filename);
 212   if (filenameext != std::string("vox")) return false;
 213   return true;
 214 }
 215
 216 //--------------------------------------------------------------------
 217 // Write Image
 218 void clitk::VoxImageIO::Write(const void * buffer)
 219 {
 220   clitk::VoxImageIO::WriteImageInformation(true);
 221   SetByteOrderToLittleEndian();
 222
 223   //-------------------------------------------
 224   // Cut & Paste from itkRawImageIO
 225   // (warning BigEndian / LittleEndian)
 226   const unsigned long numberOfBytes      = this->GetImageSizeInBytes();
 227   const unsigned long numberOfComponents = this->GetImageSizeInComponents();
 228   // Swap bytes if necessary
 229   using namespace itk;
 230   if itkWriteRawBytesAfterSwappingMacro( unsigned short, USHORT )
 231     else if itkWriteRawBytesAfterSwappingMacro( short, SHORT )
 232       else if itkWriteRawBytesAfterSwappingMacro( char, CHAR )
 233         else if itkWriteRawBytesAfterSwappingMacro( unsigned char, UCHAR )
 234           else if itkWriteRawBytesAfterSwappingMacro( unsigned int, UINT )
 235             else if itkWriteRawBytesAfterSwappingMacro( int, INT )
 236               else if itkWriteRawBytesAfterSwappingMacro( float, FLOAT )
 237                 else if itkWriteRawBytesAfterSwappingMacro( double, DOUBLE ) ;
 238   //-------------------------------------------
 239
 240   file.close();
 241 } ////
 242
 243 #endif /* end #define CLITKVOXIMAGEIO_CXX */
 244