TivoliIO_volume.h

Go to the documentation of this file.

/*****************************************************************************
 * PROJECT     : V.I.P. Library
 * MODULE NAME : vip/TivoliIO_volume.h* TYPE     : Header
 * AUTHOR      : see below            * CREATION : 27/04/1994
 * VERSION     : 0.1                  * REVISION :
 * LANGUAGE    : C                    * EXAMPLE  :
 * DEVICE      : Sun SPARC Station 5
 *****************************************************************************
 *
 * DESCRIPTION : cree le 27/04/94 par geraud@ima.enst.fr
 *               modifie le 17/03/95
 *
 *               Copyright (c) 1994
 *               Dept. IMA  TELECOM Paris
 *               46, rue Barrault  F-75634 PARIS Cedex 13
 *               All Rights Reserved
 *
 *               This file groups general utility functions used allover the
 *               tivoli library.  Please contact B.V. before adding additional
 *               functions.
 *
 *****************************************************************************
 *
 * USED MODULES : 
 *
 *****************************************************************************
 * REVISIONS :  DATE  |    AUTHOR    |       DESCRIPTION
 *--------------------|--------------|----------------------------------------
 *              / /   |              |
 *****************************************************************************/
 
 
#ifndef VIP_TIVOLI_VOLUME_H
#define VIP_TIVOLI_VOLUME_H
 
 
#include <vip/volume/structure.h>
#include <vip/TivoliIO/TivoliIO_util.h>
 
 
/* volume limitation */
 
/*bnew: changed from 2048 to 4096 */
#define IMAGE_MAXSIZE   4096            /* maximum of (Volume*)->size. */
#define BORDER_MAXWIDTH 16              /* maximum of (Volume*)->borderWidth */
#define NAME_MAXLEN     1024U           /* maximum of volume name */
 
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
/* region of interest structure */
typedef struct {
                 int  x1, x2, y1, y2, z1, z2, t1, t2, state;
             } Roi;
 
/* volume structure removed because of vip/structure.h*/
 
 
/* macro for volume declaration */
 
#define DECL_VOLUME(aVolumePtr) Volume *aVolumePtr = NULL
 
 
 
#ifdef MEMORYMAP
/* memory mapping threshold: only use memory mapping for volumes greater 
   than this threshold (in bytes) */
#define MEMORYMAP_THRESHOLD 10
#endif
 
/* volume input-output specification in functions */
             /*redefine in VIP...
#define SAME_VOLUME 100
#define NEW_VOLUME  101
*/
 
 
/* constant for the field (Volume*)->type */
 
#define U8BIT  10               /* 8 bit unsigned integer */
#define S8BIT  11               /* 8 bit signed integer */
#define U16BIT 20               /* 16 bit unsigned integer */
#define S16BIT 21               /* 16 bit signed integer */
#define U32BIT 40               /* 32 bit unsigned integer */
#define S32BIT 41               /* 32 bit signed integer */
#define VFLOAT  400             /* simple precision real */
#define VDOUBLE 800             /* double precision real */
 
 
 
/* corresponding C declaration type */
 
typedef unsigned char   U8BIT_t;
typedef char                    S8BIT_t;
typedef unsigned short  U16BIT_t;
typedef short                   S16BIT_t;
typedef unsigned long   U32BIT_t;
typedef long                    S32BIT_t;
typedef float                   F32BIT_t;
typedef float                   FLOAT_t;
typedef double                  F64BIT_t;
typedef double                  DOUBLE_t;
 
typedef char                    ANY_t;     /* any type above */
 
 
 
 
/*============================================*
 |                                            |
 |  printing functions (print to stdout)      |
 |                                            |
 *============================================*/
/*----------------------------------------------------------------------------*/
/*      extern
        void                    printfvolume*/
/*
        print the nxnxn voxel values nearest from the first volume point (mode 0)
        or from the last point (mode 1)
*/
/*----------------------------------------------------------------------------*/
/*(
        Volume      *volume,
        int                     n,
        int                     mode
);*/
 
/*----------------------------------------------------------------------------*/
void printfError ( char *s );
void printfWarning ( char *s );
void printfInfo ( char *s );
/*----------------------------------------------------------------------------*/
 
 
 
 
 
 
/*=================================================*
 |                                                 |
 |  testing functions  (return 0 (PB) on failure)  |
 |                                                 |
 *================================================*/
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testExist
/*
        test if volume contains significant information (caracteristics and/or
        data) ; this function is called by all the following ones
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
/*----------------------------------------------------------------------------*/
        extern
        int                     testExistN
