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