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