imagerw.h

#ifndef __IMAGERW_H__
#define __IMAGERW_H__
/*=============================================================================   
     Module  : imagerw.h
     Purpose : Provide routines to read and write image files of 
               different types.
     Author  : Doug Ehlenberger, CNIC Mt. Sinai School of Medicine
               
==============================================================================*/
#include "configure.h"
#include "filelist.h"
#include "vassert.h"
#include <limits.h>
#include <string.h>


/* Updated: Began on July 16, 2003. */


typedef enum
   {
   vPIXEL_FORMAT_NOT_SUPPORTED,
   vPIXEL_FORMAT_GRAYSCALE,
   vPIXEL_FORMAT_RGB,
   vPIXEL_FORMAT_RGBA,
   vPIXEL_FORMAT_BGR,
   vPIXEL_FORMAT_BGRA
   }
   vPIXEL_FORMAT_TYPE;

#define vPIXEL_FORMAT_GRAYSCALE_CHANNELS      1
#define vPIXEL_FORMAT_RGB_CHANNELS            3
#define vPIXEL_FORMAT_RGBA_CHANNELS           4
#define vPIXEL_FORMAT_BGR_CHANNELS            3
#define vPIXEL_FORMAT_BGRA_CHANNELS           4


typedef enum
   {
   vPIXEL_CHANNEL_NOT_SUPPORTED,
   vPIXEL_CHANNEL_UCHAR,
   vPIXEL_CHANNEL_USHORT12,
   vPIXEL_CHANNEL_USHORT16
   }
   vPIXEL_CHANNEL_TYPE;

#define vPIXEL_CHANNEL_UCHAR_BITS          8
#define vPIXEL_CHANNEL_USHORT12_BITS      12
#define vPIXEL_CHANNEL_USHORT16_BITS      16


#define vPIXEL_CODE( format, type )   ( ( format << 16 ) | type )

typedef enum
   {
   vPIXEL_CODE_NOT_SUPPORTED = 0,

   vPIXEL_CODE_GRAYSCALE_UCHAR = 
      vPIXEL_CODE( vPIXEL_FORMAT_GRAYSCALE, vPIXEL_CHANNEL_UCHAR ),

   vPIXEL_CODE_GRAYSCALE_USHORT12 = 
      vPIXEL_CODE( vPIXEL_FORMAT_GRAYSCALE, vPIXEL_CHANNEL_USHORT12 ),

   vPIXEL_CODE_GRAYSCALE_USHORT16 = 
      vPIXEL_CODE( vPIXEL_FORMAT_GRAYSCALE, vPIXEL_CHANNEL_USHORT16 ),

   vPIXEL_CODE_RGB_UCHAR =
      vPIXEL_CODE( vPIXEL_FORMAT_RGB, vPIXEL_CHANNEL_UCHAR ),

   vPIXEL_CODE_RGBA_UCHAR =
      vPIXEL_CODE( vPIXEL_FORMAT_RGBA, vPIXEL_CHANNEL_UCHAR ),

   vPIXEL_CODE_BGR_UCHAR =
      vPIXEL_CODE( vPIXEL_FORMAT_BGR, vPIXEL_CHANNEL_UCHAR ),

   vPIXEL_CODE_BGRA_UCHAR =
      vPIXEL_CODE( vPIXEL_FORMAT_BGRA, vPIXEL_CHANNEL_UCHAR )
   }
   vPIXEL_CODE_TYPE;


#define G_PIXEL_UNSUPPORTED   vPIXEL_CODE_NOT_SUPPORTED
#define G_PIXEL_LUMINANCE8    vPIXEL_CODE_GRAYSCALE_UCHAR
#define G_PIXEL_LUMINANCE12   vPIXEL_CODE_GRAYSCALE_USHORT12
#define G_PIXEL_LUMINANCE16   vPIXEL_CODE_GRAYSCALE_USHORT16
#define G_PIXEL_RGB24         vPIXEL_CODE_RGB_UCHAR
#define G_PIXEL_RGBA32        vPIXEL_CODE_RGBA_UCHAR
#define G_PIXEL_BGR24         vPIXEL_CODE_BGR_UCHAR
#define G_PIXEL_BGRA32        vPIXEL_CODE_BGRA_UCHAR


