SPAR/AIModule/BWTA/vendors/CGAL/CGAL/ImageIO.h

Go to the documentation of this file.

// Copyright (c) 2005, 2006 ASCLEPIOS Project, INRIA Sophia-Antipolis (France)
// Copyright (c) 2007 Geometrica Project, INRIA Sophia-Antipolis (France) 
// Copyright (c) 2008 GeometryFactory, Sophia-Antipolis (France) 
// All rights reserved.
//
// The files in this directory are part of the ImageIO Library.
// You can redistribute them and/or  modify them under the terms of the
// GNU Lesser General Public License as published by the Free Software Foundation;
// version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// These files are provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
// $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal/branches/CGAL-3.5-branch/CGALimageIO/include/CGAL/ImageIO.h $
// $Id: ImageIO.h 46133 2008-10-07 13:00:59Z lrineau $
//

#ifndef IMAGEIO_H
#define IMAGEIO_H

#include <CGAL/compiler_config.h>

#include <CGAL/auto_link/ImageIO.h>

#include <stdlib.h>
#include <stdio.h>
#include <boost/cstdint.hpp> // for uint32_t, etc.

#ifdef CGAL_USE_ZLIB
#include <zlib.h>
/* see http://www.gzip.org/zlib/
   for details and documentation
*/
#endif



#if (defined(_LINUX_) || defined(_SOLARIS_))

/* should be declared in stdio.h
 */
extern int fileno( FILE *stream);
extern FILE *fdopen (int fildes, const char *mode);
/* should be declared in string.h
 */
#ifndef __cplusplus
extern char *strdup(const char *s);
extern int strncasecmp(const char *s1, const char *s2, size_t n);
#endif

#endif





#ifndef LONGINT

#if (defined _ALPHA_ || (defined _SGI_ && (defined _64_ || defined _64_M4_ || defined _64_M3_)))
/* the 64-bits type on 64-bits platform (long int) */
#define LONGINT long  int
#else
#ifdef __GNUC__
/* the 64-bits type on 32-bits platform (long long int) */
#define LONGINT long long int
#else
/*#define LONGINT __int64 */
#define LONGINT long int
#endif
#endif

#endif








typedef enum {
  OM_CLOSE,
  OM_STD,
#ifdef CGAL_USE_ZLIB
  OM_GZ,
#endif

  OM_FILE
} OPEN_MODE;


typedef enum {
  DM_BINARY,
  DM_ASCII
} DATA_MODE;


typedef enum {
  WK_FIXED,
  WK_FLOAT,
  WK_UNKNOWN
} WORD_KIND;


typedef enum {
  SGN_SIGNED,
  SGN_UNSIGNED,
  SGN_UNKNOWN
} SIGN;


typedef enum {
  END_LITTLE,
  END_BIG,
  END_UNKNOWN
} ENDIANNESS;


typedef enum {
  VM_INTERLACED,
  VM_NON_INTERLACED,
  VM_SCALAR
} VECTORIAL_MODE;



#ifdef CGAL_USE_ZLIB
typedef gzFile _ImageIO_file;
#else
typedef FILE*  _ImageIO_file;
#endif

#define IMAGE_FORMAT_NAME_LENGTH 100


struct point_image;

typedef int (*TEST_IMAGE_FORMAT)(char *,const char *);
typedef int (*READ_IMAGE_HEADER)(const char *, struct point_image *);
typedef int (*WRITE_IMAGE)(char *,struct point_image *);


typedef struct imformat {

  TEST_IMAGE_FORMAT testImageFormat;

  READ_IMAGE_HEADER readImageHeader;

  WRITE_IMAGE writeImage;

  /* the file extension of format (including a dot ".": if several 
     extensions may be used, they should be separed with a 
     comma ".inr,.inr.gz" */
  char fileExtension[IMAGE_FORMAT_NAME_LENGTH];
  
  char realName[IMAGE_FORMAT_NAME_LENGTH];
  /* pointer towards the next image format*/
  struct imformat *next;
} IMAGE_FORMAT, *PTRIMAGE_FORMAT;;

