DGtal::LongvolReader< TImageContainer > Struct Template Reference

#include <LongvolReader.h>

Data Structures
struct	HeaderField

Public Types
typedef TImageContainer	ImageContainer

Public Member Functions
	BOOST_STATIC_ASSERT (ImageContainer::Domain::dimension==3)

Static Public Member Functions
static ImageContainer	importLongvol (const std::string &filename) throw (DGtal::IOException)

Private Types
typedef unsigned char	voxel

Static Private Member Functions
template<typename Word >
static FILE *	read_word (FILE *fin, Word &aValue)
static const char *	getHeaderValue (const char *type, const HeaderField *header)
static int	getHeaderValueAsInt (const char *type, int *dest, const HeaderField *header)
static int	getHeaderField (const char *type, const HeaderField *header)

Static Private Attributes
static const int	MAX_HEADERNUMLINES = 64
static const char *	requiredHeaders []

---

Detailed Description

template<typename TImageContainer>
struct DGtal::LongvolReader< TImageContainer >

Aim: implements methods to read a "Longvol" file format (with DGtal::uint64_t value type).

Description of template class 'LongvolReader'

The main import method "importLongvol" returns an instance of the template parameter TImageContainer.

The private methods have been backported from the Simplelvol project (see http://liris.cnrs.fr/david.coeurjolly).

Example usage:

     ...
     #include <DGtal/helpers/StdDefs.h>
    
     //Default image container = STLVector
     typedef ImageSelector<Z3i::Domain, DGtal::uint64_t>::Type Image;
    
     Image image = LongvolReader<Image>::importLongvol("data.longvol");
    
     trace.info() << image <<endl;
     ...

Template Parameters:

TImageContainer

the image container to use.

See also:

testLongvol.cpp

Definition at line 87 of file LongvolReader.h.

---

Member Typedef Documentation

template<typename TImageContainer >

typedef TImageContainer DGtal::LongvolReader< TImageContainer >::ImageContainer

Definition at line 91 of file LongvolReader.h.

template<typename TImageContainer >

typedef unsigned char DGtal::LongvolReader< TImageContainer >::voxel

private

Definition at line 127 of file LongvolReader.h.

---

Member Function Documentation

template<typename TImageContainer >

DGtal::LongvolReader< TImageContainer >::BOOST_STATIC_ASSERT

(

ImageContainer::Domain::dimension

= =3

)

template<typename T >

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

inlinestaticprivate

Internal method which returns the index of a field or -1 if not found.

Definition at line 233 of file LongvolReader.ih.

{


  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 >

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

inlinestaticprivate

Returns NULL if this field is not found.

Definition at line 251 of file LongvolReader.ih.

References DGtal::LongvolReader< TImageContainer >::HeaderField::value.

{

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

}

template<typename T >

int DGtal::LongvolReader< T >::getHeaderValueAsInt ( const char *  type, int *  dest, const HeaderField *  header  )

inlinestaticprivate

Returns non-zero if failure.

Definition at line 265 of file LongvolReader.ih.

{
  int i = getHeaderField( type, header );
  if ( i == -1 )
    return 1;

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

template<typename T >

T DGtal::LongvolReader< T >::importLongvol ( const std::string &  filename ) throw (DGtal::IOException)

inlinestatic

Main method to import a Longvol into an instance of the template parameter ImageContainer.

Parameters:

filename

the file name to import.

Returns:

an instance of the ImageContainer.

Definition at line 40 of file LongvolReader.ih.

References DGtal::Trace::error(), DGtal::trace, and DGtal::Trace::warning().

{
  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 TImageContainer >

template<typename Word >

static FILE* DGtal::LongvolReader< TImageContainer >::read_word ( FILE *  fin, Word &  aValue  )

inlinestaticprivate

Generic read word (binary mode) in little-endian mode.

Parameters:

fin	input FILE.
value	value to write.

Returns:

modified stream.

Definition at line 119 of file LongvolReader.h.

    {
      aValue = 0;
      for (unsigned size = 0; size < sizeof( Word ); ++size)
        aValue |= getc(fin) << (8 * size);
      return fin;
    }

---

Field Documentation

template<typename TImageContainer >

const int DGtal::LongvolReader< TImageContainer >::MAX_HEADERNUMLINES = 64

staticprivate

Maximum number of fields in a .longvol file header.

Definition at line 172 of file LongvolReader.h.

template<typename TImageContainer >

const char * DGtal::LongvolReader< T >::requiredHeaders

staticprivate

Initial value:

{
  "X", "Y", "Z", "Lvoxel-Size", "Int-Endian", "Lvoxel-Endian", "Alpha-Color", NULL
}

Global list of required fields in a .longvol file.

Definition at line 179 of file LongvolReader.h.

---

The documentation for this struct was generated from the following files:

• LongvolReader.h
• LongvolReader.ih