/*
        idem for n volumes
*/
/*----------------------------------------------------------------------------*/
(
        int                     n, ...
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testType
/*
        test if the volume type is the one specified
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     type
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testTypeN
/*
        test if the volume type is one of the list of n
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     n, ...
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testFilled
/*
        test if the volume contains significant data
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testEqualSize
/*
        test if both volumes have the same dimensions (size.x .y .z and .t)
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume1,
        Volume        *volume2
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testEqual2DSize
/*
        test if both volumes have the same dimensions (size.x and .y)
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume1,
        Volume        *volume2
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testEqualType
/*
        test if both volumes have the same type
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume1,
        Volume        *volume2
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testEqualBorderWidth
/*
        test if both volumes have the same border width
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume1,
        Volume        *volume2
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testSlice
/*
        test if the slice index is in the volume (# between -bW and z+bW-1)
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     slice
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     testImageSlice
/*
        test if the image contains the slice (# between 0 and size.z-1)
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     slice
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     verifyAll
/*
        verify that the volume contains correct information 
*/
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
extern 
int                        verifyRoi 
( 
        Roi *roi,
        Volume *volume 
);
/*----------------------------------------------------------------------------*/
 
 
/*----------------------------------------------------------------------------*/
extern
int testLevelInType ( double level, int type );
 
/*----------------------------------------------------------------------------*/
 
 
/*=====================================================*
 |                                                     |
 |  getting functions : access to the volume structure |
 |                                                     |
 *=====================================================*/
 
/*----------------------------------------------------------------------------*/
        extern
        void                    getSize2
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                 *sizeX,
        int                 *sizeY
);
#define getSize3 getSize
/*----------------------------------------------------------------------------*/
        extern
        void                    getSize
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                 *sizeX,
        int                 *sizeY,
        int                 *sizeZ
);
/*----------------------------------------------------------------------------*/
        extern
        void                    getSize4
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                 *sizeX,
        int                 *sizeY,
        int                 *sizeZ,
        int                 *sizeT
);
 
 
 
/*----------------------------------------------------------------------------*/
        
        int                     sizexOf
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
/*----------------------------------------------------------------------------*/
        
        int                     sizeyOf
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
/*----------------------------------------------------------------------------*/
        
        int                     sizezOf
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
/*----------------------------------------------------------------------------*/
        
        int                     sizetOf
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    getVoxelSize2              
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        float       *voxelSizeX,
        float       *voxelSizeY
);
#define getVoxelSize3 getVoxelSize
/*----------------------------------------------------------------------------*/
        extern
        void                    getVoxelSize                
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        float       *voxelSizeX,
        float       *voxelSizeY,
        float       *voxelSizeZ
);
/*----------------------------------------------------------------------------*/
        extern
        void                    getVoxelSize4
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        float       *voxelSizeX,
        float       *voxelSizeY,
        float       *voxelSizeZ,
        float       *voxelSizeT
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     borderWidthOf
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     typeOf
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
/*----------------------------------------------------------------------------*/
extern
char                *typeName
 
/*----------------------------------------------------------------------------*/
(
        int                     type
 );
 
 
/* for use in util.h */
/*----------------------------------------------------------------------------*/
extern
char                *stateName
/*----------------------------------------------------------------------------*/
(
        int                     state
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void        getMinMax
        
/*----------------------------------------------------------------------------*/
(
        Volume     *volume,
        double     *minVal,
        double     *maxVal
 );
 
 
 
 
/*============================================================*
 |                                                            |
 |  setting functions : change values in the volume structure |
 |                                                            |
 *===========================================================*/
 
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    setSize2
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     nx,
        int                     ny
);
#define setSize3 setSize
/*----------------------------------------------------------------------------*/
        extern
        void                    setSize          
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     nx,
        int                     ny,
        int                     nz
);
/*----------------------------------------------------------------------------*/
        extern
        void                    setSize4
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     nx,
        int                     ny,
        int                     nz,
        int                     nt
);
 
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    setSizex
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     nx
);
/*----------------------------------------------------------------------------*/
        extern
        void                    setSizey
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     ny
);
/*----------------------------------------------------------------------------*/
        extern
        void                    setSizez
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     nz
);
/*----------------------------------------------------------------------------*/
        extern
        void                    setSizet
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     nt
);
 
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    setVoxelSize2
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        float           dx,
        float           dy
);
#define setVoxelSize3 setVoxelSize
/*----------------------------------------------------------------------------*/
        extern
        void                    setVoxelSize                
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        float           dx,
        float           dy,
        float           dz
);
/*----------------------------------------------------------------------------*/
        extern
        void                    setVoxelSize4
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        float           dx,
        float           dy,
        float           dz,
        float           dt
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    setType
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     type
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    setBorderWidth
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     borderWidth
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    setVolumeLevel
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        double                  level
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    setImageLevel
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        double                  level
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    setBorderLevel
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        double                  level
);
 
 
 
 
 