typedef struct point_image {
  unsigned int xdim;
  unsigned int ydim;
  unsigned int zdim;
  unsigned int vdim;

  double vx;
  double vy;
  double vz;

  float tx;
  float ty;
  float tz;

  float rx;
  float ry;
  float rz;

  int cx;
  int cy;
  int cz;

  float spm_offset;
  float spm_scale;

  void *data;

  unsigned int wdim;
  PTRIMAGE_FORMAT imageFormat;
  VECTORIAL_MODE vectMode;
  WORD_KIND wordKind;
  SIGN sign;

  char **user;
  unsigned int nuser;

  _ImageIO_file fd;


  OPEN_MODE openMode;
  ENDIANNESS endianness;
  DATA_MODE dataMode;

} _image;



#define ImageIO_NO_ERROR 0
#define ImageIO_UNKNOWN_TYPE -1
#define ImageIO_OPENING -2
#define ImageIO_READING_HEADER -3
#define ImageIO_READING_IMAGE -4
#define ImageIO_WRITING_HEADER -3
#define ImageIO_WRITING_IMAGE -4
#define ImageIO_WRITING_DATA  -5





_image *_initImage();

void _freeImage(_image *im);

_image *_createImage(int x, int y, int z, int v,
                     float vx, float vy, float vz, int w,
                     WORD_KIND wk, SIGN sgn);


_image* _readImage(const char *name);

_image* _readNonInterlacedImage(const char *name);

_image* _readImage_raw(const char *name,
                       const unsigned int rx,
                       const unsigned int ry,
                       const unsigned int rz,
                       const double vx = 1.,
                       const double vy = 1.,
                       const double vz = 1.,
                       const unsigned int offset = 0);


int _writeImage(_image *im, const char *name);

void _getNextSlice(_image *im);


int addImageFormat( PTRIMAGE_FORMAT format);


PTRIMAGE_FORMAT firstImageFormat();

_image* _readImageHeader(const char *name);
_image *_readImageHeaderAndGetError( const char *name, int *error );

int _readImageData(_image *im);

int _readNonInterlacedImageData(_image *im);

int _readNonInterlacedFileData(_image *im);




void _openWriteImage(_image* im, const char *name) ;
   
void _openReadImage(_image *im, const char *name);

void _closeImage(_image *im);

void _get_image_bounding_box(_image* im,
                             double* x_min, double* y_min, double* z_min,
                             double* x_max, double* y_max, double* z_max);

ENDIANNESS  _getEndianness(); 
void initSupportedFileFormat();
void printSupportedFileFormat();
void removeSupportedFileFormat();


PTRIMAGE_FORMAT imageType(const char *fileName);

extern "C" {
typedef void *(*ALLOCATION_FUNCTION)(size_t);

typedef void (*DEALLOCATION_FUNCTION)(void *);
}

void setImageIOAllocationRoutines(ALLOCATION_FUNCTION alloc,
                                  DEALLOCATION_FUNCTION del);



void *ImageIO_alloc(size_t);
void ImageIO_free(void *);

size_t ImageIO_write(const _image *im, const void *buf, size_t len);


size_t ImageIO_read(const _image *im, void *buf, size_t len);

char *ImageIO_gets( const _image *im, char *str, int size );

int ImageIO_seek( const _image *im, long offset, int whence );

int ImageIO_error( const _image *im );

int ImageIO_close( _image *im );

float triLinInterp(const _image* image, float posx, float posy, float posz,
                   const float value_outside = 0.);

inline float trilinear_interpolation(const _image* image,
                                     float posx, float posy, float posz)
{
  return triLinInterp(image, posx, posy, posz);
}