#define vPIXEL_CODE_GRAYSCALE_UCHAR_BYTES         1
#define vPIXEL_CODE_GRAYSCALE_USHORT12_BYTES      2  /* NOTE: 12 bits are padded to 16 bits */
#define vPIXEL_CODE_GRAYSCALE_USHORT16_BYTES      2
#define vPIXEL_CODE_RGB_UCHAR_BYTES               3
#define vPIXEL_CODE_RGBA_UCHAR_BYTES              4
#define vPIXEL_CODE_BGR_UCHAR_BYTES               3
#define vPIXEL_CODE_BGRA_UCHAR_BYTES              4


/* Added 4/24/03 */
const char* GetPixelCodeDescriptionString( const vPIXEL_CODE_TYPE type );


typedef struct tagPixelDescriptor
   {
   vSIZE  channelsPerPixel;
   vSIZE  bytesPerPixel;
   vSIZE  grayscaleBits;
   vSIZE  redChannelBits;
   vSIZE  greenChannelBits;
   vSIZE  blueChannelBits;
   vSIZE  alphaChannelBits;
   }
   PixelDescriptor;


vBOOL GetPixelDescriptor( vPIXEL_CODE_TYPE pixelCode, PixelDescriptor *pd );

// vPIXEL_CODE_TYPE GetPixelCodeType( PixelDescriptor *pd );

vSIZE GetPixelBufferSize( vPIXEL_CODE_TYPE pixelCode, vSIZE width, vSIZE height );


typedef struct tagColor1ub
   {
   vUCHAR  luminance;
   }
   Color1ub;

typedef struct tagColor1us12  /* 12 bit */
   {
   vUSHORT  luminance;
   }
   Color1us12;

typedef struct tagColor1us16 /* 16 bit */
   {
   vUSHORT  luminance;
   } 
   Color1us16;

typedef struct tagColor3ub
   {
   vUCHAR  red;
   vUCHAR  green;
   vUCHAR  blue;
   }
   Color3ub;

typedef struct tagColor4ub
   {
   vUCHAR  red;
   vUCHAR  green;
   vUCHAR  blue;
   vUCHAR  alpha;
   }
   Color4ub;


Color1ub MakeColor1ub( Color3ub color );
Color1us12 MakeColor1us12( Color3ub color );
Color1us16 MakeColor1us16( Color3ub color );

Color3ub MakeColor3ub( Color3ub color, vPIXEL_CODE_TYPE type );



typedef enum
   {
   vIMAGERW_NO_ERROR,
   vIMAGERW_ERROR_FILE_OPEN,
   vIMAGERW_ERROR_FILE_READ,
   vIMAGERW_ERROR_FILE_WRITE,
   vIMAGERW_ERROR_FILE_INVALID,
   vIMAGERW_ERROR_FILE_TYPE,
   vIMAGERW_ERROR_UNSUPPORTED,
   vIMAGERW_ERROR_OUT_OF_MEMORY
   }
   vIMAGERW_ERROR_CODE;


#define G_IMAGE_DOMAIN  0


typedef vIMAGERW_ERROR_CODE  GImageErrorType;

#define G_IMAGE_NO_ERROR              vIMAGERW_NO_ERROR
#define G_IMAGE_ERROR_FILE_OPEN       vIMAGERW_ERROR_FILE_OPEN
#define G_IMAGE_ERROR_FILE_READ       vIMAGERW_ERROR_FILE_READ
#define G_IMAGE_ERROR_FILE_WRITE      vIMAGERW_ERROR_FILE_WRITE
#define G_IMAGE_ERROR_FILE_INVALID    vIMAGERW_ERROR_FILE_INVALID
#define G_IMAGE_ERROR_FILE_TYPE       vIMAGERW_ERROR_FILE_TYPE
#define G_IMAGE_ERROR_UNSUPPORTED     vIMAGERW_ERROR_UNSUPPORTED
#define G_IMAGE_ERROR_OUT_OF_MEMORY   vIMAGERW_ERROR_OUT_OF_MEMORY



