LongvolReader.ih

#include <cstdlib>


// Interface - public :
template <typename T>
inline
T
DGtal::LongvolReader<T>::importLongvol( const std::string & filename )   throw( DGtal::IOException )
{
  FILE * fin;
  DGtal::IOException dgtalexception;


  typename T::Point firstPoint( 0, 0, 0 );
  typename T::Point lastPoint( 0, 0, 0 );
  T nullImage( typename T::Domain(firstPoint, lastPoint ));

  HeaderField header[ MAX_HEADERNUMLINES ];

  fin = fopen( filename.c_str() , "r" );

  if ( fin == NULL )
  {
    trace.error() << "LongvolReader : can't open " << filename << endl;
    throw dgtalexception;
  }


  // Read header
  // Buf for a line
  char buf[128];
  int linecount = 1;
  int fieldcount = 0;

  // Read the file line by line until ".\n" is found
  for (  char *line = fgets( buf, 128, fin );
        line && strcmp( line, ".\n" ) != 0 ;
        line = fgets( line, 128, fin ), ++linecount
      )
  {

    if ( line[strlen( line ) - 1] != '\n' )
    {
      trace.error() << "LongvolReader: Line " << linecount << " too long" << std::endl;
      throw dgtalexception;
    }

    int i;
    for ( i = 0; line[i] && line[i] != ':'; ++i )
      ;

    if ( i == 0 || i >= 126 || line[i] != ':' )
    {
      trace.error() << "LongvolReader: Invalid header read at line " << linecount << std::endl;
      throw dgtalexception;
    }
    else
    {

      if ( fieldcount == MAX_HEADERNUMLINES )
      {
        trace.warning() << "LongvolReader: Too many lines in HEADER, ignoring\n";
        continue;
      }
      if ( fieldcount > MAX_HEADERNUMLINES )
        continue;

      // Remove \n from end of line
      if ( line[ strlen( line ) - 1 ] == '\n' )
        line[ strlen( line ) - 1 ] = 0;

      // hack : split line in two str ...
      line[i] = 0;
      header[ fieldcount++ ] = HeaderField( line, line + i + 2 );
      // +2 cause we skip the space
      // following the colon
    }
  }

  // Check required headers
  for ( int i = 0; requiredHeaders[i]; ++i )
  {
    if ( getHeaderValue( "Version" , header ) != NULL &&
         ( strcmp( requiredHeaders[i], "Int-Endian" ) == 0 ||
           strcmp( requiredHeaders[i], "Lvoxel-Endian" ) == 0 ) )
    {
      continue;
    }
    if ( getHeaderField( requiredHeaders[i]  , header ) == -1 )
    {
      trace.error() << "LongvolReader: Required Header Field missing: "
      << requiredHeaders[i] << std::endl;
      throw dgtalexception;

    }
  }

  int sx, sy, sz;

  getHeaderValueAsInt( "X", &sx, header );
  getHeaderValueAsInt( "Y", &sy, header );
  getHeaderValueAsInt( "Z", &sz, header );

  if ( getHeaderValue( "Version", header ) == NULL )
  {
    int rawsx, rawsy, rawsz;
    long int count = 0;
    // Size of the longvolume
    count += (long)fread( &rawsx, sizeof( int ), 1, fin );
    count += (long)fread( &rawsy, sizeof( int ), 1, fin );
    count += (long)fread( &rawsz, sizeof( int ), 1, fin );

    if ( count != 3 )
    {
      trace.error() << "LongvolReader: can't read file (raw header)\n";
      throw dgtalexception;
    }


    if ( sx != rawsx || sy != rawsy || sz != rawsz )
    {
      trace.warning() << "LongvolReader: Warning : Incoherent longvol header with raw header !\n";
    }

    int voxsize;
    if ( getHeaderValueAsInt( "Voxel-Size", &voxsize, header ) == 0 && voxsize != sizeof( voxel ) )
    {
      trace.error() << "LongvolReader: This file was generated with a voxel-size that we do not support.\n";
      throw dgtalexception;
    }

    // We should have a useless \n in the file at this point
    char tmp;
    count = (long)fread( &tmp, sizeof( char ), 1, fin );

    if ( count != 1 || tmp != '\n' )
    {
      trace.error() << "LongvolReader: I thouhgt I would have read a \\n !\n";
      throw dgtalexception;
    }
  }

  //Raw Data
  long count = 0;

  firstPoint = T::Point::zero;
  lastPoint[0] = sx - 1;
  lastPoint[1] = sy - 1;
  lastPoint[2] = sz - 1;
  typename T::Domain domain( firstPoint, lastPoint );

  try
  {
    T image( domain);

    count = 0;
    DGtal::uint64_t val=0;
    
    typename T::Domain::ConstIterator it = domain.begin();
    long int total = sx * sy * sz;

    while (( count < total ) && ( fin ) )
    {
      read_word(fin , val);
      image.setValue(( *it ), val );
      it++;
      count++;
    }

    if ( count != total )
    {
      trace.error() << "LongvolReader: can't read file (raw data) !\n";
      throw dgtalexception;
    }

    fclose( fin );
    return image;
  }
  catch ( ... )
  {
    trace.error() << "LongvolReader: not enough memory\n" ;
    throw dgtalexception;
  }

}



template <typename T>
const char *DGtal::LongvolReader<T>::requiredHeaders[] =
{
  "X", "Y", "Z", "Lvoxel-Size", "Int-Endian", "Lvoxel-Endian", "Alpha-Color", NULL
};




template<typename T>
inline
int
DGtal::LongvolReader<T>::getHeaderField( const char *type, const HeaderField * header )
{


  for ( int i = 0; i < MAX_HEADERNUMLINES; ++i )
  {
    if ( header[i].type != NULL && strcmp( header[i].type, type ) == 0 )
    {
      return i;
    }
  }
  return -1;
}


template<typename T>
inline
const char *
DGtal::LongvolReader<T>::getHeaderValue( const char *type, const HeaderField * header )
{

  int i = getHeaderField( type, header );
  if ( i == -1 )
    return NULL;
  return header[i].value;

}


template<typename T>
inline
int
DGtal::LongvolReader<T>::getHeaderValueAsInt( const char *type, int *dest, const HeaderField * header )
{
  int i = getHeaderField( type, header );
  if ( i == -1 )
    return 1;

  return sscanf( header[i].value, "%d", dest ) != 0;
}