common/clitkVoxImageIO.cxx

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