typedef enum
   {
   vFILE_TYPE_TIFF,
   vFILE_TYPE_TARGA,
   vFILE_TYPE_BIORAD_PIC,
   vFILE_TYPE_RAW,

   vFILE_TYPE_UNSUPPORTED
   }
   vFILE_TYPE;

#define vNUM_FILE_TYPES  ( ( vINT )vFILE_TYPE_UNSUPPORTED )


typedef vFILE_TYPE GImageFileType;

#define G_NUM_IMAGE_FILE_TYPES  vNUM_FILE_TYPES

#define G_IMAGE_FILE_TIFF         vFILE_TYPE_TIFF
#define G_IMAGE_FILE_TARGA        vFILE_TYPE_TARGA
#define G_IMAGE_FILE_BIORAD_PIC   vFILE_TYPE_BIORAD_PIC
#define G_IMAGE_FILE_RAW          vFILE_TYPE_RAW

#define G_IMAGE_FILE_UNSUPPORTED  vFILE_TYPE_UNSUPPORTED


//vBOOL FileTypeSupports3DImages( const vFILE_TYPE type );


typedef struct tagImageDescriptor
   {
   vPIXEL_CODE_TYPE  pixelCode;
   PixelDescriptor   pd;
   vSIZE             width;
   vSIZE             height;
   vSIZE             length;
   vENDIAN_TYPE      endian;
   vSIZE             extra1;
   }
   ImageDescriptor;


/* This routine currently checks the extension to identify the file type. */

vIMAGERW_ERROR_CODE GetFileTypeId( vSTRING fileName, vFILE_TYPE *fileType );


vFILE_TYPE GetFileTypeByExtension( const char *fileName );

#define g_image_file_type_by_extension  GetFileTypeByExtension


/* Returns e.g. for tiff files, "TIFF (*.tif,*.tiff)".
   NOTE: The pointer return should not be freed! */

vSTRING GetFileFilter( vFILE_TYPE fileType );

/* The pointer returned is static and should not be free'd */

vSTRING GetFileExtension( vFILE_TYPE fileType );


typedef struct _GImage Image_t;


/* NOTE: The 'desc' can be NULL for image formats that have headers, etc... */

vIMAGERW_ERROR_CODE ReadImage
   ( 
   const char             *fileName,
   vFILE_TYPE              fileType,
   Image_t                *image,
   const ImageDescriptor  *desc
   );

vIMAGERW_ERROR_CODE WriteImage
   ( 
   const char             *fileName,
   vFILE_TYPE              fileType,
   const Image_t          *image,
   const ImageDescriptor  *desc
   );


typedef ImageDescriptor GImageInfo;
typedef FileListNode GList;
#define g_list_next( iter ) NextFileListIterator( ( iter ) )
#define g_list_data( iter ) ( ( void* )( ( iter )->fileName ) )
typedef PixelDescriptor  GPixelInfo;
typedef vPIXEL_CODE_TYPE  GPixelType;




gpointer g_pointer_offset( gpointer ptr, glong bytes );


typedef struct _GImage       GImage;
typedef struct _GImageClass  GImageClass;

struct _GImage
   {
   GObject      parent_instance;

   GPixelType   pixel_type;
   GPixelInfo   pixel_info;
   gsize        width;
   gsize        height;
   gsize        length;
   gpointer     pixels;
   gpointer     user_data;
   GImageInfo   image_info;
   gsize        max_intensity;
   };

struct _GImageClass
   {
   GObjectClass         parent_class;
   GObjectFinalizeFunc  parent_finalize;
   };