namespace CGAL {
namespace IMAGEIO {

//
// The following definition are for the evaluate function.
// 
template <WORD_KIND wordKind, SIGN sign, unsigned int wdim>
struct Word_type_generator
{
};

template <SIGN sign>
struct Word_type_generator<WK_FLOAT, sign, 4>
{
  typedef float type;
};

template <SIGN sign>
struct Word_type_generator<WK_FLOAT, sign, 8>
{
  typedef double type;
};

template <>
struct Word_type_generator<WK_FIXED, SGN_SIGNED, 1>
{
//   typedef boost::int8_t type;
  typedef char type;
};

template <>
struct Word_type_generator<WK_FIXED, SGN_UNSIGNED, 1>
{
  typedef boost::uint8_t type;
};

template <>
struct Word_type_generator<WK_FIXED, SGN_SIGNED, 2>
{
  typedef boost::int16_t type;
};

template <>
struct Word_type_generator<WK_FIXED, SGN_UNSIGNED, 2>
{
  typedef boost::uint16_t type;
};

template <>
struct Word_type_generator<WK_FIXED, SGN_SIGNED, 4>
{
  typedef boost::int32_t type;
};

template <>
struct Word_type_generator<WK_FIXED, SGN_UNSIGNED, 4>
{
  typedef boost::uint32_t type;
};

template <WORD_KIND wordKind, SIGN sign, unsigned int wdim>
inline
typename Word_type_generator<wordKind, sign, wdim>::type
static_evaluate(const _image* image,
                const unsigned int i,
                const unsigned int j,
                const unsigned int k)
{
  typedef typename Word_type_generator<wordKind, sign, wdim>::type Word;

  return static_evaluate<Word>(image, i, j, k);
}

template <typename Word>
inline
Word
static_evaluate(const _image* image,
                const unsigned int i,
                const unsigned int j,
                const unsigned int k)
{
  return ((Word*)image->data)[(k * image->ydim + j) * image->xdim + i];
}

} // end namespace IMAGEIO
} // end namespace CGAL

#define CGAL_IMAGE_IO_CASE(image_ptr,code)                                                 \
  switch(image_ptr->wordKind)                                                              \
  {                                                                                        \
  case WK_FLOAT:                                                                           \
    switch(image_ptr->wdim)                                                                \
    {                                                                                      \
    case 4: {                                                                              \
      typedef CGAL::IMAGEIO::Word_type_generator<WK_FLOAT, SGN_UNKNOWN, 4>::type Word;     \
      code;                                                                                \
      break;                                                                               \
    }                                                                                      \
    case 8: {                                                                              \
      typedef CGAL::IMAGEIO::Word_type_generator<WK_FLOAT, SGN_UNKNOWN, 8>::type Word;     \
      code;                                                                                \
      break;                                                                               \
    }                                                                                      \
    default:                                                                               \
      break;                                                                               \
    }                                                                                      \
    break;                                                                                 \
  case WK_FIXED:                                                                           \
    switch(image_ptr->wdim)                                                                \
    {                                                                                      \
    case 2: {                                                                              \
      if(image_ptr->sign == SGN_SIGNED) {                                                  \
        typedef CGAL::IMAGEIO::Word_type_generator<WK_FIXED, SGN_SIGNED, 2>::type Word;    \
        code;                                                                              \
        break;                                                                             \
      }                                                                                    \
      else {                                                                               \
        typedef CGAL::IMAGEIO::Word_type_generator<WK_FIXED, SGN_UNSIGNED, 2>::type Word;  \
        code;                                                                              \
        break;                                                                             \
      }                                                                                    \
    }                                                                                      \
    case 1: {                                                                              \
      if(image_ptr->sign == SGN_SIGNED) {                                                  \
        typedef CGAL::IMAGEIO::Word_type_generator<WK_FIXED, SGN_SIGNED, 1>::type Word;    \
        code;                                                                              \
        break;                                                                             \
      }                                                                                    \
      else {                                                                               \
        typedef CGAL::IMAGEIO::Word_type_generator<WK_FIXED, SGN_UNSIGNED, 1>::type Word;  \
        code;                                                                              \
        break;                                                                             \
      }                                                                                    \
    }                                                                                      \
    case 4: {                                                                              \
      if(image_ptr->sign == SGN_SIGNED) {                                                  \
        typedef CGAL::IMAGEIO::Word_type_generator<WK_FIXED, SGN_SIGNED, 4>::type Word;    \
        code;                                                                              \
        break;                                                                             \
      }                                                                                    \
      else {                                                                               \
        typedef CGAL::IMAGEIO::Word_type_generator<WK_FIXED, SGN_UNSIGNED, 4>::type Word;  \
        code;                                                                              \
        break;                                                                             \
      }                                                                                    \
    }                                                                                      \
    default:                                                                               \
      break;                                                                               \
    }                                                                                      \
    break;                                                                                 \
  default:                                                                                 \
    break;                                                                                 \
  }

float evaluate(const _image* image,const unsigned int  i,const unsigned int  j,const unsigned int  k);


void convertImageTypeToFloat(_image* image);


#endif // end IMAGEIO_H