/*====================*
 |                    |
 |  offset functions  |
 |                    |
 *====================*/
 
 
/*----------------------------------------------------------------------------*/
        extern
        int                     sizeofType
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
/* the following function should disappear in the future: */
/*----------------------------------------------------------------------------*/
        extern
        long                    offset_forANYtype_BetweenPoint
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        long                    offsetFirstPoint
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        long                    offsetLine
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        long                    offsetPointBetweenLine
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        long                    offsetSlice
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        long                    offsetLineBetweenSlice
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        long                    offsetVolume
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        long                    offsetImage
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        
        long int            *offsetBox
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     connexity
);
 
 
 
 
 
 
 
/*============================*
 |                            |
 |  data accessing functions  |
 |                            |
 *============================*/
 
/*
        Rq : we can not prevent with 'lint' the six occurances of the message
        'pointer cast may result in improper alignment' caused by these functions
*/
 
 
/*----------------------------------------------------------------------------*/
        extern
        U8BIT_t      *data_U8BIT
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        S8BIT_t      *data_S8BIT
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        U16BIT_t            *data_U16BIT
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        S16BIT_t            *data_S16BIT
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        U32BIT_t            *data_U32BIT
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        S32BIT_t           *data_S32BIT
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        FLOAT_t      *data_VFLOAT
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        DOUBLE_t            *data_VDOUBLE
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        ANY_t          *data_ANY
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
/*      extern
        U8BIT_t    ***tab_U8BIT
*/
/*----------------------------------------------------------------------------*/
/*(
        Volume      *volume
);*/
 
 
/*----------------------------------------------------------------------------*/
/*      extern
        S8BIT_t    ***tab_S8BIT
*/
/*----------------------------------------------------------------------------*/
/*(
        Volume      *volume
);*/
 
 
/*----------------------------------------------------------------------------*/
/*      extern
        U16BIT_t    ***tab_U16BIT
*/
/*----------------------------------------------------------------------------*/
/*(
        Volume      *volume
);*/
 
 
/*----------------------------------------------------------------------------*/
/*      extern
        S16BIT_t    ***tab_S16BIT
*/
/*----------------------------------------------------------------------------*/
/*(
        Volume      *volume
);*/
 
 
/*----------------------------------------------------------------------------*/
/*      extern
        U32BIT_t    ***tab_U32BIT
*/
/*----------------------------------------------------------------------------*/
/*(
        Volume      *volume
);*/
 
 
/*----------------------------------------------------------------------------*/
/*      extern
        S32BIT_t   ***tab_S32BIT
*/
/*----------------------------------------------------------------------------*/
/*(
        Volume      *volume
);*/
 
 
/*----------------------------------------------------------------------------*/
/*      extern
        FLOAT_t    ***tab_FLOAT
*/
/*----------------------------------------------------------------------------*/
/*(
        Volume      *volume
);*/
 
 
/*----------------------------------------------------------------------------*/
/*      extern
        DOUBLE_t    ***tab_DOUBLE
*/
/*----------------------------------------------------------------------------*/
/*(
        Volume      *volume
);*/
 
 
 
 
 
 
/*==========================*
 |                          |
 |  input-output functions  |
 |                          |
 *==========================*/
 
 
 
/* the following function existed earlier with other parameters
   pleas change them !  The dimension info is now returned as
   a volume structure
   The old function is renamed to readVolumeDim_OLD but should 
   disappear in the future
*/
/*----------------------------------------------------------------------------*/
        
        Volume *readVolumeDim
 
/*----------------------------------------------------------------------------*/
(
        const char    *filename, 
        Roi         *roi
);
 
/*----------------------------------------------------------------------------*/
        extern
        int                     readVolumeDim_OLD
 