#define G_TYPE_IMAGE             ( g_image_get_type() )
#define G_IMAGE( obj )           ( G_TYPE_CHECK_INSTANCE_CAST( ( obj ), G_TYPE_IMAGE, GImage ) )
#define G_IMAGE_CLASS( klass )   ( G_TYPE_CHECK_CLASS_CAST( ( klass ), G_TYPE_IMAGE, GImageClass ) )
#define G_IMAGE_GET_CLASS( obj ) ( G_TYPE_INSTANCE_GET_CLASS( ( obj ), G_TYPE_IMAGE, GImageClass ) )


GType g_image_get_type( void );

GImage* g_image_new( void );


/* Convenience macros. */

#define g_image_pixel_type( image )  ( G_IMAGE( image )->pixel_type )
#define g_image_pixel_info( image )  ( G_IMAGE( image )->pixel_info )
#define g_image_width( image )       ( G_IMAGE( image )->width )
#define g_image_height( image )      ( G_IMAGE( image )->height )
#define g_image_length( image )      ( G_IMAGE( image )->length )
#define g_image_pixels( image )      ( G_IMAGE( image )->pixels )


gboolean g_image_read_from_file
   ( 
   GImage          *image,
   const gchar     *file_name,
   GImageFileType   file_type,
   gpointer         user_data,
   GError         **error
   );

gboolean g_image_write_to_file
   ( 
   const GImage    *image,
   const gchar     *file_name,
   GImageFileType   file_type,
   gpointer         user_data,
   GError         **error
   );


gboolean g_image_info_from_file  /* Stored in image->image_info. */
   ( 
   GImage          *image,
   const gchar     *file_name,
   GImageFileType   file_type,
   gpointer         user_data,
   GError         **error
   );


gboolean g_image_read_from_file_at
   (
   GImage          *image,
   const gchar     *file_name,
   GImageFileType   file_type,
   gpointer         user_data,
   gsize            z,
   GError         **error
   );


/* These classes encapsulate the complexity of stepping through a
   sequence of 2D images of length 1 and/or 3D images of any length.  */

typedef struct _GImageReader       GImageReader;
typedef struct _GImageReaderClass  GImageReaderClass;

struct _GImageReader
   {
   GObject      parent_instance;

   GList       *current_file;
   GList       *end_files;
   GImageInfo   image_info;
   GImage      *image_2d;
   gsize        length_3d;
   gsize        index_2d;
   gsize        offset;
   gboolean     enabled;
   };

struct _GImageReaderClass
   {
   GObjectClass         parent_class;
   GObjectFinalizeFunc  parent_finalize;
   };


#define G_TYPE_IMAGE_READER             ( g_image_reader_get_type() )
#define G_IMAGE_READER( obj )           ( G_TYPE_CHECK_INSTANCE_CAST( ( obj ), G_TYPE_IMAGE_READER, GImageReader ) )
#define G_IMAGE_READER_CLASS( klass )   ( G_TYPE_CHECK_CLASS_CAST( ( klass ), G_TYPE_IMAGE_READER, GImageReaderClass ) )
#define G_IMAGE_READER_GET_CLASS( obj ) ( G_TYPE_INSTANCE_GET_CLASS( ( obj ), G_TYPE_IMAGE_READER, GImageReaderClass ) )


GType g_image_reader_get_type( void );

GImageReader* g_image_reader_new( void );

gboolean g_image_reader_create
   (
   GImageReader      *image_reader,
   GList             *first_file,
   GList             *end_files,
   const GImageInfo  *image_info,
   gboolean           enabled,
   GError           **error
   );

/* If the image reader is disabled, it will still step through the images but
   it will not actually read the pixel data. */
gboolean g_image_reader_enable( GImageReader *image_reader, GError **error );
void g_image_reader_disable( GImageReader *image_reader );

gboolean g_image_reader_has_more( const GImageReader *image_reader );

gboolean g_image_reader_advance( GImageReader *image_reader, GError **error );

GImage* g_image_reader_read( GImageReader *image_reader );

/* Usage:

   g_image_reader_create();
  
   while( g_image_reader_has_more() )
      {
      g_image_reader_read();
      g_image_reader_advance();
      }
*/

#endif/* __IMAGERW_H__ */

---