/*----------------------------------------------------------------------------*/
(
        const char    *filename,
        int                 *nx,
        int                 *ny,
        int                 *nz,
        int                 *type,
        float       *dx,
        float       *dy,
        float       *dz
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        Volume        *readVolume
 
/*----------------------------------------------------------------------------*/
(
        const char    *filename,
        int                     borderWidth
);
 
 
/*----------------------------------------------------------------------------*/
extern
void                    writeVolumeDim                    /*NEW*/
 
/*----------------------------------------------------------------------------*/
(
 Volume       *volume,
 const char    *filename
 );
 
/*----------------------------------------------------------------------------*/
        extern
        void                    writeVolume
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        const char    *filename
);
 
 
/*----------------------------------------------------------------------------*/
 
        void                    writeVolumeSlices
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     firstSlice, /* slices go from 0 to n-1 */
        int                     nSlices, /* the number of consecutive slices */
        const char    *filename
 );
 
/*----------------------------------------------------------------------------*/
        extern
        void                    writeVolumeSlice
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     slice,   /* slices go from 0 to nz-1 */
        const char    *filename
);
 
 
 
 
 
/*==========================*
 |                          |
 |  volume creators         |
 |                          |
 *==========================*/
 
 
 
 
#define declareVolumeStructure3 declareVolumeStructure
/*----------------------------------------------------------------------------*/
        extern
        Volume        *declareVolumeStructure       
/*----------------------------------------------------------------------------*/
(
        int                     xSize,
        int                     ySize,
        int                     zSize,
        float           xVoxelSize,
        float           yVoxelSize,
        float           zVoxelSize,
        int                     type,
        const char    *name,
        int                     borderWidth
);
/*----------------------------------------------------------------------------*/
        extern
        Volume        *declareVolumeStructure4
        
/*----------------------------------------------------------------------------*/
(
        int                     xSize,
        int                     ySize,
        int                     zSize,
        int                     tSize,
        float           xVoxelSize,
        float           yVoxelSize,
        float           zVoxelSize,
        float           tVoxelSize,
        int                     type,
        const char    *name,
        int                     borderWidth
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        Volume        *duplicateVolumeStructure
 
/*----------------------------------------------------------------------------*/        (
        Volume        *volume,
        const char    *name
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    allocateVolumeData
        
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        Volume        *createVolume           /*  prefer new version  */
        
/*----------------------------------------------------------------------------*/
(
        int                     xSize,
        int                     ySize,
        int                     zSize,
        float           xVoxelSize,
        float           yVoxelSize,
        float           zVoxelSize,
        int                     type,
        const char    *name,
        int                     borderWidth
);
/*----------------------------------------------------------------------------*/
        extern
        Volume        *createVolume4         /*NEW*/
        
/*----------------------------------------------------------------------------*/
(
        int                     xSize,
        int                     ySize,
        int                     zSize,
        int                     tSize,
        float           xVoxelSize,
        float           yVoxelSize,
        float           zVoxelSize,
        float           tVoxelSize,
        int                     type,
        const char    *name,
        int                     borderWidth
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    transferVolumeData 
        
/*----------------------------------------------------------------------------*/
(
        Volume        *volumeR,
        Volume        *volumeW
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    appendVolume
 
/*----------------------------------------------------------------------------*/
(
        const char    *filename,
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        Volume        *copyVolume
        
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        const char    *name
);
 
 
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    copySlice
        
/*----------------------------------------------------------------------------*/
(
        Volume        *volumeSource,
        int                     sliceSource,
        Volume        *volumeDestination,
        int                     sliceDestination
);
 
 
 
/*----------------------------------------------------------------------------*/
        
        void                    addBorder
        
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        Volume        *extractSlice
        
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     slice
);
 
/*----------------------------------------------------------------------------*/
        extern
        Volume        *extractRoi
        
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        Roi      *roi
 );
 
/*----------------------------------------------------------------------------*/
        
        Volume        *vol3DtoVol2D
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume,
        int                     first,
        int                     step,
        int                     number,
        int                     width
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    freeVolumeData
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        void                    freeVolume
 
/*----------------------------------------------------------------------------*/
(
        Volume        *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        Volume                 *axial2coronal
/*----------------------------------------------------------------------------*/
(
        Volume *volume
);
 
 
 
/*----------------------------------------------------------------------------*/
        extern
        Volume                 *coronal2axial
/*----------------------------------------------------------------------------*/
(
        Volume *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        Volume                 *axial2sagittal
/*----------------------------------------------------------------------------*/
(
        Volume *volume
);
 
 
/*----------------------------------------------------------------------------*/
        extern
        Volume                 *sagittal2axial
/*----------------------------------------------------------------------------*/
(
        Volume *volume
);
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* TIVOLI_VOLUME_H */