Header file for libtpcimgio. More...

#include "tpcclibConfig.h"
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdint.h>
#include <stdlib.h>
#include <strings.h>
#include <ctype.h>
#include <float.h>
#include <unistd.h>
#include <locale.h>
#include <time.h>
#include "libtpcmisc.h"

Data Structures
struct	ANALYZE_HEADER_KEY

struct	ANALYZE_HEADER_IMGDIM

struct	ANALYZE_HEADER_HISTORY

struct	ANALYZE_DSR

struct	ECAT7_mainheader

struct	ECAT7_imageheader

struct	ECAT7_scanheader

struct	ECAT7_2Dscanheader

struct	ECAT7_2Dnormheader

struct	ECAT7_attenheader

struct	ECAT7_normheader

struct	ECAT7_polmapheader

struct	ECAT7_MatDir

struct	ECAT7_MATRIXLIST

struct	ECAT7_Matval

struct	MatDir

struct	MATRIXLIST

struct	Matval

struct	ECAT63_mainheader

struct	ECAT63_imageheader

struct	ECAT63_scanheader

struct	ECAT63_normheader

struct	ECAT63_attnheader

struct	MatDirNode

struct	MatDirList

struct	MatrixData

struct	Matrix_file

struct	SIF

struct	IMG_PIXEL

struct	IMG_PIXELS

struct	IMG_RANGE

struct	VOXEL_4D

struct	IMG

struct	VOL_PIXEL

struct	VOL_RANGE

struct	VOL

struct	SVOL

struct	NIFTI_1_HEADER

struct	NIFTI_EXTENDER

struct	NIFTI_DSR

struct	ECAT_MATRIX

struct	ECAT_HEADERS

struct	DCMTAG

struct	DCMITEM

struct	DCMFILE

struct	DCMMATRIX

struct	DCMML

Macros
#define	BACKUP_EXTENSION ".bak"

#define	ANALYZE_DT_NONE 0

#define	ANALYZE_DT_UNKNOWN 0

#define	ANALYZE_DT_BINARY 1

#define	ANALYZE_DT_UNSIGNED_CHAR 2

#define	ANALYZE_DT_SIGNED_SHORT 4

#define	ANALYZE_DT_SIGNED_INT 8

#define	ANALYZE_DT_FLOAT 16

#define	ANALYZE_DT_COMPLEX 32

#define	ANALYZE_DT_DOUBLE 64

#define	ANALYZE_DT_RGB 128

#define	ANALYZE_DT_ALL 255

#define	MatBLKSIZE 512

#define	MatFirstDirBlk 2

#define	ECAT7_BYTE 1

#define	ECAT7_VAXI2 2

#define	ECAT7_VAXI4 3

#define	ECAT7_VAXR4 4

#define	ECAT7_IEEER4 5

#define	ECAT7_SUNI2 6

#define	ECAT7_SUNI4 7

#define	M68K_I2 SUN_I2

#define	M68K_I4 SUN_I4

#define	ECAT7_UNKNOWN 0

#define	ECAT7_2DSCAN 1

#define	ECAT7_IMAGE16 2

#define	ECAT7_ATTEN 3

#define	ECAT7_2DNORM 4

#define	ECAT7_POLARMAP 5

#define	ECAT7_VOLUME8 6

#define	ECAT7_VOLUME16 7

#define	ECAT7_PROJ 8

#define	ECAT7_PROJ16 9

#define	ECAT7_IMAGE8 10

#define	ECAT7_3DSCAN 11

#define	ECAT7_3DSCAN8 12

#define	ECAT7_3DNORM 13

#define	ECAT7_3DSCANFIT 14

#define	ECAT7_Feet_First_Prone 0

#define	ECAT7_Head_First_Prone 1

#define	ECAT7_Feet_First_Supine 2

#define	ECAT7_Head_First_Supine 3

#define	ECAT7_Feet_First_Decubitus_Right 4

#define	ECAT7_Head_First_Decubitus_Right 5

#define	ECAT7_Feet_First_Decubitus_Left 6

#define	ECAT7_Head_First_Decubitus_Left 7

#define	ECAT7_Unknown_Orientation 8

#define	MatBLKSIZE 512

#define	MatFirstDirBlk 2

#define	BYTE_TYPE 1

#define	VAX_I2 2

#define	VAX_I4 3

#define	VAX_R4 4

#define	IEEE_R4 5

#define	SUN_I2 6

#define	SUN_I4 7

#define	RAW_DATA 1

#define	IMAGE_DATA 2

#define	ATTN_DATA 3

#define	NORM_DATA 4

#define	ECAT63_SYSTEM_TYPE_DEFAULT 931

#define	IMG_STATUS_UNINITIALIZED 0

#define	IMG_STATUS_INITIALIZED 1

#define	IMG_STATUS_OCCUPIED 2

#define	IMG_STATUS_ERROR 3

#define	IMG_ERR_OK 0

#define	IMG_ERR_CALLING 1

#define	IMG_ERR_OOM 2

#define	IMG_TYPE_UNKNOWN 0

#define	IMG_TYPE_IMAGE 1

#define	IMG_TYPE_RAW 2

#define	IMG_TYPE_POLARMAP 3

#define	IMG_TYPE_ATTN 4

#define	IMG_UNKNOWN 0

#define	IMG_E63 1

#define	IMG_E7 2

#define	IMG_E7_2D 3

#define	IMG_POLARMAP 9

#define	IMG_ANA 11

#define	IMG_ANA_L 12 /* little endian variant */

#define	IMG_INTERFILE 21

#define	IMG_NIFTI_1D 31 /* dual file format */

#define	IMG_NIFTI_1S 32 /* single file format */

#define	IMG_MICROPET 41

#define	IMG_FLAT 61

#define	IMG_DICOM 100

#define	IMG_DC_UNKNOWN 0

#define	IMG_DC_CORRECTED 1

#define	IMG_DC_NONCORRECTED 2

#define	IMG_MODALITY_UNKNOWN 0

#define	IMG_MODALITY_PET 1

#define	IMG_MODALITY_MRI 2

#define	IMG_MODALITY_CT 3

#define	IMG_MODALITY_SPECT 4

#define	SCANNER_UNKNOWN 0

#define	SCANNER_ECAT931 12

#define	SCANNER_ADVANCE 12096

#define	SCANNER_HRPLUS 3

#define	SCANNER_HRRT 4

#define	SCANNER_MRI 5

#define	SCANNER_STEVCT_PET 6

#define	SCANNER_STEVCT_CT 7

#define	SCANNER_DMI_PET 8

#define	SCANNER_PRIMATE 2000

#define	SCANNER_RODENT 2001

#define	SCANNER_MICROPET2 2002

#define	SCANNER_FOCUS_220 2500

#define	SCANNER_FOCUS_120 2501

#define	SCANNER_INVEON_DEDICATED_PET 5000

#define	SCANNER_INVEON_MM_PET 5500

#define	SCANNER_MR_PET_HEAD_INSERT 6000

#define	SCANNER_TUEBINGEN_PET_MR 8000

#define	MAX_POLARMAP_NUM_RINGS 32

#define	MAX_MICROPET_LINE_LEN 1024

#define	NIFTI_HEADER_SIZE 348

#define	NIFTI_HEADER_EXTENDER_SIZE 4

#define	NIFTI_UNITS_UNKNOWN 0

#define	NIFTI_UNITS_METER 1

#define	NIFTI_UNITS_MM 2

#define	NIFTI_UNITS_MICRON 4

#define	NIFTI_UNITS_SEC 8

#define	NIFTI_UNITS_MSEC 16

#define	NIFTI_UNITS_USEC 24

#define	NIFTI_UNITS_HERTZ 32

#define	NIFTI_UNITS_PPM 40

#define	NIFTI_UNITS_RADS 48

#define	NIFTI_DT_NONE 0

#define	NIFTI_DT_UNKNOWN 0

#define	NIFTI_DT_BINARY 1

#define	NIFTI_DT_UNSIGNED_CHAR 2

#define	NIFTI_DT_SIGNED_SHORT 4

#define	NIFTI_DT_SIGNED_INT 8

#define	NIFTI_DT_FLOAT 16

#define	NIFTI_DT_COMPLEX 32

#define	NIFTI_DT_DOUBLE 64

#define	NIFTI_DT_RGB 128

#define	NIFTI_DT_ALL 255

#define	NIFTI_DT_SIGNED_CHAR 256

#define	NIFTI_DT_UNSIGNED_SHORT 512

#define	NIFTI_DT_UNSIGNED_INT 768

#define	NIFTI_DT_LONG_LONG 1024

#define	NIFTI_DT_UNSIGNED_LONG_LONG 1280

#define	NIFTI_DT_LONG_DOUBLE 1536

#define	NIFTI_DT_DOUBLE_PAIR 1792

#define	NIFTI_DT_LONG_DOUBLE_PAIR 2048

#define	NIFTI_DT_RGBA 2304

#define	NIFTI_INTENT_NONE 0

#define	NIFTI_INTENT_CORREL 2

#define	NIFTI_INTENT_TTEST 3

#define	NIFTI_INTENT_FTEST 4

#define	NIFTI_INTENT_ZSCORE 5

#define	NIFTI_INTENT_CHISQ 6

#define	NIFTI_INTENT_BETA 7

#define	NIFTI_INTENT_BINOM 8

#define	NIFTI_INTENT_GAMMA 9

#define	NIFTI_INTENT_POISSON 10

#define	NIFTI_INTENT_NORMAL 11

#define	NIFTI_INTENT_FTEST_NONC 12

#define	NIFTI_INTENT_CHISQ_NONC 13

#define	NIFTI_INTENT_LOGISTIC 14

#define	NIFTI_INTENT_LAPLACE 15

#define	NIFTI_INTENT_UNIFORM 16

#define	NIFTI_INTENT_TTEST_NONC 17

#define	NIFTI_INTENT_WEIBULL 18

#define	NIFTI_INTENT_CHI 19

#define	NIFTI_INTENT_INVGAUSS 20

#define	NIFTI_INTENT_EXTVAL 21

#define	NIFTI_INTENT_PVAL 22

#define	NIFTI_INTENT_LOGPVAL 23

#define	NIFTI_INTENT_LOG10PVAL 24

#define	NIFTI_INTENT_ESTIMATE 1001

#define	NIFTI_INTENT_LABEL 1002

#define	NIFTI_INTENT_NEURONAME 1003

#define	NIFTI_INTENT_GENMATRIX 1004

#define	NIFTI_INTENT_SYMMATRIX 1005

#define	NIFTI_INTENT_DISPVECT 1006

#define	NIFTI_INTENT_VECTOR 1007

#define	NIFTI_INTENT_POINTSET 1008

#define	NIFTI_INTENT_TRIANGLE 1009

#define	NIFTI_INTENT_QUATERNION 1010

#define	NIFTI_INTENT_DIMLESS 1011

#define	NIFTI_XFORM_UNKNOWN 0

#define	NIFTI_XFORM_SCANNER_ANAT 1

#define	NIFTI_XFORM_ALIGNED_ANAT 2

#define	NIFTI_XFORM_TALAIRACH 3

#define	NIFTI_XFORM_MNI_152 4

Enumerations
enum	{ STATUS_OK , STATUS_FAULT , STATUS_NOMEMORY , STATUS_NOFILE , STATUS_UNKNOWNFORMAT , STATUS_UNSUPPORTED , STATUS_MISSINGMATRIX , STATUS_NOWRITEPERM , STATUS_DISKFULL , STATUS_NOMATLIST , STATUS_INVALIDMATLIST , STATUS_VARMATSIZE , STATUS_NOMAINHEADER , STATUS_NOSUBHEADER , STATUS_NOMATRIX , STATUS_UNSUPPORTEDAXIALCOMP , STATUS_NOIMGDATAFILE , STATUS_NOHEADERFILE , STATUS_INVALIDHEADER , STATUS_NOIMGDATA , STATUS_NOSIFDATA , STATUS_WRONGSIFDATA , STATUS_CANTWRITEIMGFILE , STATUS_CANTWRITEHEADERFILE , STATUS_WRONGFILETYPE , STATUS_CANNOTERASE , STATUS_CANNOTREAD , STATUS_CANNOTWRITE , STATUS_UNSUPPORTEDPOLARMAP , STATUS_INVALIDPOLARMAP }

enum	dcmtruid { DCM_TRUID_UNKNOWN , DCM_TRUID_LEI , DCM_TRUID_LEE , DCM_TRUID_BEE , DCM_TRUID_JPEG50 , DCM_TRUID_JPEG51 , DCM_TRUID_JPEG70 , DCM_TRUID_JPEG80 , DCM_TRUID_JPEG81 , DCM_TRUID_JPEG90 , DCM_TRUID_JPEG91 , DCM_TRUID_JPEG92 , DCM_TRUID_JPEG93 , DCM_TRUID_MPEG100 , DCM_TRUID_MPEG102 , DCM_TRUID_MPEG103 , DCM_TRUID_RLE , DCM_TRUID_RFC , DCM_TRUID_XML , DCM_TRUID_INVALID }

enum	dcmvr { DCM_VR_AE , DCM_VR_AS , DCM_VR_AT , DCM_VR_CS , DCM_VR_DA , DCM_VR_DS , DCM_VR_DT , DCM_VR_FL , DCM_VR_FD , DCM_VR_IS , DCM_VR_LO , DCM_VR_LT , DCM_VR_OB , DCM_VR_OD , DCM_VR_OF , DCM_VR_OL , DCM_VR_OW , DCM_VR_PN , DCM_VR_SH , DCM_VR_SL , DCM_VR_SQ , DCM_VR_SS , DCM_VR_ST , DCM_VR_TM , DCM_VR_UC , DCM_VR_UI , DCM_VR_UL , DCM_VR_UN , DCM_VR_UR , DCM_VR_US , DCM_VR_UT , DCM_VR_INVALID }

Functions
int	anaExists (const char *dbname)

int	anaExistsNew (const char dbname, char hdrfile, char imgile, char siffile)

int	anaRemove (const char *dbname)

void	anaRemoveFNameExtension (char *fname)

int	anaDatabaseExists (const char dbname, char hdrfile, char imgfile, char siffile)

int	anaMakeSIFName (const char dbname, char siffile)

int	anaFlipping ()

int	anaReadHeader (char filename, ANALYZE_DSR h)

int	anaReadImagedata (FILE fp, ANALYZE_DSR h, int frame, float *data)

int	anaWriteHeader (char filename, ANALYZE_DSR h)

int	anaPrintHeader (ANALYZE_DSR h, FILE fp)

int	anaEditHeader (ANALYZE_DSR h, char field, char *value)

int	ecat7ReadMainheader (FILE fp, ECAT7_mainheader h)

int	ecat7ReadImageheader (FILE fp, int blk, ECAT7_imageheader h)

int	ecat7ReadAttenheader (FILE fp, int blk, ECAT7_attenheader h)

int	ecat7ReadPolmapheader (FILE fp, int blk, ECAT7_polmapheader h)

int	ecat7ReadNormheader (FILE fp, int blk, ECAT7_normheader h)

int	ecat7ReadScanheader (FILE fp, int blk, ECAT7_scanheader h)

int	ecat7Read2DScanheader (FILE fp, int blk, ECAT7_2Dscanheader h)

int	ecat7Read2DNormheader (FILE fp, int blk, ECAT7_2Dnormheader h)

int	ecat7ReadMatrixdata (FILE fp, int start_block, int block_nr, char data, int dtype)

float	ecat7rFloat (void *bufi, int isvax, int islittle)

int	ecat7rInt (void *bufi, int isvax, int islittle)

int	ecat7ReadImageMatrix (FILE fp, int first_block, int last_block, ECAT7_imageheader h, float **fdata)

int	ecat7Read2DScanMatrix (FILE fp, int first_block, int last_block, ECAT7_2Dscanheader h, float **fdata)

int	ecat7ReadScanMatrix (FILE fp, int first_block, int last_block, ECAT7_scanheader h, float **fdata)

int	ecat7ReadPolarmapMatrix (FILE fp, int first_block, int last_block, ECAT7_polmapheader h, float **fdata)

int	ecat7pxlbytes (short int data_type)

void	ecat7InitMatlist (ECAT7_MATRIXLIST *mlist)

void	ecat7EmptyMatlist (ECAT7_MATRIXLIST *mlist)

int	ecat7ReadMatlist (FILE fp, ECAT7_MATRIXLIST ml, int verbose)

void	ecat7PrintMatlist (ECAT7_MATRIXLIST *ml)

int	ecat7EnterMatrix (FILE *fp, int matrix_id, int block_nr)

int	ecat7_val_to_id (int frame, int plane, int gate, int data, int bed)

void	ecat7_id_to_val (int matrix_id, ECAT7_Matval *matval)

void	ecat7SortMatlistByPlane (ECAT7_MATRIXLIST *ml)

void	ecat7SortMatlistByFrame (ECAT7_MATRIXLIST *ml)

int	ecat7CheckMatlist (ECAT7_MATRIXLIST *ml)

int	ecat7DeleteLateFrames (ECAT7_MATRIXLIST *ml, int frame_nr)

int	ecat7GetPlaneAndFrameNr (ECAT7_MATRIXLIST mlist, ECAT7_mainheader h, int plane_nr, int frame_nr)

int	ecat7GetMatrixBlockSize (ECAT7_MATRIXLIST mlist, int blk_nr)

int	ecat7GetNums (ECAT7_MATRIXLIST ml, ECAT7_mainheader mh, FILE fp, short int num_planes, short int num_frames, short int num_gates, short int *num_bed_pos)

int	ecat7GatherMatlist (ECAT7_MATRIXLIST *ml, short int do_planes, short int do_frames, short int do_gates, short int do_beds)

int	ecat7WriteMainheader (FILE fp, ECAT7_mainheader h)

int	ecat7WriteImageheader (FILE fp, int blk, ECAT7_imageheader h)

int	ecat7WriteAttenheader (FILE fp, int blk, ECAT7_attenheader h)

int	ecat7WritePolmapheader (FILE fp, int blk, ECAT7_polmapheader h)

int	ecat7WriteNormheader (FILE fp, int blk, ECAT7_normheader h)

int	ecat7WriteScanheader (FILE fp, int blk, ECAT7_scanheader h)

int	ecat7Write2DScanheader (FILE fp, int blk, ECAT7_2Dscanheader h)

int	ecat7Write2DNormheader (FILE fp, int blk, ECAT7_2Dnormheader h)

int	ecat7WritePolarmapMatrix (FILE fp, int matrix_id, ECAT7_polmapheader h, float *fdata)

int	ecat7WriteMatrixdata (FILE fp, int start_block, char data, long long pxl_nr, int pxl_size)

FILE *	ecat7Create (const char fname, ECAT7_mainheader h)

int	ecat7WriteImageMatrix (FILE fp, int matrix_id, ECAT7_imageheader h, float *fdata)

int	ecat7Write2DScanMatrix (FILE fp, int matrix_id, ECAT7_2Dscanheader h, float *fdata)

int	ecat7WriteScanMatrix (FILE fp, int matrix_id, ECAT7_scanheader h, float *fdata)

int	ecat7_is_scaling_needed (float amax, float *data, long long nr)

void	ecat7PrintMainheader (ECAT7_mainheader h, FILE fp)

void	ecat7PrintImageheader (ECAT7_imageheader h, FILE fp)

void	ecat7PrintScanheader (ECAT7_scanheader h, FILE fp)

void	ecat7PrintAttenheader (ECAT7_attenheader h, FILE fp)

void	ecat7PrintPolmapheader (ECAT7_polmapheader h, FILE fp)

void	ecat7PrintNormheader (ECAT7_normheader h, FILE fp)

void	ecat7Print2DScanheader (ECAT7_2Dscanheader h, FILE fp)

void	ecat7Print2DNormheader (ECAT7_2Dnormheader h, FILE fp)

int	ecat7PrintSubheader (ECAT7_mainheader mh, FILE fp, int plane, int frame, FILE ofp)

char *	ecat7filetype (short int file_type)

char *	ecat7acquisitiontype (short int acquisition_type)

char *	ecat7datatype (short int data_type)

int	ecat7EditMHeader (ECAT7_mainheader h, char field, char *value, int verbose)

int	ecat7EditSHeader (ECAT7_scanheader h, char field, char *value, int verbose)

int	ecat7EditVHeader (ECAT7_imageheader h, char field, char *value, int verbose)

int	ecat63ReadMainheader (FILE fp, ECAT63_mainheader h)

int	ecat63ReadImageheader (FILE fp, int blk, ECAT63_imageheader h, int verbose, char *errmsg)

int	ecat63ReadScanheader (FILE fp, int blk, ECAT63_scanheader h, int verbose, char *errmsg)

int	ecat63ReadAttnheader (FILE fp, int blk, ECAT63_attnheader h, int verbose, char *errmsg)

int	ecat63ReadNormheader (FILE fp, int blk, ECAT63_normheader h, int verbose, char *errmsg)

int	ecat63ReadMatdata (FILE fp, int strtblk, int blkNr, char data, int dtype)

int	ecat63ReadImageMatrix (FILE fp, int strtblk, int lastblk, ECAT63_imageheader h, float **f)

int	ecat63ReadScanMatrix (FILE fp, int strtblk, int lastblk, ECAT63_scanheader h, float **f)

int	ecat63ReadAttnMatrix (FILE fp, int strtblk, int lastblk, ECAT63_attnheader h, float **f)

float	ecat63rFloat (void *bufi, int isvax, int islittle)

int	ecat63rInt (void *bufi, int isvax, int islittle)

int	ecat63pxlbytes (short int data_type)

void	ecat63InitMatlist (MATRIXLIST *mlist)

void	ecat63EmptyMatlist (MATRIXLIST *mlist)

int	ecat63ReadMatlist (FILE fp, MATRIXLIST ml, int verbose)

void	ecat63PrintMatlist (MATRIXLIST *ml)

int	mat_numcod (int frame, int plane, int gate, int data, int bed)

void	mat_numdoc (int matnum, Matval *matval)

int	ecat63Matenter (FILE *fp, int matnum, int blkNr)

void	ecat63SortMatlistByPlane (MATRIXLIST *ml)

void	ecat63SortMatlistByFrame (MATRIXLIST *ml)

int	ecat63CheckMatlist (MATRIXLIST *ml)

int	ecat63DeleteLateFrames (MATRIXLIST *ml, int frame_nr)

int	ecat63GetMatrixBlockSize (MATRIXLIST mlist, int blk_nr)

int	ecat63GetPlaneAndFrameNr (MATRIXLIST mlist, ECAT63_mainheader h, int plane_nr, int frame_nr)

int	ecat63GetNums (MATRIXLIST ml, short int num_planes, short int num_frames, short int num_gates, short int *num_bed_pos)

int	ecat63GatherMatlist (MATRIXLIST *ml, short int do_planes, short int do_frames, short int do_gates, short int do_beds)

int	ecat63WriteMainheader (FILE fp, ECAT63_mainheader h)

int	ecat63WriteImageheader (FILE fp, int block, ECAT63_imageheader h)

int	ecat63WriteScanheader (FILE fp, int block, ECAT63_scanheader h)

int	ecat63WriteAttnheader (FILE fp, int block, ECAT63_attnheader h)

int	ecat63WriteNormheader (FILE fp, int block, ECAT63_normheader h)

FILE *	ecat63Create (const char fname, ECAT63_mainheader h)

int	ecat63WriteMatdata (FILE fp, int strtblk, char data, long long pxlNr, int pxlSize)

int	ecat63WriteScan (FILE fp, int matnum, ECAT63_scanheader h, void *data)

int	ecat63WriteImage (FILE fp, int matnum, ECAT63_imageheader h, void *data)

int	ecat63WriteNorm (FILE fp, int matnum, ECAT63_normheader h, void *data)

int	ecat63WriteAttn (FILE fp, int matnum, ECAT63_attnheader h, void *data)

int	ecat63WriteImageMatrix (FILE fp, int matnum, ECAT63_imageheader h, float *fdata)

int	ecat63WriteScanMatrix (FILE fp, int matnum, ECAT63_scanheader h, float *fdata)

void	ecat63wFloat (float bufi, void bufo, int tovax, int islittle)

void	ecat63wInt (int bufi, void bufo, int tovax, int islittle)

int	ecat63_is_scaling_needed (float amax, float *data, long long nr)

struct tm *	ecat63ScanstarttimeToTm (const ECAT63_mainheader h, struct tm tm)
	Convert scan_start_time in ECAT 6.3 main header into a struct tm.

time_t	ecat63Scanstarttime (const ECAT63_mainheader *h)
	Get calendar time from ECAT 6.3 main header.

void	ecat63PrintMainheader (ECAT63_mainheader h, FILE fp)

void	ecat63PrintImageheader (ECAT63_imageheader h, FILE fp)

void	ecat63PrintScanheader (ECAT63_scanheader h, FILE fp)

void	ecat63PrintAttnheader (ECAT63_attnheader h, FILE fp)

void	ecat63PrintNormheader (ECAT63_normheader h, FILE fp)

int	ecat6PrintSubheader (ECAT63_mainheader mh, FILE fp, int plane, int frame, FILE ofp)

char *	ecat63Datatype (short int dtype)

char *	ecat63Unit (short int dunit)

void	float2parts (float *buf)

char *	ecat63ScanstarttimeInt (const ECAT63_mainheader h, char buf)
	Convert scan_start_time in ECAT 6.3 main header into a null-terminated string of the form YYYY-MM-DD hh:mm:ss, with length of 19 characters and the null.

int	ecat63CopyMainheader (ECAT63_mainheader h1, ECAT63_mainheader h2)

int	ecat63CopyScanheader (ECAT63_scanheader h1, ECAT63_scanheader h2)

int	ecat63EditMHeader (ECAT63_mainheader h, char field, char *value, int verbose)

void	imgInit (IMG *image)

void	imgEmpty (IMG *image)

int	imgAllocate (IMG *image, int planes, int rows, int columns, int frames)

int	imgAllocateWithHeader (IMG image, int planes, int rows, int columns, int frames, IMG image_from)

int	imgDup (IMG img1, IMG img2)

char *	imgStatus (int status_index)

void	imgSetStatus (IMG *img, int status_index)

void	imgInfo (IMG *image)

int	imgCopyhdr (IMG image1, IMG image2)

int	imgExtractRange (IMG img1, IMG_RANGE r, IMG img2)

int	imgExistentTimes (IMG *img)

int	imgExistentCounts (IMG *img)

unsigned long long	imgNaNs (IMG *img, int fix)

int	sif2img (SIF sif, IMG img, int copy_header, int copy_frames, int copy_counts, int verbose)

int	img2sif (IMG img, SIF sif, int copy_header, int copy_frames, int copy_counts, int verbose)

int	imgDecayCorrection (IMG *img, int mode)

char *	imgIsotope (IMG *img)

int	imgSetDecayCorrFactors (IMG *image, int mode)

int	imgBranchingCorrection (IMG image, int mode, int verbose, char status)

int	imgRead (const char fname, IMG img)

int	imgWrite (const char fname, IMG img)

int	imgReadHeader (const char fname, IMG img, int format)

int	imgReadFrame (const char fname, int frame_to_read, IMG img, int frame_index)

int	imgWriteFrame (const char fname, int frame_to_write, IMG img, int frame_index)

void	imgFormatFromFName (IMG img, const char fname)

int	imgFormatDetermine (const char fname, char basename, char hdrfile, char imgfile, char siffile, int file_format, int scanner, int type, int *modality, int verbose)

int	ecat63ReadAllToImg (const char fname, IMG img)

int	ecat63WriteAllImg (const char fname, IMG img)

int	ecat63ReadPlaneToImg (const char fname, IMG img)

int	ecat63AddImg (const char fname, IMG img)

void	imgGetEcat63MHeader (IMG img, ECAT63_mainheader h)

void	imgSetEcat63MHeader (IMG img, ECAT63_mainheader h)

int	imgEcat63Supported (ECAT63_mainheader *h)

int	imgGetEcat63Fileformat (ECAT63_mainheader *h)

int	imgReadEcat63Header (const char fname, IMG img)

int	imgReadEcat63FirstFrame (const char fname, IMG img)

int	imgReadEcat63Frame (const char fname, int frame_to_read, IMG img, int frame_index)

int	imgWriteEcat63Frame (const char fname, int frame_to_write, IMG img, int frame_index)

void	imgSetEcat63SHeader (IMG img, void h)

int	imgReadEcat7 (const char fname, IMG img)

int	imgWriteEcat7 (const char fname, IMG img)

int	imgWrite2DEcat7 (const char fname, IMG img)

int	imgWritePolarmap (const char fname, IMG img)

void	imgGetEcat7MHeader (IMG img, ECAT7_mainheader h)

void	imgSetEcat7MHeader (IMG img, ECAT7_mainheader h)

int	imgReadEcat7Header (const char fname, IMG img)

int	imgEcat7Supported (ECAT7_mainheader *h)

int	imgReadEcat7Frame (const char fname, int frame_to_read, IMG img, int frame_index)

int	imgReadEcat7FirstFrame (const char fname, IMG img)

int	imgGetEcat7Fileformat (ECAT7_mainheader *h)

int	imgWriteEcat7Frame (const char fname, int frame_to_write, IMG img, int frame_index)

void	imgSetEcat7SHeader (IMG img, void h)

int	imgReadAnalyze (const char dbname, IMG img)

int	imgWriteAnalyze (const char dbname, IMG img)

int	imgReadAnalyzeHeader (const char dbname, IMG img)

int	imgGetAnalyzeHeader (IMG img, ANALYZE_DSR h)

int	imgSetAnalyzeHeader (IMG img, const char dbname, ANALYZE_DSR *h, float fmin, float fmax)

int	imgReadAnalyzeFrame (const char dbname, int frame_to_read, IMG img, int frame_index)

int	imgReadAnalyzeFirstFrame (const char fname, IMG img)

int	imgWriteAnalyzeFrame (const char fname, int frame_to_write, IMG img, int frame_index, float fmin, float fmax)

int	imgMicropetToEcat7 (char upetname, char ecatfile, int verbose)

int	imgMicropetPETToEcat7 (FILE fph, FILE fpi, char *ecatfile, int verbose)

int	imgMicropetCTToEcat7 (FILE fph, FILE fpi, char *ecatfile, int verbose)

int	imgGetMicropetMainHeader (FILE fp, IMG img, float *calibration_factor, int verbose)

int	imgGetMicropetFrameHeader (FILE fp, IMG img, int frame_index, int verbose)

int	imgGetMicropetSIF (FILE fp, SIF sif)

int	imgGetMicropetHeader (IMG *img)

int	imgReadMicropetHeader (const char dbname, IMG img)

int	imgReadMicropetFrame (const char fname, int frame_to_read, IMG img, int frame_index)

int	imgReadMicropetFirstFrame (const char fname, IMG img)

int	imgReadMicropet (const char fname, IMG img)

int	imgReadNifti (const char filename, IMG img, int verbose)

int	imgReadNiftiFirstFrame (const char filename, IMG img, int verbose)

int	imgReadNiftiHeader (const char filename, IMG img, int verbose)

int	imgGetNiftiHeader (IMG img, NIFTI_DSR h, int verbose)

int	imgReadNiftiFrame (const char filename, int frame_to_read, IMG img, int frame_index, int verbose)

int	imgSetNiftiHeader (IMG img, const char dbname, NIFTI_DSR *dsr, float fmin, float fmax, int verbose)

int	imgWriteNiftiFrame (const char dbname, int frame_to_write, IMG img, int frame_index, float fmin, float fmax, int verbose)

int	imgWriteNifti (const char dbname, IMG img, int save_sif, int verbose)

int	imgMatch (IMG img1, IMG img2, float accuracy)

int	imgMatchMatrix (IMG img1, IMG img2, double accuracy)

int	imgMatchHeader (IMG img1, IMG img2)

int	imgMatchTransform (IMG img1, IMG img2)

int	imgMatchFrames (IMG img1, IMG img2)

int	imgMatchPlanes (IMG img1, IMG img2)

int	imgMaxDifference (IMG img1, IMG img2, VOXEL_4D absdiff, float abs_max, VOXEL_4D reldiff, float rel_max)

int	imgSS (IMG img1, IMG img2, double *ss)

int	imgMatchMatrixSize (IMG img1, IMG img2)

int	imgMax (IMG img, float maxvalue)

int	imgAbsMax (IMG img, float maxvalue)

int	imgRangeMinMax (IMG img, IMG_RANGE r, IMG_PIXEL maxp, float maxv, IMG_PIXEL minp, float minv)

int	imgMinMax (IMG img, float minvalue, float *maxvalue)

int	imgFrameMinMax (IMG img, int frame, float minvalue, float *maxvalue)

int	imgReadMinMax (const char fname, float fmin, float *fmax)

int	imgSmoothMax (IMG img, float maxvalue, IMG_PIXEL *p)

int	imgGetPeak (IMG img, float beforeTime, IMG_PIXEL p, int verbose)

int	imgGetMaxFrame (IMG img, IMG mimg, int verbose)

int	imgGetMaxTime (IMG img, IMG mimg, const int w, int verbose)

int	imgAvg (IMG img, IMG_RANGE r, float *avg)

float	f_kth_smallest (float *data, long long int n, long long int k)

float	fmedian (float *data, long long int n)

float	fmean (float data, long long int n, float sd)

void	fMinMaxFin (float data, long long int n, float fmin, float *fmax)

int	imgUnitId (char *unit)

void	imgUnitFromEcat (IMG *img, int ecat_unit)

void	imgUnitFromEcat7 (IMG img, ECAT7_mainheader h)

int	imgUnitToEcat6 (IMG *img)

void	imgUnitToEcat7 (IMG img, ECAT7_mainheader h)

char *	imgUnit (int dunit)

int	imgSetUnit (IMG img, char unit)

int	interfile_read (char headerName[256], char searchWord[256], char returnValue[256], char errorMessage[300])

int	interfileIsHeader (const char hdrfile, char imgfile)

int	interfileExists (const char fname, char hdrfile, char *imgfile, int verbose)

int	upetHeaderReadParameter (FILE fp, char parameter, char *value)

int	upetIsHeader (char *hdrfile)

int	upetExists (const char upetname, char hdrfile, char *imgfile, int verbose)

int	upetGetImageDimensions (FILE fp, int z, int x, int y, int *f)

int	upetScanStart (FILE fp, time_t scant)

int	upetReadImagedata (FILE fp, IFT ift, int frame, float *data)

int	niftiExists (const char dbname, char hdrfile, char imgile, char siffile, NIFTI_DSR header, int verbose, char status)

int	niftiCreateFNames (const char filename, char hdrfile, char imgfile, char siffile, int fileformat)

int	niftiRemove (const char *dbname, int fileformat, int verbose)

int	niftiReadHeader (char filename, NIFTI_DSR h, int verbose, char *status)

int	niftiPrintHeader (NIFTI_DSR h, FILE fp)

void	niftiRemoveFNameExtension (char *fname)

int	niftiReadImagedata (FILE fp, NIFTI_DSR h, int frame, float data, int verbose, char status)

int	niftiWriteHeader (char filename, NIFTI_DSR dsr, int verbose, char *status)

int	sifRead (char filename, SIF data)

int	sifWrite (SIF data, char filename)

void	sifPrint (SIF *data)

void	sifEmpty (SIF *data)

void	sifInit (SIF *data)

int	sifSetmem (SIF *data, int frameNr)

void	sifWeight (SIF *data, double halflife)
	Calculate weights for frames in SIF data based on true counts. Weights are normalized to have an average of 1.0.

void	sifWeightByFrames (SIF *data, double halflife)
	Calculate weights for frames in SIF data based on frame lengths. Weights are normalized to have an average of 1.0.

void	sifWeightNorm (SIF *data)

void	sifModerateTrues (SIF *sif, double limit)

void	sifModerateWeights (SIF *sif, double limit)

int	sifExistentCounts (SIF *sif)

void	ematInitiate (ECAT_MATRIX *emat)

void	ehdrInitiate (ECAT_HEADERS *ehdr)

void	ematEmpty (ECAT_MATRIX *emat)

void	ehdrEmpty (ECAT_HEADERS *ehdr)

int	ehdrAllocate (ECAT_HEADERS *ehdr, int nr)

int	ecat7MHeaderToIFT (ECAT7_mainheader h, IFT ift, int verbose)

int	ecat7MainheaderFromIFT (ECAT7_mainheader h, IFT ift, int verbose)

int	ecat7ImageheaderToIFT (ECAT7_imageheader h, IFT ift, int verbose)

int	ecat7ScanheaderToIFT (ECAT7_scanheader h, IFT ift, int verbose)

int	ecat7ReadSubheaderToIFT (FILE fp, ECAT7_mainheader h, int strtblk, IFT *ift, int verbose)

int	ecat7WriteSubheaderFromIFT (FILE fp, ECAT7_mainheader h, int strtblk, IFT *ift, int verbose)

int	ecat7ReadHeaders (const char fname, ECAT_HEADERS ehdr, int verbose)

int	ecat7WriteHeaders (const char fname, ECAT_HEADERS ehdr, int verbose)

int	string_to_xyzf (const char str, IMG_PIXEL v)

int	irdReorder (IMG_RANGE *img_range)

int	irdRead (char irdfile, IMG_RANGE img_range, char *status)

int	irdCheck (IMG_RANGE r, IMG img)

void	volInit (VOL *vol)

void	volEmpty (VOL *vol)

int	volAllocate (VOL *vol, int planes, int rows, int columns)

int	img2vol (IMG img, VOL vol, int frame)

int	vol2img (VOL vol, IMG img, int frame)

void	volInfo (VOL vol, FILE fp)

void	volContents (VOL vol, VOL_RANGE r, FILE fp)

int	volMax (VOL vol, VOL_RANGE r, VOL_PIXEL maxp, float maxv, VOL_PIXEL minp, float minv)

int	volAvg (VOL vol, VOL_RANGE r, float *avg)

void	svolInit (SVOL *svol)

void	svolEmpty (SVOL *svol)

int	svolAllocate (SVOL *svol, int planes, int rows, int columns)

int	img2svol (IMG img, SVOL svol, int frame)

int	svol2img (SVOL svol, IMG img, int frame)

void	svolInfo (SVOL svol, FILE fp)

int	vrdReorder (VOL_RANGE *vol_range)

int	vrdVxlNr (VOL_RANGE *vol_range)

int	vrd2vol (VOL_RANGE r, VOL vol, float in, float out, char *status)

int	vrdRead (char vdffile, VOL_RANGE vol_range, char *status)

int	string_to_xyz (char str, int x, int y, int z)

void	pxlInit (IMG_PIXELS *pxl)

void	pxlFree (IMG_PIXELS *pxl)

int	pxlAllocate (IMG_PIXELS *pxl, long long int pxlNr)

int	pxlAllocateMore (IMG_PIXELS *pxl, long long int pxlNr)

int	pxlMakeRoom (IMG_PIXELS *list, long long int i, long long int n)

int	pxlAdd (IMG_PIXELS list, IMG_PIXEL pxl)

int	pxlGet (IMG_PIXELS list, long long int i, IMG_PIXEL pxl)

long long int	pxlAddFromMask (IMG_PIXELS list, IMG img)

void	pxlMove (IMG_PIXELS *list, long long int from, long long int to)

int	pxlRm (IMG_PIXELS *list, long long int index)

long long int	pxlRmDuplicates (IMG_PIXELS *list)

int	pxlWrite (IMG_PIXELS pxl, FILE fp, char *status)

int	pxlRead (IMG_PIXELS pxl, const char fname, char *status)

int	dcmVerifyMagic (const char filename, FILE fp)

unsigned char	dcmVRReserved (dcmvr id)

dcmvr	dcmVRId (const char *s)

char *	dcmVRName (dcmvr id)

size_t	dcmVRVLength (dcmvr id)

char *	dcmVRDescr (dcmvr id)

char *	dcmDA2intl (const char orig, char intl)

char *	dcmTM2intl (const char orig, char intl)

char *	dcmDT2intl (const char orig, char intl)

unsigned int	dcmSOPIdentify (const char *s)

char *	dcmSOPName (unsigned int i)

char *	dcmSOPUID (unsigned int i)

char *	dcmSOPUIDName (const char *s)

dcmtruid	dcmTrUID (const char *s)

char *	dcmTrUIDDescr (dcmtruid id)

char *	dcmTrUIDString (dcmtruid id)

dcmtruid	dcmReadTransferSyntaxUID (FILE *fp)

int	dcmReadFileTag (FILE fp, DCMTAG tag)

int	dcmWriteFileTag (FILE fp, DCMTAG tag)

int	dcmWriteFileSQDelimItem (FILE *fp)

int	dcmWriteFileSQItemDelimTag (FILE *fp)

dcmvr	dcmReadFileVR (FILE fp, char vrstr)

unsigned int	dcmReadFileVL (FILE *fp, unsigned int n)

int	dcmReadFileVRVL (FILE fp, dcmvr vr, unsigned int vl, unsigned int n)

int	dcmWriteFileVRVL (FILE fp, dcmvr vr, unsigned int vl, unsigned int n)

void	dcmfileInit (DCMFILE *d)

void	dcmitemFree (DCMITEM *d)

void	dcmfileFree (DCMFILE *d)

unsigned short int	dcmfileMaxDepth (DCMFILE *df)

unsigned short int	dcmitemMaxDepth (DCMITEM *d)

unsigned short int	dcmitemParentNr (DCMITEM *d)

char *	dcmValueString (DCMITEM *d)

long int	dcmitemGetInt (DCMITEM *d)

double	dcmitemGetReal (DCMITEM *d)

DCMITEM *	dcmFindTag (DCMITEM d, const short int omit, DCMTAG tag, const int verbose)

void	dcmitemPrint (DCMITEM *d)

void	dcmTagSet (DCMTAG *tag, unsigned short int group, unsigned short int element)

int	dcmAddItem (DCMFILE dcm, DCMITEM d, short int aschild, DCMTAG tag, dcmvr vr, unsigned int vl, char *rd, const int verbose)

int	dcmFileReadNextElement (DCMFILE dcm, DCMITEM prev_item, DCMITEM *parent_item, const short int sub, const short int headerOnly, int verbose)

int	dcmFileRead (const char filename, DCMFILE dcm, const short int headerOnly, int verbose)

int	dcmFileWrite (const char filename, DCMFILE dcm, int verbose)

Variables
int	ANALYZE_TEST

char	ecat7errmsg [128]

int	ECAT7_TEST

char	ecat63errmsg [128]

int	ECAT63_TEST

char	siferrmsg [128]

int	SIF_TEST

int	IMG_TEST

int	VOL_TEST

int	MICROPET_TEST

Detailed Description

Header file for libtpcimgio.

Author: Vesa Oikonen

Definition in file libtpcimgio.h.

Macro Definition Documentation

◆ ANALYZE_DT_ALL

#define ANALYZE_DT_ALL 255

Analyze 7.5 datatype

Definition at line 67 of file libtpcimgio.h.

◆ ANALYZE_DT_BINARY

#define ANALYZE_DT_BINARY 1

Analyze 7.5 datatype, 1 bit

Definition at line 51 of file libtpcimgio.h.

Referenced by anaReadImagedata().

◆ ANALYZE_DT_COMPLEX

#define ANALYZE_DT_COMPLEX 32

Analyze 7.5 datatype, 64 bits (two floats)

Definition at line 61 of file libtpcimgio.h.

Referenced by anaReadImagedata().

◆ ANALYZE_DT_DOUBLE

#define ANALYZE_DT_DOUBLE 64

Analyze 7.5 datatype, 64 bits

Definition at line 63 of file libtpcimgio.h.

Referenced by anaReadImagedata().

◆ ANALYZE_DT_FLOAT

#define ANALYZE_DT_FLOAT 16

Analyze 7.5 datatype, 32 bits

Definition at line 59 of file libtpcimgio.h.

Referenced by anaReadImagedata().

◆ ANALYZE_DT_NONE

#define ANALYZE_DT_NONE 0

Analyze 7.5 datatype

Definition at line 47 of file libtpcimgio.h.

◆ ANALYZE_DT_RGB

#define ANALYZE_DT_RGB 128

Analyze 7.5 datatype

Definition at line 65 of file libtpcimgio.h.

Referenced by anaReadImagedata().

◆ ANALYZE_DT_SIGNED_INT

#define ANALYZE_DT_SIGNED_INT 8

Analyze 7.5 datatype, 32 bits

Definition at line 57 of file libtpcimgio.h.

Referenced by anaReadImagedata().

◆ ANALYZE_DT_SIGNED_SHORT

#define ANALYZE_DT_SIGNED_SHORT 4

Analyze 7.5 datatype, 16 bits

Definition at line 55 of file libtpcimgio.h.

Referenced by anaReadImagedata(), imgSetAnalyzeHeader(), and imgWriteAnalyze().

◆ ANALYZE_DT_UNKNOWN

#define ANALYZE_DT_UNKNOWN 0

Analyze 7.5 datatype

Definition at line 49 of file libtpcimgio.h.

◆ ANALYZE_DT_UNSIGNED_CHAR

#define ANALYZE_DT_UNSIGNED_CHAR 2

Analyze 7.5 datatype, 8 bits

Definition at line 53 of file libtpcimgio.h.

Referenced by anaReadImagedata().

◆ ATTN_DATA

#define ATTN_DATA 3

ECAT 6.3 file type

Definition at line 954 of file libtpcimgio.h.

Referenced by atnMake(), ecat63ReadAllToImg(), ecat63ReadMainheader(), ecat63ReadPlaneToImg(), ecat6PrintSubheader(), ecatCopy63to7mainheader(), ecatCopy7to63mainheader(), imgEcat63Supported(), imgGetEcat63Fileformat(), imgGetEcat63MHeader(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ BACKUP_EXTENSION

#define BACKUP_EXTENSION ".bak"

Backup file extension

Definition at line 32 of file libtpcimgio.h.

◆ BYTE_TYPE

#define BYTE_TYPE 1

ECAT 6.3 data type

Definition at line 935 of file libtpcimgio.h.

Referenced by ecat63pxlbytes(), ecat63ReadAllToImg(), ecat63ReadAttnheader(), ecat63ReadAttnMatrix(), ecat63ReadImageheader(), ecat63ReadImageMatrix(), ecat63ReadMainheader(), ecat63ReadMatdata(), ecat63ReadNormheader(), ecat63ReadPlaneToImg(), ecat63ReadScanheader(), ecat63ReadScanMatrix(), ecat63WriteAttn(), ecat63WriteImage(), ecat63WriteNorm(), ecat63WriteScan(), and imgReadEcat63Frame().

◆ ECAT63_SYSTEM_TYPE_DEFAULT

#define ECAT63_SYSTEM_TYPE_DEFAULT 931

Default system type in ECAT 6.3 file header

Definition at line 959 of file libtpcimgio.h.

Referenced by ecat63AddImg(), ecat63WriteAllImg(), and imgSetEcat63MHeader().

◆ ECAT7_2DNORM

#define ECAT7_2DNORM 4

ECAT7 matrix filetype

Definition at line 251 of file libtpcimgio.h.

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy63to7mainheader(), and ecatCopy7to63mainheader().

◆ ECAT7_2DSCAN

#define ECAT7_2DSCAN 1

ECAT7 matrix filetype

Definition at line 245 of file libtpcimgio.h.

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy7to63mainheader(), imgEcat7Supported(), imgGetEcat7Fileformat(), imgReadEcat7(), imgReadEcat7Header(), imgSetEcat7MHeader(), and imgWrite2DEcat7().

◆ ECAT7_3DNORM

#define ECAT7_3DNORM 13

ECAT7 matrix filetype

Definition at line 269 of file libtpcimgio.h.

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), and ecat7WriteSubheaderFromIFT().

◆ ECAT7_3DSCAN

#define ECAT7_3DSCAN 11

ECAT7 matrix filetype

Definition at line 265 of file libtpcimgio.h.

Referenced by ecat7GetNums(), ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy63to7mainheader(), ecatCopy7to63mainheader(), imgEcat7Supported(), imgGetEcat7Fileformat(), imgReadEcat7(), imgReadEcat7Header(), and imgSetEcat7MHeader().

◆ ECAT7_3DSCAN8

#define ECAT7_3DSCAN8 12

ECAT7 matrix filetype

Definition at line 267 of file libtpcimgio.h.

Referenced by ecat7GetNums(), ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy7to63mainheader(), imgEcat7Supported(), imgGetEcat7Fileformat(), imgReadEcat7(), and imgReadEcat7Header().

◆ ECAT7_3DSCANFIT

#define ECAT7_3DSCANFIT 14

ECAT7 matrix filetype

Definition at line 271 of file libtpcimgio.h.

Referenced by ecat7GetNums(), ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy7to63mainheader(), imgEcat7Supported(), imgGetEcat7Fileformat(), imgReadEcat7(), and imgReadEcat7Header().

◆ ECAT7_ATTEN

#define ECAT7_ATTEN 3

ECAT7 matrix filetype

Definition at line 249 of file libtpcimgio.h.

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy63to7mainheader(), and ecatCopy7to63mainheader().

◆ ECAT7_BYTE

#define ECAT7_BYTE 1

ECAT7 matrix data type

Definition at line 224 of file libtpcimgio.h.

Referenced by ecat7pxlbytes(), ecat7Read2DScanMatrix(), ecat7ReadImageMatrix(), ecat7ReadMatrixdata(), ecat7ReadPolarmapMatrix(), and ecat7ReadScanMatrix().

◆ ECAT7_Feet_First_Decubitus_Left

#define ECAT7_Feet_First_Decubitus_Left 6

ECAT7 patient orientation

Definition at line 286 of file libtpcimgio.h.

◆ ECAT7_Feet_First_Decubitus_Right

#define ECAT7_Feet_First_Decubitus_Right 4

ECAT7 patient orientation

Definition at line 282 of file libtpcimgio.h.

◆ ECAT7_Feet_First_Prone

#define ECAT7_Feet_First_Prone 0

ECAT7 patient orientation

Definition at line 274 of file libtpcimgio.h.

◆ ECAT7_Feet_First_Supine

#define ECAT7_Feet_First_Supine 2

ECAT7 patient orientation

Definition at line 278 of file libtpcimgio.h.

◆ ECAT7_Head_First_Decubitus_Left

#define ECAT7_Head_First_Decubitus_Left 7

ECAT7 patient orientation

Definition at line 288 of file libtpcimgio.h.

◆ ECAT7_Head_First_Decubitus_Right

#define ECAT7_Head_First_Decubitus_Right 5

ECAT7 patient orientation

Definition at line 284 of file libtpcimgio.h.

◆ ECAT7_Head_First_Prone

#define ECAT7_Head_First_Prone 1

ECAT7 patient orientation

Definition at line 276 of file libtpcimgio.h.

◆ ECAT7_Head_First_Supine

#define ECAT7_Head_First_Supine 3

ECAT7 patient orientation

Definition at line 280 of file libtpcimgio.h.

Referenced by ecatCopy63to7mainheader().

◆ ECAT7_IEEER4

#define ECAT7_IEEER4 5

ECAT7 matrix data type

Definition at line 232 of file libtpcimgio.h.

Referenced by ecat7pxlbytes(), ecat7Read2DScanMatrix(), ecat7ReadImageMatrix(), ecat7ReadMatrixdata(), ecat7ReadPolarmapMatrix(), ecat7ReadScanMatrix(), ecat7Write2DNormheader(), ecat7Write2DScanheader(), ecat7WriteAttenheader(), ecat7WriteImageheader(), ecat7WriteNormheader(), ecat7WritePolmapheader(), and ecat7WriteScanheader().

◆ ECAT7_IMAGE16

#define ECAT7_IMAGE16 2

ECAT7 matrix filetype

Definition at line 247 of file libtpcimgio.h.

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy7to63mainheader(), imgEcat7Supported(), imgGetEcat7Fileformat(), imgGetEcat7MHeader(), imgReadEcat7(), imgReadEcat7Header(), imgSetEcat7MHeader(), and imgWrite2DEcat7().

◆ ECAT7_IMAGE8

#define ECAT7_IMAGE8 10

ECAT7 matrix filetype

Definition at line 263 of file libtpcimgio.h.

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy7to63mainheader(), imgEcat7Supported(), imgGetEcat7Fileformat(), imgGetEcat7MHeader(), imgReadEcat7(), and imgReadEcat7Header().

◆ ECAT7_POLARMAP

#define ECAT7_POLARMAP 5

ECAT7 matrix filetype

Definition at line 253 of file libtpcimgio.h.

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), imgEcat7Supported(), imgGetEcat7Fileformat(), imgGetEcat7MHeader(), imgReadEcat7(), imgReadEcat7Header(), and imgSetEcat7MHeader().

◆ ECAT7_PROJ

#define ECAT7_PROJ 8

ECAT7 matrix filetype

Definition at line 259 of file libtpcimgio.h.

◆ ECAT7_PROJ16

#define ECAT7_PROJ16 9

ECAT7 matrix filetype

Definition at line 261 of file libtpcimgio.h.

◆ ECAT7_SUNI2

#define ECAT7_SUNI2 6

◆ ECAT7_SUNI4

#define ECAT7_SUNI4 7

ECAT7 matrix data type

Definition at line 236 of file libtpcimgio.h.

Referenced by ecat7pxlbytes(), ecat7Read2DScanMatrix(), ecat7ReadImageMatrix(), ecat7ReadMatrixdata(), ecat7ReadPolarmapMatrix(), ecat7ReadScanMatrix(), ecat7Write2DNormheader(), ecat7Write2DScanheader(), ecat7WriteAttenheader(), ecat7WriteImageheader(), ecat7WriteNormheader(), ecat7WritePolmapheader(), and ecat7WriteScanheader().

◆ ECAT7_UNKNOWN

#define ECAT7_UNKNOWN 0

ECAT7 matrix filetype

Definition at line 243 of file libtpcimgio.h.

◆ ECAT7_Unknown_Orientation

#define ECAT7_Unknown_Orientation 8

ECAT7 patient orientation

Definition at line 290 of file libtpcimgio.h.

◆ ECAT7_VAXI2

#define ECAT7_VAXI2 2

ECAT7 matrix data type

Definition at line 226 of file libtpcimgio.h.

Referenced by ecat7pxlbytes(), ecat7Read2DScanMatrix(), ecat7ReadImageMatrix(), ecat7ReadMatrixdata(), ecat7ReadPolarmapMatrix(), ecat7ReadScanMatrix(), ecat7Write2DNormheader(), ecat7Write2DScanheader(), ecat7WriteAttenheader(), ecat7WriteImageheader(), ecat7WriteNormheader(), ecat7WritePolmapheader(), and ecat7WriteScanheader().

◆ ECAT7_VAXI4

#define ECAT7_VAXI4 3

ECAT7 matrix data type

Definition at line 228 of file libtpcimgio.h.

Referenced by ecat7pxlbytes(), ecat7Read2DScanMatrix(), ecat7ReadImageMatrix(), ecat7ReadMatrixdata(), ecat7ReadPolarmapMatrix(), ecat7ReadScanMatrix(), ecat7Write2DNormheader(), ecat7Write2DScanheader(), ecat7WriteAttenheader(), ecat7WriteImageheader(), ecat7WriteNormheader(), ecat7WritePolmapheader(), and ecat7WriteScanheader().

◆ ECAT7_VAXR4

#define ECAT7_VAXR4 4

ECAT7 matrix data type

Definition at line 230 of file libtpcimgio.h.

Referenced by ecat7pxlbytes(), ecat7Read2DScanMatrix(), ecat7ReadImageMatrix(), ecat7ReadMatrixdata(), ecat7ReadPolarmapMatrix(), ecat7ReadScanMatrix(), ecat7Write2DNormheader(), ecat7Write2DScanheader(), ecat7WriteAttenheader(), ecat7WriteImageheader(), ecat7WriteNormheader(), ecat7WritePolmapheader(), and ecat7WriteScanheader().

◆ ECAT7_VOLUME16

#define ECAT7_VOLUME16 7

ECAT7 matrix filetype

Definition at line 257 of file libtpcimgio.h.

Referenced by ecat7GetNums(), ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy63to7mainheader(), ecatCopy7to63mainheader(), imgEcat7Supported(), imgGetEcat7Fileformat(), imgGetEcat7MHeader(), imgReadEcat7(), imgReadEcat7Header(), and imgSetEcat7MHeader().

◆ ECAT7_VOLUME8

#define ECAT7_VOLUME8 6

ECAT7 matrix filetype

Definition at line 255 of file libtpcimgio.h.

Referenced by ecat7GetNums(), ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), ecatCopy7to63mainheader(), imgEcat7Supported(), imgGetEcat7Fileformat(), imgGetEcat7MHeader(), imgReadEcat7(), and imgReadEcat7Header().

◆ IEEE_R4

#define IEEE_R4 5

ECAT 6.3 data type

Definition at line 943 of file libtpcimgio.h.

Referenced by atnMake(), ecat63pxlbytes(), ecat63ReadAllToImg(), ecat63ReadAttnMatrix(), ecat63ReadImageMatrix(), ecat63ReadMatdata(), ecat63ReadPlaneToImg(), ecat63ReadScanMatrix(), ecat63WriteAttn(), ecat63WriteImage(), ecat63WriteNorm(), ecat63WriteScan(), and imgReadEcat63Frame().

◆ IMAGE_DATA

#define IMAGE_DATA 2

ECAT 6.3 file type

Definition at line 952 of file libtpcimgio.h.

Referenced by atnMake(), ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadMainheader(), ecat63ReadPlaneToImg(), ecat63WriteAllImg(), ecat6PrintSubheader(), ecatCopy63to7mainheader(), ecatCopy7to63mainheader(), imgEcat63Supported(), imgGetEcat63Fileformat(), imgGetEcat63MHeader(), imgReadEcat63Frame(), imgReadEcat63Header(), and imgSetEcat63MHeader().

◆ IMG_ANA

#define IMG_ANA 11

Definition for file format: big endian

Definition at line 1512 of file libtpcimgio.h.

Referenced by imgFormatDetermine(), imgFormatFromFName(), imgGetAnalyzeHeader(), imgReadAnalyze(), imgReadFrame(), imgReadHeader(), imgWrite(), imgWriteAnalyzeFrame(), and imgWriteFrame().

◆ IMG_ANA_L

#define IMG_ANA_L 12 /* little endian variant */

Definition for file format: little endian variant

Definition at line 1514 of file libtpcimgio.h.

Referenced by imgGetAnalyzeHeader(), imgReadAnalyze(), imgReadFrame(), imgReadHeader(), imgSetAnalyzeHeader(), imgWrite(), imgWriteAnalyze(), imgWriteAnalyzeFrame(), and imgWriteFrame().

◆ IMG_DC_CORRECTED

#define IMG_DC_CORRECTED 1

Definition for physical decay correction

Definition at line 1531 of file libtpcimgio.h.

Referenced by ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat63WriteAllImg(), img2sif(), imgDecayCorrection(), imgFrameIntegral(), imgGetAnalyzeHeader(), imgGetMicropetHeader(), imgGetMicropetMainHeader(), imgGetNiftiHeader(), imgInfo(), imgReadAnalyze(), imgReadEcat63Frame(), imgReadEcat63Header(), imgReadEcat7(), imgReadEcat7Frame(), imgReadEcat7Header(), imgSetAnalyzeHeader(), imgSetDecayCorrFactors(), imgWrite2DEcat7(), imgWriteAnalyze(), imgWriteEcat63Frame(), imgWriteEcat7(), and imgWriteEcat7Frame().

◆ IMG_DC_NONCORRECTED

#define IMG_DC_NONCORRECTED 2

Definition for physical decay correction

Definition at line 1533 of file libtpcimgio.h.

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), img_k1_using_ki(), img_logan(), img_patlak(), imgDecayCorrection(), imgFBP(), imgFrameIntegral(), imgGetAnalyzeHeader(), imgGetMicropetHeader(), imgGetMicropetMainHeader(), imgMRP(), imgReadAnalyze(), imgReadEcat63Header(), imgSetAnalyzeHeader(), imgSetDecayCorrFactors(), and imgWriteAnalyze().

◆ IMG_DC_UNKNOWN

#define IMG_DC_UNKNOWN 0

Definition for physical decay correction

Definition at line 1529 of file libtpcimgio.h.

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), img2sif(), imgEmpty(), imgInit(), imgReadEcat63Frame(), imgReadEcat63Header(), imgReadEcat7(), imgReadEcat7Frame(), and imgReprojection().

◆ IMG_DICOM

#define IMG_DICOM 100

Definition for file format

Definition at line 1526 of file libtpcimgio.h.

Referenced by imgFormatDetermine(), and imgFormatFromFName().

◆ IMG_E63

#define IMG_E63 1

Definition for file format

Definition at line 1504 of file libtpcimgio.h.

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), imgFormatFromFName(), imgGetEcat63Fileformat(), imgReadFrame(), imgReadHeader(), imgWrite(), imgWriteEcat63Frame(), and imgWriteFrame().

◆ IMG_E7

#define IMG_E7 2

Definition for file format

Definition at line 1506 of file libtpcimgio.h.

Referenced by imgFormatFromFName(), imgGetEcat7Fileformat(), imgMicropetCTToEcat7(), imgMicropetPETToEcat7(), imgNiftiToEcat(), imgReadEcat7(), imgReadFrame(), imgReadHeader(), imgWriteEcat7Frame(), and imgWriteFrame().

◆ IMG_E7_2D

#define IMG_E7_2D 3

Definition for file format

Definition at line 1508 of file libtpcimgio.h.

Referenced by imgGetEcat7Fileformat(), imgReadEcat7(), imgReadEcat7Frame(), imgReadFrame(), imgReadHeader(), imgSetEcat7MHeader(), imgSetEcat7SHeader(), imgWrite(), imgWriteEcat7Frame(), and imgWriteFrame().

◆ IMG_ERR_CALLING

#define IMG_ERR_CALLING 1

Definition for img error status message

Definition at line 1486 of file libtpcimgio.h.

◆ IMG_ERR_OK

#define IMG_ERR_OK 0

Definition for img error status message

Definition at line 1484 of file libtpcimgio.h.

◆ IMG_ERR_OOM

#define IMG_ERR_OOM 2

Definition for img error status message

Definition at line 1488 of file libtpcimgio.h.

◆ IMG_FLAT

#define IMG_FLAT 61

Definition for file format

Definition at line 1524 of file libtpcimgio.h.

◆ IMG_INTERFILE

#define IMG_INTERFILE 21

Definition for file format

Definition at line 1516 of file libtpcimgio.h.

Referenced by imgFormatDetermine(), and imgFormatFromFName().

◆ IMG_MICROPET

#define IMG_MICROPET 41

Definition for file format

Definition at line 1522 of file libtpcimgio.h.

Referenced by imgFormatDetermine(), imgGetMicropetHeader(), imgReadFrame(), and imgReadHeader().

◆ IMG_MODALITY_CT

#define IMG_MODALITY_CT 3

Definition for modality

Definition at line 1542 of file libtpcimgio.h.

◆ IMG_MODALITY_MRI

#define IMG_MODALITY_MRI 2

Definition for modality

Definition at line 1540 of file libtpcimgio.h.

◆ IMG_MODALITY_PET

#define IMG_MODALITY_PET 1

Definition for modality

Definition at line 1538 of file libtpcimgio.h.

◆ IMG_MODALITY_SPECT

#define IMG_MODALITY_SPECT 4

Definition for modality

Definition at line 1544 of file libtpcimgio.h.

◆ IMG_MODALITY_UNKNOWN

#define IMG_MODALITY_UNKNOWN 0

Definition for modality

Definition at line 1536 of file libtpcimgio.h.

Referenced by imgFormatDetermine().

◆ IMG_NIFTI_1D

#define IMG_NIFTI_1D 31 /* dual file format */

Definition for file format: dual file format

Definition at line 1518 of file libtpcimgio.h.

Referenced by imgGetNiftiHeader(), imgReadFrame(), imgReadHeader(), imgSetNiftiHeader(), imgWrite(), imgWriteFrame(), imgWriteNifti(), imgWriteNiftiFrame(), niftiCreateFNames(), and niftiRemove().

◆ IMG_NIFTI_1S

#define IMG_NIFTI_1S 32 /* single file format */

Definition for file format: single file format

Definition at line 1520 of file libtpcimgio.h.

Referenced by imgFormatFromFName(), imgGetNiftiHeader(), imgReadFrame(), imgReadHeader(), imgWrite(), imgWriteFrame(), imgWriteNifti(), imgWriteNiftiFrame(), niftiCreateFNames(), and niftiRemove().

◆ IMG_POLARMAP

#define IMG_POLARMAP 9

Definition for file format

Definition at line 1510 of file libtpcimgio.h.

Referenced by imgFormatFromFName(), imgGetEcat7Fileformat(), imgReadEcat7(), imgReadFrame(), imgReadHeader(), imgWrite(), imgWriteEcat7Frame(), and imgWriteFrame().

◆ IMG_STATUS_ERROR

#define IMG_STATUS_ERROR 3

Definition for img struct status

Definition at line 1481 of file libtpcimgio.h.

Referenced by imgInfo(), svolInfo(), and volInfo().

◆ IMG_STATUS_INITIALIZED

#define IMG_STATUS_INITIALIZED 1

Definition for img struct status

Definition at line 1477 of file libtpcimgio.h.

Referenced by ecat63ReadAllToImg(), imgEmpty(), imgGetAnalyzeHeader(), imgGetMicropetHeader(), imgGetNiftiHeader(), imgInfo(), imgInit(), imgRead(), imgReadAnalyze(), imgReadAnalyzeFirstFrame(), imgReadAnalyzeHeader(), imgReadEcat63FirstFrame(), imgReadEcat63Header(), imgReadEcat7(), imgReadEcat7FirstFrame(), imgReadEcat7Header(), imgReadFrame(), imgReadHeader(), imgReadMicropet(), imgReadMicropetFirstFrame(), imgReadMicropetHeader(), imgReadNifti(), imgReadNiftiFirstFrame(), imgReadNiftiHeader(), imgSetAnalyzeHeader(), imgSetNiftiHeader(), svolEmpty(), svolInfo(), svolInit(), volEmpty(), volInfo(), and volInit().

◆ IMG_STATUS_OCCUPIED

#define IMG_STATUS_OCCUPIED 2

Definition for img struct status

Definition at line 1479 of file libtpcimgio.h.

Referenced by dftAllocateWithIMG(), ecat63AddImg(), ecat63ReadPlaneToImg(), ecat63WriteAllImg(), idiSimulateTubeImg(), idiSimulateTubeImgPlane(), idiSimulateTubeVol(), img2cube(), img2svol(), img2vol(), img_k1_using_ki(), img_logan(), img_patlak(), imgAbs(), imgAbsMax(), imgAllocate(), imgArithm(), imgArithmConst(), imgArithmFrame(), imgAUMC(), imgAverageAUC(), imgAverageMaskTAC(), imgAvg(), imgBorderAverageTAC(), imgBranchingCorrection(), imgCircleMask(), imgDecayCorrection(), imgDeleteFrameOverlap(), imgDeleteFrameOverlap_old(), imgEmpty(), imgExistentCounts(), imgExistentTimes(), imgExtractRange(), imgFBP(), imgFrameGapFill(), imgFrameIntegral(), imgFrameMinMax(), imgFramesCheck(), imgGetAnalyzeHeader(), imgGetConcWeightedPeakPos(), imgGetFrameDiff(), imgGetFrameDyn(), imgGetMaxFrame(), imgGetMaxTime(), imgGetMicropetHeader(), imgGetNiftiHeader(), imgGetPeak(), imgInv(), imgLn(), imgLog10(), imgMaskFloodFill(), imgMaskPixelTACs(), imgMaskRegionLabeling(), imgMaskTAC(), imgMax(), imgMRP(), imgMRT(), imgNoiseTemplate(), imgOutlierFilter(), imgRangeMinMax(), imgRangeWeightedMax(), imgRawCountsPerTime(), imgReadAnalyzeFrame(), imgReadEcat63Frame(), imgReadEcat7Frame(), imgReadFrame(), imgReadMicropetFrame(), imgReadNiftiFrame(), imgRegionGrowingByThreshold(), imgReprojection(), imgsegmClusterExpand(), imgsegmFindMaxOutsideClusters(), imgsegmMaskToCluster(), imgsegmSimilar(), imgsegmThreshold(), imgsegmThresholdByMask(), imgsegmThresholdMask(), imgSetAnalyzeHeader(), imgSetDecayCorrFactors(), imgSetNiftiHeader(), imgSetScanner(), imgSetWeights(), imgSimulateRing(), imgSimulateSphere(), imgSmoothMax(), imgSmoothOverFrames(), imgThresholdByMask(), imgThresholding(), imgThresholdingLowHigh(), imgThresholdMaskCount(), imgTimeIntegral(), imgVoiMaskTAC(), imgWrite(), imgWrite2DEcat7(), imgWriteAnalyze(), imgWriteAnalyzeFrame(), imgWriteEcat63Frame(), imgWriteEcat7(), imgWriteEcat7Frame(), imgWriteFrame(), imgWriteNifti(), imgWriteNiftiFrame(), imgWritePolarmap(), sifAllocateWithIMG(), svol2img(), svolAllocate(), svolEmpty(), tiffWriteImg(), vol2img(), volAllocate(), volAvg(), volContents(), volEmpty(), volMax(), and vrd2vol().

◆ IMG_STATUS_UNINITIALIZED

#define IMG_STATUS_UNINITIALIZED 0

Definition for img struct status

Definition at line 1475 of file libtpcimgio.h.

Referenced by ecat63ReadPlaneToImg(), img2svol(), img2vol(), imgAllocate(), imgExtractRange(), imgInfo(), svolAllocate(), svolInfo(), volAllocate(), and volInfo().

◆ IMG_TYPE_ATTN

#define IMG_TYPE_ATTN 4

Definition for 'image type' attenuation data

Definition at line 1499 of file libtpcimgio.h.

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), and imgReadEcat63Header().

◆ IMG_TYPE_IMAGE

#define IMG_TYPE_IMAGE 1

Definition for image type

Definition at line 1493 of file libtpcimgio.h.

Referenced by ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat63WriteAllImg(), imgFBP(), imgFrameIntegral(), imgGetAnalyzeHeader(), imgGetEcat63MHeader(), imgGetEcat7MHeader(), imgGetMicropetHeader(), imgGetNiftiHeader(), imgMicropetCTToEcat7(), imgMicropetPETToEcat7(), imgMRP(), imgReadAnalyze(), imgReadEcat7(), imgReadEcat7Frame(), imgReadModelingData(), imgSetEcat63MHeader(), imgSetScanner(), imgWrite(), imgWrite2DEcat7(), imgWriteEcat63Frame(), and imgWriteEcat7().

◆ IMG_TYPE_POLARMAP

#define IMG_TYPE_POLARMAP 3

Definition for image type

Definition at line 1497 of file libtpcimgio.h.

Referenced by imgGetEcat7MHeader(), imgReadEcat7(), imgReadEcat7Frame(), imgSetEcat7MHeader(), imgSetEcat7SHeader(), imgWrite(), and imgWritePolarmap().

◆ IMG_TYPE_RAW

#define IMG_TYPE_RAW 2

Definition for 'image type' sinogram

Definition at line 1495 of file libtpcimgio.h.

Referenced by ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat63WriteAllImg(), img2sif(), imgFrameIntegral(), imgGetEcat63MHeader(), imgGetEcat7MHeader(), imgRawCountsPerTime(), imgReadEcat63Header(), imgReadEcat7(), imgReprojection(), imgSetEcat63SHeader(), imgSetEcat7MHeader(), imgSetEcat7SHeader(), imgWrite(), imgWrite2DEcat7(), imgWriteEcat63Frame(), imgWriteEcat7(), and imgWriteEcat7Frame().

◆ IMG_TYPE_UNKNOWN

#define IMG_TYPE_UNKNOWN 0

Definition for image type

Definition at line 1491 of file libtpcimgio.h.

Referenced by imgFormatDetermine(), and imgMatchHeader().

◆ IMG_UNKNOWN

#define IMG_UNKNOWN 0

Definition for file format

Definition at line 1502 of file libtpcimgio.h.

Referenced by imgFormatDetermine(), imgFormatFromFName(), imgGetEcat63Fileformat(), imgGetEcat7Fileformat(), imgReadEcat63Header(), imgReadEcat7(), imgReadEcat7Header(), imgReadFrame(), imgReadHeader(), and imgWrite().

◆ M68K_I2

#define M68K_I2 SUN_I2

ECAT matrix data type

Definition at line 238 of file libtpcimgio.h.

◆ M68K_I4

#define M68K_I4 SUN_I4

ECAT matrix data type

Definition at line 240 of file libtpcimgio.h.

◆ MatBLKSIZE [1/2]

#define MatBLKSIZE 512

ECAT matrix block size

ECAT 6.3 matrix block size

Definition at line 210 of file libtpcimgio.h.

Referenced by ecat63CopyFile(), ecat63Create(), ecat63Matenter(), ecat63ReadAllToImg(), ecat63ReadAttnheader(), ecat63ReadAttnMatrix(), ecat63ReadImageheader(), ecat63ReadImageMatrix(), ecat63ReadMainheader(), ecat63ReadMatdata(), ecat63ReadMatlist(), ecat63ReadNormheader(), ecat63ReadPlaneToImg(), ecat63ReadScanheader(), ecat63ReadScanMatrix(), ecat63WriteAttn(), ecat63WriteAttnheader(), ecat63WriteImage(), ecat63WriteImageheader(), ecat63WriteImageMatrix(), ecat63WriteMainheader(), ecat63WriteMatdata(), ecat63WriteNorm(), ecat63WriteNormheader(), ecat63WriteScan(), ecat63WriteScanheader(), ecat63WriteScanMatrix(), ecat7CopyFile(), ecat7Create(), ecat7EnterMatrix(), ecat7Read2DNormheader(), ecat7Read2DScanheader(), ecat7Read2DScanMatrix(), ecat7ReadAttenheader(), ecat7ReadImageheader(), ecat7ReadImageMatrix(), ecat7ReadMainheader(), ecat7ReadMatlist(), ecat7ReadMatrixdata(), ecat7ReadNormheader(), ecat7ReadPolarmapMatrix(), ecat7ReadPolmapheader(), ecat7ReadScanheader(), ecat7ReadScanMatrix(), ecat7Write2DNormheader(), ecat7Write2DScanheader(), ecat7Write2DScanMatrix(), ecat7WriteAttenheader(), ecat7WriteImageheader(), ecat7WriteImageMatrix(), ecat7WriteMainheader(), ecat7WriteMatrixdata(), ecat7WriteNormheader(), ecat7WritePolarmapMatrix(), ecat7WritePolmapheader(), ecat7WriteScanheader(), ecat7WriteScanMatrix(), and imgReadEcat63Frame().

◆ MatBLKSIZE [2/2]

#define MatBLKSIZE 512

ECAT matrix block size

ECAT 6.3 matrix block size

Definition at line 210 of file libtpcimgio.h.

◆ MatFirstDirBlk [1/2]

#define MatFirstDirBlk 2

ECAT matrix directory start block

ECAT 6.3 first directory block

Definition at line 214 of file libtpcimgio.h.

Referenced by ecat63Create(), ecat63Matenter(), ecat63ReadAttnMatrix(), ecat63ReadImageMatrix(), ecat63ReadMatlist(), ecat63ReadScanMatrix(), ecat7Create(), ecat7EnterMatrix(), ecat7Read2DScanMatrix(), ecat7ReadImageMatrix(), ecat7ReadMatlist(), ecat7ReadPolarmapMatrix(), and ecat7ReadScanMatrix().

◆ MatFirstDirBlk [2/2]

#define MatFirstDirBlk 2

ECAT matrix directory start block

ECAT 6.3 first directory block

Definition at line 214 of file libtpcimgio.h.

◆ MAX_MICROPET_LINE_LEN

#define MAX_MICROPET_LINE_LEN 1024

Max line length in micropet header

Definition at line 1994 of file libtpcimgio.h.

Referenced by imgGetMicropetFrameHeader(), imgGetMicropetHeader(), imgGetMicropetMainHeader(), imgGetMicropetSIF(), imgMicropetCTToEcat7(), imgMicropetToEcat7(), imgReadMicropetFrame(), upetGetImageDimensions(), upetHeaderReadParameter(), upetIsHeader(), upetReadImagedata(), and upetScanStart().

◆ MAX_POLARMAP_NUM_RINGS

#define MAX_POLARMAP_NUM_RINGS 32

Maximum nr of rings in polar map (based on ECAT 7 polar map header)

Definition at line 1586 of file libtpcimgio.h.

Referenced by imgCopyhdr(), imgEmpty(), imgInit(), and imgReadEcat7Header().

◆ NIFTI_DT_ALL

#define NIFTI_DT_ALL 255

NIFTI1 datatype (same as Analyze datatypes)

Definition at line 2051 of file libtpcimgio.h.

◆ NIFTI_DT_BINARY

#define NIFTI_DT_BINARY 1

NIFTI1 datatype 1 bit (same as Analyze datatypes)

Definition at line 2035 of file libtpcimgio.h.

Referenced by niftiReadImagedata().

◆ NIFTI_DT_COMPLEX

#define NIFTI_DT_COMPLEX 32

NIFTI1 datatype 64 bits (same as Analyze datatypes)

Definition at line 2045 of file libtpcimgio.h.

Referenced by niftiReadImagedata().

◆ NIFTI_DT_DOUBLE

#define NIFTI_DT_DOUBLE 64

NIFTI1 datatype 64 bits (same as Analyze datatypes)

Definition at line 2047 of file libtpcimgio.h.

Referenced by niftiReadImagedata().

◆ NIFTI_DT_DOUBLE_PAIR

#define NIFTI_DT_DOUBLE_PAIR 1792

NIFTI1 datatype 128 bits

Definition at line 2065 of file libtpcimgio.h.

◆ NIFTI_DT_FLOAT

#define NIFTI_DT_FLOAT 16

NIFTI1 datatype 32 bits (same as Analyze datatypes)

Definition at line 2043 of file libtpcimgio.h.

Referenced by imgSetNiftiHeader(), and niftiReadImagedata().

◆ NIFTI_DT_LONG_DOUBLE

#define NIFTI_DT_LONG_DOUBLE 1536

NIFTI1 datatype 128 bits

Definition at line 2063 of file libtpcimgio.h.

◆ NIFTI_DT_LONG_DOUBLE_PAIR

#define NIFTI_DT_LONG_DOUBLE_PAIR 2048

NIFTI1 datatype 256 bits

Definition at line 2067 of file libtpcimgio.h.

◆ NIFTI_DT_LONG_LONG

#define NIFTI_DT_LONG_LONG 1024

NIFTI1 datatype 64 bits

Definition at line 2059 of file libtpcimgio.h.

◆ NIFTI_DT_NONE

#define NIFTI_DT_NONE 0

NIFTI1 datatype (same as Analyze datatypes)

Definition at line 2031 of file libtpcimgio.h.

◆ NIFTI_DT_RGB

#define NIFTI_DT_RGB 128

NIFTI1 datatype 24 bits (same as Analyze datatypes)

Definition at line 2049 of file libtpcimgio.h.

Referenced by niftiReadImagedata().

◆ NIFTI_DT_RGBA

#define NIFTI_DT_RGBA 2304

NIFTI1 datatype 32 bits

Definition at line 2069 of file libtpcimgio.h.

◆ NIFTI_DT_SIGNED_CHAR

#define NIFTI_DT_SIGNED_CHAR 256

NIFTI1 datatype 8 bits

Definition at line 2053 of file libtpcimgio.h.

◆ NIFTI_DT_SIGNED_INT

#define NIFTI_DT_SIGNED_INT 8

NIFTI1 datatype 32 bits (same as Analyze datatypes)

Definition at line 2041 of file libtpcimgio.h.

Referenced by niftiReadImagedata().

◆ NIFTI_DT_SIGNED_SHORT

#define NIFTI_DT_SIGNED_SHORT 4

NIFTI1 datatype 16 bits (same as Analyze datatypes)

Definition at line 2039 of file libtpcimgio.h.

Referenced by niftiReadImagedata().

◆ NIFTI_DT_UNKNOWN

#define NIFTI_DT_UNKNOWN 0

NIFTI1 datatype (same as Analyze datatypes)

Definition at line 2033 of file libtpcimgio.h.

Referenced by niftiReadImagedata().

◆ NIFTI_DT_UNSIGNED_CHAR

#define NIFTI_DT_UNSIGNED_CHAR 2

NIFTI1 datatype 8 bits (same as Analyze datatypes)

Definition at line 2037 of file libtpcimgio.h.

Referenced by niftiReadImagedata().

◆ NIFTI_DT_UNSIGNED_INT

#define NIFTI_DT_UNSIGNED_INT 768

NIFTI1 datatype 32 bits

Definition at line 2057 of file libtpcimgio.h.

◆ NIFTI_DT_UNSIGNED_LONG_LONG

#define NIFTI_DT_UNSIGNED_LONG_LONG 1280

NIFTI1 datatype 64 bits

Definition at line 2061 of file libtpcimgio.h.

◆ NIFTI_DT_UNSIGNED_SHORT

#define NIFTI_DT_UNSIGNED_SHORT 512

NIFTI1 datatype 16 bits

Definition at line 2055 of file libtpcimgio.h.

Referenced by niftiReadImagedata().

◆ NIFTI_HEADER_EXTENDER_SIZE

#define NIFTI_HEADER_EXTENDER_SIZE 4

NIFTI1 header size

Definition at line 2006 of file libtpcimgio.h.

Referenced by niftiWriteHeader().

◆ NIFTI_HEADER_SIZE

#define NIFTI_HEADER_SIZE 348

NIFTI1 header size

Definition at line 2004 of file libtpcimgio.h.

Referenced by imgSetNiftiHeader(), niftiReadHeader(), and niftiWriteHeader().

◆ NIFTI_INTENT_BETA

#define NIFTI_INTENT_BETA 7

NIFTI1 intent statistics

Definition at line 2085 of file libtpcimgio.h.

◆ NIFTI_INTENT_BINOM

#define NIFTI_INTENT_BINOM 8

NIFTI1 intent statistics

Definition at line 2087 of file libtpcimgio.h.

◆ NIFTI_INTENT_CHI

#define NIFTI_INTENT_CHI 19

NIFTI1 intent statistics

Definition at line 2109 of file libtpcimgio.h.

◆ NIFTI_INTENT_CHISQ

#define NIFTI_INTENT_CHISQ 6

NIFTI1 intent statistics

Definition at line 2083 of file libtpcimgio.h.

◆ NIFTI_INTENT_CHISQ_NONC

#define NIFTI_INTENT_CHISQ_NONC 13

NIFTI1 intent statistics

Definition at line 2097 of file libtpcimgio.h.

◆ NIFTI_INTENT_CORREL

#define NIFTI_INTENT_CORREL 2

NIFTI1 intent statistics

Definition at line 2075 of file libtpcimgio.h.

◆ NIFTI_INTENT_DIMLESS

#define NIFTI_INTENT_DIMLESS 1011

NIFTI1 intent other

Definition at line 2141 of file libtpcimgio.h.

◆ NIFTI_INTENT_DISPVECT

#define NIFTI_INTENT_DISPVECT 1006

NIFTI1 intent other

Definition at line 2131 of file libtpcimgio.h.

◆ NIFTI_INTENT_ESTIMATE

#define NIFTI_INTENT_ESTIMATE 1001

NIFTI1 intent other

Definition at line 2121 of file libtpcimgio.h.

◆ NIFTI_INTENT_EXTVAL

#define NIFTI_INTENT_EXTVAL 21

NIFTI1 intent statistics

Definition at line 2113 of file libtpcimgio.h.

◆ NIFTI_INTENT_FTEST

#define NIFTI_INTENT_FTEST 4

NIFTI1 intent statistics

Definition at line 2079 of file libtpcimgio.h.

◆ NIFTI_INTENT_FTEST_NONC

#define NIFTI_INTENT_FTEST_NONC 12

NIFTI1 intent statistics

Definition at line 2095 of file libtpcimgio.h.

◆ NIFTI_INTENT_GAMMA

#define NIFTI_INTENT_GAMMA 9

NIFTI1 intent statistics

Definition at line 2089 of file libtpcimgio.h.

◆ NIFTI_INTENT_GENMATRIX

#define NIFTI_INTENT_GENMATRIX 1004

NIFTI1 intent other

Definition at line 2127 of file libtpcimgio.h.

◆ NIFTI_INTENT_INVGAUSS

#define NIFTI_INTENT_INVGAUSS 20

NIFTI1 intent statistics

Definition at line 2111 of file libtpcimgio.h.

◆ NIFTI_INTENT_LABEL

#define NIFTI_INTENT_LABEL 1002

NIFTI1 intent other

Definition at line 2123 of file libtpcimgio.h.

◆ NIFTI_INTENT_LAPLACE

#define NIFTI_INTENT_LAPLACE 15

NIFTI1 intent statistics

Definition at line 2101 of file libtpcimgio.h.

◆ NIFTI_INTENT_LOG10PVAL

#define NIFTI_INTENT_LOG10PVAL 24

NIFTI1 intent statistics

Definition at line 2119 of file libtpcimgio.h.

◆ NIFTI_INTENT_LOGISTIC

#define NIFTI_INTENT_LOGISTIC 14

NIFTI1 intent statistics

Definition at line 2099 of file libtpcimgio.h.

◆ NIFTI_INTENT_LOGPVAL

#define NIFTI_INTENT_LOGPVAL 23

NIFTI1 intent statistics

Definition at line 2117 of file libtpcimgio.h.

◆ NIFTI_INTENT_NEURONAME

#define NIFTI_INTENT_NEURONAME 1003

NIFTI1 intent other

Definition at line 2125 of file libtpcimgio.h.

◆ NIFTI_INTENT_NONE

#define NIFTI_INTENT_NONE 0

NIFTI1 intent dataset

Definition at line 2073 of file libtpcimgio.h.

Referenced by imgSetNiftiHeader().

◆ NIFTI_INTENT_NORMAL

#define NIFTI_INTENT_NORMAL 11

NIFTI1 intent statistics

Definition at line 2093 of file libtpcimgio.h.

◆ NIFTI_INTENT_POINTSET

#define NIFTI_INTENT_POINTSET 1008

NIFTI1 intent other

Definition at line 2135 of file libtpcimgio.h.

◆ NIFTI_INTENT_POISSON

#define NIFTI_INTENT_POISSON 10

NIFTI1 intent statistics

Definition at line 2091 of file libtpcimgio.h.

◆ NIFTI_INTENT_PVAL

#define NIFTI_INTENT_PVAL 22

NIFTI1 intent statistics

Definition at line 2115 of file libtpcimgio.h.

◆ NIFTI_INTENT_QUATERNION

#define NIFTI_INTENT_QUATERNION 1010

NIFTI1 intent other

Definition at line 2139 of file libtpcimgio.h.

◆ NIFTI_INTENT_SYMMATRIX

#define NIFTI_INTENT_SYMMATRIX 1005

NIFTI1 intent other

Definition at line 2129 of file libtpcimgio.h.

◆ NIFTI_INTENT_TRIANGLE

#define NIFTI_INTENT_TRIANGLE 1009

NIFTI1 intent other

Definition at line 2137 of file libtpcimgio.h.

◆ NIFTI_INTENT_TTEST

#define NIFTI_INTENT_TTEST 3

NIFTI1 intent statistics

Definition at line 2077 of file libtpcimgio.h.

◆ NIFTI_INTENT_TTEST_NONC

#define NIFTI_INTENT_TTEST_NONC 17

NIFTI1 intent statistics

Definition at line 2105 of file libtpcimgio.h.

◆ NIFTI_INTENT_UNIFORM

#define NIFTI_INTENT_UNIFORM 16

NIFTI1 intent statistics

Definition at line 2103 of file libtpcimgio.h.

◆ NIFTI_INTENT_VECTOR

#define NIFTI_INTENT_VECTOR 1007

NIFTI1 intent other

Definition at line 2133 of file libtpcimgio.h.

◆ NIFTI_INTENT_WEIBULL

#define NIFTI_INTENT_WEIBULL 18

NIFTI1 intent statistics

Definition at line 2107 of file libtpcimgio.h.

◆ NIFTI_INTENT_ZSCORE

#define NIFTI_INTENT_ZSCORE 5

NIFTI1 intent statistics

Definition at line 2081 of file libtpcimgio.h.

◆ NIFTI_UNITS_HERTZ

#define NIFTI_UNITS_HERTZ 32

NIFTI1 units: Hertz

Definition at line 2023 of file libtpcimgio.h.

◆ NIFTI_UNITS_METER

#define NIFTI_UNITS_METER 1

NIFTI1 units: meter

Definition at line 2011 of file libtpcimgio.h.

Referenced by imgGetNiftiHeader().

◆ NIFTI_UNITS_MICRON

#define NIFTI_UNITS_MICRON 4

NIFTI1 units: micrometer

Definition at line 2015 of file libtpcimgio.h.

Referenced by imgGetNiftiHeader().

◆ NIFTI_UNITS_MM

#define NIFTI_UNITS_MM 2

NIFTI1 units: millimetre

Definition at line 2013 of file libtpcimgio.h.

Referenced by imgGetNiftiHeader(), and imgSetNiftiHeader().

◆ NIFTI_UNITS_MSEC

#define NIFTI_UNITS_MSEC 16

NIFTI1 units: milliseconds

Definition at line 2019 of file libtpcimgio.h.

◆ NIFTI_UNITS_PPM

#define NIFTI_UNITS_PPM 40

NIFTI1 units: parts per million

Definition at line 2025 of file libtpcimgio.h.

◆ NIFTI_UNITS_RADS

#define NIFTI_UNITS_RADS 48

NIFTI1 units: radians per second

Definition at line 2027 of file libtpcimgio.h.

◆ NIFTI_UNITS_SEC

#define NIFTI_UNITS_SEC 8

NIFTI1 units: seconds

Definition at line 2017 of file libtpcimgio.h.

Referenced by imgSetNiftiHeader().

◆ NIFTI_UNITS_UNKNOWN

#define NIFTI_UNITS_UNKNOWN 0

NIFTI1 units: unknown

Definition at line 2009 of file libtpcimgio.h.

◆ NIFTI_UNITS_USEC

#define NIFTI_UNITS_USEC 24

NIFTI1 units: microseconds

Definition at line 2021 of file libtpcimgio.h.

◆ NIFTI_XFORM_ALIGNED_ANAT

#define NIFTI_XFORM_ALIGNED_ANAT 2

NIFTI1 Coordinate System: Coordinates aligned to another file or "truth".

Definition at line 2148 of file libtpcimgio.h.

◆ NIFTI_XFORM_MNI_152

#define NIFTI_XFORM_MNI_152 4

NIFTI1 Coordinate System: Coordinates aligned to the MNI space.

Definition at line 2152 of file libtpcimgio.h.

◆ NIFTI_XFORM_SCANNER_ANAT

#define NIFTI_XFORM_SCANNER_ANAT 1

NIFTI1 Coordinate System: Scanner-based anatomical coordinates.

Definition at line 2146 of file libtpcimgio.h.

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), imgReadAnalyze(), imgReadEcat63Frame(), imgReadEcat7(), and imgReadEcat7Header().

◆ NIFTI_XFORM_TALAIRACH

#define NIFTI_XFORM_TALAIRACH 3

NIFTI1 Coordinate System: Coordinates aligned to the Talairach space.

Definition at line 2150 of file libtpcimgio.h.

◆ NIFTI_XFORM_UNKNOWN

#define NIFTI_XFORM_UNKNOWN 0

NIFTI1 Coordinate System: Arbitrary coordinates.

Definition at line 2144 of file libtpcimgio.h.

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), imgEmpty(), imgInit(), imgReadAnalyze(), imgReadEcat63Frame(), imgReadEcat7(), and imgReadEcat7Header().

◆ NORM_DATA

#define NORM_DATA 4

ECAT 6.3 file type

Definition at line 956 of file libtpcimgio.h.

Referenced by ecat63ReadAllToImg(), ecat63ReadMainheader(), ecat63ReadPlaneToImg(), ecat6PrintSubheader(), ecatCopy63to7mainheader(), ecatCopy7to63mainheader(), imgEcat63Supported(), imgGetEcat63Fileformat(), imgGetEcat63MHeader(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ RAW_DATA

#define RAW_DATA 1

ECAT 6.3 file type

Definition at line 950 of file libtpcimgio.h.

Referenced by atnMake(), ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadMainheader(), ecat63ReadPlaneToImg(), ecat63WriteAllImg(), ecat6PrintSubheader(), ecatCopy63to7mainheader(), ecatCopy7to63mainheader(), imgEcat63Supported(), imgGetEcat63Fileformat(), imgGetEcat63MHeader(), imgReadEcat63Frame(), imgReadEcat63Header(), and imgSetEcat63MHeader().

◆ SCANNER_ADVANCE

#define SCANNER_ADVANCE 12096

Definition for scanner model (system type)

Definition at line 1551 of file libtpcimgio.h.

Referenced by imgSetScanner().

◆ SCANNER_DMI_PET

#define SCANNER_DMI_PET 8

Definition for scanner model (system type): nonstandard

Definition at line 1564 of file libtpcimgio.h.

◆ SCANNER_ECAT931

#define SCANNER_ECAT931 12

Definition for scanner model (system type)

Definition at line 1549 of file libtpcimgio.h.

Referenced by imgSetScanner().

◆ SCANNER_FOCUS_120

#define SCANNER_FOCUS_120 2501

Definition for scanner model (system type): nonstandard

Definition at line 1575 of file libtpcimgio.h.

◆ SCANNER_FOCUS_220

#define SCANNER_FOCUS_220 2500

Definition for scanner model (system type): nonstandard

Definition at line 1573 of file libtpcimgio.h.

◆ SCANNER_HRPLUS

#define SCANNER_HRPLUS 3

Definition for scanner model (system type)

Definition at line 1553 of file libtpcimgio.h.

Referenced by imgSetScanner().

◆ SCANNER_HRRT

#define SCANNER_HRRT 4

Definition for scanner model (system type)

Definition at line 1555 of file libtpcimgio.h.

Referenced by imgSetScanner().

◆ SCANNER_INVEON_DEDICATED_PET

#define SCANNER_INVEON_DEDICATED_PET 5000

Definition for scanner model (system type): nonstandard

Definition at line 1577 of file libtpcimgio.h.

◆ SCANNER_INVEON_MM_PET

#define SCANNER_INVEON_MM_PET 5500

Definition for scanner model (system type): nonstandard

Definition at line 1579 of file libtpcimgio.h.

◆ SCANNER_MICROPET2

#define SCANNER_MICROPET2 2002

Definition for scanner model (system type): nonstandard

Definition at line 1571 of file libtpcimgio.h.

◆ SCANNER_MR_PET_HEAD_INSERT

#define SCANNER_MR_PET_HEAD_INSERT 6000

Definition for scanner model (system type): nonstandard

Definition at line 1581 of file libtpcimgio.h.

◆ SCANNER_MRI

#define SCANNER_MRI 5

Definition for scanner model (system type): nonstandard

Definition at line 1558 of file libtpcimgio.h.

◆ SCANNER_PRIMATE

#define SCANNER_PRIMATE 2000

Definition for scanner model (system type): nonstandard

Definition at line 1567 of file libtpcimgio.h.

◆ SCANNER_RODENT

#define SCANNER_RODENT 2001

Definition for scanner model (system type): nonstandard

Definition at line 1569 of file libtpcimgio.h.

◆ SCANNER_STEVCT_CT

#define SCANNER_STEVCT_CT 7

Definition for scanner model (system type): nonstandard

Definition at line 1562 of file libtpcimgio.h.

◆ SCANNER_STEVCT_PET

#define SCANNER_STEVCT_PET 6

Definition for scanner model (system type): nonstandard

Definition at line 1560 of file libtpcimgio.h.

Referenced by imgSetScanner().

◆ SCANNER_TUEBINGEN_PET_MR

#define SCANNER_TUEBINGEN_PET_MR 8000

Definition for scanner model (system type): nonstandard

Definition at line 1583 of file libtpcimgio.h.

◆ SCANNER_UNKNOWN

#define SCANNER_UNKNOWN 0

Definition for scanner model (system type)

Definition at line 1547 of file libtpcimgio.h.

Referenced by imgFormatDetermine().

◆ SUN_I2

#define SUN_I2 6

ECAT 6.3 data type

Definition at line 945 of file libtpcimgio.h.

Referenced by atnMake(), ecat63pxlbytes(), ecat63ReadAllToImg(), ecat63ReadAttnMatrix(), ecat63ReadImageMatrix(), ecat63ReadMatdata(), ecat63ReadPlaneToImg(), ecat63ReadScanMatrix(), ecat63WriteAttn(), ecat63WriteImage(), ecat63WriteNorm(), ecat63WriteScan(), ecatCopy7to63mainheader(), and imgReadEcat63Frame().

◆ SUN_I4

#define SUN_I4 7

ECAT 6.3 data type

Definition at line 947 of file libtpcimgio.h.

Referenced by ecat63pxlbytes(), ecat63ReadAllToImg(), ecat63ReadAttnheader(), ecat63ReadAttnMatrix(), ecat63ReadImageheader(), ecat63ReadImageMatrix(), ecat63ReadMainheader(), ecat63ReadMatdata(), ecat63ReadNormheader(), ecat63ReadPlaneToImg(), ecat63ReadScanheader(), ecat63ReadScanMatrix(), ecat63WriteAttn(), ecat63WriteImage(), ecat63WriteNorm(), ecat63WriteScan(), and imgReadEcat63Frame().

◆ VAX_I2

#define VAX_I2 2

◆ VAX_I4

#define VAX_I4 3

ECAT 6.3 data type

Definition at line 939 of file libtpcimgio.h.

Referenced by ecat63pxlbytes(), ecat63ReadAllToImg(), ecat63ReadAttnMatrix(), ecat63ReadImageMatrix(), ecat63ReadMatdata(), ecat63ReadPlaneToImg(), ecat63ReadScanMatrix(), ecat63WriteAttn(), ecat63WriteAttnheader(), ecat63WriteImage(), ecat63WriteImageheader(), ecat63WriteMainheader(), ecat63WriteNorm(), ecat63WriteNormheader(), ecat63WriteScan(), ecat63WriteScanheader(), imgGetEcat63MHeader(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ VAX_R4

#define VAX_R4 4

ECAT 6.3 data type

Definition at line 941 of file libtpcimgio.h.

Referenced by ecat63pxlbytes(), ecat63ReadAllToImg(), ecat63ReadAttnMatrix(), ecat63ReadImageMatrix(), ecat63ReadMatdata(), ecat63ReadPlaneToImg(), ecat63ReadScanMatrix(), ecat63WriteAttn(), ecat63WriteAttnheader(), ecat63WriteImage(), ecat63WriteImageheader(), ecat63WriteMainheader(), ecat63WriteNorm(), ecat63WriteNormheader(), ecat63WriteScan(), ecat63WriteScanheader(), imgGetEcat63MHeader(), imgReadEcat63Frame(), and imgReadEcat63Header().

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Definitions for IMG struct status message

Definition at line 1589 of file libtpcimgio.h.

     {STATUS_OK,STATUS_FAULT,STATUS_NOMEMORY,STATUS_NOFILE,STATUS_UNKNOWNFORMAT,
    STATUS_UNSUPPORTED,STATUS_MISSINGMATRIX,STATUS_NOWRITEPERM,STATUS_DISKFULL,
    STATUS_NOMATLIST,STATUS_INVALIDMATLIST,STATUS_VARMATSIZE,STATUS_NOMAINHEADER,
    STATUS_NOSUBHEADER, STATUS_NOMATRIX, STATUS_UNSUPPORTEDAXIALCOMP,
    STATUS_NOIMGDATAFILE, STATUS_NOHEADERFILE, STATUS_INVALIDHEADER,
    STATUS_NOIMGDATA, STATUS_NOSIFDATA, STATUS_WRONGSIFDATA, 
    STATUS_CANTWRITEIMGFILE, STATUS_CANTWRITEHEADERFILE, STATUS_WRONGFILETYPE, 
    STATUS_CANNOTERASE, STATUS_CANNOTREAD, STATUS_CANNOTWRITE,
    STATUS_UNSUPPORTEDPOLARMAP, STATUS_INVALIDPOLARMAP};

◆ dcmtruid

enum dcmtruid

DICOM Transfer Syntax UID.

In case of implicit VR, elements do NOT contain VR ! Reference: DICOM PS3.5 2017a chapter 10.

Items must be the same and in the same order as the dcm_truid list.

Enumerator
DCM_TRUID_UNKNOWN	Unknown Transfer Syntax UID
DCM_TRUID_LEI	Little Endian Implicit VR (DICOM default)
DCM_TRUID_LEE	Little Endian Explicit VR.
DCM_TRUID_BEE	Big Endian Explicit VR.
DCM_TRUID_JPEG50	Lossy JPEG 8-bit compression.
DCM_TRUID_JPEG51	Lossy JPEG 12-bit compression.
DCM_TRUID_JPEG70	Lossless JPEG.
DCM_TRUID_JPEG80	Lossless JPEG-LS.
DCM_TRUID_JPEG81	Lossy JPEG-LS.
DCM_TRUID_JPEG90	Lossless JPEG 2000.
DCM_TRUID_JPEG91	JPEG 2000.
DCM_TRUID_JPEG92	Lossless multicomponent JPEG 2000.
DCM_TRUID_JPEG93	Multicomponent JPEG 2000.
DCM_TRUID_MPEG100	MPEG-2.
DCM_TRUID_MPEG102	MPEG-4.
DCM_TRUID_MPEG103	MPEG-4 BD-compatible.
DCM_TRUID_RLE	Lossless RLE.
DCM_TRUID_RFC	RFC 2557.
DCM_TRUID_XML	XML encoding.
DCM_TRUID_INVALID	Invalid Transfer Syntax UID.

Definition at line 2818 of file libtpcimgio.h.

             {
  DCM_TRUID_UNKNOWN, 
  DCM_TRUID_LEI,     
  DCM_TRUID_LEE,     
  DCM_TRUID_BEE,     
  DCM_TRUID_JPEG50,  
  DCM_TRUID_JPEG51,  
  DCM_TRUID_JPEG70,  
  DCM_TRUID_JPEG80,  
  DCM_TRUID_JPEG81,  
  DCM_TRUID_JPEG90,  
  DCM_TRUID_JPEG91,  
  DCM_TRUID_JPEG92,  
  DCM_TRUID_JPEG93,  
  DCM_TRUID_MPEG100, 
  DCM_TRUID_MPEG102, 
  DCM_TRUID_MPEG103, 
  DCM_TRUID_RLE,     
  DCM_TRUID_RFC,     
  DCM_TRUID_XML,     
  DCM_TRUID_INVALID  
} dcmtruid;

◆ dcmvr

enum dcmvr

DICOM value representation (VR).

Reference: DICOM PS3.5 2017a chapter 6.2.

Items must be the same and in the same order as the dcm_vr list.

Enumerator
DCM_VR_AE	DICOM application entity, max 16 bytes.
DCM_VR_AS	DICOM age string, 4 bytes fixed.
DCM_VR_AT	DICOM attribute tag, 4 bytes fixed.
DCM_VR_CS	DICOM code (control) string, max 16 bytes.
DCM_VR_DA	DICOM date in format YYYYMMDD, 8 bytes fixed. Note In old standard 10 bytes fixed, in format YYYY.MM.DD
DCM_VR_DS	DICOM decimal string, max 16 bytes.
DCM_VR_DT	DICOM date time, max 26 bytes.
DCM_VR_FL	DICOM floating point single precision, 4 bytes fixed.
DCM_VR_FD	DICOM floating point double precision, 8 bytes fixed.
DCM_VR_IS	DICOM integer string, max 12 bytes.
DCM_VR_LO	DICOM long string, max 64 chars.
DCM_VR_LT	DICOM long text, max 10240 chars.
DCM_VR_OB	DICOM other byte string, even bytes, endian insensitive.
DCM_VR_OD	DICOM other double (64-bit) stream, endian sensitive.
DCM_VR_OF	DICOM other float (32-bit) stream, endian sensitive.
DCM_VR_OL	DICOM other long (32-bit) stream, endian sensitive.
DCM_VR_OW	DICOM other word (16-bit) stream, even bytes, endian sensitive.
DCM_VR_PN	DICOM person name, max 64 chars per component group.
DCM_VR_SH	DICOM short string, max 16 chars.
DCM_VR_SL	DICOM signed long (32-bit integer), 4 bytes fixed.
DCM_VR_SQ	DICOM sequence of zero or more elements (used for nested data).
DCM_VR_SS	DICOM signed short (16-bit integer), 2 bytes fixed.
DCM_VR_ST	DICOM short text, max 1024 chars.
DCM_VR_TM	DICOM time HHMMSS.FFFFFF, max 14 bytes. Note In old standard 16 bytes max.
DCM_VR_UC	DICOM unlimited characters.
DCM_VR_UI	DICOM unique identifier (UID), max 64 bytes.
DCM_VR_UL	DICOM unsigned long (32-bit) integer, 4 bytes fixed.
DCM_VR_UN	DICOM unknown, any valid length of another VR.
DCM_VR_UR	DICOM URI or URL, string of characters.
DCM_VR_US	DICOM unsigned short (16-bit) integer, 2 bytes fixed.
DCM_VR_UT	DICOM unlimited text, character string.
DCM_VR_INVALID	Invalid DICOM value representation.

Definition at line 2847 of file libtpcimgio.h.

             {
  DCM_VR_AE,        
  DCM_VR_AS,        
  DCM_VR_AT,        
  DCM_VR_CS,        
  DCM_VR_DA,        
  DCM_VR_DS,        
  DCM_VR_DT,        
  DCM_VR_FL,        
  DCM_VR_FD,        
  DCM_VR_IS,        
  DCM_VR_LO,        
  DCM_VR_LT,        
  DCM_VR_OB,        
  DCM_VR_OD,        
  DCM_VR_OF,        
  DCM_VR_OL,        
  DCM_VR_OW,        
  DCM_VR_PN,        
  DCM_VR_SH,        
  DCM_VR_SL,        
  DCM_VR_SQ,        
  DCM_VR_SS,        
  DCM_VR_ST,        
  DCM_VR_TM,        
  DCM_VR_UC,        
  DCM_VR_UI,        
  DCM_VR_UL,        
  DCM_VR_UN,        
  DCM_VR_UR,        
  DCM_VR_US,        
  DCM_VR_UT,        
  DCM_VR_INVALID    
} dcmvr;

Function Documentation

◆ anaDatabaseExists()

int anaDatabaseExists	(	const char *	dbname,
		char *	hdrfile,
		char *	imgfile,
		char *	siffile )

extern

Check if Analyze database files exist (*.hdr, *.img, and optionally *.sif).

Returns: Returns 0, if files do not exist, 1 if .img and .hdr do exist, and 2, if also .sif exists.

See also: anaExists, anaRemove, anaRemoveFNameExtension

Parameters

dbname	analyze database name that is tested. String may contain standard extensions .hdr, .img or .sif
hdrfile	pointer to an allocated string, where existing header filename is written. If not found, then set to "". NULL can be entered, if not needed.
imgfile	pointer to an allocated string, where existing image filename is written. If not found, then set to "". NULL can be entered, if not needed.
siffile	pointer to an allocated string, where existing sif filename is written. If not found, then set to "". NULL can be entered, if not needed.

Definition at line 704 of file analyze.c.

  {
  char temp[FILENAME_MAX], database[FILENAME_MAX];
  int checked=0;
 
  if(ANALYZE_TEST)
    printf("\nanaDatabaseExists(%s, *hdrfile, *imgfile, *siffile)\n", dbname);
 
  /* Check the input */
  if(hdrfile!=NULL) strcpy(hdrfile, "");
  if(imgfile!=NULL) strcpy(imgfile, "");
  if(siffile!=NULL) strcpy(siffile, "");
  if(dbname==NULL || strlen(dbname)==0) return(0);
 
  strcpy(database, dbname);
  while(1) {
    /* Header file? */
    strcpy(temp, database); strcat(temp, ".hdr");
    if(access(temp, 0) != -1) {
      /* Also image file? */
      strcpy(temp, database); strcat(temp, ".img");
      if(access(temp, 0) != -1) {
        if(hdrfile!=NULL) sprintf(hdrfile, "%s.hdr", database);
        if(imgfile!=NULL) sprintf(imgfile, "%s.img", database);
        /* Even SIF? */
        if(anaMakeSIFName(database, temp)==0) { /* yes! */
          if(siffile!=NULL) strcpy(siffile, temp);
          return(2);
        }
        /* Image and header files did exist anyway */
        return(1);
      }
    }
    if(checked==1) break;
    /* Try to remove extension */
    anaRemoveFNameExtension(database);
    checked=1;
  } /* try again */
  return(0);
}

Referenced by anaRemove(), imgFormatDetermine(), imgReadAnalyzeFrame(), imgReadAnalyzeHeader(), and imgWriteAnalyzeFrame().

◆ anaEditHeader()

int anaEditHeader	(	ANALYZE_DSR *	h,
		char *	field,
		char *	value )

extern

Edits Analyze 7.5 header.

Returns: Returns 0, if ok, and 1 or 2, if field name or or value is invalid.

See also: anaReadHeader, imgSetAnalyzeHeader, imgReadAnalyzeHeader

Parameters

h	Pointer to Analyze header struct.
field	Header field name.
value	New value for the header field.

Definition at line 783 of file analyze.c.

  {
  int ii;
  short int si;
  float f;
 
  si=atoi(value); ii=atoi(value); f=atof(value);
  /* Header keys */
  if(strcmp(field, "header_key.sizeof_hdr")==0 || strcmp(field, "sizeof_hdr")==0) {
    h->hk.sizeof_hdr=ii;
  } else if(strcmp(field, "header_key.data_type")==0 || strcmp(field, "data_type")==0) {
    strlcpy(h->hk.data_type, value, 10);
  } else if(strcmp(field, "header_key.db_name")==0 || strcmp(field, "db_name")==0) {
    strlcpy(h->hk.db_name, value, 18);
  } else if(strcmp(field, "header_key.extents")==0 || strcmp(field, "extents")==0) {
    h->hk.extents=ii;
  } else if(strcmp(field, "header_key.session_error")==0 || strcmp(field, "session_error")==0) {
    h->hk.session_error=si;
  } else if(strcmp(field, "header_key.regular")==0 || strcmp(field, "regular")==0) {
    h->hk.regular=value[0];
  } else if(strcmp(field, "header_key.hkey_un0")==0 || strcmp(field, "hkey_un0")==0) {
    h->hk.hkey_un0=value[0];
  /* Header imgdim */
  } else if(strcmp(field, "header_image_dimension.dim")==0 || strcmp(field, "dim")==0) {
    sscanf(value, "%hd %hd %hd %hd %hd %hd %hd %hd",
      h->dime.dim+0, h->dime.dim+1, h->dime.dim+2, h->dime.dim+3,
      h->dime.dim+4, h->dime.dim+5, h->dime.dim+6, h->dime.dim+7
    );
  } else if(strcmp(field, "header_image_dimension.unused8")==0 || strcmp(field, "unused8")==0) {
    h->dime.unused8=si;
  } else if(strcmp(field, "header_image_dimension.unused9")==0 || strcmp(field, "unused9")==0) {
    h->dime.unused9=si;
  } else if(strcmp(field, "header_image_dimension.unused10")==0 || strcmp(field, "unused10")==0) {
    h->dime.unused10=si;
  } else if(strcmp(field, "header_image_dimension.unused11")==0 || strcmp(field, "unused11")==0) {
    h->dime.unused11=si;
  } else if(strcmp(field, "header_image_dimension.unused12")==0 || strcmp(field, "unused12")==0) {
    h->dime.unused12=si;
  } else if(strcmp(field, "header_image_dimension.unused13")==0 || strcmp(field, "unused13")==0) {
    h->dime.unused13=si;
  } else if(strcmp(field, "header_image_dimension.unused14")==0 || strcmp(field, "unused14")==0) {
    h->dime.unused14=si;
  } else if(strcmp(field, "header_image_dimension.datatype")==0 || strcmp(field, "datatype")==0) {
    h->dime.datatype=si;
  } else if(strcmp(field, "header_image_dimension.bitpix")==0 || strcmp(field, "bitpix")==0) {
    h->dime.bitpix=si;
  } else if(strcmp(field, "header_image_dimension.dim_un0")==0 || strcmp(field, "dim_un0")==0) {
    h->dime.dim_un0=si;
  } else if(strcmp(field, "header_image_dimension.pixdim")==0 || strcmp(field, "pixdim")==0) {
    sscanf(value, "%f %f %f %f %f %f %f %f",
      h->dime.pixdim+0, h->dime.pixdim+1, h->dime.pixdim+2, h->dime.pixdim+3,
      h->dime.pixdim+4, h->dime.pixdim+5, h->dime.pixdim+6, h->dime.pixdim+7
    );
  } else if(strcmp(field, "header_image_dimension.vox_offset")==0 || strcmp(field, "vox_offset")==0) {
    h->dime.vox_offset=f;
  } else if(strcmp(field, "header_image_dimension.funused1")==0 || strcmp(field, "funused1")==0) {
    h->dime.funused1=f;
  } else if(strcmp(field, "header_image_dimension.funused2")==0 || strcmp(field, "funused2")==0) {
    h->dime.funused2=f;
  } else if(strcmp(field, "header_image_dimension.funused3")==0 || strcmp(field, "funused3")==0) {
    h->dime.funused3=f;
  } else if(strcmp(field, "header_image_dimension.cal_max")==0 || strcmp(field, "cal_max")==0) {
    h->dime.cal_max=f;
  } else if(strcmp(field, "header_image_dimension.cal_min")==0 || strcmp(field, "cal_min")==0) {
    h->dime.cal_min=f;
  } else if(strcmp(field, "header_image_dimension.compressed")==0 || strcmp(field, "compressed")==0) {
    h->dime.compressed=f;
  } else if(strcmp(field, "header_image_dimension.verified")==0 || strcmp(field, "verified")==0) {
    h->dime.verified=f;
  } else if(strcmp(field, "header_image_dimension.glmax")==0 || strcmp(field, "glmax")==0) {
    h->dime.glmax=ii;
  } else if(strcmp(field, "header_image_dimension.glmin")==0 || strcmp(field, "glmin")==0) {
    h->dime.glmin=ii;
  /* Header history */
  } else if(strcmp(field, "header_data_history.descrip")==0 || strcmp(field, "descrip")==0) {
    strlcpy(h->hist.descrip, value, 80);
  } else if(strcmp(field, "header_data_history.aux_file")==0 || strcmp(field, "aux_file")==0) {
    strlcpy(h->hist.aux_file, value, 24);
  } else if(strcmp(field, "header_data_history.orient")==0 || strcmp(field, "orient")==0) {
    h->hist.orient=value[0];
  } else if(strcmp(field, "header_data_history.originator")==0 || strcmp(field, "originator")==0) {
    strlcpy(h->hist.originator, value, 10);
  } else if(strcmp(field, "header_data_history.generated")==0 || strcmp(field, "generated")==0) {
    strlcpy(h->hist.generated, value, 10);
  } else if(strcmp(field, "header_data_history.scannum")==0 || strcmp(field, "scannum")==0) {
    strlcpy(h->hist.scannum, value, 10);
  } else if(strcmp(field, "header_data_history.patient_id")==0 || strcmp(field, "patient_id")==0) {
    strlcpy(h->hist.patient_id, value, 10);
  } else if(strcmp(field, "header_data_history.exp_date")==0 || strcmp(field, "exp_date")==0) {
    strlcpy(h->hist.exp_date, value, 10);
  } else if(strcmp(field, "header_data_history.exp_time")==0 || strcmp(field, "exp_time")==0) {
    strlcpy(h->hist.exp_time, value, 10);
  } else if(strcmp(field, "header_data_history.hist_un0")==0 || strcmp(field, "hist_un0")==0) {
    memcpy(h->hist.hist_un0, value, 3);
  } else if(strcmp(field, "header_data_history.views")==0 || strcmp(field, "views")==0) {
    h->hist.views=ii;
  } else if(strcmp(field, "header_data_history.vols_added")==0 || strcmp(field, "vols_added")==0) {
    h->hist.vols_added=ii;
  } else if(strcmp(field, "header_data_history.start_field")==0 || strcmp(field, "start_field")==0) {
    h->hist.start_field=ii;
  } else if(strcmp(field, "header_data_history.field_skip")==0 || strcmp(field, "field_skip")==0) {
    h->hist.field_skip=ii;
  } else if(strcmp(field, "header_data_history.omax")==0 || strcmp(field, "omax")==0) {
    h->hist.omax=ii;
  } else if(strcmp(field, "header_data_history.omin")==0 || strcmp(field, "omin")==0) {
    h->hist.omin=ii;
  } else if(strcmp(field, "header_data_history.smax")==0 || strcmp(field, "smax")==0) {
    h->hist.smax=ii;
  } else if(strcmp(field, "header_data_history.smin")==0 || strcmp(field, "smin")==0) {
    h->hist.smin=ii;
  } else
    return(1);
 
  return(0);
}

◆ anaExists()

int anaExists ( const char * dbname )

extern

Check if Analyze files exist.

Parameters

dbname basename of Analyze 7.5 file.

Returns: 0, if they do not, 1 if .img and .hdr do exist, and 2, if also .sif exists.

Definition at line 20 of file analyze.c.

  {
  char temp[FILENAME_MAX];
 
  if(dbname==NULL || strlen(dbname)==0) return(0);
  /* Header file? */
  strlcpy(temp, dbname, FILENAME_MAX); strlcat(temp, ".hdr", FILENAME_MAX);
  if(access(temp, 0) == -1) return(0);
  /* Image data? */
  strlcpy(temp, dbname, FILENAME_MAX); strlcat(temp, ".img", FILENAME_MAX);
  if(access(temp, 0) == -1) return(0);
  /* SIF? */
  strlcat(temp, ".sif", FILENAME_MAX); if(access(temp, 0) != -1) return(2);
  strlcpy(temp, dbname, FILENAME_MAX); strlcat(temp, ".sif", FILENAME_MAX);
  if(access(temp, 0) != -1) return(2);
  return(1);
}

◆ anaExistsNew()

int anaExistsNew	(	const char *	filename,
		char *	hdrfile,
		char *	imgfile,
		char *	siffile )

extern

Check if specified filename is a Analyze file.

Returns: Returns 0 if it is not, 1 if it is, and both image and header is found, and 2, if sif file is found too.

Parameters

filename	Filename, either header file, image file, or base name without extensions. this string is never modified.
hdrfile	If filename refers to a Analyze file, then header filename will be written in this char pointer (space needs to allocated by caller); NULL if not needed.
imgfile	If filename refers to a Analyze file, then image filename will be written in this char pointer (space needs to allocated by caller); NULL if not needed.
siffile	If filename refers to a Analyze file, and if SIF exists, then SIF filename will be written in this char pointer (space needs to allocated by caller); NULL if not needed.

Definition at line 45 of file analyze.c.

  {
  char *cptr, basefile[FILENAME_MAX], temp[FILENAME_MAX];
  ANALYZE_DSR h;
  int ret;
 
  if(filename==NULL || strlen(filename)==0) return(0);
  if(ANALYZE_TEST>1) printf("\nanaExistsNew(%s, *str, *str, *str)\n", filename);
 
  /* Construct the base file name wo extensions */
  strcpy(basefile, filename);
  cptr=strrchr(basefile, '.');
  if(cptr!=NULL) {
    if(strncasecmp(cptr, ".HDR", 4)==0 || strncasecmp(cptr, ".IMG", 4)==0 )
      *cptr=(char)0;
  } 
  cptr=strrchr(basefile, '.');
  if(cptr!=NULL) {
    if(strncasecmp(cptr, ".IMG", 4)==0 )
      *cptr=(char)0;
  }
  if(ANALYZE_TEST>2) printf("\n  basefile := %s\n", basefile);
 
  /* Header file exists? */
  strcpy(temp, basefile); strcat(temp, ".hdr");
  if(access(temp, 0) == -1) {
    strcpy(temp, basefile); strcat(temp, ".img.hdr");
    if(access(temp, 0) == -1) {
      if(ANALYZE_TEST) printf("\n  hdr file not found or accessible.\n");
      return(0);
    }
  }
  /* Is this Analyze header file? */
  if((ret=anaReadHeader(temp, &h))!=0) {
    if(ANALYZE_TEST) printf("\n  %s was not identified as Analyze header file (%d).\n", temp, ret);
    return(0);
  }
  /* Preserve header filename */
  if(hdrfile!=NULL) strcpy(hdrfile, temp);
 
  /* Image file exists? */
  strcpy(temp, basefile); strcat(temp, ".img");
  if(access(temp, 0) == -1) {
    if(ANALYZE_TEST) printf("\n  %s not found or accessible.\n", temp);
    return(0);
  }
  /* Preserve image filename */
  if(imgfile!=NULL) strcpy(imgfile, temp);
 
  /* SIF exists? */
  strcpy(temp, basefile); strcat(temp, ".sif");
  if(access(temp, 0) == -1) {
    strcpy(temp, basefile); strcat(temp, ".img.sif");
    if(access(temp, 0) == -1) {
      if(ANALYZE_TEST) printf("\n  SIF not found or accessible.\n");
      if(siffile!=NULL) strcpy(siffile, "");
      return(1); // but otherwise ok
    }
  }
  /* Preserve SIF filename */
  if(siffile!=NULL) strcpy(siffile, temp);
  return(2);
}

Referenced by imgRead(), and imgReadAnalyze().

◆ anaFlipping()

int anaFlipping ( )

extern

Check whether Analyze image is flipped in z-direction when it is read from/written to file (x,y-flipping is done always).

Returns: 1 if Analyze data is flipped.

See also: anaReadHeader, anaEditHeader, anaReadImagedata

Definition at line 635 of file analyze.c.

                  {
  int ret;
  char *cptr;
 
  /* Is there an environment variable name for flipping? */
  cptr=getenv("ANALYZE_FLIP");
  if(cptr==NULL) cptr=getenv("ANALYZE_FLIPPING");
  if(cptr==NULL) cptr=getenv("analyze_flip");
  if(cptr==NULL) cptr=getenv("analyze_flipping");
  if(cptr==NULL) {
    if(ANALYZE_TEST>1) printf("ANALYZE_FLIP = not defined\n");
    ret=ANALYZE_FLIP_DEFAULT; /* if not, then use default value */
  } else {
    if(ANALYZE_TEST>1) printf("ANALYZE_FLIP = '%s'\n", cptr);
    if(*cptr=='y' || *cptr=='Y' || *cptr=='1') ret=1;
    else if(*cptr=='n' || *cptr=='N' || *cptr=='0') ret=0;
    else ret=ANALYZE_FLIP_DEFAULT;
  }
  if(ANALYZE_TEST) printf("anaFlipping()=%d\n", ret);
  return(ret);
}

Referenced by imgAnalyzeToEcat(), imgReadAnalyze(), imgReadAnalyzeFrame(), imgWriteAnalyze(), and imgWriteAnalyzeFrame().

◆ anaMakeSIFName()

int anaMakeSIFName	(	const char *	dbname,
		char *	siffile )

extern

Make SIF filename from Analyze 7.5 database name.

Returns: Returns 0 if SIF file is accessible, 1 if invalid input, 2 if sif name not found.

See also: anaDatabaseExists, anaExists

Parameters

dbname	Analyze 7.5 database name (including possible path but not extension.
siffile	Pointer to allocated space for SIF filename.

Definition at line 763 of file analyze.c.

  {
  if(dbname==NULL || siffile==NULL) return(1);
  sprintf(siffile, "%s.sif", dbname); if(access(siffile, 0) != -1) return(0);
  sprintf(siffile, "%s.SIF", dbname); if(access(siffile, 0) != -1) return(0);
  sprintf(siffile, "%s.img.sif", dbname); if(access(siffile, 0) != -1) return(0);
  sprintf(siffile, "%s.IMG.SIF", dbname); if(access(siffile, 0) != -1) return(0);
  sprintf(siffile, "%s.sif", dbname); return(2);
}

Referenced by anaDatabaseExists().

◆ anaPrintHeader()

int anaPrintHeader	(	ANALYZE_DSR *	h,
		FILE *	fp )

extern

Print the contents of Analyze header to specified file pointer.

Returns: Returns 0 if ok, 1 if invalid input

See also: anaReadHeader

Parameters

h	Pointer to Analyze header structure.
fp	Output file pointer.

Definition at line 380 of file analyze.c.

  {
  if(fp==NULL || h==NULL) return(1);
  fprintf(fp, "original_byte_order := %d (1=little, 0=big)\n", h->little);
  /* Key */
  fprintf(fp, "header_key.sizeof_hdr := %d\n", h->hk.sizeof_hdr);
  fprintf(fp, "header_key.data_type := %.10s\n", h->hk.data_type);
  fprintf(fp, "header_key.db_name := %.18s\n", h->hk.db_name);
  fprintf(fp, "header_key.extents := %d\n", h->hk.extents);
  fprintf(fp, "header_key.session_error := %d\n", h->hk.session_error);
  fprintf(fp, "header_key.regular := %d (%c)\n",
          (int)h->hk.regular, h->hk.regular);
  fprintf(fp, "header_key.hkey_un0 := %d\n", (int)h->hk.hkey_un0);
  /* Image dimension */
  fprintf(fp, "header_image_dimension.dim :=");
  for(int i=0; i<8; i++) fprintf(fp, " %d", h->dime.dim[i]);
  fprintf(fp, "\n");
  fprintf(fp, "header_image_dimension.unused8 := %d\n", h->dime.unused8);
  fprintf(fp, "header_image_dimension.unused9 := %d\n", h->dime.unused9);
  fprintf(fp, "header_image_dimension.unused10 := %d\n", h->dime.unused10);
  fprintf(fp, "header_image_dimension.unused11 := %d\n", h->dime.unused11);
  fprintf(fp, "header_image_dimension.unused12 := %d\n", h->dime.unused12);
  fprintf(fp, "header_image_dimension.unused13 := %d\n", h->dime.unused13);
  fprintf(fp, "header_image_dimension.unused14 := %d\n", h->dime.unused14);
  fprintf(fp, "header_image_dimension.datatype := %d\n", h->dime.datatype);
  fprintf(fp, "header_image_dimension.bitpix := %d\n", h->dime.bitpix);
  fprintf(fp, "header_image_dimension.dim_un0 := %d\n", h->dime.dim_un0);
  fprintf(fp, "header_image_dimension.pixdim :=");
  for(int i=0; i<8; i++) fprintf(fp, " %g", h->dime.pixdim[i]);
  fprintf(fp, "\n");
  fprintf(fp, "header_image_dimension.vox_offset := %g\n", h->dime.vox_offset);
  fprintf(fp, "header_image_dimension.funused1 := %g\n", h->dime.funused1);
  fprintf(fp, "header_image_dimension.funused2 := %g\n", h->dime.funused2);
  fprintf(fp, "header_image_dimension.funused3 := %g\n", h->dime.funused3);
  fprintf(fp, "header_image_dimension.cal_max := %g\n", h->dime.cal_max);
  fprintf(fp, "header_image_dimension.cal_min := %g\n", h->dime.cal_min);
  fprintf(fp, "header_image_dimension.compressed := %g\n", h->dime.compressed);
  fprintf(fp, "header_image_dimension.verified := %g\n", h->dime.verified);
  fprintf(fp, "header_image_dimension.glmax := %d\n", h->dime.glmax);
  fprintf(fp, "header_image_dimension.glmin := %d\n", h->dime.glmin);
  /* Data history */
  fprintf(fp, "header_data_history.descrip := %s.80\n", h->hist.descrip);
  fprintf(fp, "header_data_history.aux_file := %.24s\n", h->hist.aux_file);
  fprintf(fp, "header_data_history.orient := %d\n", (int)h->hist.orient);
  fprintf(fp, "header_data_history.originator := %.10s\n", h->hist.originator);
  fprintf(fp, "header_data_history.generated := %.10s\n", h->hist.generated);
  fprintf(fp, "header_data_history.scannum := %.10s\n", h->hist.scannum);
  fprintf(fp, "header_data_history.patient_id := %.10s\n", h->hist.patient_id);
  fprintf(fp, "header_data_history.exp_date := %.10s\n", h->hist.exp_date);
  fprintf(fp, "header_data_history.exp_time := %.10s\n", h->hist.exp_time);
  fprintf(fp, "header_data_history.hist_un0 := %.3s\n", h->hist.hist_un0);
  fprintf(fp, "header_data_history.views := %d\n", h->hist.views);
  fprintf(fp, "header_data_history.vols_added := %d\n", h->hist.vols_added);
  fprintf(fp, "header_data_history.start_field := %d\n", h->hist.start_field);
  fprintf(fp, "header_data_history.field_skip := %d\n", h->hist.field_skip);
  fprintf(fp, "header_data_history.omax := %d\n", h->hist.omax);
  fprintf(fp, "header_data_history.omin := %d\n", h->hist.omin);
  fprintf(fp, "header_data_history.smax := %d\n", h->hist.smax);
  fprintf(fp, "header_data_history.smin := %d\n", h->hist.smin);
 
  return(0);
}

Referenced by imgReadAnalyze().

◆ anaReadHeader()

int anaReadHeader	(	char *	filename,
		ANALYZE_DSR *	h )

extern

Read analyze header contents.

Returns: 0, if ok, 1 if invalid input, 2 if file cannot be opened, 3 if header could not be read, 4 if header image dimension could not be read.

See also: anaWriteHeader, anaPrintHeader, anaEditHeader, imgReadAnalyzeHeader, imgGetAnalyzeHeader

Parameters

filename	Name of file to read (including path and extension).
h	Pointer to previously allocated header structure.

Definition at line 131 of file analyze.c.

  {
  unsigned char buf1[ANALYZE_HEADER_KEY_SIZE];
  unsigned char buf2[ANALYZE_HEADER_IMGDIM_SIZE];
  unsigned char buf3[ANALYZE_HEADER_HISTORY_SIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
  FILE *fp;
  int ret, nr=0, s1, s2, same_order;
 
  if(ANALYZE_TEST) printf("anaReadHeader(%s, *dsr)\n", filename);
 
  /* Check arguments */
  if(strlen(filename)<1 || h==NULL) return(1);
  little=little_endian();
  /* Open file */
  fp=fopen(filename, "rb"); if(fp==NULL) return(2);
  /* Get file size */
  nr=0; while((ret=fgetc(fp))!=EOF) nr++; rewind(fp);
  if(nr<1) {fclose(fp); return(3);}
  /* Read Analyze header key */
  if(fread(buf1, ANALYZE_HEADER_KEY_SIZE, 1, fp)<1) return(3);
  /* Read Analyze header image dimension */
  if(fread(buf2, ANALYZE_HEADER_IMGDIM_SIZE, 1, fp)<1) return(3);
  /* Read Analyze header image data history */
  memset(buf3, 0, sizeof(ANALYZE_HEADER_HISTORY));
  ret=fread(buf3, ANALYZE_HEADER_HISTORY_SIZE, 1, fp);
  if(ANALYZE_TEST>1 && ret<1) printf(" complete data_history not found.\n");
  /* Close file */
  fclose(fp);
  /* Compare file size from header contents to the calculated value */
  /* to determine whether Analyze file is in little or big endian */
  memcpy(&s1, buf1+0, 4); s2=s1; swawbip(&s2, 4);
  if(abs(s1-nr)<abs(s2-nr)) same_order=1; else same_order=0;
  if(ANALYZE_TEST>1) printf("same byte order: %d (s1=%d s2=%d nr=%d)\n",
    same_order, s1, s2, nr);
  if(same_order) h->little=little;
  else {if(little) h->little=0; else h->little=1;}
 
  /* Set key header structure contents */
  if(!same_order) swawbip(buf1+0, 4);
  memcpy(&h->hk.sizeof_hdr, buf1+0, 4);
  memcpy(h->hk.data_type, buf1+4, 10);
  memcpy(h->hk.db_name, buf1+14, 18);
  if(!same_order) swawbip(buf1+32, 4);
  memcpy(&h->hk.extents, buf1+32, 4);
  if(!same_order) swabip(buf1+36, 2);
  memcpy(&h->hk.session_error, buf1+36, 2);
  memcpy(&h->hk.regular, buf1+38, 1);
  memcpy(&h->hk.hkey_un0, buf1+39, 1);
 
  /* Set image dimension header structure contents */
  if(!same_order) swabip(buf2+0, 16);
  memcpy(h->dime.dim, buf2+0, 16);
  if(!same_order) swabip(buf2+16, 2);
  memcpy(&h->dime.unused8, buf2+16, 2);
  if(!same_order) swabip(buf2+18, 2);
  memcpy(&h->dime.unused9, buf2+18, 2);
  if(!same_order) swabip(buf2+20, 2);
  memcpy(&h->dime.unused10, buf2+20, 2);
  if(!same_order) swabip(buf2+22, 2);
  memcpy(&h->dime.unused11, buf2+22, 2);
  if(!same_order) swabip(buf2+24, 2);
  memcpy(&h->dime.unused12, buf2+24, 2);
  if(!same_order) swabip(buf2+26, 2);
  memcpy(&h->dime.unused13, buf2+26, 2);
  if(!same_order) swabip(buf2+28, 2);
  memcpy(&h->dime.unused14, buf2+28, 2);
  if(!same_order) swabip(buf2+30, 2);
  memcpy(&h->dime.datatype, buf2+30, 2);
  if(!same_order) swabip(buf2+32, 2);
  memcpy(&h->dime.bitpix, buf2+32, 2);
  if(!same_order) swabip(buf2+34, 2);
  memcpy(&h->dime.dim_un0, buf2+34, 2);
  if(!same_order) swawbip(buf2+36, 32);
  memcpy(h->dime.pixdim, buf2+36, 32);
  if(!same_order) swawbip(buf2+68, 4);
  memcpy(&h->dime.vox_offset, buf2+68, 4);
  if(!same_order) swawbip(buf2+72, 4);
  memcpy(&h->dime.funused1, buf2+72, 4);
  if(!same_order) swawbip(buf2+76, 4);
  memcpy(&h->dime.funused2, buf2+76, 4);
  if(!same_order) swawbip(buf2+80, 4);
  memcpy(&h->dime.funused3, buf2+80, 4);
  if(!same_order) swawbip(buf2+84, 4);
  memcpy(&h->dime.cal_max, buf2+84, 4);
  if(!same_order) swawbip(buf2+88, 4);
  memcpy(&h->dime.cal_min, buf2+88, 4);
  if(!same_order) swawbip(buf2+92, 4);
  memcpy(&h->dime.compressed, buf2+92, 4);
  if(!same_order) swawbip(buf2+96, 4);
  memcpy(&h->dime.verified, buf2+96, 4);
  if(!same_order) swawbip(buf2+100, 4);
  memcpy(&h->dime.glmax, buf2+100, 4);
  if(!same_order) swawbip(buf2+104, 4);
  memcpy(&h->dime.glmin, buf2+104, 4);
 
  /* Set data history header structure contents */
  memcpy(h->hist.descrip, buf3+0, 80);
  memcpy(h->hist.aux_file, buf3+80, 24);
  memcpy(&h->hist.orient, buf3+104, 1);
  memcpy(h->hist.originator, buf3+105, 10);
  memcpy(h->hist.generated, buf3+115, 10);
  memcpy(h->hist.scannum, buf3+125, 10);
  memcpy(h->hist.patient_id, buf3+135, 10);
  memcpy(h->hist.exp_date, buf3+145, 10);
  memcpy(h->hist.exp_time, buf3+155, 10);
  memcpy(h->hist.hist_un0, buf3+165, 3);
  if(!same_order) swawbip(buf3+168, 4);
  memcpy(&h->hist.views, buf3+168, 4);
  if(!same_order) swawbip(buf3+172, 4);
  memcpy(&h->hist.vols_added, buf3+172, 4);
  if(!same_order) swawbip(buf3+176, 4);
  memcpy(&h->hist.start_field, buf3+176,4);
  if(!same_order) swawbip(buf3+180, 4);
  memcpy(&h->hist.field_skip, buf3+180, 4);
  if(!same_order) swawbip(buf3+184, 4);
  memcpy(&h->hist.omax, buf3+184, 4);
  if(!same_order) swawbip(buf3+188, 4);
  memcpy(&h->hist.omin, buf3+188, 4);
  if(!same_order) swawbip(buf3+192, 4);
  memcpy(&h->hist.smax, buf3+192, 4);
  if(!same_order) swawbip(buf3+196, 4);
  memcpy(&h->hist.smin, buf3+196, 4);
 
  /* Check header contents */
  if(h->hk.extents!=16384 && h->hk.extents!=0) {
    if(ANALYZE_TEST>1) printf("hk.extents := %d\n", h->hk.extents);
    return(11);
  }
  if(h->hk.regular!='r') {
    if(ANALYZE_TEST>1) printf("hk.regular := %c\n", h->hk.regular);
    return(12);
  }
 
  return(0);
}

Referenced by anaExistsNew(), imgReadAnalyze(), imgReadAnalyzeFrame(), imgReadAnalyzeHeader(), and imgWriteAnalyzeFrame().

◆ anaReadImagedata()

int anaReadImagedata	(	FILE *	fp,
		ANALYZE_DSR *	h,
		int	frame,
		float *	data )

extern

Read Analyze 7.5 image data, convert byte order if necessary, and scale values to floats. Reads only one frame at a time!

Returns: Returns 0 if ok, <>0 in case of an error.

See also: anaReadHeader

Parameters

fp	File, opened previously in binary mode.
h	Analyze header, read previously.
frame	Frame number to read [1..number of frames].
data	Pointer to image float data allocated previously.

Definition at line 454 of file analyze.c.

  {
  int little;
  long int dimNr, dimx, dimy, dimz=1, dimt=1;
  char *mdata, *mptr;
  float f, *fptr;
  short int *sptr;
  int *iptr;
  double d;
 
 
  if(ANALYZE_TEST) printf("anaReadImagedata(fp, h, %d, data)\n", frame);
 
  /* Check the arguments */
  if(frame<=0 || fp==NULL || h==NULL || data==NULL) return(1);
 
  /* Get the image dimensions from header */
  dimNr=h->dime.dim[0]; if(dimNr<2) return(2);
  dimx=h->dime.dim[1];
  dimy=h->dime.dim[2];
  if(dimNr>2) dimz=h->dime.dim[3];
  if(dimNr>3) dimt=h->dime.dim[4];
  if(frame>dimt) return(3);
  long long pxlNr=dimx*dimy*dimz; if(pxlNr<1) return(4);
 
  /* Allocate memory for the binary data */
  if(h->dime.bitpix==0 && h->dime.datatype>0) { /* Fix bitpix if necessary */
    if(h->dime.datatype==ANALYZE_DT_BINARY) h->dime.bitpix=1;
    else if(h->dime.datatype==ANALYZE_DT_UNSIGNED_CHAR) h->dime.bitpix=8;
    else if(h->dime.datatype==ANALYZE_DT_SIGNED_SHORT) h->dime.bitpix=16;
    else if(h->dime.datatype==ANALYZE_DT_SIGNED_INT) h->dime.bitpix=32;
    else if(h->dime.datatype==ANALYZE_DT_FLOAT) h->dime.bitpix=32;
    else if(h->dime.datatype==ANALYZE_DT_DOUBLE) h->dime.bitpix=64;
    else if(h->dime.datatype==ANALYZE_DT_RGB) h->dime.bitpix=24;
  }
  if(h->dime.bitpix<8) return(5); /* We don't support bit data */
  long long rawSize=pxlNr*(h->dime.bitpix/8); if(rawSize<1) return(5);
  if(ANALYZE_TEST>0) printf("  pxlNr=%lld  rawSize=%lld\n", pxlNr, rawSize);
  mdata=(char*)malloc(rawSize); if(mdata==NULL) return(11);
 
  /* Seek the start of current frame data */
  long long start_pos=(frame-1)*rawSize;
  {
    long int n=(long int)h->dime.vox_offset; 
    if((n>0 && frame==1) || (n<0)) start_pos+=labs(n);
  }
  if(ANALYZE_TEST>2) printf("start_pos=%lld\n", start_pos);
  fseeko(fp, start_pos, SEEK_SET);
  if(ftello(fp)!=start_pos) {
    if(ANALYZE_TEST>5) printf("could not move to start_pos\n");
    free(mdata); return(7);
  }
 
  /* Read the data */
  mptr=mdata;
  {
    size_t n=fread(mptr, rawSize, 1, fp);
    if(n<1) {
      if(ANALYZE_TEST>5) printf("could read only %zu bytes when request was %lld\n", n, rawSize);
      free(mdata); return(8);
    }
  }
 
  /* Convert byte order if necessary */
  little=little_endian(); mptr=mdata;
  if(little!=h->little) {
    if(ANALYZE_TEST>0) printf("byte conversion\n");
    switch(h->dime.bitpix) {
      case 8: /* no conversion needed */ break;
      case 16: swabip(mptr, rawSize); break;
      case 32: swawbip(mptr, rawSize); break;
      case 64: swawbip(mptr, rawSize); break;
      default: 
        if(ANALYZE_TEST>5) printf("unsupported anahdr.dime.bitpix := %d\n", h->dime.bitpix);
        free(mdata); return(5);
    }
  }
 
  /* Get scale factor */
  f=1.0;
  if(h->dime.funused1>0.0) f*=h->dime.funused1;
 
  /* Copy data to float pixel values */
  mptr=mdata; fptr=data;
  switch(h->dime.datatype) {
    case ANALYZE_DT_UNSIGNED_CHAR:
      if(h->dime.bitpix!=8) {
        if(ANALYZE_TEST>5) printf("invalid combination of datatype and bitpix (%d, %d)\n",
                                  h->dime.datatype, h->dime.bitpix);
        free(mdata); return(5);
      }
      for(long long i=0; i<pxlNr; i++, mptr++, fptr++)
        *fptr=f*(float)(unsigned char)(*mptr);
      break;
    case ANALYZE_DT_SIGNED_SHORT:
      if(h->dime.bitpix!=16) {
        if(ANALYZE_TEST>5) printf("invalid combination of datatype and bitpix (%d, %d)\n",
                                  h->dime.datatype, h->dime.bitpix);
        free(mdata); return(5);
      }
      for(long long i=0; i<pxlNr; i++, mptr+=2, fptr++) {
        sptr=(short int*)mptr; *fptr=f*(float)(*sptr);
      }
      break;
    case ANALYZE_DT_SIGNED_INT:
      if(h->dime.bitpix!=16 && h->dime.bitpix!=32) {
        if(ANALYZE_TEST>5) printf("invalid combination of datatype and bitpix (%d, %d)\n",
                                  h->dime.datatype, h->dime.bitpix);
        free(mdata); return(5);
      }
      if(h->dime.bitpix==16) {
        for(long long i=0; i<pxlNr; i++, mptr+=2, fptr++) {
          iptr=(int*)mptr; *fptr=f*(float)(*iptr);
        }
      } else if(h->dime.bitpix==32) {
        for(long long i=0; i<pxlNr; i++, mptr+=4, fptr++) {
          iptr=(int*)mptr; *fptr=f*(float)(*iptr);
        }
      }
      break;
    case ANALYZE_DT_FLOAT:
      if(h->dime.bitpix!=16 && h->dime.bitpix!=32) {
        if(ANALYZE_TEST>5) printf("invalid combination of datatype and bitpix (%d, %d)\n",
                                  h->dime.datatype, h->dime.bitpix);
        free(mdata); return(5);
      }
      if(h->dime.bitpix==16) {
        memcpy(fptr, mptr, pxlNr*2);
        for(long long i=0; i<pxlNr; i++, fptr++) *fptr*=f;
      } else if(h->dime.bitpix==32) {
        memcpy(fptr, mptr, pxlNr*4);
        for(long long i=0; i<pxlNr; i++, fptr++) *fptr*=f;
      }
      break;
    case ANALYZE_DT_COMPLEX:
      if(h->dime.bitpix!=32) {
        if(ANALYZE_TEST>5) printf("invalid combination of datatype and bitpix (%d, %d)\n",
                                  h->dime.datatype, h->dime.bitpix);
        free(mdata); return(5);
      }
      if(h->dime.bitpix==32) {
        memcpy(fptr, mptr, pxlNr*4);
        for(long long i=0; i<pxlNr; i++, fptr++) *fptr*=f;
      }
      break;
    case ANALYZE_DT_DOUBLE:
      /* Add support for 64-bit double, if needed */
      if(h->dime.bitpix!=32) {
        if(ANALYZE_TEST>5) printf("invalid combination of datatype and bitpix (%d, %d)\n",
                                  h->dime.datatype, h->dime.bitpix);
        free(mdata); return(5);
      }
      for(long long i=0; i<pxlNr; i++, mptr+=8, fptr++) {
        memcpy(&d, mptr, 8); *fptr=f*d;
      }
      break;
    default:
      if(ANALYZE_TEST>5) printf("unsupported anahdr.dime.datatype := %d\n", h->dime.datatype);
      free(mdata); return(5);
  }
 
  free(mdata);
  if(ANALYZE_TEST>1) printf("anaReadImagedata() succeeded\n");
  return(0);
}

Referenced by imgReadAnalyze(), and imgReadAnalyzeFrame().

◆ anaRemove()

int anaRemove ( const char * dbname )

extern

Remove header and data files belonging to specified Analyze 7.5 database. SIF is not deleted in any case.

Returns: Returns 0 when call was successful, 1 if header file deletion failed, 2 if data file deletion failed. Call is considered successful, if database does not exist initially.

See also: anaExists

Parameters

dbname Analyze database name.

Definition at line 666 of file analyze.c.

  {
  char datfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
 
  if(ANALYZE_TEST) printf("anaRemove(%s)\n", dbname);
  if(anaDatabaseExists(dbname, hdrfile, datfile, siffile)==0) return 0;
  if(ANALYZE_TEST>2) printf("  removing %s and %s\n", hdrfile, datfile);
  if(remove(hdrfile)!=0) return 1;
  if(remove(datfile)!=0) return 2;
  return 0;
}

◆ anaRemoveFNameExtension()

void anaRemoveFNameExtension ( char * fname )

extern

Check if Analyze 7.5 filename was given accidentally with extension. Remove the extension if necessary.

See also: anaExists, anaRemove

Parameters

fname Full name of file.

Definition at line 687 of file analyze.c.

  {
  char *cptr;
  cptr=strrchr(fname, '.'); if(cptr==NULL) return;
  if(strcasecmp(cptr, ".")==0 || strcasecmp(cptr, ".img")==0 ||
     strcasecmp(cptr, ".hdr")==0 || strcasecmp(cptr, ".sif")==0)
       *cptr=(char)0;
}

Referenced by anaDatabaseExists(), and imgRead().

◆ anaWriteHeader()

int anaWriteHeader	(	char *	filename,
		ANALYZE_DSR *	h )

extern

Write Analyze header contents. Header field 'little' is used to determine the required byte order.

Returns: Returns 0, if ok, 1 if invalid input, 2 if file could not be opened for writing, 3 if data header write failed, 4 if image dimension write failed, and 5 if header history write failed.

See also: anaReadHeader

Parameters

filename	Name of file to read (including path and extension)
h	Pointer to Analyze header structure

Definition at line 282 of file analyze.c.

  {
  unsigned char buf1[ANALYZE_HEADER_KEY_SIZE];
  unsigned char buf2[ANALYZE_HEADER_IMGDIM_SIZE];
  unsigned char buf3[ANALYZE_HEADER_HISTORY_SIZE];
  FILE *fp;
  int same_order, little;
 
 
  if(ANALYZE_TEST) printf("anaWriteHeader(%s, *dsr)\n", filename);
 
  /* Check arguments */
  if(strlen(filename)<1 || h==NULL) return(1);
  little=little_endian();
  if(little==h->little) same_order=1; else same_order=0;
  
  /* Copy header contents into buffers */
  /* Header key */
  memset(buf1, 0, ANALYZE_HEADER_KEY_SIZE);
  memcpy(buf1+0, &h->hk.sizeof_hdr, 4); if(!same_order) swawbip(buf1+0, 4);
  memcpy(buf1+4, &h->hk.data_type, 10);
  memcpy(buf1+14, &h->hk.db_name, 18);
  memcpy(buf1+32, &h->hk.extents, 4); if(!same_order) swawbip(buf1+32, 4);
  memcpy(buf1+36, &h->hk.session_error, 2); if(!same_order) swabip(buf1+36, 2);
  memcpy(buf1+38, &h->hk.regular, 1);
  memcpy(buf1+39, &h->hk.hkey_un0, 1);
  /* Image dimension */
  memset(buf2, 0, ANALYZE_HEADER_IMGDIM_SIZE);
  memcpy(buf2+0, h->dime.dim, 16); if(!same_order) swabip(buf2+0, 16);
  memcpy(buf2+16, &h->dime.unused8, 2); if(!same_order) swabip(buf2+16, 2);
  memcpy(buf2+18, &h->dime.unused9, 2); if(!same_order) swabip(buf2+18, 2);
  memcpy(buf2+20, &h->dime.unused10, 2); if(!same_order) swabip(buf2+20, 2);
  memcpy(buf2+22, &h->dime.unused11, 2); if(!same_order) swabip(buf2+22, 2);
  memcpy(buf2+24, &h->dime.unused12, 2); if(!same_order) swabip(buf2+24, 2);
  memcpy(buf2+26, &h->dime.unused13, 2); if(!same_order) swabip(buf2+26, 2);
  memcpy(buf2+28, &h->dime.unused14, 2); if(!same_order) swabip(buf2+28, 2);
  memcpy(buf2+30, &h->dime.datatype, 2); if(!same_order) swabip(buf2+30, 2);
  memcpy(buf2+32, &h->dime.bitpix, 2); if(!same_order) swabip(buf2+32, 2);
  memcpy(buf2+34, &h->dime.dim_un0, 2); if(!same_order) swabip(buf2+34, 2);
  memcpy(buf2+36, h->dime.pixdim, 32); if(!same_order) swawbip(buf2+36, 32);
  memcpy(buf2+68, &h->dime.vox_offset, 4); if(!same_order) swawbip(buf2+68, 4);
  memcpy(buf2+72, &h->dime.funused1, 4); if(!same_order) swawbip(buf2+72, 4);
  memcpy(buf2+76, &h->dime.funused2, 4); if(!same_order) swawbip(buf2+76, 4);
  memcpy(buf2+80, &h->dime.funused3, 4); if(!same_order) swawbip(buf2+80, 4);
  memcpy(buf2+84, &h->dime.cal_max, 4); if(!same_order) swawbip(buf2+84, 4);
  memcpy(buf2+88, &h->dime.cal_min, 4); if(!same_order) swawbip(buf2+88, 4);
  memcpy(buf2+92, &h->dime.compressed, 4); if(!same_order) swawbip(buf2+92, 4);
  memcpy(buf2+96, &h->dime.verified, 4); if(!same_order) swawbip(buf2+96, 4);
  memcpy(buf2+100, &h->dime.glmax, 4); if(!same_order) swawbip(buf2+100, 4);
  memcpy(buf2+104, &h->dime.glmin, 4); if(!same_order) swawbip(buf2+104, 4);
  /* Data history */
  memset(buf3, 0, ANALYZE_HEADER_HISTORY_SIZE);
  memcpy(buf3+0, &h->hist.descrip, 80);
  memcpy(buf3+80, &h->hist.aux_file, 24);
  memcpy(buf3+104, &h->hist.orient, 1);
  memcpy(buf3+105, &h->hist.originator, 10);
  memcpy(buf3+115, &h->hist.generated, 10);
  memcpy(buf3+125, &h->hist.scannum, 10);
  memcpy(buf3+135, &h->hist.patient_id, 10);
  memcpy(buf3+145, &h->hist.exp_date, 10);
  memcpy(buf3+155, &h->hist.exp_time, 10);
  memcpy(buf3+165, &h->hist.hist_un0, 3);
  memcpy(buf3+168, &h->hist.views, 4); if(!same_order) swawbip(buf3+168, 4);
  memcpy(buf3+172, &h->hist.vols_added,4); if(!same_order) swawbip(buf3+172, 4);
  memcpy(buf3+176, &h->hist.start_field,4); if(!same_order) swawbip(buf3+176,4);
  memcpy(buf3+180, &h->hist.field_skip,4); if(!same_order) swawbip(buf3+180, 4);
  memcpy(buf3+184, &h->hist.omax, 4); if(!same_order) swawbip(buf3+184, 4);
  memcpy(buf3+188, &h->hist.omin, 4); if(!same_order) swawbip(buf3+188, 4);
  memcpy(buf3+192, &h->hist.smax, 4); if(!same_order) swawbip(buf3+192, 4);
  memcpy(buf3+196, &h->hist.smin, 4); if(!same_order) swawbip(buf3+196, 4);
 
  /* Open header file for write */
  fp=fopen(filename, "wb"); if(fp==NULL) return(2);
  /* Write header key */
  if(fwrite(buf1, 1, ANALYZE_HEADER_KEY_SIZE, fp) != ANALYZE_HEADER_KEY_SIZE) {
    fclose(fp); return(3);}
  /* Write image dimension */
  if(fwrite(buf2, 1, ANALYZE_HEADER_IMGDIM_SIZE, fp) != ANALYZE_HEADER_IMGDIM_SIZE) {
    fclose(fp); return(4);}
  /* Write data history */
  if(fwrite(buf3, 1, ANALYZE_HEADER_HISTORY_SIZE, fp) != ANALYZE_HEADER_HISTORY_SIZE) {
    fclose(fp); return(5);}
  fclose(fp);
 
  return(0);
}

Referenced by imgWriteAnalyze(), and imgWriteAnalyzeFrame().

◆ dcmAddItem()

int dcmAddItem	(	DCMFILE *	dcm,
		DCMITEM *	d,
		short int	aschild,
		DCMTAG	tag,
		dcmvr	vr,
		unsigned int	vl,
		char *	rd,
		const int	verbose )

extern

Add an item to DCMFILE data struct.

See also: dcmfileInit, dcmfileFree

Returns: 0 if successful, otherwise >0.

Parameters

dcm	Pointer to DCMFILE.
d	Pointer to a previous item in DCMFILE, into which to link this item; enter NULL to add as next item to the highest level.
aschild	Add as child; 1=yes, 0=no.
tag	Tag
vr	VR
vl	VL; enter 0xFFFFFFFF to use VR's default length.
rd	Pointer to the item value as byte array
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 1239 of file dcm.c.

  {
  if(verbose>0) {
    printf("%s(dcm, (%04X,%04X))", __func__, tag.group, tag.element);
    if(d==NULL) printf(", null"); else printf(", ptr");
    printf(", %d, %s, 0x%08X, rd", aschild, dcmVRName(vr), vl);
    printf(")\n");
  }
  if(dcm==NULL) return(1);
  if(vr==DCM_VR_INVALID) return(2);
 
  /* Check that caller has not given previous item pointer when there are none in DCMFILE */
  if(d!=NULL && dcm->item==NULL) return(3);
  /* Check that caller has not given previous item pointer that already has child */
  if(d!=NULL && aschild && d->child_item!=NULL) return(4);
 
  /* Check whether we currently support the Transfer UID */
  if(dcm->truid!=DCM_TRUID_LEE) return(5);
 
  /* Allocate memory for the new element; do not free it here, since it will be part of
     DCMFILE struct. */
  if(verbose>1) printf("  allocating memory for the item\n");
  DCMITEM *item=(DCMITEM*)malloc(sizeof(DCMITEM));
  if(item==NULL) return(11);
  item->next_item=item->child_item=(DCMITEM*)NULL;
  item->fp=dcm->fp; item->truid=dcm->truid;
  item->rd=(char*)NULL;
 
  /* Set item tag, VR, and VL */
  if(verbose>1) printf("  setting item contents\n");
  item->tag.group=tag.group;
  item->tag.element=tag.element;
  item->vr=vr;
  item->vl=vl;
  /* Allocate memory for item value */
  size_t s;
  if(vl==0xFFFFFFFF) s=dcmVRVLength(vr); else s=vl;
  if(s>0) {
    if(item->vl==0xFFFFFFFF) item->vl=(unsigned int)s;
    if(verbose>1) printf("  allocating %u bytes for the item value\n", (unsigned int)s);
    item->rd=(char*)calloc(s, sizeof(char));
    if(item->rd==NULL) {free(item); return(21);}
  } else {
    if(verbose>1) printf("zero size for item value\n");
    if(rd==NULL) {
      if(verbose>1) printf("... which is ok since value is empty, too.\n");
    } else {
      if(verbose>0) printf("... which is not ok because we have value to store.\n");
      if(item->rd==NULL) {free(item); return(22);}
    }
  }
  /* Copy the item value */
  if(rd!=NULL && s>0) {
    if(verbose>1) printf("  copying the item value\n");
    /* Special treatment for strings, because those tend to be shorter than told */
    if(vr==DCM_VR_LO || vr==DCM_VR_LT || vr==DCM_VR_PN || vr==DCM_VR_SH || vr==DCM_VR_UI || vr==DCM_VR_UR) 
    {
      unsigned int len=strnlen(rd, s);
      if(len<s) strlcpy(item->rd, rd, s);
      else memcpy(item->rd, rd, s);
    } else if(vr==DCM_VR_DS || vr==DCM_VR_IS) 
    {
      unsigned int len=strnlen(rd, s);
      if(len<s) strlcpy(item->rd, rd, s);
      else memcpy(item->rd, rd, s);
    } else {
      memcpy(item->rd, rd, s);
    }
  }
 
 
  /* If we have the item to link to, then do the linking */
  if(verbose>1) printf("  link the item.\n");
  if(d!=NULL) {
    if(aschild) {
      d->child_item=item;
      item->parent_item=d;
      item->prev_item=(DCMITEM*)NULL;
    } else if(d->next_item==NULL) {
      d->next_item=item;
      item->prev_item=d;
      item->parent_item=d->parent_item;
    } else {
      /* find the last item in the list */
      DCMITEM *ip=d; while(ip->next_item!=NULL) ip=ip->next_item;
      ip->next_item=item;
      item->prev_item=ip;
      item->parent_item=ip->parent_item;
    }
  } else if(dcm->item==NULL) {
    /* This is truly the first item ever */
    dcm->item=item;
    item->prev_item=item->parent_item=(DCMITEM*)NULL;
  } else {
    /* Caller lets us find the item to link to */
    DCMITEM *ip=dcm->item; while(ip->next_item!=NULL) ip=ip->next_item;
    ip->next_item=item;
    item->prev_item=ip;
    item->parent_item=ip->parent_item;
  }
 
  if(verbose>2) dcmitemPrint(item);
 
  if(verbose>1) printf("  all done.\n");
  return(0);
}

◆ dcmDA2intl()

char * dcmDA2intl	(	const char *	orig,
		char *	intl )

extern

Convert DICOM date 'DA' to international format YYYY-MM-DD.

Returns: Returns pointer to the date string, or NULL in case of an error.

Parameters

orig	Pointer to original DICOM string.
intl	Pointer to string where date in international format will be written; must be allocated for at least 11 characters.

Definition at line 299 of file dcm.c.

  {
  if(orig==NULL || intl==NULL) return(NULL);
  if(strnlen(orig, 10)<8) return(NULL);
  if(isdigit(orig[4])) { // modern format YYYYMMDD
    sprintf(intl, "%4.4s-%2.2s-%2.2s", orig, orig+4, orig+6);
  } else { // old format YYYY.MM.DD
    sprintf(intl, "%4.4s-%2.2s-%2.2s", orig, orig+5, orig+8);
  }
  if(isdate(intl)) {intl[0]=(char)0; return(NULL);}
  return(intl);
}

◆ dcmDT2intl()

char * dcmDT2intl	(	const char *	orig,
		char *	intl )

extern

Convert DICOM datetime 'DT' to international format YYYY-MM-DD hh:mm:ss.

Returns: Returns pointer to the time string, or NULL in case of an error.

Parameters

orig	Pointer to original DICOM string. Should be in format YYYYMMDDhhmmss.FFFFFF+hhmm
intl	Pointer to string where date and time in international format will be written; must be allocated for at least 20 characters.

Definition at line 345 of file dcm.c.

  {
  if(orig==NULL || intl==NULL) return(NULL);
  if(strnlen(orig, 26)<14) return(NULL);
  sprintf(intl, "%4.4s-%2.2s-%2.2s %2.2s:%2.2s:%2.2s",
          orig, orig+4, orig+6, orig+8, orig+10, orig+12);
  if(isdatetime(intl, NULL)) {intl[0]=(char)0; return(NULL);}
  return(intl);
}

◆ dcmfileFree()

void dcmfileFree ( DCMFILE * d )

extern

Free memory allocated for DCMFILE data. All contents are destroyed.

Precondition: Before first use initialize the struct with dcmfileInit().

See also: dcmfileInit

Author: Vesa Oikonen

Parameters

d	Pointer to DCMFILE.

Definition at line 868 of file dcm.c.

  {
  if(d==NULL) return;
  dcmitemFree(d->item);
  dcmfileInit(d);
}

Referenced by dcmFileRead().

◆ dcmfileInit()

void dcmfileInit ( DCMFILE * d )

extern

Initiate the DCMFILE struct before any use.

See also: dcmfileFree

Parameters

d	Pointer to DCMFILE.

Definition at line 823 of file dcm.c.

  {
  if(d==NULL) return;
  d->filename[0]=(char)0;
  d->fp=(FILE*)NULL;
  d->truid=DCM_TRUID_UNKNOWN;
  d->item=(DCMITEM*)NULL;
}

Referenced by dcmfileFree().

◆ dcmfileMaxDepth()

unsigned short int dcmfileMaxDepth ( DCMFILE * df )

extern

Get the maximum depth of DCMFILE items tree.

Returns: Returns the number of item levels under specified DCMFILE, or zero in case of an error or if there are no items.

See also: dcmitemParentNr, dcmitemMaxDepth

Parameters

df	Pointer to DCMFILE item.

Definition at line 903 of file dcm.c.

  {
  if(df==NULL || df->item==NULL) return(0);
  unsigned short int m=0, n=0;
  DCMITEM *sd=df->item;
  while(sd!=NULL) { // go through all sisters
    n=dcmitemMaxDepth(sd); if(n>m) m=n;
    sd=sd->next_item;
  }
  return(m+1);
}

◆ dcmFileRead()

int dcmFileRead	(	const char *	filename,
		DCMFILE *	dcm,
		const short int	headerOnly,
		int	verbose )

extern

Read a single DICOM file.

See also: dcmVerifyMagic, dcmfileInit, dcmfileFree, dcmReadTransferSyntaxUID, dcmFileWrite

Returns: 0 when successful.

Parameters

filename	Pointer to filename.
dcm	Pointer to initiated data structure.
headerOnly	Read only header (1), or read both header and pixel data (0).
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 1687 of file dcm.c.

  {
  if(filename==NULL || strnlen(filename, 10)<1 || dcm==NULL) return(1);
  if(verbose>1) printf("%s('%s', %d)\n", __func__, filename, headerOnly);
 
  /* Delete any previous data */
  dcmfileFree(dcm);
 
  /* Open the file */
  strlcpy(dcm->filename, filename, FILENAME_MAX);
  dcm->fp=fopen(dcm->filename, "rb");
  if(dcm->fp==NULL) {
    return(2);
  }
 
  /* Check the magic number and move file pointer to the end of it */
  if(verbose>2) printf("checking DICOM magic number\n");
  if(dcmVerifyMagic(NULL, dcm->fp)!=1) {
    fclose(dcm->fp);
    return(2);
  }
 
  /* Get the Transfer Syntax UID */
  if(verbose>2) printf("checking Transfer Syntax UID\n");
  dcm->truid=dcmReadTransferSyntaxUID(dcm->fp);
  if(dcm->truid==DCM_TRUID_INVALID) { // not found
    fclose(dcm->fp);
    return(2);
  }
  if(verbose>0) { // print the UID
    printf("Transfer Syntax UID := %s\n", dcmTrUIDDescr(dcm->truid));
    fflush(stdout);
  }
 
  /* Check whether we currently support the Transfer UID */
  if(dcm->truid!=DCM_TRUID_LEE) {
    fclose(dcm->fp);
    return(2);
  }
 
  /* Read DICOM file elements */
  int ret=0;
  do {
    // note that the next function may need to call itself,
    // therefore counting loops here would not be useful.
    ret=dcmFileReadNextElement(dcm, NULL, NULL, 0, headerOnly, verbose-10);
  } while(ret==0 && !feof(dcm->fp));
  fclose(dcm->fp);
  /* TPCERROR_NO_KEY means that no (more) tag was found;
     other codes still mean that something bad happened. */
  if(ret==-1) {
    if(verbose>1) printf(" eof\n");
    ret=0;
  }
  return(ret);
}

◆ dcmFileReadNextElement()

int dcmFileReadNextElement	(	DCMFILE *	dcm,
		DCMITEM *	prev_item,
		DCMITEM *	parent_item,
		const short int	sub,
		const short int	headerOnly,
		int	verbose )

extern

Read an element from DICOM file, and add it to the given linked list. This function will be called recursively in case of sequential items.

Returns: 0 when successful, >0 in case of an error, -1 when no more elements could be read.

See also: dcmFileRead

Parameters

dcm	Pointer to DCMFILE struct; must be initiated before first call.
prev_item	Pointer to previous element; NULL if none exists (yet).
parent_item	Pointer to parent element; NULL if none exists (yet).
sub	Add as next element (0) or as child element.
headerOnly	Read only header (1), or read both header and pixel data (0).
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 1370 of file dcm.c.

  {
  if(verbose>0) printf("%s(DCMFILE*, DCMITEM*, DCMITEM*, %d, %d)\n", __func__, sub, headerOnly);
  if(dcm==NULL || dcm->fp==NULL) return(1);
  if(sub!=0 && parent_item==NULL) return(1);
  if(feof(dcm->fp)) return(-1);
 
  /* Check whether we currently support the Transfer UID */
  if(dcm->truid!=DCM_TRUID_LEE) return(2);
 
  if(verbose>10) {
    if(dcm->item==NULL) printf(" will add first element\n");
    else if(sub==0) printf(" will add next element\n");
    else printf(" will add subelement\n");
  }
 
  /* Is this a child to a sequence element? */
  int sq_child=0;
  if(parent_item!=NULL && parent_item->vr==DCM_VR_SQ) {sq_child=1;}
  if(verbose>10 && sq_child!=0) printf(" we're a child to a sequence element\n");
 
  /* Allocate memory for the new element */
  DCMITEM *item=(DCMITEM*)malloc(sizeof(DCMITEM));
  if(item==NULL) return(4);
  item->prev_item=prev_item;
  item->parent_item=parent_item;
  item->next_item=item->child_item=(DCMITEM*)NULL;
  item->fp=dcm->fp; item->truid=dcm->truid;
  item->rd=(char*)NULL;
 
  /* Save current file position (should be the start of element) */
  if(fgetpos(dcm->fp, &item->pos)) {
    free(item); return(2);
  }
 
  /* Read the tag (2x2 bytes) */
  if(verbose>10) {
    long int tagpos=ftell(dcm->fp);
    printf(" reading tag at %ld\n", tagpos);
  }
  if(dcmReadFileTag(dcm->fp, &item->tag)) {
    if(verbose>1 && !feof(dcm->fp)) printf(" error in reading the tag.\n");
    free(item);
    if(feof(dcm->fp)) return(-1);
    return(2);
  }
 
  if(verbose>2) {
    printf(" tag(%04x,%04x) with %u parents\n", 
           item->tag.group, item->tag.element, dcmitemParentNr(item));
  }
 
  /* If child, then check for item delimitation tag (although it should not be here) */
  if(dcmitemParentNr(item)>0 && item->tag.group==0xFFFE && item->tag.element==0xE00D) {
    if(verbose>10)
      printf(" item delimitation tag(%04x,%04x) found, reading VL\n", 
             item->tag.group, item->tag.element);
    unsigned long int vl=dcmReadFileVL(dcm->fp, 4); 
    if(verbose>1) printf(" item delimitation tag VL := %lu (0x%08lx)\n", vl, vl);
    if(vl!=0) {
      if(verbose>1) printf(" error: VL should have been 0\n");
      return(3);
    }
    return(0);
  }
 
 
  /* Read value representation and length (VR and VL, 2x2 or 2x4 bytes) */
  {
    if(verbose>10) printf(" reading VR and VL\n");
    int ret;
    unsigned int n;
    ret=dcmReadFileVRVL(dcm->fp, &item->vr, &item->vl, &n);
    if(ret!=0) {
      if(verbose>1) printf(" invalid VR or VL\n");
      free(item); return(ret);
    }
    if(verbose>1) {
      printf(" VR := %s (%s)\n", dcmVRName(item->vr), dcmVRDescr(item->vr));
      printf(" VL := %u (0x%08x) (%d bytes field)\n", item->vl, item->vl, n/2);
      fflush(stdout);
    }
  }
 
  /* Read value field, and add the current element to the list */
  if(item->vr==DCM_VR_SQ) {
    if(ftell(dcm->fp)<0) return(2);
    unsigned long int sqPos=(unsigned long int)ftell(dcm->fp);
    if(verbose>10) {printf(" sequence... at %ld\n", sqPos); fflush(stdout);}
    unsigned long int sqContentLength=item->vl;
    if(verbose>12) printf("    sequence contents length is %lu\n", sqContentLength);
    /* File position is now at the start of first item in the sequence */
    int ret;
    /* If parent has no previous child, then define this as its child */
    if(sq_child!=0 && parent_item->child_item==NULL) {
      parent_item->child_item=item;
    } else {
      /* else, add SQ sequence itself as next element to the list, and later
         add each sequence item as child to it */
      if(prev_item==NULL) {
        if(dcm->item==NULL) { // truly the first item
          dcm->item=item;
        } else { // search for the previous one
          DCMITEM *ip; ip=dcm->item;
          while(ip->next_item!=NULL) ip=ip->next_item;
          ip->next_item=item; item->prev_item=ip;
        }
      } else {
        prev_item->next_item=item; item->prev_item=prev_item;
      }
    }
    /* Read the first item tag and length, but there is no VR to read this time */
    if(verbose>10) {
      long int tagpos=ftell(dcm->fp);
      printf(" reading first item tag at %ld\n", tagpos);
    }
    DCMTAG itemtag;
    ret=dcmReadFileTag(dcm->fp, &itemtag);
    if(ret!=0) {
      if(verbose>1) printf(" error %d in reading the tag.\n", ret);
      return(2);
    }
    if(verbose>1) printf("  item tag(%04x,%04x)\n", itemtag.group, itemtag.element);
    /* It is common that sequence is empty; check it first */
    if(itemtag.group==0xFFFE && (itemtag.element==0xE0DD || itemtag.element==0xE00D)) {
      /* yes; then read also the 4 byte LV, which should be zero */
      if(verbose>10) 
        printf(" sequence delimitation item tag(%04x,%04x) found, reading VL\n",
          itemtag.group, itemtag.element);
      unsigned long int vl=dcmReadFileVL(dcm->fp, 4); 
      if(verbose>1) printf(" item tag VL := %lu (0x%08lx)\n", vl, vl);
      if(vl!=0) {
        if(verbose>1) printf(" error: VL should have been 0\n");
        return(2);
      }
      if(verbose>3) printf(" ending sequence before it really started.\n");
      return(0);
    }
    /* If sequence actually contains something, the Item tag must be 0xFFFE,0xE000 */
    if(itemtag.group!=0xFFFE || itemtag.element!=0xE000) {
      if(verbose>1) printf(" invalid sequence item tag(%04x,%04x)\n", itemtag.group, itemtag.element);
      return(2);
    }
    /* Read past the VL of this item (always 4 bytes) */
    unsigned long int itemvl=dcmReadFileVL(dcm->fp, 4);
    if(verbose>3) {printf(" item_VL := %lu (0x%08lx)\n", itemvl, itemvl);}
    if(ftell(dcm->fp)<0) return(2);
    unsigned long int sqItemPos=(unsigned long int)ftell(dcm->fp);
    /* Check if that is all of this sequence (probably Siemens) */
    if((sqItemPos-sqPos)>=sqContentLength) {
      if(verbose>3) printf(" ending sequence since it was found to be empty.\n");
      return(0);
    }
    if(verbose>12) printf("  sequence content start position at %ld\n", sqItemPos);
    /* Read the first item value as its own element, adding it as child to SQ */
    ret=dcmFileReadNextElement(dcm, NULL, item, 1, headerOnly, verbose-1);
    if(ret!=0) {
      if(verbose>1) printf(" error in reading the first item value dataset\n");
      return(ret);
    }
    /* Now we continue reading more items, until we reach Sequence Delimitation Item */
    while(!feof(dcm->fp)) {
      /* Do not read pass the length of the sequence data */
      if(ftell(dcm->fp)<0) return(2);
      unsigned long int cPos=(unsigned long int)ftell(dcm->fp);
      if(sqContentLength>0 && (cPos-sqPos)>=sqContentLength) {
        if(verbose>3) printf(" we reached the end of sequence VL %lu\n", sqContentLength);
        /* set fake sequence delimitation tag */
        itemtag.group=0xFFFE; itemtag.element=0xE0DD;
        break;
      }
      if(verbose>10) {
        long int tagpos=ftell(dcm->fp);
        printf(" reading next sequence item tag at %ld, %ld after start\n", tagpos, tagpos-sqItemPos);
      }
      if(dcmReadFileTag(dcm->fp, &itemtag)) return(2);
      if(verbose>1) printf(" next item tag(%04x,%04x)\n", itemtag.group, itemtag.element);
      itemvl=dcmReadFileVL(dcm->fp, 4); // delimitation tag has this too
      if(verbose>3) {printf(" item_VL := %lu (0x%08lx)\n", itemvl, itemvl);}
      /* Check if we got sequence delimitation tag */
      if(itemtag.group==0xFFFE && itemtag.element==0xE0DD) 
      {
        if(verbose>3) printf(" we got sequence delimitation tag\n");
        break;
      }
      /* Check if we got item delimitation tag from the previous item */
      if(itemtag.group==0xFFFE && itemtag.element==0xE00D) 
      {
        if(verbose>3) printf(" we got item delimitation tag\n");
        if(itemvl!=0) {
          if(verbose>1) printf(" error: VL should have been 0\n");
          return(3);
        }
        continue;
      }
      /* Otherwise this should be sequence item tag */
      if(itemtag.group!=0xFFFE || itemtag.element!=0xE000) {
        if(verbose>3) printf(" not sequence item tag, move file position back 2x4 bytes\n");
        fseek(dcm->fp, -8, SEEK_CUR);  //return(TPCERROR_INVALID_VALUE);
      }
      /* Read the item value as its own element, adding it to the SQ child list */
      DCMITEM *child=item->child_item;
      if(child==NULL) {
        if(verbose>1) printf(" error had happened in adding the child element\n");
        return(2);
      }
      while(child->next_item!=NULL) child=child->next_item;
      ret=dcmFileReadNextElement(dcm, child, item, 0, headerOnly, verbose-1);
      if(ret!=0) {
        if(verbose>1) printf(" error in reading item value dataset\n");
        return(ret);
      }
    }    
    /* Check that loop really stopped at sequence delimitation item */
    /* 0xE00D means the end of item, 0xE0DD the end of sequence. */ 
    if(itemtag.group!=0xFFFE || itemtag.element!=0xE0DD) {
      if(verbose>1)
        printf(" invalid sequence delimitation item tag(%04x,%04x)\n", itemtag.group, itemtag.element);
      return(2);
    }
    /* Done. Do not free item! */
    if(verbose>10) {printf(" end of sequence.\n"); fflush(stdout);}
  } else if(item->vl!=0xFFFFFFFF) {
    if(verbose>10) {printf(" reading value of %u bytes...\n", item->vl); fflush(stdout);}
    char *buf=NULL;
    if(item->vl>0) {
      buf=(char*)calloc(item->vl+1, sizeof(char));
      if(buf==NULL) {free(item); return(4);}
      if(fread(buf, 1, item->vl, item->fp)!=item->vl) {
        free(item); free(buf); return(3);
      }
      /* Do not store pixel data, if that was the request */
      if(headerOnly!=0 && 
         ((item->tag.group==0x7FE0 && item->tag.element>0) || item->tag.group==0x7FE1))
      {
        if(verbose>5) {printf(" ...not storing pixel data\n"); fflush(stdout);}
        free(buf); buf=(char*)NULL;
      } else {
        item->rd=buf;
      }
    } else if(verbose>4) {
      printf(" VL=0\n");
    }
    /* Add to list */
    if(sub==0) {
      if(prev_item==NULL) {
        if(dcm->item==NULL) { // truly the first item
          dcm->item=item;
        } else { // search for the previous one
          DCMITEM *ip; ip=dcm->item;
          while(ip->next_item!=NULL) ip=ip->next_item;
          ip->next_item=item; item->prev_item=ip;
        }
      } else {
        prev_item->next_item=item; item->prev_item=prev_item;
      }
    } else { // add as child
      parent_item->child_item=item; item->parent_item=parent_item;
    }
    /* Done. Do no free item or buf! */
    return(0);
 
  } else { // VL=0xFFFFFFFF
    size_t s=dcmVRVLength(item->vr);
    if(s==0) {
      if(verbose>0) printf(" Unknown VL!!\n");
      free(item);
      return(3); //return(TPCERROR_OK);
    }
    if(verbose>4) printf(" VR_based_VL=%u\n", (unsigned int)s);
    char *buf=(char*)calloc(s+1, sizeof(char));
    if(buf==NULL) {free(item); return(4);}
    if(fread(buf, 1, s, item->fp)!=s) {
      free(item); free(buf); return(3);
    }
    item->rd=buf;
    /* Add to list */
    if(sub==0) {
      if(prev_item==NULL) {
        if(dcm->item==NULL) { // truly the first item
          dcm->item=item;
        } else { // search for the previous one
          DCMITEM *ip; ip=dcm->item;
          while(ip->next_item!=NULL) ip=ip->next_item;
          ip->next_item=item; item->prev_item=ip;
        }
      } else {
        prev_item->next_item=item; item->prev_item=prev_item;
      }
    } else { // add as child
      parent_item->child_item=item; item->parent_item=parent_item;
    }
    /* Done. Do no free item or buf! */
    return(0);
  }
 
  return(0);
}

Referenced by dcmFileRead(), and dcmFileReadNextElement().

◆ dcmFileWrite()

int dcmFileWrite	(	const char *	filename,
		DCMFILE *	dcm,
		int	verbose )

extern

Write a single DICOM file.

See also: dcmFileRead, dcmfileInit, dcmfileFree

Returns: 0 when successful.

Parameters

filename	Pointer to file name.
dcm	Pointer to DICOM data to be written.
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 1758 of file dcm.c.

  {
  if(filename==NULL || strnlen(filename, 10)<1 || dcm==NULL) return(1);
  if(verbose>1) {printf("%s('%s')\n", __func__, filename); fflush(stdout);}
 
  /* Check for the data */
  if(dcm->item==NULL) {
    return(2);
  }
 
  /* Check whether we currently support the Transfer UID */
  if(dcm->truid!=DCM_TRUID_LEE) { // Little endian explicit
    return(2);
  }
 
 
  /* Open the file */
  if(verbose>1) printf("opening the file for writing\n");
  FILE *fp;
  fp=fopen(filename, "wb");
  if(fp==NULL) return(3);
 
  /* Write preamble (just 128 zeroes) and magic number */
  {
    if(verbose>1) printf("writing preamble\n");
    char buf1[128], buf2[5]; 
    for(int i=0; i<128; i++) buf1[i]=(char)0;
    strcpy(buf2, "DICM");
    if(fwrite(buf1, 128, 1, fp)<1 || fwrite(buf2, 4, 1, fp)<1) {
      fclose(fp);
      return(3);
    }
  }
 
 
  /* Write the contents */
  if(verbose>1) printf("writing DICOM contents\n");
  int ret=0;
  DCMITEM *iptr;
  DCMITEM *d1=dcm->item;
  while(d1!=NULL) {
    if(verbose>2) {dcmitemPrint(d1);}
    /* Write */
    iptr=d1;
    {
      size_t n;
      /* Write tag */
      if(dcmWriteFileTag(fp, &iptr->tag)!=0) {ret=1; break;}
      /* Write VR and VL */
      if(dcmWriteFileVRVL(fp, iptr->vr, iptr->vl, NULL)!=0) {ret=2; break;}
      /* Write value, unless zero length, or SQ, in which case written later */
      if(iptr->vl>0 && iptr->vr!=DCM_VR_SQ) {
        size_t len;
        if(iptr->vl==0xFFFFFFFF) {
          len=dcmVRVLength(iptr->vr);
          if(verbose>30) printf("  value_len1 := %u\n", (unsigned int)len);
          n=fwrite(iptr->rd, dcmVRVLength(iptr->vr), 1, fp);
        } else {
          len=iptr->vl;
          if(verbose>30) printf("  value_len3 := %u\n", (unsigned int)len);
          n=fwrite(iptr->rd, iptr->vl, 1, fp);
        }
        if(verbose>30) printf("  value_len := %u\n", (unsigned int)len);
        if(n!=1) {ret=4; break;}
      } else if(iptr->vr==DCM_VR_SQ && d1->child_item==NULL) {
        if(verbose>1) printf("SQ, but no contents to write!\n");
        /* Write Sequence Delimitation Item */
        if(dcmWriteFileSQDelimItem(fp)!=0) {ret=6; break;}
      }
    }
 
    /* If this element (SQ) has children, then write those */
    /* Data Elements with a group of 0000, 0002 and 0006 shall not be present within Sequence Items,
       but that is not verified here */
    if(d1->child_item!=NULL) {
      DCMITEM *d2=d1->child_item;
      unsigned int d2counter=0;
      while(d2!=NULL) {
        if(verbose>2) {printf("  "); dcmitemPrint(d2);}
 
        /* Write */
        iptr=d2;
 
        /* First, write Item tag (FFFE,E000) */
        if(d2counter==0) {
          DCMTAG tag; tag.group=0xFFFE; tag.element=0xE000;
          if(dcmWriteFileTag(fp, &tag)!=0) {ret=11; break;}
        }
        /* Write item length; write 0xFFFFFFFF for now, correct later when known */
        fpos_t d2ilpos; // position for item length
        unsigned int d2il=0; // item length
        if(d2counter==0) {
          if(fgetpos(fp, &d2ilpos)) {ret=12; break;} // save position for writing later
          unsigned int ibuf;
          ibuf=0xFFFFFFFF;
          if(fwrite(&ibuf, 4, 1, fp)!=1) {ret=13; break;}
        }
        d2counter++;
 
        /* Write item value data set */
        {
          /* Write tag */
          if(dcmWriteFileTag(fp, &iptr->tag)!=0) {ret=14; break;}
          d2il+=4;
          /* Write VR and VL */
          unsigned int s;
          if(dcmWriteFileVRVL(fp, iptr->vr, iptr->vl, &s)!=0) {ret=15; break;}
          d2il+=s;
          /* Write value, unless zero length, or SQ, in which case written later */
          if(iptr->vl>0 && iptr->vr!=DCM_VR_SQ) {
            size_t len, n;
            if(iptr->vl==0xFFFFFFFF) {
              len=dcmVRVLength(iptr->vr);
              if(verbose>30) printf("  value_len1 := %u\n", (unsigned int)len);
              n=fwrite(iptr->rd, dcmVRVLength(iptr->vr), 1, fp);
              d2il+=len;
            } else {
              len=iptr->vl;
              if(verbose>30) printf("  value_len3 := %u\n", (unsigned int)len);
              n=fwrite(iptr->rd, iptr->vl, 1, fp);
              d2il+=iptr->vl;
            }
            if(verbose>30) printf("  value_len := %u\n", (unsigned int)len);
            if(n!=1) {ret=17; break;}
          } else if(iptr->vr==DCM_VR_SQ && iptr->child_item==NULL) {
            if(verbose>1) printf("SQ, but no contents to write!\n");
            /* Write Sequence Delimitation Item */
            if(dcmWriteFileSQDelimItem(fp)!=0) {ret=19; break;}
          }
        }
 
        /* If this element has children, then write those */
        if(d2->child_item!=NULL) {
          DCMITEM *d3=d2->child_item;
          unsigned int d3counter=0;
          while(d3!=NULL) {
            if(verbose>2) {printf("    "); dcmitemPrint(d3);}
 
            /* Write */
            iptr=d3;
            if(iptr->vr==DCM_VR_SQ) {d3=d3->next_item; continue;} // for now do not write SQs
 
            /* First, write Item tag (FFFE,E000) */
            if(d3counter==0) {
              DCMTAG tag; tag.group=0xFFFE; tag.element=0xE000;
              if(dcmWriteFileTag(fp, &tag)!=0) {ret=31; break;}
              d2il+=4;
            }
            /* Write item length; write 0xFFFFFFFF for now, correct later when known */
            fpos_t d3ilpos; // position for item length
            unsigned int d3il=0; // item length
            if(d3counter==0) {
              unsigned int ibuf;
              if(fgetpos(fp, &d3ilpos)) {ret=32; break;} // save position for writing later
              ibuf=0xFFFFFFFF;
              if(fwrite(&ibuf, 4, 1, fp)!=1) {ret=33; break;}
              d2il+=4;
            }
            d3counter++;
 
            /* Write item value data set */
            {
              /* Write tag */
              if(dcmWriteFileTag(fp, &iptr->tag)!=0) {ret=34; break;}
              d3il+=4; d2il+=4;
              /* Write VR and VL */
              unsigned int s;
              if(dcmWriteFileVRVL(fp, iptr->vr, iptr->vl, &s)!=0) {ret=35; break;}
              d3il+=s; d2il+=s;
              /* Write value, unless zero length, or SQ, in which case written later */
              if(iptr->vl>0 && iptr->vr!=DCM_VR_SQ) {
                size_t len, n;
                if(iptr->vl==0xFFFFFFFF) {
                  len=dcmVRVLength(iptr->vr);
                  if(verbose>30) printf("  value_len1 := %u\n", (unsigned int)len);
                  n=fwrite(iptr->rd, dcmVRVLength(iptr->vr), 1, fp);
                  d3il+=len; d2il+=len;
                } else {
                  len=iptr->vl;
                  if(verbose>30) printf("  value_len3 := %u\n", (unsigned int)len);
                  n=fwrite(iptr->rd, iptr->vl, 1, fp);
                  d3il+=iptr->vl; d2il+=iptr->vl;
                }
                if(verbose>30) printf("  value_len := %u\n", (unsigned int)len);
                if(n!=1) {ret=37; break;}
              } else if(iptr->vr==DCM_VR_SQ && iptr->child_item==NULL) {
                if(verbose>1) printf("SQ, but no contents to write!\n");
                /* Write Sequence Delimitation Item */
                if(dcmWriteFileSQDelimItem(fp)!=0) {ret=39; break;}
                d2il+=8;
              }
            }
 
            /* If this element has children, then write those */
            if(d3->child_item!=NULL) {
              //DCMITEM *d4=d3->child_item;
              if(verbose>0) fprintf(stderr, "Warning: 4th level items not written.\n");
            }
 
            /* now that we known the length, write it to the saved position */
            if(0) {
              fpos_t opos; // current position to return to
              if(fgetpos(fp, &opos)) {ret=40; break;}
              fsetpos(fp, &d3ilpos); // go to the position for item length
              char buf[4];
              memcpy(buf, &d3il, 4);
              if(!little_endian()) swabip(buf, 4);
              if(fwrite(&buf, 4, 1, fp)!=1) {ret=41; break;}
              fsetpos(fp, &opos); // back to the position where we were
            }
 
            d3=d3->next_item;
          }
          if(ret!=0) break;
 
          /* Write Item Delimitation Tag */
          if(dcmWriteFileSQItemDelimTag(fp)!=0) {ret=21; break;}
          /* End of the sequence - write Sequence Delimitation Item */
          if(dcmWriteFileSQDelimItem(fp)!=0) {ret=21; break;}
 
        }
 
 
        /* now that we known the length, write it to the saved position */
        if(0) {
          fpos_t opos; // current position to return to
          if(fgetpos(fp, &opos)) {ret=18; break;}
          fsetpos(fp, &d2ilpos); // go to the position for item length
          char buf[4];
          memcpy(buf, &d2il, 4);
          if(!little_endian()) swabip(buf, 4);
          if(fwrite(&buf, 4, 1, fp)!=1) {ret=19; break;}
          fsetpos(fp, &opos); // back to the position where we were
        }
 
        d2=d2->next_item;
      }
      if(ret!=0) break;
 
      /* Write Item Delimitation Tag */
      if(dcmWriteFileSQItemDelimTag(fp)!=0) {ret=21; break;}
      /* End of the sequence - write Sequence Delimitation Item */
      if(dcmWriteFileSQDelimItem(fp)!=0) {ret=21; break;}
 
    }
 
    d1=d1->next_item;
  } // next
  if(ret!=0) {
    if(verbose>0) fprintf(stderr, "  ret := %d\n", ret);
    fclose(fp);
    return(3);
  }
 
 
  fclose(fp);
 
  return(0);
}

◆ dcmFindTag()

DCMITEM * dcmFindTag	(	DCMITEM *	d,
		const short int	omit,
		DCMTAG *	tag,
		const int	verbose )

extern

Search for specified tag in DCMITEM data tree.

Returns: Returns pointer to next item with the tag, or NULL if not found.

Parameters

d	Pointer to current DICOM item.
omit	Omit this item from the search.
tag	Pointer to the DICOM tag that is searched for.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 1163 of file dcm.c.

  {
  if(d==NULL || tag==NULL) return(NULL);
  if(verbose>0) printf("%s(%04X,%04X)\n", __func__, tag->group, tag->element);
  DCMITEM *iptr;
  if(omit==0) iptr=d; else iptr=d->next_item;
  while(iptr!=NULL) {
    if(verbose>2)
      printf(" checking tag(%04X,%04X)...\n", iptr->tag.group, iptr->tag.element);
    if(iptr->tag.group==tag->group && iptr->tag.element==tag->element) {
      if(verbose>2) printf("  found!\n");
      break;
    }
    /* Check if this item has children */
    if(iptr->child_item!=NULL) {
      if(verbose>2) printf("  going to search inside children...\n");
      DCMITEM *rptr=dcmFindTag(iptr->child_item, 0, tag, verbose);
      if(rptr!=NULL) return(rptr);
      if(verbose>3) printf("  nothing found in any of the children\n");
    }
    iptr=iptr->next_item;
  }
  /* Stop if we found tag, or if we do not have parent */
  if(iptr!=NULL) return(iptr);
  if(d->parent_item==NULL) return(NULL);
 
  /* Search from the parent */
  if(verbose>2) printf("  going to search inside parent...\n");
  return(dcmFindTag(d->parent_item, 1, tag, verbose));
}

Referenced by dcmFindTag().

◆ dcmitemFree()

void dcmitemFree ( DCMITEM * d )

extern

Recursively free memory allocated for DCMITEM items and their children items.

See also: dcmfileFree

Author: Vesa Oikonen

Parameters

d	Pointer to DCMITEM.

Definition at line 840 of file dcm.c.

  {
  if(d==NULL) return;
  /* find the last item in the list */
  DCMITEM *ip=d; while(ip->next_item!=NULL) ip=ip->next_item;
  while(ip!=NULL) {
    /* Free items child and their children */
    if(ip->child_item!=NULL) dcmitemFree(ip->child_item);
    /* Free this item and move to previous item */
    if(ip->prev_item!=NULL) {
      ip=ip->prev_item; 
      free(ip->next_item->rd); free(ip->next_item); 
      ip->next_item=NULL;
    } else {
      free(ip->rd); free(ip); ip=NULL;
    }
  }
}

Referenced by dcmfileFree(), and dcmitemFree().

◆ dcmitemGetInt()

long int dcmitemGetInt ( DCMITEM * d )

extern

Read integer value from given DICOM item.

VR must be either UL, US, SL, SS, or IS; otherwise 0 is returned.

Returns: Returns the value as long int, in order to cope with originally unsigned integers.

See also: dcmitemGetInt, dcmValueString, dcmFindTag

Parameters

d	Pointer to item.

Definition at line 1084 of file dcm.c.

  {
  if(d==NULL || d->rd==NULL) return(0);
  long int li=0;
  if(d->vr==DCM_VR_UL) { // unsigned 32-bit int
    unsigned int i;
    memcpy(&i, d->rd, 4); if(!little_endian()) swap(&i, &i, 4);
    li=(long int)i;
  } else if(d->vr==DCM_VR_US) { // unsigned 16-bit int
    unsigned short int i;
    memcpy(&i, d->rd, 2); if(!little_endian()) swap(&i, &i, 2);
    li=(long int)i;
  } else if(d->vr==DCM_VR_SL) { // signed 32-bit int
    int i;
    memcpy(&i, d->rd, 4); if(!little_endian()) swap(&i, &i, 4);
    li=(long int)i;
  } else if(d->vr==DCM_VR_SS) { // signed 16-bit int
    short int i;
    memcpy(&i, d->rd, 2); if(!little_endian()) swap(&i, &i, 2);
    li=(long int)i;
  } else if(d->vr==DCM_VR_IS) { // integer string
    li=atol(d->rd);
  }
  return(li);
}

◆ dcmitemGetReal()

double dcmitemGetReal ( DCMITEM * d )

extern

Read floating point value from given DICOM item.

VR must be either FL, FD, DS, UL, US, SL, SS, or IS; otherwise 0 is returned.

Returns: Returns the value as double.

See also: dcmitemGetInt, dcmValueString, dcmFindTag

Parameters

d	Pointer to item.

Definition at line 1120 of file dcm.c.

  {
  if(d==NULL || d->rd==NULL) return(0);
  double r=0.0;
  if(d->vr==DCM_VR_FL) { // 32-bit float
    float f;
    memcpy(&f, d->rd, 4); if(!little_endian()) swap(&f, &f, 4);
    r=(double)f;
  } else if(d->vr==DCM_VR_FD) { // 64-bit double
    double f;
    memcpy(&f, d->rd, 8); if(!little_endian()) swap(&f, &f, 8);
    r=f;
  } else if(d->vr==DCM_VR_DS) { // decimal string
    r=atof(d->rd);
  } else if(d->vr==DCM_VR_UL) { // unsigned 32-bit int
    unsigned int i;
    memcpy(&i, d->rd, 4); if(!little_endian()) swap(&i, &i, 4);
    r=(double)i;
  } else if(d->vr==DCM_VR_US) { // unsigned 16-bit int
    unsigned short int i;
    memcpy(&i, d->rd, 2); if(!little_endian()) swap(&i, &i, 2);
    r=(double)i;
  } else if(d->vr==DCM_VR_SL) { // signed 32-bit int
    int i;
    memcpy(&i, d->rd, 4); if(!little_endian()) swap(&i, &i, 4);
    r=(double)i;
  } else if(d->vr==DCM_VR_SS) { // signed 16-bit int
    short int i;
    memcpy(&i, d->rd, 2); if(!little_endian()) swap(&i, &i, 2);
    r=(double)i;
  } else if(d->vr==DCM_VR_IS) { // integer string
    r=(double)atol(d->rd);
  }
  return(r);
}

◆ dcmitemMaxDepth()

unsigned short int dcmitemMaxDepth ( DCMITEM * d )

extern

Get the maximum depth of DCMITEM tree.

Returns: Returns the number of levels under specified item, not including given item itself.

See also: dcmitemParentNr, dcmfileMaxDepth

Parameters

d	Pointer to DCMITEM item.

Definition at line 884 of file dcm.c.

  {
  if(d==NULL || d->child_item==NULL) return(0);
  unsigned short int m=0, n=0;
  DCMITEM *cd=d->child_item;
  /* go through all children */
  while(cd!=NULL) {
    n=dcmitemMaxDepth(cd); if(n>m) m=n;
    cd=cd->next_item;
  }
  return(m+1);
}

Referenced by dcmfileMaxDepth(), and dcmitemMaxDepth().

◆ dcmitemParentNr()

unsigned short int dcmitemParentNr ( DCMITEM * d )

extern

Check how deep in DCMITEM tree this item is.

Returns: Returns the number of parents this item has.

See also: dcmitemMaxDepth, dcmfileMaxDepth

Parameters

d	Pointer to DCMITEM.

Definition at line 923 of file dcm.c.

  {
  if(d==NULL) return(0);
  unsigned short int n=0;
  DCMITEM *pd=d->parent_item;
  while(pd!=NULL) {n++; pd=pd->parent_item;}
  return(n);
}

Referenced by dcmFileReadNextElement().

◆ dcmitemPrint()

void dcmitemPrint ( DCMITEM * d )

extern

Print contents of given DICOM item into stdout.

Parameters

d	Pointer to item.

Definition at line 1205 of file dcm.c.

  {
  if(d==NULL) {printf("(null)\n"); fflush(stdout); return;}
  printf("tag(%04X,%04X)", d->tag.group, d->tag.element); fflush(stdout);
  printf(" VR=%s", dcmVRName(d->vr)); fflush(stdout);
  if(d->vl==0xFFFFFFFF) printf(" VL=%08X", d->vl); else printf(" VL=%u", d->vl);
  fflush(stdout);
  char *buf=dcmValueString(d); printf(" '%s'", buf); free(buf);
  printf("\n"); fflush(stdout);
}

Referenced by dcmAddItem(), and dcmFileWrite().

◆ dcmReadFileTag()

int dcmReadFileTag	(	FILE *	fp,
		DCMTAG *	tag )

extern

Read DICOM tag from current file position.

Note: Tag validity is not verified here; error may be caused by end-of-file. Alternatively, read may seem to be successful, but tag contents are file padding symbols (0xFFFC).

See also: dcmReadFile, dcmReadFileElement

Returns: Returns 0 when successful, otherwise >0.

Author: Vesa Oikonen

Parameters

fp	File pointer, positioned at the start of the element (and tag).
tag	Pointer to DICOM tag struct; enter NULL if you just need to move file position over the tag.

Definition at line 553 of file dcm.c.

  {
  if(tag!=NULL) {tag->group=tag->element=0xFFFC;} // padding
  if(fp==NULL || feof(fp)) return(1);
  unsigned short int buf[2];
  size_t n=fread(&buf, 2, 2, fp);
  if(n!=2) return(2+n);
  if(tag!=NULL) {
    tag->group=buf[0];
    tag->element=buf[1];
    if(!little_endian()) { // tag is by default little endian
      swap(&tag->group, &tag->group, 2);
      swap(&tag->element, &tag->element, 2);
    }
  }
  return(0);
}

Referenced by dcmFileReadNextElement(), and dcmReadTransferSyntaxUID().

◆ dcmReadFileVL()

unsigned int dcmReadFileVL	(	FILE *	fp,
		unsigned int	n )

extern

Read DICOM value length (2 or 4 bytes, depending on VR) from current file position.

See also: dcmReadFileTag, dcmReadFileVR, dcmReadFileElement

Returns: Returns the value length.

Author: Vesa Oikonen

Parameters

fp	File pointer, positioned at the VL start.
n	Number of bytes (2 or 4) in the VL representation.

Definition at line 692 of file dcm.c.

  {
  unsigned int vl=0;
  if(fp==NULL || (n!=2 && n!=4)) return(vl);
 
  /* Read 2 or 4 bytes */
  if(n==2) {
    unsigned short int si;
    if(fread(&si, 2, 1, fp)!=1) return(vl);
    if(!little_endian()) swap(&si, &si, 2);
    vl=si;
  } else if(n==4) {
    unsigned int li;
    if(fread(&li, 4, 1, fp)!=1) return(vl);
    if(!little_endian()) swap(&li, &li, 4);
    vl=li;
  }
  return(vl);
}

Referenced by dcmFileReadNextElement(), and dcmReadTransferSyntaxUID().

◆ dcmReadFileVR()

dcmvr dcmReadFileVR	(	FILE *	fp,
		char *	vrstr )

extern

Read DICOM value representation (2 or 4 bytes) from current file position.

See also: dcmReadFileTag, dcmReadFileElement

Returns: Returns the enumerated VR number, DCM_VR_INVALID in case of an error.

Author: Vesa Oikonen

Parameters

fp	File pointer, positioned at the VR start.
vrstr	Pointer for VR string, allocated for at least 3 characters to have space for the trailing null; enter NULL if not needed.

Definition at line 655 of file dcm.c.

  {
  if(vrstr!=NULL) vrstr[0]=(char)0;
  if(fp==NULL) return(DCM_VR_INVALID);
 
  /* Read the first two bytes */
  char buf[3];
  if(fread(&buf, 1, 2, fp)!=2) return(DCM_VR_INVALID);
  buf[2]=(char)0;
 
  /* Identify the VR */
  dcmvr lvr=dcmVRId(buf);
  if(vrstr!=NULL) {
    if(lvr!=DCM_VR_INVALID) strcpy(vrstr, dcmVRName(lvr));
    else strcpy(vrstr, buf);
  }
 
  /* If this VR has extra 2 byte reserved space, then
     we need to read but do not use the next 2 bytes. */
  if(dcmVRReserved(lvr)!=0) {
    if(fread(&buf, 1, 2, fp)!=2) return(DCM_VR_INVALID);
  }
  return(lvr);
}

Referenced by dcmReadTransferSyntaxUID().

◆ dcmReadFileVRVL()

int dcmReadFileVRVL	(	FILE *	fp,
		dcmvr *	vr,
		unsigned int *	vl,
		unsigned int *	n )

extern

Read DICOM Value Representation (VR, 2 or 4 bytes) and Value Length (VL, 2 or 4 bytes) from current file position.

See also: dcmReadFileVR, dcmReadFileVL, dcmReadFileTag, dcmReadFileElement, dcmWriteFileVRVL

Returns: 0 when successful.

Author: Vesa Oikonen

Parameters

fp	File pointer, positioned at the VR start.
vr	Pointer for enumerated VR value; enter NULL if not needed (file pointer moved anyway).
vl	Pointer for VL; enter NULL if not needed (file pointer moved anyway).
n	Pointer for number of bytes read from file; enter NULL if not needed.

Definition at line 724 of file dcm.c.

  {
  if(vr!=NULL) *vr=DCM_VR_INVALID;
  if(vl!=NULL) *vl=0;
  if(n!=NULL) *n=0;
  if(fp==NULL) return(1);
 
  /* Read the first two bytes */
  char buf[3];
  if(fread(&buf, 1, 2, fp)!=2) return(2); else if(n!=NULL) *n+=2;
  buf[2]=(char)0;
 
  /* Identify the VR */
  dcmvr lvr=dcmVRId(buf);
  if(vr!=NULL) *vr=lvr;
  if(lvr==DCM_VR_INVALID) return(3);
 
  /* If this VR has extra 2 byte reserved space, then
     we need to read but do not use the next 2 bytes. */
  unsigned int bsize=2+dcmVRReserved(lvr);
  if(bsize==4) {
    if(fread(&buf, 1, 2, fp)!=2) return(2);
    if(n!=NULL) *n+=2;
  }
 
  /* Read VL from the next 2 or 4 bytes */
  unsigned int lvl=0;
  if(bsize==2) {
    unsigned short int si;
    if(fread(&si, 2, 1, fp)!=1) return(2);
    if(!little_endian()) swap(&si, &si, 2);
    lvl=si;
  } else {
    unsigned int li;
    if(fread(&li, 4, 1, fp)!=1) return(2);
    if(!little_endian()) swap(&li, &li, 4);
    lvl=li;
  }
  if(n!=NULL) *n+=bsize;
  if(vl!=NULL) *vl=lvl;
 
  return(0);
}

Referenced by dcmFileReadNextElement().

◆ dcmReadTransferSyntaxUID()

dcmtruid dcmReadTransferSyntaxUID ( FILE * fp )

extern

Read and identify the DICOM Transfer Syntax UID.

Returns: Returns the enumerated UID, or DCM_TRUID_INVALID.

See also: dcmVerifyMagic

Parameters

fp	Pointer to DICOM file opened in binary format, and positioned right after the Magic number. Position will be returned to this position.

Definition at line 502 of file dcm.c.

  {
  if(fp==NULL || feof(fp)) return(DCM_TRUID_INVALID);
  /* Save original file position */
  fpos_t opos;
  if(fgetpos(fp, &opos)) return(DCM_TRUID_INVALID);
  /* Read file until we find DICOM tag 0x0002,0x0010 */
  DCMTAG tag;
  int tag_found=0;
  while(!tag_found && !feof(fp)) {
    if(dcmReadFileTag(fp, &tag)) break;
    if(tag.group==0x0002 && tag.element==0x0010) {tag_found=1; break;}
    /* not the tag that we want, so just go through this item */
    dcmvr vr=dcmReadFileVR(fp, NULL);
    unsigned int vl=0;
    if(dcmVRReserved(vr)==0) vl=dcmReadFileVL(fp, 2); 
    else vl=dcmReadFileVL(fp, 4); 
    if(vr==DCM_VR_SQ) break;
    if(vl==0xFFFFFFFF) break;
    char buf[vl+1];
    if(fread(buf, 1, vl, fp)!=vl) break;
  } // get next tag
  if(!tag_found) {fsetpos(fp, &opos); return(DCM_TRUID_INVALID);}
  /* Read the UID */
  if(dcmReadFileVR(fp, NULL)!=DCM_VR_UI) {
    fsetpos(fp, &opos); return(DCM_TRUID_INVALID);
  }
  unsigned int vl=dcmReadFileVL(fp, 2); 
  if(vl==0 || vl==0xFFFFFFFF) {fsetpos(fp, &opos); return(DCM_TRUID_INVALID);}
  char uid[vl+1];
  if(fread(uid, 1, vl, fp)!=vl) {fsetpos(fp, &opos); return(DCM_TRUID_INVALID);}
  /* Return file position to the original */
  fsetpos(fp, &opos);
  /* Identify the UID */
  return(dcmTrUID(uid));
}

Referenced by dcmFileRead().

◆ dcmSOPIdentify()

unsigned int dcmSOPIdentify ( const char * s )

extern

Identify the DICOM SOP UID.

Returns: Returns the SOP UID list index.

See also: dcmSOPName, dcmSOPUID

Parameters

s	SOP UID string.

Definition at line 367 of file dcm.c.

  {
  if(s==NULL || strnlen(s, 3)<3) return(0);
 
  /* Identify the SOP UID */
  unsigned int i=0;
  while(strcmp(dcm_sop[i].uid, "unknown")!=0) {
    if(strcmp(dcm_sop[i].uid, s)==0) return(i);
    i++;
  }
  return(i);
}

◆ dcmSOPName()

char * dcmSOPName ( unsigned int i )

extern

Get the DICOM SOP UID Name.

Returns: Returns pointer to the SOP Name string.

See also: dcmSOPIdentify, dcmSOPUID

Parameters

i	SOP UID list index.

Definition at line 388 of file dcm.c.

  {
  unsigned int j=0;
  while(strcmp(dcm_sop[j].uid, "unknown")!=0) {
    if(i==j) return(dcm_sop[j].name);
    j++;
  }
  return(dcm_sop[j].name);
}

◆ dcmSOPUID()

char * dcmSOPUID ( unsigned int i )

extern

Get the DICOM SOP UID.

Returns: Returns pointer to the UID string.

See also: dcmSOPIdentify, dcmSOPName

Parameters

i	SOP UID list index.

Definition at line 406 of file dcm.c.

  {
  unsigned int j=0;
  while(strcmp(dcm_sop[j].uid, "unknown")!=0) {
    if(i==j) return(dcm_sop[j].uid);
    j++;
  }
  return(dcm_sop[j].uid);
}

◆ dcmSOPUIDName()

char * dcmSOPUIDName ( const char * s )

extern

Get the name of DICOM SOP UID.

Returns: Returns pointer to the SOP UID name string.

See also: dcmSOPName, dcmSOPUID

Parameters

s	SOP UID string.

Definition at line 424 of file dcm.c.

  {
  if(s==NULL || strnlen(s, 3)<3) return(dcm_sop[0].name);
 
  /* Identify the SOP UID */
  unsigned int i=0;
  while(strcmp(dcm_sop[i].uid, "unknown")!=0) {
    if(strcmp(dcm_sop[i].uid, s)==0) return(dcm_sop[i].name);
    i++;
  }
  return(dcm_sop[i].name);
}

◆ dcmTagSet()

void dcmTagSet	(	DCMTAG *	tag,
		unsigned short int	group,
		unsigned short int	element )

extern

Set DICOM Tag group and element.

Parameters

tag	Pointer to Tag to set.
group	Tag Group
element	Tag Element

Definition at line 1221 of file dcm.c.

  {
  tag->group=group;
  tag->element=element;
}

◆ dcmTM2intl()

char * dcmTM2intl	(	const char *	orig,
		char *	intl )

extern

Convert DICOM time 'TM' to international format hh:mm:ss.

Returns: Returns pointer to the time string, or NULL in case of an error.

Parameters

orig	Pointer to original DICOM string.
intl	Pointer to string where time in international format will be written; must be allocated for at least 9 characters.

Definition at line 322 of file dcm.c.

  {
  if(orig==NULL || intl==NULL) return(NULL);
  if(strnlen(orig, 14)<6) return(NULL);
  if(isdigit(orig[2])) { // modern format hhmmss.fract
    sprintf(intl, "%2.2s:%2.2s:%2.2s", orig, orig+2, orig+4);
  } else { // old format hh.mm.ss
    sprintf(intl, "%2.2s:%2.2s:%2.2s", orig, orig+3, orig+6);
  }
  if(istime(intl)) {intl[0]=(char)0; return(NULL);}
  return(intl);
}

◆ dcmTrUID()

dcmtruid dcmTrUID ( const char * s )

extern

Identify the DICOM Transfer Syntax UID.

Returns: Returns the enumerated id.

See also: dcmTrUIDDescr

Parameters

s	UID string.

Definition at line 445 of file dcm.c.

  {
  if(s==NULL || strnlen(s, 5)<5) return(DCM_TRUID_INVALID);
 
  /* Identify the UID */
  unsigned short int i=1;  // 1 because 0 is unknown
  while(dcm_truid[i].id!=DCM_TRUID_INVALID) {
    if(strcmp(dcm_truid[i].uid, s)==0) return(dcm_truid[i].id);
    i++;
  }
  return(DCM_TRUID_UNKNOWN);
}

Referenced by dcmReadTransferSyntaxUID().

◆ dcmTrUIDDescr()

char * dcmTrUIDDescr ( dcmtruid id )

extern

Get the DICOM Transfer Syntax UID description.

Returns: Returns pointer to the description string.

See also: dcmTrUID

Parameters

id	Transfer Syntax UID id (DCM_TRUID_LEI, ...).

Definition at line 466 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_truid[i].id!=DCM_TRUID_INVALID) {
    if(id==dcm_truid[i].id) return(dcm_truid[i].descr);
    i++;
  }
  return(dcm_truid[DCM_TRUID_INVALID].descr);
}

Referenced by dcmFileRead().

◆ dcmTrUIDString()

char * dcmTrUIDString ( dcmtruid id )

extern

Get the DICOM Transfer Syntax UID string.

Returns: Returns pointer to the description string.

See also: dcmTrUID

Parameters

id	Transfer Syntax UID id (DCM_TRUID_LEI, ...).

Definition at line 484 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_truid[i].id!=DCM_TRUID_INVALID) {
    if(id==dcm_truid[i].id) return(dcm_truid[i].uid);
    i++;
  }
  return(dcm_truid[DCM_TRUID_INVALID].uid);
}

◆ dcmValueString()

char * dcmValueString ( DCMITEM * d )

extern

Pre-process the DICOM element value into format suitable for printing.

Note: Use only for printing information for the user.

Returns: Returns pointer to locally allocated null-terminated string.

Postcondition: Free the pointer after use.

See also: dcmitemGetInt, dcmitemGetReal, dcmFindTag

Attribute tag

Float

Double

Unsigned 32-bit int

Unsigned 16-bit int

Signed 32-bit int

Signed 16-bit int

Parameters

d	Pointer to item containing the value to print.

Definition at line 942 of file dcm.c.

  {
  if(d==NULL) return((char*)NULL);
 
  /* For sequence, return string 'na' */
  if(d->vr==DCM_VR_SQ) {
    char *s=malloc(3); strcpy(s, "na"); // do not write char *s="na";
    return(s);
  }
 
  /* If there is no value, then return string 'empty', or
     'na', if value just was not stored (pixel data) */
  if(d->vl==0) {
    char *s=malloc(6); strcpy(s, "empty"); 
    return(s);
  } else if(d->rd==NULL) {
    char *s=malloc(3); strcpy(s, "na"); 
    return(s);
  }
 
  unsigned int len;
  if(d->vl==0xFFFFFFFF) len=(unsigned int)dcmVRVLength(d->vr); else len=d->vl;
 
  /* String values */
  if(d->vr==DCM_VR_CS || d->vr==DCM_VR_DS || d->vr==DCM_VR_IS || 
     d->vr==DCM_VR_LO || d->vr==DCM_VR_LT || d->vr==DCM_VR_PN || 
     d->vr==DCM_VR_SH || d->vr==DCM_VR_ST)
  {
    char *s=malloc(len+1);
    memcpy(s, d->rd, len); s[len]=(char)0;
    return(s);
  }
 
  /* More string values */
  if(d->vr==DCM_VR_AS || d->vr==DCM_VR_PN || 
     d->vr==DCM_VR_DA || d->vr==DCM_VR_DT || d->vr==DCM_VR_TM || 
     d->vr==DCM_VR_UT || d->vr==DCM_VR_AE || 
     d->vr==DCM_VR_UI || d->vr==DCM_VR_UR)
  {
    char *s=malloc(len+1);
    memcpy(s, d->rd, len); s[len]=(char)0;
    return(s);
  }
 
 
  if(d->vr==DCM_VR_AT) {
    DCMTAG tag;
    memcpy(&tag.group, d->rd, 2);
    memcpy(&tag.element, d->rd+2, 2);
    if(!little_endian()) {
      swap(&tag.group, &tag.group, 2);
      swap(&tag.element, &tag.element, 2);
    }
    char *s=malloc(14);
    sprintf(s, "0x%04x,0x%04x", tag.group, tag.element);
    return(s);
  }
 
 
  if(d->vr==DCM_VR_FL) {
    float f;
    memcpy(&f, d->rd, 4);
    if(!little_endian()) swap(&f, &f, 4);
    char *s=malloc(16);
    sprintf(s, "%g", f);
    return(s);
  }
 
 
  if(d->vr==DCM_VR_FD) {
    char *s=malloc(32);
    double f;
    memcpy(&f, d->rd, 8);
    if(!little_endian()) swap(&f, &f, 8);
    sprintf(s, "%g", f);
    return(s);
  }
 
 
  if(d->vr==DCM_VR_UL) {
    unsigned int i;
    memcpy(&i, d->rd, 4);
    if(!little_endian()) swap(&i, &i, 4);
    char *s=malloc(16);
    sprintf(s, "%u", i);
    return(s);
  }
 
 
  if(d->vr==DCM_VR_US) {
    unsigned short int i;
    memcpy(&i, d->rd, 2);
    if(!little_endian()) swap(&i, &i, 2);
    char *s=malloc(8);
    sprintf(s, "%u", i);
    return(s);
  }
 
 
  if(d->vr==DCM_VR_SL) {
    int i;
    memcpy(&i, d->rd, 4);
    if(!little_endian()) swap(&i, &i, 4);
    char *s=malloc(16);
    sprintf(s, "%d", i);
    return(s);
  }
 
 
  if(d->vr==DCM_VR_SS) {
    short int i;
    memcpy(&i, d->rd, 2);
    if(!little_endian()) swap(&i, &i, 2);
    char *s=malloc(8);
    sprintf(s, "%d", i);
    return(s);
  }
 
/* Not (yet) printed:
  DCM_VR_OB,        ///< DICOM other byte string, even bytes, endian insensitive.
  DCM_VR_OD,        ///< DICOM other double (64-bit) stream, endian sensitive.
  DCM_VR_OF,        ///< DICOM other float (32-bit) stream, endian sensitive.
  DCM_VR_OL,        ///< DICOM other long (32-bit) stream, endian sensitive.
  DCM_VR_OW,        ///< DICOM other word (16-bit) stream, even bytes, endian sensitive.
  DCM_VR_UC,        ///< DICOM unlimited characters.
  DCM_VR_UN,        ///< DICOM unknown, any valid length of another VR.
  DCM_VR_INVALID    ///< Invalid DICOM value representation.
*/
  char *s=malloc(3); strcpy(s, "na"); // do not write char *s="na";
  return(s);
}

Referenced by dcmitemPrint().

◆ dcmVerifyMagic()

int dcmVerifyMagic	(	const char *	filename,
		FILE *	fp )

extern

Verify that given file (either file name or file pointer) appears to be DICOM file, based on the magic number.

See also: dcmReadFile, dcmReadTransferSyntaxUID

Returns: Returns 1 if DICOM magic number can be found, or 0 if not.

Author: Vesa Oikonen

Parameters

filename	Name of file to open and to verify for the magic number; enter NULL to use the file pointer (next argument) instead.
fp	File pointer of file to check, opened with fp=fopen(filename, "rb"); enter NULL to open file (previous argument) locally. Previously opened file pointer is first rewound to start; if DICOM magic number is found, then file pointer is left to the end of magic number, and if not, it is rewound to the file start.

Definition at line 157 of file dcm.c.

  {
  FILE *lfp;
 
  if(filename==NULL && fp==NULL) return(0);
  if(fp!=NULL) {
    lfp=fp; rewind(lfp);
  } else {
    lfp=fopen(filename, "rb");
  }
  if(lfp==NULL) return(0);
 
  /* Skip the first 128 bytes */
  if(fseek(lfp, 128, SEEK_SET)) {if(fp==NULL) fclose(lfp); return(0);}
 
  /* Read the next 4 bytes as characters */
  char buf[5];
  size_t n=fread(&buf, 1, 4, lfp);
  buf[4]=(char)0;
  if(n!=(size_t)4) {rewind(lfp); return(0);}
 
  /* Check the magic number */
  if(strncmp(buf, "DICM", 4)==0) {
    if(fp==NULL) fclose(lfp);
    return(1);
  } else {
    if(fp==NULL) fclose(lfp); else rewind(lfp);
    return(0);
  }
}

Referenced by dcmFileRead(), and imgFormatDetermine().

◆ dcmVRDescr()

char * dcmVRDescr ( dcmvr id )

extern

Get the DICOM VR description.

Returns: Returns pointer to the description string.

See also: dcmIdentifyVR

Parameters

id	VR id (DCM_VR_AE, ...).

Definition at line 282 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(id==dcm_vr[i].vr) return(dcm_vr[i].descr);
    i++;
  }
  return(dcm_vr[DCM_VR_INVALID].descr);
}

Referenced by dcmFileReadNextElement().

◆ dcmVRId()

dcmvr dcmVRId ( const char * s )

extern

Identify the DICOM VR based on the two-character long string.

Returns: Returns the VR id.

See also: dcmVRName

Parameters

s	VR string. Two first characters are used. String does not need to be null-terminated.

Definition at line 223 of file dcm.c.

  {
  if(s==NULL) return(DCM_VR_INVALID);
  char buf[3]; buf[0]=s[0]; buf[1]=s[1]; buf[2]=(char)0;
 
  /* Identify the VR */
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(strncmp(dcm_vr[i].name, buf, 2)==0) return(dcm_vr[i].vr);
    i++;
  }
  return(DCM_VR_INVALID);
}

Referenced by dcmReadFileVR(), and dcmReadFileVRVL().

◆ dcmVRName()

char * dcmVRName ( dcmvr id )

extern

Get the DICOM VR name.

Returns: Returns pointer to the name string.

See also: dcmIdentifyVR

Parameters

id	VR id (DCM_VR_AE, ...).

Definition at line 246 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(id==dcm_vr[i].vr) return(dcm_vr[i].name);
    i++;
  }
  return(dcm_vr[DCM_VR_INVALID].name);
}

Referenced by dcmAddItem(), dcmFileReadNextElement(), dcmitemPrint(), dcmReadFileVR(), and dcmWriteFileVRVL().

◆ dcmVRReserved()

unsigned char dcmVRReserved ( dcmvr id )

extern

Is the explicit VR (2 bytes) followed by reserved 2 bytes? If yes, then the following Value Length is also given as 32-byte integer, if no, then as 16-bit integer.

Returns: Returns 0, if not, and 2, if it is.

Parameters

id	VR id (DCM_VR_AE, ...).

Definition at line 205 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(id==dcm_vr[i].vr) return(dcm_vr[i].res);
    i++;
  }
  return(2);
}

Referenced by dcmReadFileVR(), dcmReadFileVRVL(), dcmReadTransferSyntaxUID(), and dcmWriteFileVRVL().

◆ dcmVRVLength()

size_t dcmVRVLength ( dcmvr id )

extern

Get the DICOM VR max value length in bytes; 0 if not defined.

Returns: Returns the length in bytes.

See also: dcmIdentifyVR

Parameters

id	VR id (DCM_VR_AE, ...).

Definition at line 264 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(id==dcm_vr[i].vr) return(dcm_vr[i].s);
    i++;
  }
  return(dcm_vr[DCM_VR_INVALID].s);
}

Referenced by dcmAddItem(), dcmFileReadNextElement(), dcmFileWrite(), and dcmValueString().

◆ dcmWriteFileSQDelimItem()

int dcmWriteFileSQDelimItem ( FILE * fp )

extern

Write DICOM Sequence delimitation item into current file position.

This item consists of four byte sequence delimitation tag (0xFFFE, 0xE0DD) and four byte item length (0x00000000), i.e. together 8 bytes.

See also: dcmWriteFileTag, dcmReadFileTag, dcmWriteFileSQItemDelimTag

Returns: 0 when successful.

Author: Vesa Oikonen

Parameters

fp	File pointer, at the write position.

Definition at line 609 of file dcm.c.

  {
  if(fp==NULL) return(1);
  int ret;
  DCMTAG tag; 
  tag.group=0xFFFE; tag.element=0xE0DD;
  ret=dcmWriteFileTag(fp, &tag); if(ret!=0) return(ret);
  tag.group=0x0000; tag.element=0x0000;
  ret=dcmWriteFileTag(fp, &tag); if(ret!=0) return(ret);
  return(0);
}

Referenced by dcmFileWrite().

◆ dcmWriteFileSQItemDelimTag()

int dcmWriteFileSQItemDelimTag ( FILE * fp )

extern

Write DICOM Sequence Item Delimitation Tag with VL into current file position.

This tag consists of four bytes, sequence item delimitation tag (0xFFFE, 0xE00D), followed by four byte item length (0x00000000), i.e. together 8 bytes.

See also: dcmWriteFileTag, dcmReadFileTag, dcmWriteFileSQDelimItem

Returns: 0 when successful.

Author: Vesa Oikonen

Parameters

fp	File pointer, at the write position.

Definition at line 634 of file dcm.c.

  {
  if(fp==NULL) return(1);
  int ret;
  DCMTAG tag; 
  tag.group=0xFFFE; tag.element=0xE00D;
  ret=dcmWriteFileTag(fp, &tag); if(ret!=0) return(ret);
  tag.group=0x0000; tag.element=0x0000;
  ret=dcmWriteFileTag(fp, &tag); if(ret!=0) return(ret);
  return(0);
}

Referenced by dcmFileWrite().

◆ dcmWriteFileTag()

int dcmWriteFileTag	(	FILE *	fp,
		DCMTAG *	tag )

extern

Write DICOM tag into current file position.

See also: dcmWriteFile, dcmReadFileTag

Returns: 0 when successful.

Author: Vesa Oikonen

Parameters

fp	File pointer, at the write position.
tag	Pointer to DICOM tag struct to write.

Definition at line 583 of file dcm.c.

  {
  if(fp==NULL || tag==NULL) return(1);
  unsigned short int buf[2];
  buf[0]=tag->group;
  buf[1]=tag->element;
  if(!little_endian()) swabip(buf, 4); // tag is by default little endian
  if(fwrite(&buf, 2, 2, fp)!=2) return(2);
  return(0);
}

Referenced by dcmFileWrite(), dcmWriteFileSQDelimItem(), and dcmWriteFileSQItemDelimTag().

◆ dcmWriteFileVRVL()

int dcmWriteFileVRVL	(	FILE *	fp,
		dcmvr	vr,
		unsigned int	vl,
		unsigned int *	n )

extern

Write DICOM Value Representation (VR, 2 or 4 bytes) and Value Length (VL, 2 or 4 bytes) into current file position.

See also: dcmWriteFileTag, dcmReadFileElement, dcmWriteFileVRVL

Returns: 0 when successful.

Author: Vesa Oikonen

Parameters

fp	File pointer, opened fro writing in binary mode.
vr	Enumerated VR value.
vl	VL
n	Pointer for number of bytes written into file; enter NULL if not needed.

Definition at line 784 of file dcm.c.

  {
  if(n!=NULL) *n=0;
  if(fp==NULL || vr==DCM_VR_INVALID) return(1);
 
  /* If this VR has extra 2 byte reserved space, then
     we need to write VR and VL with 4 bytes each, other wise with 2 bytes each. */
  unsigned int bsize=2+dcmVRReserved(vr);
 
  char buf[10];
 
  /* Write VR */
  memcpy(buf, dcmVRName(vr), 2); buf[2]=buf[3]=(char)0;
  if(fwrite(buf, bsize, 1, fp)!=1) return(2);
  if(n!=NULL) *n+=bsize;
 
  /* Write VL */
  memcpy(buf, &vl, bsize);
  if(bsize==2) buf[2]=buf[3]=(char)0;
  if(!little_endian()) swap(buf, buf, bsize);
  if(fwrite(buf, bsize, 1, fp)!=1) return(2);
  if(n!=NULL) *n+=bsize;
 
  return(0);
}

Referenced by dcmFileWrite().

◆ ecat63_is_scaling_needed()

int ecat63_is_scaling_needed	(	float	amax,
		float *	data,
		long long	nr )

extern

Check if pixel float values need to be scaled to be saved as short ints, or if they are already all very close to integers.

Returns: 1 if scaling is necessary, and 0 if not.

Parameters

amax	Absolute maximum value.
data	Float array.
nr	Number of float values in float array.

Definition at line 662 of file ecat63w.c.

  {
  double d;
 
  if(nr<1 || data==NULL) return(0);
  /* scaling is necessary if all values are between -1 - 1 */
  if(amax<0.9999) return(1);
  /* Lets check first if at least the max value is close to integers or not */
  if(modf(amax, &d)>0.0001) return(1);
  /* if it is, then check all pixels */
  for(long long i=0; i<nr; i++) if(modf(*data++, &d)>0.0001) return(1);
  return(0);
}

Referenced by ecat63WriteImageMatrix(), and ecat63WriteScanMatrix().

◆ ecat63AddImg()

int ecat63AddImg	(	const char *	fname,
		IMG *	img )

extern

Adds all matrices in memory to the ECAT file. If ECAT file does not exist, it is created.

Please note that existing ECAT file is NOT saved as bak file.

Returns: 0 if ok, 1 invalid input, 2 image status is not 'occupied', 3 failed to open file for reading, 4 failed to allocate memory for data, 9 failed to write data, 21 invalid matrix list, 22 failed to write main header

Parameters

fname	Name of the output ECAT 6.3 file.
img	Pointer to data structure from which the data is written.

Definition at line 878 of file img_e63.c.

  {
  int                 n, m, ret=0, add=0;
  int                 frameNr, planeNr;
  int                 frame, plane, prev_plane;
  float               f, fmax, fmin, g, scale;
  short int          *sdata, *sptr, smin, smax;
  FILE               *fp;
  ECAT63_mainheader   main_header;
  ECAT63_imageheader  image_header;
  ECAT63_scanheader   scan_header;
  MATRIXLIST          mlist;
  MatDir              tmpMatdir;
  Matval              matval;
  struct tm           tm;
 
  if(IMG_TEST) printf("ecat63AddImg(%s, *img)\n", fname);
  if(IMG_TEST>4) imgInfo(img);
  /* Check the arguments */
  if(fname==NULL) {strcpy(ecat63errmsg, "invalid ECAT filename"); return(1);}
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    strcpy(ecat63errmsg, "image data is empty"); return(2);}
  if(img->_dataType<1) img->_dataType=VAX_I2;
 
  /* Check image size */
  if(img->dimt>511 || img->dimz>255 || img->dimx>1024 || img->dimy>1024) {
    strcpy(ecat63errmsg, "too large matrix size"); return(2);}
 
  /* Initiate headers */
  memset(&main_header, 0, sizeof(ECAT63_mainheader));
  memset(&image_header,0, sizeof(ECAT63_imageheader));
  memset(&scan_header, 0, sizeof(ECAT63_scanheader));
 
  /* Make a main header */
  main_header.sw_version=2;
  main_header.num_planes=img->dimz;  
  main_header.num_frames=img->dimt;  
  main_header.num_gates=1;
  main_header.num_bed_pos=1;
  if(img->type==IMG_TYPE_IMAGE) main_header.file_type=IMAGE_DATA;
  else if(img->type==IMG_TYPE_RAW) main_header.file_type=RAW_DATA;
  else {strcpy(ecat63errmsg, "invalid filetype"); return(1);}
  main_header.data_type=img->_dataType;
  if(img->scanner>0) main_header.system_type=img->scanner;
  else main_header.system_type=ECAT63_SYSTEM_TYPE_DEFAULT;
  main_header.calibration_factor=1.0;
  main_header.axial_fov=img->axialFOV/10.0;
  main_header.transaxial_fov=img->transaxialFOV/10.0;
  main_header.plane_separation=img->sizez/10.0;
  main_header.calibration_units=imgUnitToEcat6(img);
  strncpy(main_header.radiopharmaceutical, img->radiopharmaceutical, 32);
  if(gmtime_r((time_t*)&img->scanStart, &tm)!=NULL) {
    main_header.scan_start_year=tm.tm_year+1900;
    main_header.scan_start_month=tm.tm_mon+1;
    main_header.scan_start_day=tm.tm_mday;
    main_header.scan_start_hour=tm.tm_hour;
    main_header.scan_start_minute=tm.tm_min;
    main_header.scan_start_second=tm.tm_sec;
    if(IMG_TEST>2) {
      printf("  img->scanStart := %ld\n", (long int)img->scanStart);
      printf("  -> tm_year := %d\n", tm.tm_year);
      printf("  -> tm_hour := %d\n", tm.tm_hour);
    } 
  } else {
    main_header.scan_start_year=1900;
    main_header.scan_start_month=1;
    main_header.scan_start_day=1;
    main_header.scan_start_hour=0;
    main_header.scan_start_minute=0;
    main_header.scan_start_second=0;
    if(IMG_TEST>0) printf("invalid scan_start_time in IMG\n");
  }
  main_header.isotope_halflife=img->isotopeHalflife;
  strcpy(main_header.isotope_code, imgIsotope(img));
  strlcpy(main_header.study_name, img->studyNr, 12);
  strcpy(main_header.patient_name, img->patientName);
  strcpy(main_header.patient_id, img->patientID);
  strlcpy(main_header.study_description, img->studyDescription, 32);
  strlcpy(main_header.user_process_code, img->userProcessCode, 10);
 
  /* Check if the ECAT file exists */
  if(access(fname, 0) != -1) {
    if(IMG_TEST) printf("Opening existing ECAT file.\n");
    add=1;
    /* Open the ECAT file */
    if((fp=fopen(fname, "rb+")) == NULL) {
      strcpy(ecat63errmsg, "cannot create ECAT file"); return(3);}
    /* Read main header */
    if((ret=ecat63ReadMainheader(fp, &main_header))) {
      sprintf(ecat63errmsg, "cannot read main header (%d)", ret);
      fclose(fp); return(3);
    }
    fflush(fp);
    /* Check that filetypes are matching */
    if((main_header.file_type==IMAGE_DATA && img->type==IMG_TYPE_IMAGE) ||
       (main_header.file_type==RAW_DATA && img->type==IMG_TYPE_RAW)) {
      /* ok */
    } else {
      sprintf(ecat63errmsg, "cannot add different filetype");
      fclose(fp); return(3);
    }
  } else {
    if(IMG_TEST) printf("ECAT file does not exist.\n");
    add=0;
    /* Create output ECAT file */
    fp=ecat63Create(fname, &main_header);
    if(fp==NULL) {strcpy(ecat63errmsg, "cannot create ECAT file"); return(3);}
  }
  if(IMG_TEST) ecat63PrintMainheader(&main_header, stdout);
 
  /* Allocate memory for matrix data */
  sdata=(short int*)malloc((size_t)img->dimx*img->dimy*sizeof(short int));
  if(sdata==NULL) {strcpy(ecat63errmsg, "out of memory"); return(4);}
 
  /* Set the subheader contents, as far as possible */
  switch(main_header.file_type) {
    case RAW_DATA:
      scan_header.data_type=main_header.data_type;
      scan_header.dimension_1=img->dimx;
      scan_header.dimension_2=img->dimy;
      scan_header.frame_duration_sec=1;
      scan_header.scale_factor=1.0;
      scan_header.frame_start_time=0;
      scan_header.frame_duration=1000;
      scan_header.loss_correction_fctr=1.0;
      scan_header.sample_distance=(img->sampleDistance)/10.0;
      /*if(IMG_TEST) ecat63PrintScanheader(&scan_header);*/
      break;
    case IMAGE_DATA:
      image_header.data_type=main_header.data_type;
      image_header.num_dimensions=2;
      image_header.dimension_1=img->dimx;
      image_header.dimension_2=img->dimy;
      image_header.recon_scale=img->zoom;
      image_header.quant_scale=1.0;
      image_header.slice_width=img->sizez/10.;
      image_header.pixel_size=img->sizex/10.;
      image_header.frame_start_time=0;
      image_header.frame_duration=1000;
      image_header.plane_eff_corr_fctr=1.0;
      image_header.decay_corr_fctr=0.0;
      image_header.loss_corr_fctr=1.0;
      image_header.ecat_calibration_fctr=1.0;
      image_header.well_counter_cal_fctr=1.0;
      image_header.quant_units=main_header.calibration_units;
      /*if(IMG_TEST) ecat63PrintImageheader(&image_header);*/
      break;
  }
 
  /* Write one matrix at a time */
  n=0;
  for(plane=1; plane<=img->dimz;plane++) for(frame=1;frame<=img->dimt;frame++) {
    /* Scale data to short ints */
    /* Search min and max */
    fmin=fmax=f=img->m[plane-1][0][0][frame-1];
    for(int i=0; i<img->dimy; i++) for(int j=0; j<img->dimx; j++) {
      f=img->m[plane-1][i][j][frame-1];
      if(f>fmax) fmax=f; else if(f<fmin) fmin=f;
    }
    /* Calculate scaling factor */
    if(fabs(fmin)>fabs(fmax)) g=fabs(fmin); else g=fabs(fmax);
    if(!isfinite(g)) {
      sprintf(ecat63errmsg, "invalid pixel values on pl%02d fr%02d (%d).", plane, frame, ret);
      fclose(fp); remove(fname); free(sdata);
      return(1);
    }
    if(g>0.0) scale=32766./g; else scale=1.0;
    if(!isfinite(scale)) scale=1.0;
    /*printf("fmin=%e fmax=%e g=%e scale=%e\n", fmin, fmax, g, scale);*/
    /* Scale matrix data to shorts */
    sptr=sdata;
    for(int i=0; i<img->dimy; i++) for(int j=0; j<img->dimx; j++) {
      *sptr=(short int)temp_roundf(scale*img->m[plane-1][i][j][frame-1]);
      sptr++;
    }
    /* Calculate and set subheader min&max and scale */
    smin=(short int)temp_roundf(scale*fmin);
    smax=(short int)temp_roundf(scale*fmax);
    if(main_header.file_type==RAW_DATA) {
      scan_header.scan_min=smin; scan_header.scan_max=smax;
      scan_header.scale_factor=1.0/scale;
      scan_header.frame_start_time=(int)temp_roundf(1000.*img->start[frame-1]);
      scan_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[frame-1]-img->start[frame-1]));
      scan_header.prompts=temp_roundf(img->prompts[frame-1]);
      scan_header.delayed=temp_roundf(img->randoms[frame-1]);
    } else if(main_header.file_type==IMAGE_DATA) {
      image_header.image_min=smin; image_header.image_max=smax;
      image_header.quant_scale=1.0/scale;
      image_header.frame_start_time=(int)temp_roundf(1000.*img->start[frame-1]);
      image_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[frame-1]-img->start[frame-1]));
      /* Set decay correction factor */
      if(img->decayCorrection==IMG_DC_CORRECTED)
        image_header.decay_corr_fctr=img->decayCorrFactor[frame-1];
      else
        image_header.decay_corr_fctr=0.0;
    } 
    /* Write matrix data */
    m=mat_numcod(frame, img->planeNumber[plane-1], 1, 0, 0);
    sptr=sdata;
    if(IMG_TEST) printf("  writing matnum=%d\n", m);
    if(main_header.file_type==RAW_DATA) {
      /*if(IMG_TEST) ecat63PrintScanheader(&scan_header);*/
      ret=ecat63WriteScan(fp, m, &scan_header, sptr);
    } else if(main_header.file_type==IMAGE_DATA) {
      /*if(IMG_TEST) ecat63PrintImageheader(&image_header);*/
      ret=ecat63WriteImage(fp, m, &image_header, sptr);
    }
    if(ret) {
      sprintf(ecat63errmsg, "cannot write data on pl%02d fr%02d (%d).",
        plane, frame, ret);
      fclose(fp); remove(fname); free(sdata);
      return(9);
    }
    n++;
  } /* next matrix */
  if(IMG_TEST) printf("  %d matrices written in %s\n", n, fname);
 
  /* Free matrix memory */
  free(sdata);
 
  /* If matrices were added, set main header */
  if(add==1) {
    fflush(fp);
    /* Read matrix list */
    ecat63InitMatlist(&mlist);
    ret=ecat63ReadMatlist(fp, &mlist, IMG_TEST);
    if(ret) {
      sprintf(ecat63errmsg, "cannot read matrix list (%d)", ret);
      fclose(fp); return(21);
    }
    if(mlist.matrixNr<=0) {
      strcpy(ecat63errmsg, "matrix list is empty"); fclose(fp); return(21);}
    /* Sort matrix list */
    for(int i=0; i<mlist.matrixNr-1; i++) for(int j=i+1; j<mlist.matrixNr; j++) {
      if(mlist.matdir[i].matnum>mlist.matdir[j].matnum) {
        tmpMatdir=mlist.matdir[i];
        mlist.matdir[i]=mlist.matdir[j]; mlist.matdir[j]=tmpMatdir;
      }
    }
    /* Calculate the number of planes and frames */
    prev_plane=plane=-1; /*prev_frame=frame=-1;*/ frameNr=planeNr=0;
    for(int m=0; m<mlist.matrixNr; m++) {
      mat_numdoc(mlist.matdir[m].matnum, &matval);
      plane=matval.plane; frame=matval.frame;
      if(plane!=prev_plane) {frameNr=1; planeNr++;} else {frameNr++;}
      prev_plane=plane; /*prev_frame=frame;*/
    } /* next matrix */
    ecat63EmptyMatlist(&mlist);
    main_header.num_planes=planeNr; main_header.num_frames=frameNr;
    /* Write main header */
    ret=ecat63WriteMainheader(fp, &main_header);
    if(ret) {
      sprintf(ecat63errmsg, "cannot write mainheader (%d)", ret);
      fclose(fp); return(22);
    }
  }
 
  /* Close file and free memory */
  fclose(fp);
 
  return(0);
}

◆ ecat63CheckMatlist()

int ecat63CheckMatlist ( MATRIXLIST * ml )

extern

Checks that all matrixlist entries have read/write status.

Parameters

ml	matrix list

Returns: 0 if ok, or 1 if an entry is marked as deleted or unfinished.

Definition at line 324 of file ecat63ml.c.

  {
  if(ml==NULL) return(1);
  for(int i=0; i<ml->matrixNr; i++) if(ml->matdir[i].matstat!=1) return(1);
  return(0);
}

Referenced by atnMake(), and ecatFixMatrixlist().

◆ ecat63CopyMainheader()

int ecat63CopyMainheader	(	ECAT63_mainheader *	h1,
		ECAT63_mainheader *	h2 )

extern

Copy ECAT 6.3 main header from one struct into another.

Returns: Returns 0 if ok.

Parameters

h1	Pointer to source header
h2	Pointer to target header

Definition at line 16 of file ecat63h.c.

  {
  int i;
 
  if(h1==NULL || h2==NULL) return(1);
  memset(h2, 0, sizeof(ECAT63_mainheader));
 
  for(i=0; i<14; i++) h2->ecat_format[i]=h1->ecat_format[i];
  for(i=0; i<14; i++) h2->fill1[i]=h1->fill1[i];
  for(i=0; i<20; i++) h2->original_file_name[i]=h1->original_file_name[i];
  h2->sw_version=h1->sw_version;
  h2->data_type=h1->data_type;
  h2->system_type=h1->system_type;
  h2->file_type=h1->file_type;
  for(i=0; i<10; i++) h2->node_id[i]=h1->node_id[i];
  h2->scan_start_day=h1->scan_start_day;
  h2->scan_start_month=h1->scan_start_month;
  h2->scan_start_year=h1->scan_start_year;
  h2->scan_start_hour=h1->scan_start_hour;
  h2->scan_start_minute=h1->scan_start_minute;
  h2->scan_start_second=h1->scan_start_second;
  for(i=0; i<8; i++) h2->isotope_code[i]=h1->isotope_code[i];
  h2->isotope_halflife=h1->isotope_halflife;
  for(i=0; i<32; i++) h2->radiopharmaceutical[i]=h1->radiopharmaceutical[i];
  h2->gantry_tilt=h1->gantry_tilt;
  h2->gantry_rotation=h1->gantry_rotation;
  h2->bed_elevation=h1->bed_elevation;
  h2->rot_source_speed=h1->rot_source_speed;
  h2->wobble_speed=h1->wobble_speed;
  h2->transm_source_type=h1->transm_source_type;
  h2->axial_fov=h1->axial_fov;
  h2->transaxial_fov=h1->transaxial_fov;
  h2->transaxial_samp_mode=h1->transaxial_samp_mode;
  h2->coin_samp_mode=h1->coin_samp_mode;
  h2->axial_samp_mode=h1->axial_samp_mode;
  h2->calibration_factor=h1->calibration_factor;
  h2->calibration_units=h1->calibration_units;
  h2->compression_code=h1->compression_code;
  for(i=0; i<12; i++) h2->study_name[i]=h1->study_name[i];
  for(i=0; i<16; i++) h2->patient_id[i]=h1->patient_id[i];
  for(i=0; i<32; i++) h2->patient_name[i]=h1->patient_name[i];
  h2->patient_sex=h1->patient_sex;
  for(i=0; i<10; i++) h2->patient_age[i]=h1->patient_age[i];
  for(i=0; i<10; i++) h2->patient_height[i]=h1->patient_height[i];
  for(i=0; i<10; i++) h2->patient_weight[i]=h1->patient_weight[i];
  h2->patient_dexterity=h1->patient_dexterity;
  for(i=0; i<32; i++) h2->physician_name[i]=h1->physician_name[i];
  for(i=0; i<32; i++) h2->operator_name[i]=h1->operator_name[i];
  for(i=0; i<32; i++) h2->study_description[i]=h1->study_description[i];
  h2->acquisition_type=h1->acquisition_type;
  h2->bed_type=h1->bed_type;
  h2->septa_type=h1->septa_type;
  for(i=0; i<20; i++) h2->facility_name[i]=h1->facility_name[i];
  h2->num_planes=h1->num_planes;
  h2->num_frames=h1->num_frames;
  h2->num_gates=h1->num_gates;
  h2->num_bed_pos=h1->num_bed_pos;
  h2->init_bed_position=h1->init_bed_position;
  for(i=0; i<15; i++) h2->bed_offset[i]=h1->bed_offset[i];
  h2->plane_separation=h1->plane_separation;
  h2->lwr_sctr_thres=h1->lwr_sctr_thres;
  h2->lwr_true_thres=h1->lwr_true_thres;
  h2->upr_true_thres=h1->upr_true_thres;
  h2->collimator=h1->collimator;
  for(i=0; i<10; i++) h2->user_process_code[i]=h1->user_process_code[i];
  for(i=0; i<20; i++) h2->fill2[i]=h1->fill2[i];
  return(0);
}

Referenced by atnMake().

◆ ecat63CopyScanheader()

int ecat63CopyScanheader	(	ECAT63_scanheader *	h1,
		ECAT63_scanheader *	h2 )

extern

Copy ECAT 6.3 scan sub header from one struct into another.

Returns: Returns 0 if ok.

Parameters

h1	Pointer to source header
h2	Pointer to target header

Definition at line 94 of file ecat63h.c.

  {
  int i;
 
  if(h1==NULL || h2==NULL) return(1);
  memset(h2, 0, sizeof(ECAT63_scanheader));
 
  for(i=0; i<126; i++) h2->fill1[i]=h1->fill1[i];
  h2->data_type=h1->data_type;
  h2->dimension_1=h1->dimension_1;
  h2->dimension_2=h1->dimension_2;
  h2->smoothing=h1->smoothing;
  h2->processing_code=h1->processing_code;
  h2->sample_distance=h1->sample_distance;
  h2->isotope_halflife=h1->isotope_halflife;
  h2->frame_duration_sec=h1->frame_duration_sec;
  h2->gate_duration=h1->gate_duration;
  h2->r_wave_offset=h1->r_wave_offset;
  h2->scale_factor=h1->scale_factor;
  h2->scan_min=h1->scan_min;
  h2->scan_max=h1->scan_max;
  h2->prompts=h1->prompts;
  h2->delayed=h1->delayed;
  h2->multiples=h1->multiples;
  h2->net_trues=h1->net_trues;
  for(i=0; i<16; i++) h2->cor_singles[i]=h1->cor_singles[i];
  for(i=0; i<16; i++) h2->uncor_singles[i]=h1->uncor_singles[i];
  h2->tot_avg_cor=h1->tot_avg_cor;
  h2->tot_avg_uncor=h1->tot_avg_uncor;
  h2->total_coin_rate=h1->total_coin_rate;
  h2->frame_start_time=h1->frame_start_time;
  h2->frame_duration=h1->frame_duration;
  h2->loss_correction_fctr=h1->loss_correction_fctr;
  for(i=0; i<22; i++) h2->fill2[i]=h1->fill2[i];
  return(0);
}

◆ ecat63Create()

FILE * ecat63Create	(	const char *	fname,
		ECAT63_mainheader *	h )

extern

Create a new ECAT 6.3 file and return file pointer or NULL in case of an error. If file exists, it is renamed as fname% if possible. Directory list is written in big endian byte order.

Parameters

fname	file name
h	Ecat 6.3 main header

Returns: opened file pointer, or NULL in case of failure

Definition at line 365 of file ecat63w.c.

  {
  FILE *fp;
  char tmp[FILENAME_MAX];
  int buf[MatBLKSIZE/4];
 
  if(ECAT63_TEST) printf("ecat63Create()\n");
  /* Check the arguments */
  if(fname==NULL || h==NULL) return(NULL);
  /* Check if file exists; backup, if necessary */
  if(access(fname, 0) != -1) {
    strcpy(tmp, fname); strcat(tmp, BACKUP_EXTENSION);
    if(access(tmp, 0) != -1) remove(tmp);
    if(ECAT63_TEST) printf("Renaming %s -> %s\n", fname, tmp);
    rename(fname, tmp);
  }
  /* Open file */
  fp=fopen(fname, "wb+"); if(fp==NULL) return(fp);
  /* Write main header */
  if(ecat63WriteMainheader(fp, h)) return(NULL);
  /* Construct an empty matrix list ; convert to little endian if necessary */
  memset(buf, 0, MatBLKSIZE);  
  buf[0]=31; buf[1]=2; if(!little_endian()) swawbip(buf, MatBLKSIZE);
  /* Write data buffer */
  fseek(fp, (MatFirstDirBlk-1)*MatBLKSIZE, SEEK_SET);
  if(ftell(fp)!=(MatFirstDirBlk-1)*MatBLKSIZE) return(NULL);
  if(fwrite(buf, 4, MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(NULL);
  /* OK, then return file pointer */
  return(fp);
}

Referenced by atnMake(), ecat63AddImg(), ecat63CopyFile(), ecat63WriteAllImg(), and imgWriteEcat63Frame().

◆ ecat63Datatype()

char * ecat63Datatype ( short int dtype )

extern

Return pointer to string describing the ECAT 6.3 data_type

Parameters

dtype data type code

Returns: pointer to static string

Definition at line 218 of file ecat63p.c.

  {
  static char *ecat63_datatype[]={
  /*  0 */  "Unknown",
  /*  1 */  "BYTE_TYPE",
  /*  2 */  "VAX_I2",
  /*  3 */  "VAX_I4",
  /*  4 */  "VAX_R4",
  /*  5 */  "IEEE_R4",
  /*  6 */  "SUN_I2",
  /*  7 */  "SUN_I4",
  /*  8 */  "Unknown",
  /*  9 */  "Unknown"
  };
  if(dtype>=0 && dtype<10) return(ecat63_datatype[dtype]);
  else return(ecat63_datatype[0]);
}

Referenced by ecat63PrintAttnheader(), ecat63PrintImageheader(), ecat63PrintMainheader(), ecat63PrintNormheader(), ecat63PrintScanheader(), and ecat63ReadMainheader().

◆ ecat63DeleteLateFrames()

int ecat63DeleteLateFrames	(	MATRIXLIST *	ml,
		int	frame_nr )

extern

Mark deleted the frames after the specified frame number.

This can be used to delete sum images from the end of dynamic ECAT images.

Parameters

ml	matrix list.
frame_nr	last index not to be marked as deleted.

Returns: number of deleted matrices.

Definition at line 342 of file ecat63ml.c.

  {
  int del_nr=0;
  Matval matval;
 
  for(int i=0; i<ml->matrixNr; i++) {
    mat_numdoc(ml->matdir[i].matnum, &matval);
    if(matval.frame>frame_nr) {del_nr++; ml->matdir[i].matstat=-1;}
  }
  return(del_nr);
}

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), and imgReadEcat63Header().

◆ ecat63EditMHeader()

int ecat63EditMHeader	(	ECAT63_mainheader *	h,
		char *	field,
		char *	value,
		int	verbose )

extern

Edit ECAT 6.3 main header.

Returns: Returns 0, if ok, and 1 or 2, if field name or or value is invalid.

Parameters

h	Pointer to ECAT 6.3 mainheader structure
field	Field name to be changed
value	New value for the field
verbose	Verbose level; if <=0, then nothing is printed into stdout

Definition at line 140 of file ecat63h.c.

  {
//  int yy, mm, dd;
  short int si;
  float f;
 
  if(verbose>0) printf("ecat63EditMHeader('%s', '%s')\n", field, value);
  si=atoi(value); f=atof(value);
 
  if(strcmp(field, "ecat_format")==0 || strcmp(field, "magic_number")==0) {
    strlcpy(h->ecat_format, value, 14);
  } else if(strcmp(field, "fill1")==0) {
    strlcpy(h->fill1, value, 14);
  } else if(strcmp(field, "original_file_name")==0) {
    strlcpy(h->original_file_name, value, 20);
  } else if(strcmp(field, "sw_version")==0) {
    if(si<=0) return(2); else h->sw_version=si;
  } else if(strcmp(field, "data_type")==0) {
    if(si<0) return(2); else h->data_type=si;
  } else if(strcmp(field, "system_type")==0) {
    if(si<0) return(2); else h->system_type=si;
  } else if(strcmp(field, "file_type")==0) {
    if(si<0) return(2); else h->file_type=si;
  } else if(strcmp(field, "node_id")==0 || strcmp(field, "serial_number")==0) {
    strlcpy(h->node_id, value, 10);
  } else if(strcmp(field, "scan_start_day")==0) {
    if(si<0) return(2); else h->scan_start_day=si;
  } else if(strcmp(field, "scan_start_month")==0) {
    if(si<0) return(2); else h->scan_start_month=si;
  } else if(strcmp(field, "scan_start_year")==0) {
    if(si<0) return(2); else h->scan_start_year=si;
  } else if(strcmp(field, "scan_start_hour")==0) {
    if(si<0) return(2); else h->scan_start_hour=si;
  } else if(strcmp(field, "scan_start_minute")==0) {
    if(si<0) return(2); else h->scan_start_minute=si;
  } else if(strcmp(field, "scan_start_second")==0) {
    if(si<0) return(2); else h->scan_start_second=si;
  } else if(strcmp(field, "scan_start_time")==0) {
    int YYYY, MM, DD, hh, mm, ss, n;
    n=sscanf(value, "%d-%d-%d %d:%d:%d", &YYYY, &MM, &DD, &hh, &mm, &ss);
    if(n!=6 && n!=3) return(2);
    h->scan_start_year=YYYY;
    h->scan_start_month=MM;
    h->scan_start_day=DD;
    if(n==6) {
      h->scan_start_hour=hh;
      h->scan_start_minute=mm;
      h->scan_start_second=ss;
    }
  } else if(strcmp(field, "isotope_code")==0 || strcmp(field, "isotope_name")==0) {
    strlcpy(h->isotope_code, value, 8);
  } else if(strcmp(field, "isotope_halflife")==0) {
    if(f<=1.0E-3) return(2); else h->isotope_halflife=f;
  } else if(strcmp(field, "radiopharmaceutical")==0) {
    strlcpy(h->radiopharmaceutical, value, 32);
  } else if(strcmp(field, "gantry_tilt")==0) {
    h->gantry_tilt=f;
  } else if(strcmp(field, "gantry_rotation")==0) {
    h->gantry_rotation=f;
  } else if(strcmp(field, "bed_elevation")==0) {
    h->bed_elevation=f;
  } else if(strcmp(field, "rot_source_speed")==0) {
    h->rot_source_speed=si;
  } else if(strcmp(field, "wobble_speed")==0) {
    h->wobble_speed=si;
  } else if(strcmp(field, "transm_source_type")==0) {
    h->transm_source_type=si;
  } else if(strcmp(field, "axial_fov")==0) {
    h->axial_fov=f;
  } else if(strcmp(field, "transaxial_fov")==0) {
    h->transaxial_fov=f;
  } else if(strcmp(field, "transaxial_samp_mode")==0) {
    h->transaxial_samp_mode=si;
  } else if(strcmp(field, "coin_samp_mode")==0) {
    h->coin_samp_mode=si;
  } else if(strcmp(field, "axial_samp_mode")==0) {
    h->axial_samp_mode=si;
  } else if(strcmp(field, "calibration_factor")==0) {
    h->calibration_factor=f;
  } else if(strcmp(field, "calibration_units")==0) {
    h->calibration_units=si;
  } else if(strcmp(field, "compression_code")==0) {
    h->compression_code=si;
  } else if(strcmp(field, "study_name")==0) {
    strlcpy(h->study_name, value, 12);
  } else if(strcmp(field, "patient_id")==0) {
    strlcpy(h->patient_id, value, 16);
  } else if(strcmp(field, "patient_name")==0) {
    strlcpy(h->patient_name, value, 32);
  } else if(strcmp(field, "patient_sex")==0) {
    h->patient_sex=value[0];
  } else if(strcmp(field, "patient_age")==0) {
    strlcpy(h->patient_name, value, 10);
  } else if(strcmp(field, "patient_height")==0) {
    strlcpy(h->patient_height, value, 10);
  } else if(strcmp(field, "patient_weight")==0) {
    strlcpy(h->patient_weight, value, 10);
  } else if(strcmp(field, "patient_dexterity")==0) {
    h->patient_dexterity=value[0];
  } else if(strcmp(field, "physician_name")==0) {
    strlcpy(h->physician_name, value, 32);
  } else if(strcmp(field, "operator_name")==0) {
    strlcpy(h->operator_name, value, 32);
  } else if(strcmp(field, "study_description")==0) {
    strlcpy(h->study_description, value, 32);
  } else if(strcmp(field, "acquisition_type")==0) {
    h->acquisition_type=si;
  } else if(strcmp(field, "bed_type")==0) {
    h->bed_type=si;
  } else if(strcmp(field, "septa_type")==0) {
    h->septa_type=si;
  } else if(strcmp(field, "facility_name")==0) {
    strlcpy(h->facility_name, value, 20);
  } else if(strcmp(field, "num_planes")==0) {
    h->num_planes=si;
  } else if(strcmp(field, "num_frames")==0) {
    h->num_frames=si;
  } else if(strcmp(field, "num_gates")==0) {
    h->num_gates=si;
  } else if(strcmp(field, "num_bed_pos")==0) {
    h->num_bed_pos=si;
  } else if(strcmp(field, "init_bed_position")==0) {
    h->init_bed_position=f;
  } else if(strcmp(field, "bed_offset")==0) {
    sscanf(value, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
      h->bed_offset+0, h->bed_offset+1, h->bed_offset+2,
      h->bed_offset+3, h->bed_offset+4, h->bed_offset+5,
      h->bed_offset+6, h->bed_offset+7, h->bed_offset+8,
      h->bed_offset+9, h->bed_offset+10, h->bed_offset+11,
      h->bed_offset+12, h->bed_offset+13, h->bed_offset+14
    );
  } else if(strcmp(field, "plane_separation")==0) {
    h->plane_separation=f;
  } else if(strcmp(field, "lwr_sctr_thres")==0) {
    h->lwr_sctr_thres=si;
  } else if(strcmp(field, "lwr_true_thres")==0) {
    h->lwr_true_thres=si;
  } else if(strcmp(field, "upr_true_thres")==0) {
    h->upr_true_thres=si;
  } else if(strcmp(field, "collimator")==0) {
    h->collimator=f;
  } else if(strcmp(field, "user_process_code")==0) {
    strlcpy(h->user_process_code, value, 10);
  } else if(strcasecmp(field, "FILL2")==0) {
    char *cptr;
    cptr=strtok(value, " \t,;\n\r");
    for(int i=0; i<20; i++) {
      if(cptr==NULL) break;
      h->fill2[i]=(short int)atoi(cptr);
      cptr=strtok(NULL, " \t,;\n\r");
    }
  } else
    return(1);
 
  return(0);
}

◆ ecat63EmptyMatlist()

void ecat63EmptyMatlist ( MATRIXLIST * mlist )

extern

Free memory allocated for ECAT matrix list

Parameters

mlist matrix list

Definition at line 31 of file ecat63ml.c.

                                           {
  if(mlist->matrixSpace>0) free((char*)(mlist->matdir));
  mlist->matrixSpace=mlist->matrixNr=0;
}

Referenced by atnMake(), ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadMatlist(), ecat63ReadPlaneToImg(), ecat6PrintSubheader(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ ecat63GatherMatlist()

int ecat63GatherMatlist	(	MATRIXLIST *	ml,
		short int	do_planes,
		short int	do_frames,
		short int	do_gates,
		short int	do_beds )

extern

Matrix numbers in ECAT 6.3 matrix list are edited, when necessary, so that plane, frame, gate and/or bed numbers are continuous, starting from one (planes, frames and gates) or from zero (beds). List order is not changed.

Parameters

ml	ECAT 6.3 matrix list, where the matrix numbers will be edited
do_planes	Plane numbers are gathered together (1) or not (0)
do_frames	Frame numbers are gathered together (1) or not (0)
do_gates	Gate numbers are gathered together (1) or not (0)
do_beds	Bed numbers are gathered together (1) or not (0)

Returns: 0 if successful, 1 if invalid input, 3 failed to allocate memory

Definition at line 510 of file ecat63ml.c.

  {
  int i, ncurr, n;
  Matval* matval;
 
  if(ml==NULL) return(1);
  if(ml->matrixNr<1) return(0);
 
  /* Allocate memory for matrix values */
  matval = (Matval*)calloc(ml->matrixNr,sizeof(Matval));
  if(matval == NULL) return(3);
 
  /* And get the matrix values */
  for(i=0; i<ml->matrixNr; i++) mat_numdoc(ml->matdir[i].matnum, matval+i);
 
  /* Planes */
  if(do_planes!=0) {
    ncurr=1;
    while(ncurr <= ml->matrixNr) {
      /* Find any matrix with this number? */
      for(i=0, n=0; i<ml->matrixNr; i++) if(matval[i].plane==ncurr) {n=1; break;}
      /* If yes, then go on to the next matrix number */
      if(n==1) {ncurr++; continue;}
      /* If not, then subtract 1 from all matrix numbers that are larger */
      for(i=0, n=0; i<ml->matrixNr; i++)
        if(matval[i].plane>ncurr) {
          matval[i].plane--; n++;
        }
      /* If no larger values were found any more, then quit */
      if(n<1) break;
    }
  }
 
  /* Frames */
  if(do_frames!=0) {
    ncurr=1;
    while(ncurr <= ml->matrixNr) {
      /* Find any matrix with this number? */
      for(i=0, n=0; i<ml->matrixNr; i++) if(matval[i].frame==ncurr) {n=1; break;}
      /* If yes, then go on to the next matrix number */
      if(n==1) {ncurr++; continue;}
      /* If not, then subtract 1 from all matrix numbers that are larger */
      for(i=0, n=0; i<ml->matrixNr; i++)
        if(matval[i].frame>ncurr) {matval[i].frame--; n++;}
      /* If no larger values were found any more, then quit */
      if(n<1) break;
    }
  }
 
  /* Gates */
  if(do_gates!=0) {
    ncurr=1;
    while(ncurr <= ml->matrixNr) {
      /* Find any matrix with this number? */
      for(i=0, n=0; i<ml->matrixNr; i++) if(matval[i].gate==ncurr) {n=1; break;}
      /* If yes, then go on to the next matrix number */
      if(n==1) {ncurr++; continue;}
      /* If not, then subtract 1 from all matrix numbers that are larger */
      for(i=0, n=0; i<ml->matrixNr; i++)
        if(matval[i].gate>ncurr) {matval[i].gate--; n++;}
      /* If no larger values were found any more, then quit */
      if(n<1) break;
    }
  }
 
  /* Beds */
  if(do_beds!=0) {
    ncurr=1;
    while(ncurr <= ml->matrixNr) {
      /* Find any matrix with this number? */
      for(i=0, n=0; i<ml->matrixNr; i++) if(matval[i].bed==ncurr) {n=1; break;}
      /* If yes, then go on to the next matrix number */
      if(n==1) {ncurr++; continue;}
      /* If not, then subtract 1 from all matrix numbers that are larger */
      for(i=0, n=0; i<ml->matrixNr; i++)
        if(matval[i].bed>ncurr) {matval[i].bed--; n++;}
      /* If no larger values were found any more, then quit */
      if(n<1) break;
    }
  }
 
  /* Write matrix values (possibly changed) into matrix list */
  for(i=0; i<ml->matrixNr; i++) ml->matdir[i].matnum=mat_numcod(
            matval[i].frame, matval[i].plane,
            matval[i].gate, matval[i].data,
            matval[i].bed);
  free(matval);
  return(0);
}

Referenced by ecatFixMatrixlist(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ ecat63GetMatrixBlockSize()

int ecat63GetMatrixBlockSize	(	MATRIXLIST *	mlist,
		int *	blk_nr )

extern

Calculate the size of one data matrix in ECAT 6.3 file matrix list, and check that the size is same in all matrices.

Parameters

mlist	Ecat 6.3 matrix list; note that this list is here sorted by planes
blk_nr	Number of blocks will be put here; NULL if not needed

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 366 of file ecat63ml.c.

  {
  int m, prev_blk, blk;
 
  /* Check input */
  if(mlist==NULL) return STATUS_FAULT;
  if(blk_nr!=NULL) *blk_nr=0;
 
  /* Calculate the size of first data matrix */
  m=0; prev_blk=blk=mlist->matdir[m].endblk - mlist->matdir[m].strtblk;
  for(m=1; m<mlist->matrixNr; m++) {
    blk=mlist->matdir[m].endblk - mlist->matdir[m].strtblk;
    if(blk!=prev_blk) return STATUS_VARMATSIZE;
    else prev_blk=blk;
  }
  if(blk_nr!=NULL) *blk_nr=blk;
  return STATUS_OK;
}

Referenced by imgReadEcat63Frame(), and imgReadEcat63Header().

◆ ecat63GetNums()

int ecat63GetNums	(	MATRIXLIST *	ml,
		short int *	num_planes,
		short int *	num_frames,
		short int *	num_gates,
		short int *	num_bed_pos )

extern

Read the maximum plane, frame, gate and bed number from matrixlist.

Parameters

ml	Pointer to matrixlist
num_planes	number of planes will be put here; NULL if not needed
num_frames	number of frames will be put here; NULL if not needed
num_gates	number of gates will be put here; NULL if not needed
num_bed_pos	number of gates will be put here; NULL if not needed

Returns: 0 if successful, 1 no matrix list, 2 invalid matrix number, 3 failed to allocate memory

Definition at line 450 of file ecat63ml.c.

  {
  int i, nmax;
  Matval* matval;
 
  if(ml==NULL) return(1);
  if(ml->matrixNr<1) return(2);
 
  /* Allocate memory for matrix values */
  matval = (Matval*)calloc(ml->matrixNr,sizeof(Matval));
  if(matval == NULL) return(3);
 
  /* And get the matrix values */
  for(i=0; i<ml->matrixNr; i++) mat_numdoc(ml->matdir[i].matnum, matval+i);
 
  /* Planes */
  if(num_planes!=NULL) {
    nmax=matval[0].plane;
    for(i=1; i<ml->matrixNr; i++) if(matval[i].plane>nmax) nmax=matval[i].plane;
    *num_planes=nmax;
  }
  /* Frames */
  if(num_frames!=NULL) {
    nmax=matval[0].frame;
    for(i=1; i<ml->matrixNr; i++) if(matval[i].frame>nmax) nmax=matval[i].frame;
    *num_frames=nmax;
  }
  /* Gates */
  if(num_gates!=NULL) {
    nmax=matval[0].gate;
    for(i=1; i<ml->matrixNr; i++) if(matval[i].gate>nmax) nmax=matval[i].gate;
    *num_gates=nmax;
  }
  /* Beds */
  if(num_bed_pos!=NULL) {
    nmax=matval[0].bed;
    for(i=1; i<ml->matrixNr; i++) if(matval[i].bed>nmax) nmax=matval[i].bed;
    *num_bed_pos=nmax;
  }
  free(matval);
  return(0);
}

Referenced by ecatFixMatrixlist().

◆ ecat63GetPlaneAndFrameNr()

int ecat63GetPlaneAndFrameNr	(	MATRIXLIST *	mlist,
		ECAT63_mainheader *	h,
		int *	plane_nr,
		int *	frame_nr )

extern

Calculate the number of planes and frames/gates from ECAT 6.3 matrix list. Check that all planes have equal nr of frames/gates, that frames/gates are sequentially numbered. This routines sorts the matrix list by planes.

Parameters

mlist	Ecat 6.3 matrix list; note that this list is here sorted by planes
h	Ecat 6.3 mainheader
plane_nr	Number of planes will be put here; NULL if not needed
frame_nr	Number of frames/gates will be put here; NULL if not needed

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 400 of file ecat63ml.c.

  {
  Matval matval;
  int m, plane, frame, prev_plane, prev_frame, fnr, pnr;
 
  /* Check input */
  if(mlist==NULL) return STATUS_FAULT;
  if(plane_nr!=NULL) *plane_nr=0;
  if(frame_nr!=NULL) *frame_nr=0;
 
  /* Sort matrices by plane so that following computation works */
  ecat63SortMatlistByPlane(mlist);
 
  prev_plane=plane=-1; prev_frame=frame=-1;
  fnr=pnr=0;
  for(m=0; m<mlist->matrixNr; m++) if(mlist->matdir[m].matstat==1) {
    mat_numdoc(mlist->matdir[m].matnum, &matval);
    plane=matval.plane;
    if(h->num_frames>=h->num_gates)
      frame=matval.frame;
    else
      frame=matval.gate;
    if(plane!=prev_plane) {
      fnr=1; pnr++;
    } else {
      fnr++;
      if(prev_frame>0 && frame!=prev_frame+1) return STATUS_MISSINGMATRIX;
    }
    prev_plane=plane; prev_frame=frame;
  } /* next matrix */
  if(fnr*pnr != mlist->matrixNr) return STATUS_MISSINGMATRIX;
  if(plane_nr!=NULL) *plane_nr=pnr;
  if(frame_nr!=NULL) *frame_nr=fnr;
  return STATUS_OK;
}

Referenced by imgReadEcat63Header().

◆ ecat63InitMatlist()

void ecat63InitMatlist ( MATRIXLIST * mlist )

extern

Initiate ECAT matrix list. Call this once before first use.

Parameters

mlist matrix list

Definition at line 20 of file ecat63ml.c.

                                          {
  mlist->matrixSpace=mlist->matrixNr=0; mlist->matdir=NULL;
}

Referenced by atnMake(), ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat6PrintSubheader(), ecatFixMatrixlist(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ ecat63Matenter()

int ecat63Matenter	(	FILE *	fp,
		int	matnum,
		int	blkNr )

extern

Prepare matrix list for additional matrix data and Directory records are written in big endian byte order. Set block_nr to the number of data blocks excluding header;

Parameters

fp	file pointer
matnum	matrix number [1..number of matrices]
blkNr	matrix block number [ >= 1]

Returns: block number for matrix header, or 0 in case of an error.

Definition at line 159 of file ecat63ml.c.

  {
  unsigned int i=0, dirblk, little, busy=1, nxtblk=0, oldsize;
  unsigned int dirbuf[MatBLKSIZE/4];
 
  if(ECAT63_TEST) printf("ecat63Matenter(fp, %d, %d)\n", matnum, blkNr);
  if(fp==NULL || matnum<1 || blkNr<1) return(0);
  little=little_endian(); memset(dirbuf, 0, MatBLKSIZE);
  /* Read first matrix list block */
  dirblk=MatFirstDirBlk;
  fseeko(fp, (dirblk-1)*MatBLKSIZE, SEEK_SET);
  if(ftello(fp)!=(int)(dirblk-1)*MatBLKSIZE) return(0);
  if(fread(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(0);
  /* Byte order conversion for ints in big endian platforms */
  if(!little) swawbip(dirbuf, MatBLKSIZE);
 
  while(busy) {
    nxtblk=dirblk+1;
    for(i=4; i<MatBLKSIZE/4; i+=4) {
      if(dirbuf[i]==0) {  /* Check for end of matrix list */
        busy=0; break;
      } else if(dirbuf[i]==(unsigned int)matnum) {  /* Check if this matrix already exists */
        oldsize=dirbuf[i+2]-dirbuf[i+1]+1;
        if(oldsize<(unsigned int)blkNr) {  /* If old matrix is smaller */
          dirbuf[i] = 0xFFFFFFFF;
          if(!little) swawbip(dirbuf, MatBLKSIZE);
          fseeko(fp, (dirblk-1)*MatBLKSIZE, SEEK_SET);
          if(ftello(fp)!=(int)(dirblk-1)*MatBLKSIZE) return(0);
          if(fwrite(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(0);
          if(!little) swawbip(dirbuf, MatBLKSIZE);
          nxtblk=dirbuf[i+2]+1;
        } else { /* old matrix size is ok */
          nxtblk=dirbuf[i+1]; dirbuf[0]++; dirbuf[3]--; busy=0;
          break;
        }
      } else  /* not this one */
        nxtblk=dirbuf[i+2]+1;
    }
    if(!busy) break;
    if(dirbuf[1]!=MatFirstDirBlk) {
      dirblk=dirbuf[1];
      fseeko(fp, (dirblk-1)*MatBLKSIZE, SEEK_SET);
      if(ftello(fp)!=(int)(dirblk-1)*MatBLKSIZE) return(0);
      if(fread(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(0);
      if(!little) swawbip(dirbuf, MatBLKSIZE);
    } else {
      dirbuf[1]=nxtblk;
      if(!little) swawbip(dirbuf, MatBLKSIZE);
      fseeko(fp, (dirblk-1)*MatBLKSIZE, SEEK_SET);
      if(ftello(fp)!=(int)(dirblk-1)*MatBLKSIZE) return(0);
      if(fwrite(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(0);
      dirbuf[0]=31; dirbuf[1]=MatFirstDirBlk; dirbuf[2]=dirblk;
      dirbuf[3]=0; dirblk=nxtblk;
      for(i=4; i<MatBLKSIZE/4; i++) dirbuf[i]=0;
    }
  }
  dirbuf[i]=matnum;
  dirbuf[i+1]=nxtblk;
  dirbuf[i+2]=nxtblk+blkNr;
  dirbuf[i+3]=1;
  dirbuf[0]--;
  dirbuf[3]++;
  if(!little) swawbip(dirbuf, MatBLKSIZE);
  fseeko(fp, (dirblk-1)*MatBLKSIZE, SEEK_SET); 
  if(ftello(fp)!=(int)(dirblk-1)*MatBLKSIZE) return(0);
  if(fwrite(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(0);
  if(ECAT63_TEST) printf("returning %d from ecat63Matenter()\n", nxtblk);
  return(nxtblk);
}

Referenced by ecat63CopyFile(), ecat63WriteAttn(), ecat63WriteImage(), ecat63WriteImageMatrix(), ecat63WriteNorm(), ecat63WriteScan(), and ecat63WriteScanMatrix().

◆ ecat63PrintAttnheader()

void ecat63PrintAttnheader	(	ECAT63_attnheader *	h,
		FILE *	fp )

extern

Print ECAT 6.3 attnheader contents to specified file pointer

Parameters

h	Ecat 6.3 attenuation header
fp	target file pointer

Definition at line 173 of file ecat63p.c.

  {
  if(ECAT63_TEST) printf("ecat63PrintAttnheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type, ecat63Datatype(h->data_type));
  fprintf(fp, "dimension_1 := %d\n", h->dimension_1);
  fprintf(fp, "dimension_2 := %d\n", h->dimension_2);
  fprintf(fp, "sample_distance := %g cm\n", h->sample_distance);
  fprintf(fp, "attenuation_type := %d\n", h->attenuation_type);
  fprintf(fp, "scale_factor := %g\n", h->scale_factor);
  fprintf(fp, "x_origin := %g\ny_origin := %g\nx_radius := %g\ny_radius := %g\n",
    h->x_origin, h->y_origin, h->x_radius, h->y_radius);
  fprintf(fp, "tilt_angle := %g\nattenuation_coeff := %g\n",
    h->tilt_angle, h->attenuation_coeff);
}

Referenced by ecat63ReadAttnMatrix(), and ecat6PrintSubheader().

◆ ecat63PrintImageheader()

void ecat63PrintImageheader	(	ECAT63_imageheader *	h,
		FILE *	fp )

extern

Print ECAT 6.3 imageheader contents to specified file pointer

Parameters

h	Ecat 6.3 image header
fp	target file pointer

Definition at line 94 of file ecat63p.c.

  {
  if(ECAT63_TEST) printf("ecat63PrintImageheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type, ecat63Datatype(h->data_type));
  fprintf(fp, "dimension_1 := %d\n", h->dimension_1);
  fprintf(fp, "dimension_2 := %d\n", h->dimension_2);
  fprintf(fp, "x_origin := %g\ny_origin := %g\nrecon_scale := %g\n",
    h->x_origin, h->y_origin, h->recon_scale);
  fprintf(fp, "quant_scale := %g\nimage_min := %d\nimage_max := %d\n",
    h->quant_scale, h->image_min, h->image_max);
  fprintf(fp, "slice_width := %g\npixel_size := %g\n", h->slice_width, h->pixel_size);
  fprintf(fp, "frame_start_time := %d\nframe_duration := %d\n",
    h->frame_start_time, h->frame_duration );
/*
  fprintf(fp, "reconstruction_start := %02d.%02d.%04d %02d:%02d:%02d\n",
    h->recon_start_day, h->recon_start_month, h->recon_start_year,
    h->recon_start_hour, h->recon_start_min, h->recon_start_sec);
*/
  fprintf(fp, "reconstruction_start := %04d-%02d-%02d %02d:%02d:%02d\n",
    h->recon_start_year, h->recon_start_month, h->recon_start_day,
    h->recon_start_hour, h->recon_start_min, h->recon_start_sec);
  fprintf(fp, "filter_code := %d\nimage_rotation := %g\nintrinsic_tilt := %g\n",
    h->filter_code, h->image_rotation, h->intrinsic_tilt);
  fprintf(fp, "filter_params :=");
  for(int i=0; i<6; i++) fprintf(fp, " %g", h->filter_params[i]);
  fprintf(fp, "\n");
  fprintf(fp, "plane_eff_corr_fctr := %g\ndecay_corr_fctr := %g\nloss_corr_fctr := %g\n",
    h->plane_eff_corr_fctr, h->decay_corr_fctr, h->loss_corr_fctr);
  fprintf(fp, "quant_units := %d (%s)\n", h->quant_units, ecat63Unit(h->quant_units));
  fprintf(fp, "ecat_calibration_fctr := %g\nwell_counter_cal_fctr := %g\n",
    h->ecat_calibration_fctr, h->well_counter_cal_fctr);
  fprintf(fp, "annotation := %.40s\n", h->annotation);
}

Referenced by ecat63ReadImageMatrix(), ecat63WriteAllImg(), and ecat6PrintSubheader().

◆ ecat63PrintMainheader()

void ecat63PrintMainheader	(	ECAT63_mainheader *	h,
		FILE *	fp )

extern

Print ECAT 6.3 mainheader contents to specified file pointer.

Parameters

h	Ecat 6.3 main header
fp	file pointer

Definition at line 16 of file ecat63p.c.

  {
  char tmp[32];
 
  if(ECAT63_TEST) fprintf(stdout, "ecat63PrintMainheader()\n");
 
  fprintf(fp, "original_file_name := %.20s\n", h->original_file_name);
  fprintf(fp, "sw_version := %d\n", h->sw_version);
  fprintf(fp, "data_type := %d (%s)\n", 
          h->data_type, ecat63Datatype(h->data_type));
  fprintf(fp, "system_type := %d\n", h->system_type);
  if(h->file_type==1) strcpy(tmp, "sinogram");
  else if(h->file_type==2) strcpy(tmp, "image");
  else if(h->file_type==3) strcpy(tmp, "attenuation");
  else if(h->file_type==4) strcpy(tmp, "normalization");
  else strcpy(tmp, "unknown");
  fprintf(fp, "file_type := %d (%s)\n", h->file_type, tmp);
  fprintf(fp, "scan_start_time := %04d-%02d-%02d %02d:%02d:%02d\n",
          h->scan_start_year, h->scan_start_month, h->scan_start_day, 
          h->scan_start_hour, h->scan_start_minute, h->scan_start_second);
/*
  fprintf(fp, "scan start := %02d.%02d.%04d %02d:%02d:%02d\n",
    h->scan_start_day, h->scan_start_month, h->scan_start_year,
    h->scan_start_hour, h->scan_start_minute, h->scan_start_second);
*/
  fprintf(fp, "isotope_code := %.8s\n", h->isotope_code);
  fprintf(fp, "isotope_halflife := %E sec\n", h->isotope_halflife);
  fprintf(fp, "radiopharmaceutical := %.32s\n", h->radiopharmaceutical);
  fprintf(fp, "gantry_tilt := %g\n", h->gantry_tilt);
  fprintf(fp, "gantry_rotation := %g\n", h->gantry_rotation);
  fprintf(fp, "bed_elevation := %g\n", h->bed_elevation);
  fprintf(fp, "axial_fov := %g\n", h->axial_fov);
  fprintf(fp, "transaxial_fov := %g\n", h->transaxial_fov);
  fprintf(fp, "calibration_factor := %g\n", h->calibration_factor);
  fprintf(fp, "calibration_units := %d (%s)\n", 
               h->calibration_units, ecat63Unit(h->calibration_units));
  fprintf(fp, "study_name := %.12s\n", h->study_name);
  fprintf(fp, "patient_id := %.32s\n", h->patient_id);
  fprintf(fp, "patient_name := %.32s\n", h->patient_name);
 
  if(isalnum(h->patient_sex))
    fprintf(fp, "patient_sex := %c\n", h->patient_sex);
  else fprintf(fp, "patient_sex := \n");
 
  fprintf(fp, "patient_age := %.10s\n", h->patient_age);
  fprintf(fp, "patient_height := %.10s\n", h->patient_height);
  fprintf(fp, "patient_weigth := %.10s\n", h->patient_weight);
 
  if(isalnum(h->patient_dexterity))
    fprintf(fp, "patient_dexterity := %c\n", h->patient_dexterity);
  else fprintf(fp, "patient_dexterity := \n");
 
  fprintf(fp, "physician_name := %.32s\n", h->physician_name);
  fprintf(fp, "operator_name := %.32s\n", h->operator_name);
  fprintf(fp, "study_description := %.32s\n", h->study_description);
  fprintf(fp, "acquisition_type := %d\n", h->acquisition_type);
  fprintf(fp, "bed_type := %d\n", h->bed_type);
  fprintf(fp, "septa_type := %d\n", h->septa_type);
  fprintf(fp, "facility_name := %.20s\n", h->facility_name);
 
  fprintf(fp, "num_planes := %d\n", h->num_planes);
  fprintf(fp, "num_frames := %d\n", h->num_frames);
  fprintf(fp, "num_gates := %d\n", h->num_gates);
  fprintf(fp, "num_bed_pos := %d\n", h->num_bed_pos);
  fprintf(fp, "init_bed_position := %g\n", h->init_bed_position);
  fprintf(fp, "plane_separation := %g cm\n", h->plane_separation);
  fprintf(fp, "user_process_code := %.10s\n", h->user_process_code);
}

Referenced by atnMake(), ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat63WriteAllImg(), and imgWriteEcat63Frame().

◆ ecat63PrintMatlist()

void ecat63PrintMatlist ( MATRIXLIST * ml )

extern

Print ECAT matrix list on stdout.

Parameters

ml	Pointer to matrix list to print.

Definition at line 130 of file ecat63ml.c.

  {
  int i;
  Matval matval;
 
  printf("nr\tmatrix\tpl\tfr\tgate\tbed\tstartblk\tblknr\n");
  for(i=0; i<ml->matrixNr; i++) {
    mat_numdoc(ml->matdir[i].matnum, &matval);
    printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n", i+1, ml->matdir[i].matnum,
      matval.plane, matval.frame, matval.gate, matval.bed,
      ml->matdir[i].strtblk, 1+ml->matdir[i].endblk-ml->matdir[i].strtblk);
  }
  return;
}

Referenced by ecat63ReadAllToImg(), ecat6PrintSubheader(), and ecatFixMatrixlist().

◆ ecat63PrintNormheader()

void ecat63PrintNormheader	(	ECAT63_normheader *	h,
		FILE *	fp )

extern

Print ECAT 6.3 normheader contents to specified file pointer.

Parameters

h	Ecat 6.3 normalization header
fp	target file pointer

Definition at line 197 of file ecat63p.c.

  {
  if(ECAT63_TEST) printf("ecat63PrintNormheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type, ecat63Datatype(h->data_type));
  fprintf(fp, "dimension_1 := %d\n", h->dimension_1);
  fprintf(fp, "dimension_2 := %d\n", h->dimension_2);
  fprintf(fp, "scale_factor := %g\n", h->scale_factor);
  fprintf(fp, "norm_time := %04d-%02d-%02d %02d:%02d:%02d\n",
    h->norm_year, h->norm_month, h->norm_day,
    h->norm_hour, h->norm_minute, h->norm_second);
}

Referenced by ecat6PrintSubheader().

◆ ecat63PrintScanheader()

void ecat63PrintScanheader	(	ECAT63_scanheader *	h,
		FILE *	fp )

extern

Print ECAT 6.3 scanheader contents to specified file pointer

Parameters

h	Ecat 6.3 scan header
fp	target file pointer

Definition at line 137 of file ecat63p.c.

  {
  if(ECAT63_TEST) printf("ecat63PrintScanheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type, ecat63Datatype(h->data_type));
  fprintf(fp, "dimension_1 := %d\n", h->dimension_1);
  fprintf(fp, "dimension_2 := %d\n", h->dimension_2);
  fprintf(fp, "sample_distance := %g cm\n", h->sample_distance);
  fprintf(fp, "isotope_halflife := %g sec\n", h->isotope_halflife);
  fprintf(fp, "gate_duration := %d\nr_wave_offset := %d\n",
    h->gate_duration, h->r_wave_offset);
  fprintf(fp, "scale_factor := %g\n", h->scale_factor);
  fprintf(fp, "scan_min := %d\nscan_max := %d\n", h->scan_min, h->scan_max);
  fprintf(fp, "prompts := %d\ndelayed := %d\nmultiples := %d\nnet_trues := %d\n",
    h->prompts, h->delayed, h->multiples, h->net_trues);
  fprintf(fp, "cor_singles :=");
  for(int i=0; i<16; i++) fprintf(fp, " %8.0f", h->cor_singles[i]);
  printf("\n");
  fprintf(fp, "uncor_singles :=");
  for(int i=0; i<16; i++) fprintf(fp, " %8.0f", h->uncor_singles[i]);
  printf("\n");
  fprintf(fp, "tot_avg_cor := %g\ntot_avg_uncor := %g\n", h->tot_avg_cor, h->tot_avg_uncor);
  fprintf(fp, "total_coin_rate := %d\n", h->total_coin_rate);
  fprintf(fp, "frame_start_time := %d\nframe_duration := %d\n",
    h->frame_start_time, h->frame_duration);
  fprintf(fp, "loss_correction_fctr := %g\n", h->loss_correction_fctr);
}

Referenced by atnMake(), ecat63ReadScanMatrix(), ecat63WriteAllImg(), and ecat6PrintSubheader().

◆ ecat63pxlbytes()

int ecat63pxlbytes ( short int data_type )

extern

Returns the nr of bytes required for storage of one pixel of specified data_type

Parameters

data_type data type code

Returns: number of bytes

Definition at line 973 of file ecat63r.c.

  {
  int byteNr=0;
  switch(data_type) {
    case BYTE_TYPE: byteNr=1; break;
    case VAX_I2:
    case SUN_I2: byteNr=2; break;
    case VAX_I4:
    case VAX_R4:
    case IEEE_R4:
    case SUN_I4: byteNr=4; break;
  }
  return(byteNr);
}

Referenced by ecat63WriteImageMatrix(), and ecat63WriteScanMatrix().

◆ ecat63ReadAllToImg()

int ecat63ReadAllToImg	(	const char *	fname,
		IMG *	img )

extern

Read all matrices in ECAT file to memory.

Sinograms are dead-time corrected.

See also: imgInit

Returns: 0 if ok, 1 invalid input, 3 failed to open file for reading, 4 failed to read main header, 5 failed to read matrix list, 6 matrix not found, 7 variable matrix sizes, 8 failed to read matrix sub header, 9 failed to allocate memory for data, 10 failed to read sub header, 11 failed to read matrix data.

Parameters

fname	Name of the input ECAT 6.3 file.
img	Data structure in which the file is read; must be initialized before using this function.

Definition at line 22 of file img_e63.c.

  {
  int                 m, ret, blkNr=0, dim_x=0, dim_y=0;
  int                 frameNr, planeNr, del_nr=0;
  int                 frame, plane, prev_frame, prev_plane, seqplane;
  FILE               *fp;
  ECAT63_mainheader   main_header;
  MATRIXLIST          mlist;
  MatDir              tmpMatdir;
  Matval              matval;
  ECAT63_imageheader  image_header;
  ECAT63_scanheader   scan_header;
  ECAT63_attnheader   attn_header;
  ECAT63_normheader   norm_header;
  float               scale=1.0;
  short int          *sptr;
  char               *mdata=NULL, *mptr;
  /*int                *iptr;*/
 
 
  if(IMG_TEST) printf("ecat63ReadAllToImg(%s, *img)\n", fname);
  /* Check the arguments */
  if(fname==NULL || img==NULL || img->status!=IMG_STATUS_INITIALIZED) {
    if(img) imgSetStatus(img, STATUS_FAULT);
    return 1;
  }
 
  /* Open input CTI file for read */
  if((fp=fopen(fname, "rb")) == NULL) {
    imgSetStatus(img, STATUS_NOFILE);
    return 3;
  }
 
  /* Read main header */
  if((ret=ecat63ReadMainheader(fp, &main_header))) {
    imgSetStatus(img, STATUS_NOMAINHEADER);
    return 4;
  }
  if(IMG_TEST>5) ecat63PrintMainheader(&main_header, stdout);
 
  /* Read matrix list and nr */
  ecat63InitMatlist(&mlist);
  ret=ecat63ReadMatlist(fp, &mlist, ECAT63_TEST-1);
  if(ret) {
    imgSetStatus(img, STATUS_NOMATLIST);
    return 5;
  }
  if(mlist.matrixNr<=0) {
    strcpy(ecat63errmsg, "matrix list is empty");
    return 5;
  }
  /* Sort matrix list */
  for(int i=0; i<mlist.matrixNr-1; i++)
    for(int j=i+1; j<mlist.matrixNr; j++) {
      if(mlist.matdir[i].matnum>mlist.matdir[j].matnum) {
        tmpMatdir=mlist.matdir[i];
        mlist.matdir[i]=mlist.matdir[j]; mlist.matdir[j]=tmpMatdir;
      }
    }
  if(IMG_TEST>6) {
    printf("matrix list after sorting:\n");
    ecat63PrintMatlist(&mlist);
  }
 
  /* Trim extra frames */
  if(main_header.num_frames>0) {
    del_nr=ecat63DeleteLateFrames(&mlist, main_header.num_frames);
    if(IMG_TEST && del_nr>0)
      printf("  %d entries in matrix list will not be used.\n", del_nr);
  }
  /* Calculate the number of planes, frames and gates */
  /* Check that all planes have equal nr of frames (gates) */
  /* and check that frames (gates) are consequentially numbered */
  prev_plane=plane=-1; prev_frame=frame=-1; frameNr=planeNr=0; ret=0;
  for(int m=0; m<mlist.matrixNr; m++) if(mlist.matdir[m].matstat==1) {
    /* get frame and plane */
    mat_numdoc(mlist.matdir[m].matnum, &matval);
    plane=matval.plane;
    if(main_header.num_frames>=main_header.num_gates) frame=matval.frame;
    else frame=matval.gate;
    if(IMG_TEST>2) printf("frame=%d plane=%d\n", frame, plane);
    /* did plane change? */
    if(plane!=prev_plane) {
      frameNr=1; planeNr++;
    } else {
      frameNr++;
      /* In each plane, frame (gate) numbers must be continuous */
      if(prev_frame>0 && frame!=prev_frame+1) {ret=1; break;}
    }
    prev_plane=plane; prev_frame=frame;
    /* Calculate and check the size of one data matrix */
    if(m==0) {
      blkNr=mlist.matdir[m].endblk-mlist.matdir[m].strtblk;
    } else if(blkNr!=mlist.matdir[m].endblk-mlist.matdir[m].strtblk) {
      ret=2; break;
    }
  } /* next matrix */
  if(IMG_TEST) printf("frameNr=%d planeNr=%d\n", frameNr, planeNr);
  if(ret==1 || (frameNr*planeNr != mlist.matrixNr-del_nr)) {
    strcpy(ecat63errmsg, "missing matrix");
    ecat63EmptyMatlist(&mlist); fclose(fp);
    return(6); /* this number is used in imgRead() */
  }
  if(ret==2) {
    strcpy(ecat63errmsg, "matrix sizes are different");
    ecat63EmptyMatlist(&mlist); fclose(fp); return(7);
  }
  /* Read x,y-dimensions from 1st matrix subheader */
  m=0; if(main_header.file_type==IMAGE_DATA) {
    ret=ecat63ReadImageheader(fp, mlist.matdir[m].strtblk, &image_header, IMG_TEST-4, NULL);
    dim_x=image_header.dimension_1; dim_y=image_header.dimension_2;
  } else if(main_header.file_type==RAW_DATA) {
    ret=ecat63ReadScanheader(fp, mlist.matdir[m].strtblk, &scan_header, IMG_TEST-4, NULL);
    dim_x=scan_header.dimension_1; dim_y=scan_header.dimension_2;
  } else if(main_header.file_type==ATTN_DATA) {
    ret=ecat63ReadAttnheader(fp, mlist.matdir[m].strtblk, &attn_header, IMG_TEST-10, NULL);
    dim_x=attn_header.dimension_1; dim_y=attn_header.dimension_2;
  } else if(main_header.file_type==NORM_DATA) {
    ret=ecat63ReadNormheader(fp, mlist.matdir[m].strtblk, &norm_header, IMG_TEST-10, NULL);
    dim_x=norm_header.dimension_1; dim_y=norm_header.dimension_2;
  }
  if(ret) {
    sprintf(ecat63errmsg, "cannot read matrix %u subheader",
            mlist.matdir[m].matnum);
    ecat63EmptyMatlist(&mlist); fclose(fp); return(8);
  }
 
  /* Allocate memory for ECAT data matrix */
  if(IMG_TEST>1) printf("allocating memory for %d blocks\n", blkNr);
  mdata=(char*)malloc((size_t)blkNr*MatBLKSIZE); if(mdata==NULL) {
    strcpy(ecat63errmsg, "out of memory");
    fclose(fp); ecat63EmptyMatlist(&mlist); return(8);
  }
  /* Allocate memory for whole img data */
  ret=imgAllocate(img, planeNr, dim_y, dim_x, frameNr);
  if(ret) {
    sprintf(ecat63errmsg, "out of memory (%d)", ret);
    fclose(fp); ecat63EmptyMatlist(&mlist); free(mdata); return(9);
  }
 
  /* Fill img info with ECAT main and sub header information */
  img->scanner=main_header.system_type;
  img->unit=main_header.calibration_units; /* this continues below */
  strlcpy(img->radiopharmaceutical, main_header.radiopharmaceutical, 32);
  img->isotopeHalflife=main_header.isotope_halflife;
  img->scanStart=ecat63Scanstarttime(&main_header);
  if(img->scanStart==-1) {
    img->scanStart=0;
    if(IMG_TEST>0) printf("invalid scan_start_time in mainheader\n");
  }
  img->axialFOV=10.*main_header.axial_fov;
  img->transaxialFOV=10.*main_header.transaxial_fov;
  strlcpy(img->studyNr, main_header.study_name, MAX_STUDYNR_LEN+1);
  strlcpy(img->patientName, main_header.patient_name, 32);
  strlcpy(img->patientID, main_header.patient_id, 16);
  img->sizez=10.*main_header.plane_separation;
  if(main_header.file_type==IMAGE_DATA) {
    img->type=IMG_TYPE_IMAGE;
    if(img->unit<1) img->unit=image_header.quant_units;
    img->zoom=image_header.recon_scale;
    if(image_header.decay_corr_fctr>1.0) img->decayCorrection=IMG_DC_CORRECTED;
    else img->decayCorrection=IMG_DC_UNKNOWN;
    img->sizex=img->sizey=10.*image_header.pixel_size;
    if(img->sizez<10.*image_header.slice_width)
      img->sizez=10.*image_header.slice_width;
    img->xform[0]=NIFTI_XFORM_UNKNOWN; // qform
    img->xform[1]=NIFTI_XFORM_SCANNER_ANAT; // sform
    img->quatern[6]=img->sizex; img->quatern[9]=img->sizex;
    img->quatern[11]=img->sizey; img->quatern[13]=img->sizey;
    img->quatern[16]=img->sizez; img->quatern[17]=img->sizez;
  } else if(main_header.file_type==RAW_DATA) {
    img->type=IMG_TYPE_RAW;
    img->decayCorrection=IMG_DC_NONCORRECTED;
  } else if(main_header.file_type==ATTN_DATA) {
    img->type=IMG_TYPE_ATTN;
    img->decayCorrection=IMG_DC_NONCORRECTED;
  } else if(main_header.file_type==NORM_DATA) {
    img->type=IMG_TYPE_RAW;
    img->decayCorrection=IMG_DC_NONCORRECTED;
  }
  strlcpy(img->studyDescription, main_header.study_description, 32);
  strncpy(img->userProcessCode, main_header.user_process_code, 10);
  img->userProcessCode[10]=(char)0;
  /* If valid study number is found in user_process_code, then take it */  
  if(!img->studyNr[0] && studynr_validity_check(img->userProcessCode))
    strlcpy(img->studyNr, img->userProcessCode, MAX_STUDYNR_LEN+1);
    
  /* Set _fileFormat */
  img->_fileFormat=IMG_E63;
 
  /* Read one ECAT matrix at a time and put them to img */
  prev_plane=plane=-1; seqplane=-1;
  for(int m=0; m<mlist.matrixNr; m++) if(mlist.matdir[m].matstat==1) {
    /* get plane */
    mat_numdoc(mlist.matdir[m].matnum, &matval);
    plane=matval.plane;
    /* did plane change? */
    if(plane!=prev_plane) {seqplane++; frame=1;} else frame++;
    prev_plane=plane;
    img->planeNumber[seqplane]=plane;
    /* Read subheader */
    if(main_header.file_type==IMAGE_DATA) {
      ret=ecat63ReadImageheader(fp, mlist.matdir[m].strtblk, &image_header, IMG_TEST-10, NULL);
      if(ret==0 && (dim_x!=image_header.dimension_1 || dim_y!=image_header.dimension_2)) ret=1;
      scale=image_header.quant_scale;
      if(image_header.ecat_calibration_fctr>0.0 &&
         fabs(main_header.calibration_factor/image_header.ecat_calibration_fctr - 1.0)>0.0001)
        scale*=image_header.ecat_calibration_fctr;
      if(img->unit==0 && image_header.quant_units>0)
        img->unit=image_header.quant_units;
      img->_dataType=image_header.data_type;
      img->start[frame-1]=image_header.frame_start_time/1000.;
      img->end[frame-1]=img->start[frame-1]+image_header.frame_duration/1000.;
      img->mid[frame-1]=0.5*(img->start[frame-1]+img->end[frame-1]);
      if(image_header.decay_corr_fctr>1.0)
        img->decayCorrFactor[frame-1]=image_header.decay_corr_fctr;
      else
        img->decayCorrFactor[frame-1]=0.0;
      /* Dead-time correction is assumed to be included in scale factor */
    } else if(main_header.file_type==RAW_DATA) {
      ret=ecat63ReadScanheader(fp, mlist.matdir[m].strtblk, &scan_header, IMG_TEST-10, NULL);
      if(ret==0 && (dim_x!=scan_header.dimension_1 || dim_y!=scan_header.dimension_2)) ret=1;
      scale=scan_header.scale_factor;
      /* Dead-time correction is done here */
      if(scan_header.loss_correction_fctr>0.0)
        scale*=scan_header.loss_correction_fctr;
      img->_dataType=scan_header.data_type;
      img->start[frame-1]=scan_header.frame_start_time/1000.;
      img->end[frame-1]=img->start[frame-1]+scan_header.frame_duration/1000.;
      img->mid[frame-1]=0.5*(img->start[frame-1]+img->end[frame-1]);
      img->sampleDistance=10.0*scan_header.sample_distance;
      img->prompts[frame-1]=(float)scan_header.prompts;
      img->randoms[frame-1]=(float)scan_header.delayed;
    } else if(main_header.file_type==ATTN_DATA) {
      ret=ecat63ReadAttnheader(fp, mlist.matdir[m].strtblk, &attn_header, IMG_TEST-10, NULL);
      if(ret==0 && (dim_x!=attn_header.dimension_1 || dim_y!=attn_header.dimension_2)) ret=1;
      img->_dataType=attn_header.data_type;
      scale=attn_header.scale_factor;
      img->sampleDistance=10.0*attn_header.sample_distance;
    } else if(main_header.file_type==NORM_DATA) {
      ret=ecat63ReadNormheader(fp, mlist.matdir[m].strtblk, &norm_header, IMG_TEST-10, NULL);
      if(ret==0 && (dim_x!=norm_header.dimension_1 || dim_y!=norm_header.dimension_2)) ret=1;
      scale=norm_header.scale_factor;
      img->_dataType=norm_header.data_type;
    } else img->_dataType=-1;
    if(ret) {
      sprintf(ecat63errmsg, "cannot read matrix %u subheader", mlist.matdir[m].matnum);
      ecat63EmptyMatlist(&mlist); free(mdata); fclose(fp); return(10);
    }
    if(main_header.calibration_factor>0.0) scale*=main_header.calibration_factor;
    if(IMG_TEST>2) printf("scale=%e datatype=%d\n", scale, img->_dataType);
    /* Read the pixel data */
    ret=ecat63ReadMatdata(fp, mlist.matdir[m].strtblk+1,
         mlist.matdir[m].endblk-mlist.matdir[m].strtblk,
         mdata, img->_dataType);
    if(ret) {
      strcpy(ecat63errmsg, "cannot read matrix data");
      ecat63EmptyMatlist(&mlist); free(mdata); fclose(fp); return(11);
    }
    mptr=mdata;
    if(img->_dataType==BYTE_TYPE) {
      for(int i=0; i<dim_y; i++) for(int j=0; j<dim_x; j++, mptr++) {
        img->m[seqplane][i][j][frame-1]=scale*(float)(*mptr);
      }
    } else if(img->_dataType==VAX_I2 || img->_dataType==SUN_I2) {
      for(int i=0; i<dim_y; i++) for(int j=0; j<dim_x; j++, mptr+=2) {
        sptr=(short int*)mptr;
        img->m[seqplane][i][j][frame-1]=scale*(float)(*sptr);
      }
    } else if(img->_dataType==VAX_I4 || img->_dataType==SUN_I4) {
      for(int i=0; i<dim_y; i++) for(int j=0; j<dim_x; j++, mptr+=4) {
        /*iptr=(int*)mptr;*/
        img->m[seqplane][i][j][frame-1]=1.0; /*scale*(float)(*iptr);*/
      }
    } else if(img->_dataType==VAX_R4 || img->_dataType==IEEE_R4) {
      for(int i=0; i<dim_y; i++) for(int j=0; j<dim_x; j++, mptr+=4) {
        memcpy(&img->m[seqplane][i][j][frame-1], mptr, 4);
        img->m[seqplane][i][j][frame-1]*=scale;
      }
    }
  } /* next matrix */
 
  /* Set the unit */
  imgUnitFromEcat(img, img->unit);
 
  /* Free memory and close file */
  free(mdata);
  ecat63EmptyMatlist(&mlist);
  fclose(fp);
 
  /* For saving, only 2-byte VAX data types are allowed */
  if(img->_dataType==VAX_I4 || img->_dataType==VAX_R4) img->_dataType=VAX_I2;
 
  return(0);
}

Referenced by imgRead().

◆ ecat63ReadAttnheader()

int ecat63ReadAttnheader	(	FILE *	fp,
		int	blk,
		ECAT63_attnheader *	h,
		int	verbose,
		char *	errmsg )

extern

Read ECAT 6.3 attenuation header

Returns: 0 if ok, 1 failed to find block, 3 failed to read block, 4 invalid data type, 5 invalid scale factor.

Parameters

fp	File pointer to ECAT file; position is not important.
blk	Block number from matrix list [2..number of blocks].
h	Pointer to the header struct where contents are put.
verbose	Verbose level; if zero, then only warnings are printed into stderr.
errmsg	Pointer to error message, at least 128 characters; enter NULL, if not needed.

Definition at line 296 of file ecat63r.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
  int vaxdata=1; /* 1 if data is in VAX format, else 0 */
 
  if(ECAT63_TEST) printf("ecat63ReadAttnheader(fp, %d, ah)\n", blk);
  if(fp==NULL || blk<2 || h==NULL) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid input");
    if(verbose>0) fprintf(stderr, "Invalid input.\n");
    return(1);
  }
  little=little_endian();
  /* Seek the subheader block */
  fseeko(fp, (blk-1)*MatBLKSIZE, SEEK_SET);
  if(ftello(fp)!=(blk-1)*MatBLKSIZE) {
    if(errmsg!=NULL) sprintf(errmsg, "failed to find block %d", blk);
    if(verbose>0) fprintf(stderr, "Failed to find block %d.\n", blk);
    return(2);
  }
  /* Read the subheader block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) {
    if(errmsg!=NULL) sprintf(errmsg, "failed to read block %d", blk);
    if(verbose>0) fprintf(stderr, "Failed to read block %d.\n", blk);
    return(3);
  }
 
  /* Copy short ints */
  /* in big endian platform, change byte order temporarily */
  if(!little) swabip(buf, MatBLKSIZE);
  memcpy(&h->data_type, buf+126, 2); if(h->data_type>4) vaxdata=0;
  /*printf("data_type=%d\n", h->data_type);*/
  memcpy(&h->attenuation_type, buf+128, 2);
  memcpy(&h->dimension_1, buf+132, 2); memcpy(&h->dimension_2, buf+134, 2);
  /* Change back the byte order */
  if(!little) swabip(buf, MatBLKSIZE);
 
  /* Copy floats */
  h->scale_factor=ecat63rFloat(buf+182, vaxdata, little);
  h->x_origin=ecat63rFloat(buf+186, vaxdata, little);
  h->y_origin=ecat63rFloat(buf+190, vaxdata, little);
  h->x_radius=ecat63rFloat(buf+194, vaxdata, little);
  h->y_radius=ecat63rFloat(buf+198, vaxdata, little);
  h->tilt_angle=ecat63rFloat(buf+202, vaxdata, little);
  h->attenuation_coeff=ecat63rFloat(buf+206, vaxdata, little);
  h->sample_distance=ecat63rFloat(buf+210, vaxdata, little);
 
  /* Check that most important contents are ok */
  if(h->data_type<BYTE_TYPE || h->data_type>SUN_I4) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid data types; probable conversion error");
    if(verbose>0) fprintf(stderr, "Invalid data types; probable conversion error.\n");
    if(verbose>1) printf("data_type := %d\n", h->data_type);
    return(4);
  }
  if(h->scale_factor<=0.0 || h->scale_factor>1.0e8) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid scale factor; probable conversion error");
    if(verbose>0) fprintf(stderr, "Invalid scale factor; probable conversion error.\n");
    return(5);
  }
  if(errmsg!=NULL) strcpy(errmsg, "ok");
 
  return(0);
}

Referenced by ecat63ReadAllToImg(), ecat63ReadAttnMatrix(), ecat63ReadPlaneToImg(), ecat6PrintSubheader(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ ecat63ReadAttnMatrix()

int ecat63ReadAttnMatrix	(	FILE *	fp,
		int	first_block,
		int	last_block,
		ECAT63_attnheader *	h,
		float **	fdata )

extern

Read ECAT63 attenuation matrix header and data.

If only header is to be read, set last_block=first_block. Note: data is not calibrated with factor in main header.

Returns: 0 if ok, 1 invalid input, 5 failed to read sub header, 6 invalid (x,y,z) dimensions, 8 failed to allocate memory for meta-data, 9 failed to read matrix data, 11 failed to allocate memory for the data

Parameters

fp	ECAT file pointer.
first_block	Subheader record number.
last_block	Last data block number.
h	Pointer to subheader data which is filled.
fdata	Float pointer to the address of the matrix data; any old contents are not freed, therefore you must free the pointer after data is copied elsewhere.

Definition at line 830 of file ecat63r.c.

  {
  int ret, blockNr;
  char *mdata, *mptr, errmsg[128];
  float *_fdata, *fptr;
  short int *sptr;
  int *iptr;
  
  
  if(ECAT63_TEST) printf("ecat63ReadAttnMatrix(fp, %d, %d, hdr, fdata)\n",
    first_block, last_block);
  if(fp==NULL || first_block<=MatFirstDirBlk || h==NULL) {
    sprintf(ecat63errmsg, "invalid function parameter.\n");
    return(1);
  }
  *fdata=(float*)NULL;
  
  /* Read subheader */
  ret=ecat63ReadAttnheader(fp, first_block, h, ECAT63_TEST-2, errmsg);
  if(ret) {
    strcpy(ecat63errmsg, errmsg);
    return(5);
  }
  if(ECAT63_TEST>4) ecat63PrintAttnheader(h, stdout);
  long long pxlNr=h->dimension_1*h->dimension_2;
  if(pxlNr<=0) {
    sprintf(ecat63errmsg, "invalid matrix dimension.\n");
    return(6);  
  }
  
  /* Read matrix data */
  blockNr=last_block-first_block; if(blockNr<1) return(0);
  mdata=(char*)malloc((size_t)blockNr*MatBLKSIZE);
  if(mdata==NULL) {
    sprintf(ecat63errmsg, "cannot allocate memory.\n");
    return(8);  
  }
  mptr=mdata;
  ret=ecat63ReadMatdata(fp, first_block+1, blockNr, mptr, h->data_type);
  if(ret || mdata==NULL) {
    sprintf(ecat63errmsg, "cannot read matrix data (%d).\n", ret);
    free(mdata); return(9);
  }
  
  /* Allocate memory for float data */
  _fdata=(float*)malloc((size_t)pxlNr*sizeof(float));
  if(_fdata==NULL) {
    sprintf(ecat63errmsg, "cannot allocate memory.\n");
    free(mdata); return(11);  
  }
 
  /* Convert matrix data to floats */
  fptr=_fdata; mptr=mdata;
  if(h->data_type==BYTE_TYPE) {
    for(long long i=0; i<pxlNr; i++, mptr++, fptr++)
      *fptr=h->scale_factor*(float)(*mptr);
  } else if(h->data_type==VAX_I2 || h->data_type==SUN_I2) {
    for(long long i=0; i<pxlNr; i++, mptr+=2, fptr++) {
      sptr=(short int*)mptr;
      *fptr=h->scale_factor*(float)(*sptr);
    }
  } else if(h->data_type==VAX_I4 || h->data_type==SUN_I4) {
    for(long long i=0; i<pxlNr; i++, mptr+=4, fptr++) {
      iptr=(int*)mptr;
      *fptr=h->scale_factor*(float)(*iptr);
    }
  } else if(h->data_type==VAX_R4 || h->data_type==IEEE_R4) {
    memcpy(fptr, mptr, pxlNr*4);
    for(long long i=0; i<pxlNr; i++, fptr++) *fptr *= h->scale_factor;
  }
  free(mdata);
  *fdata=_fdata;
 
  return(0);
}

◆ ecat63ReadImageheader()

int ecat63ReadImageheader	(	FILE *	fp,
		int	blk,
		ECAT63_imageheader *	h,
		int	verbose,
		char *	errmsg )

extern

Read ECAT 6.3 image header.

Returns: 0 if ok, 1 invalid input, 2 failed to find block, 3 failed to read block, 4 invalid data type, 5 invalid calibration factor, 6 invalid frame duration.

Parameters

fp	File pointer to ECAT file; position is not important.
blk	Block number from matrix list [2..number of blocks].
h	Pointer to the header struct where contents are put.
verbose	Verbose level; if zero, then only warnings are printed into stderr.
errmsg	Pointer to error message, at least 128 characters; enter NULL, if not needed.

Definition at line 187 of file ecat63r.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
  int vaxdata=1; /* 1 if data is in VAX format, else 0 */
 
  if(verbose>0) {printf("ecat63ReadImageheader(fp, %d ih)\n", blk); fflush(stdout);}
  if(fp==NULL || blk<2 || h==NULL) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid input");
    if(verbose>0) {fprintf(stderr, "Invalid input.\n"); fflush(stderr);}
    return(1);
  }
  little=little_endian();
  /* Seek the subheader block */
  fseeko(fp, (blk-1)*MatBLKSIZE, SEEK_SET); 
  if(ftello(fp)!=(blk-1)*MatBLKSIZE) {
    if(errmsg!=NULL) sprintf(errmsg, "failed to find block %d", blk);
    if(verbose>0) {fprintf(stderr, "Failed to find block %d.\n", blk); fflush(stderr);}
    return(2);
  }
  /* Read the subheader block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) {
    if(errmsg!=NULL) sprintf(errmsg, "failed to read block %d", blk);
    if(verbose>0) {fprintf(stderr, "Failed to read block %d.\n", blk); fflush(stderr);}
    return(3);
  }
 
  /* Copy char data to header structure */
  memcpy(h->fill1, buf+0, 126); memcpy(h->annotation, buf+420, 40);
 
  /* Copy short ints */
  /* in big endian platform, change byte order temporarily */
  if(!little) swabip(buf, MatBLKSIZE);
  memcpy(&h->data_type, buf+126, 2); if(h->data_type>4) vaxdata=0;
  if(verbose>10) printf("data_type=%d\n", h->data_type);
  memcpy(&h->num_dimensions, buf+128, 2);
  memcpy(&h->dimension_1, buf+132, 2); memcpy(&h->dimension_2, buf+134, 2);
  memcpy(&h->image_min, buf+176, 2); memcpy(&h->image_max, buf+178, 2);
  memcpy(&h->slice_location, buf+200, 2); memcpy(&h->recon_start_hour, buf+202, 2);
  memcpy(&h->recon_start_min, buf+204, 2); memcpy(&h->recon_start_sec, buf+206, 2);
  memcpy(&h->filter_code, buf+236, 2); memcpy(&h->processing_code, buf+376, 2);
  memcpy(&h->quant_units, buf+380, 2); memcpy(&h->recon_start_day, buf+382, 2);
  memcpy(&h->recon_start_month, buf+384, 2); memcpy(&h->recon_start_year, buf+386, 2);
  memcpy(h->fill2, buf+460, 52);
  /* Change back the byte order */
  if(!little) swabip(buf, MatBLKSIZE);
 
  /* Copy ints */
  h->frame_duration=ecat63rInt(buf+192, vaxdata, little);
  h->frame_start_time=ecat63rInt(buf+196, vaxdata, little);
  h->recon_duration=ecat63rInt(buf+208, vaxdata, little);
  h->scan_matrix_num=ecat63rInt(buf+238, vaxdata, little);
  h->norm_matrix_num=ecat63rInt(buf+242, vaxdata, little);
  h->atten_cor_mat_num=ecat63rInt(buf+246, vaxdata, little);
 
  /* Copy floats */
  h->x_origin=ecat63rFloat(buf+160, vaxdata, little);
  h->y_origin=ecat63rFloat(buf+164, vaxdata, little);
  h->recon_scale=ecat63rFloat(buf+168, vaxdata, little);
  h->quant_scale=ecat63rFloat(buf+172, vaxdata, little);
  h->pixel_size=ecat63rFloat(buf+184, vaxdata, little);
  h->slice_width=ecat63rFloat(buf+188, vaxdata, little);
  h->image_rotation=ecat63rFloat(buf+296, vaxdata, little);
  h->plane_eff_corr_fctr=ecat63rFloat(buf+300, vaxdata, little);
  h->decay_corr_fctr=ecat63rFloat(buf+304, vaxdata, little);
  h->loss_corr_fctr=ecat63rFloat(buf+308, vaxdata, little);
  h->intrinsic_tilt=ecat63rFloat(buf+312, vaxdata, little);
  h->ecat_calibration_fctr=ecat63rFloat(buf+388, vaxdata, little);
  h->well_counter_cal_fctr=ecat63rFloat(buf+392, vaxdata, little);
  for(int i=0; i<6; i++) h->filter_params[i]=ecat63rFloat(buf+396+i*4, vaxdata, little);
 
  /* Check that most important contents are ok */
  if(h->data_type<BYTE_TYPE || h->data_type>SUN_I4) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid data types; probable conversion error");
    if(verbose>0) {fprintf(stderr, "Invalid data types; probable conversion error.\n"); fflush(stderr);}
    if(verbose>1) {printf("data_type := %d\n", h->data_type); fflush(stdout);}
    return(4);
  }
  if(h->ecat_calibration_fctr<0.0 || h->ecat_calibration_fctr>1.0e10) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid calibration factor; probable conversion error");
    if(verbose>0) {fprintf(stderr, "Invalid calibration factor; probable conversion error.\n"); fflush(stderr);}
    return(5);
  }
  if(h->frame_duration<0.0 || h->frame_duration>1.0e12) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid frame duration; probable conversion error");
    if(verbose>0) {fprintf(stderr, "Invalid frame duration; probable conversion error.\n"); fflush(stderr);}
    return(6);
  }
  if(errmsg!=NULL) strcpy(errmsg, "ok");
 
  return(0);
}

Referenced by ecat63ReadAllToImg(), ecat63ReadImageMatrix(), ecat63ReadPlaneToImg(), ecat6PrintSubheader(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ ecat63ReadImageMatrix()

int ecat63ReadImageMatrix	(	FILE *	fp,
		int	first_block,
		int	last_block,
		ECAT63_imageheader *	h,
		float **	fdata )

extern

Read ECAT63 image matrix header and data.

If only header is to be read, set last_block=first_block. Note: data is not calibrated with factor in main header.

Returns: 0 if ok, 1 invalid input, 5 failed to read sub header, 6 invalid (x,y,z) dimensions, 8 failed to allocate memory for meta-data, 9 failed to read matrix data, 11 failed to allocate memory for image data

Parameters

fp	ECAT file pointer
first_block	Subheader record number
last_block	Last data block number
h	Ptr to subheader data which is filled
fdata	Ptr to the address of the matrix data; any old contents are not freed, therefore you must free the pointer after data is copied elsewhere.

Definition at line 627 of file ecat63r.c.

  {
  int ret, blockNr;
  char *mdata, *mptr, errmsg[128];
  float *_fdata, *fptr;
  short int *sptr;
  int *iptr;
  
  
  if(ECAT63_TEST) printf("ecat63ReadImageMatrix(fp, %d, %d, hdr, fdata)\n",
    first_block, last_block);
  if(fp==NULL || first_block<=MatFirstDirBlk || h==NULL) {
    sprintf(ecat63errmsg, "invalid function parameter.\n");
    return(1);
  }
  *fdata=(float*)NULL;
  
  /* Read subheader */
  ret=ecat63ReadImageheader(fp, first_block, h, ECAT63_TEST-2, errmsg);
  if(ret) {
    strcpy(ecat63errmsg, errmsg);
    return(5);
  }
  if(ECAT63_TEST>4) ecat63PrintImageheader(h, stdout);
  long long pxlNr=h->dimension_1*h->dimension_2;
  if(pxlNr<=0) {
    sprintf(ecat63errmsg, "invalid matrix dimension.\n");
    return(6);  
  }
  
  /* Read matrix data */
  blockNr=last_block-first_block; if(blockNr<1) return(0);
  mdata=(char*)malloc((size_t)blockNr*MatBLKSIZE);
  if(mdata==NULL) {
    sprintf(ecat63errmsg, "cannot allocate memory.\n");
    return(8);  
  }
  mptr=mdata;
  ret=ecat63ReadMatdata(fp, first_block+1, blockNr, mptr, h->data_type);
  if(ret || mdata==NULL) {
    sprintf(ecat63errmsg, "cannot read matrix data (%d).\n", ret);
    free(mdata); return(9);
  }
  
  /* Allocate memory for float data */
  _fdata=(float*)malloc((size_t)pxlNr*sizeof(float));
  if(_fdata==NULL) {
    sprintf(ecat63errmsg, "cannot allocate memory.\n");
    free(mdata); return(11);  
  }
 
  /* Convert matrix data to floats */
  if(h->ecat_calibration_fctr>0.0) h->quant_scale*=h->ecat_calibration_fctr;
  fptr=_fdata; mptr=mdata;
  if(h->data_type==BYTE_TYPE) {
    for(long long i=0; i<pxlNr; i++, mptr++, fptr++)
      *fptr=h->quant_scale*(float)(*mptr);
  } else if(h->data_type==VAX_I2 || h->data_type==SUN_I2) {
    for(long long i=0; i<pxlNr; i++, mptr+=2, fptr++) {
      sptr=(short int*)mptr;
      *fptr=h->quant_scale*(float)(*sptr);
      if(!(*fptr>-1.0E+22 && *fptr<1.0E+22)) *fptr=0.0;
    }
  } else if(h->data_type==VAX_I4 || h->data_type==SUN_I4) {
    for(long long i=0; i<pxlNr; i++, mptr+=4, fptr++) {
      iptr=(int*)mptr;
      *fptr=h->quant_scale*(float)(*iptr);
      if(!(*fptr>-1.0E+22 && *fptr<1.0E+22)) *fptr=0.0;
    }
  } else if(h->data_type==VAX_R4 || h->data_type==IEEE_R4) {
    memcpy(fptr, mptr, pxlNr*4);
    for(long long i=0; i<pxlNr; i++, fptr++) {
      *fptr *= h->quant_scale;
      if(!(*fptr>-1.0E+22 && *fptr<1.0E+22)) *fptr=0.0;
    }
  }
  free(mdata);
  *fdata=_fdata;
 
  return(0);
}

◆ ecat63ReadMainheader()

int ecat63ReadMainheader	(	FILE *	fp,
		ECAT63_mainheader *	h )

extern

Read ECAT 6.3 main header.

Returns: 0 if ok, 1 invalid input, 2 failed to find subheader block, 3 invalid magic number (should be "ECAT63") at start of file, 5 invalid data type, 6 invalid calibration factor, 7 invalid file type.

Parameters

fp	file pointer
h	target Ecat 6.3 main header structure

Definition at line 25 of file ecat63r.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
  int vaxdata=1; /* 1 if data is in VAX format, else 0 */
 
  if(ECAT63_TEST>0) {printf("ecat63ReadMainheader()\n"); fflush(stdout);}
  if(fp==NULL || h==NULL) return(1);
  little=little_endian(); if(ECAT63_TEST>1) {printf("little := %d\n", little); fflush(stdout);}
  /* Seek the first block */
  fseek(fp, 0, SEEK_SET); if(ftell(fp)!=0) return(1);
  /* Read the main header block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) return(2);
 
  /* Copy char data to header structure */
  memcpy(h->ecat_format, buf+0, 14); 
  memcpy(h->fill1, buf+14, 14);
  memcpy(h->original_file_name, buf+28, 20);
  if(ECAT63_TEST>10) {
    printf("original_file_name := '%.20s'\n", h->original_file_name); fflush(stdout);}
  memcpy(h->node_id, buf+56, 10);
  memcpy(h->isotope_code, buf+78, 8);
  memcpy(h->radiopharmaceutical, buf+90, 32);
  memcpy(h->study_name, buf+162, 12);
  memcpy(h->patient_id, buf+174, 16);
  memcpy(h->patient_name, buf+190, 32);
  h->patient_sex=buf[222];
  memcpy(h->patient_age, buf+223, 10);
  memcpy(h->patient_height, buf+233, 10);
  memcpy(h->patient_weight, buf+243, 10);
  h->patient_dexterity=buf[253];
  memcpy(h->physician_name, buf+254, 32);
  memcpy(h->operator_name, buf+286, 32);
  memcpy(h->study_description, buf+318, 32);
  memcpy(h->facility_name, buf+356, 20);
  memcpy(h->user_process_code, buf+462, 10);
 
  /* Copy short ints; in big endian platform, change byte order */
  if(!little) swabip(buf+50, 2);
  memcpy(&h->data_type, buf+50, 2); 
  if(ECAT63_TEST>10) {printf("main_header.data_type=%d\n", h->data_type); fflush(stdout);}
  if(h->data_type<1) {
    if(ECAT63_TEST>1) {printf("invalid data_type; assuming VAX_I2\n"); fflush(stdout);}
    h->data_type=VAX_I2;
  }
  if(h->data_type>4) vaxdata=0;
 
  if(!little) swabip(buf+48, 2);
  memcpy(&h->sw_version, buf+48, 2);
  if(!little) swabip(buf+52, 2);
  memcpy(&h->system_type, buf+52, 2);
  if(!little) swabip(buf+54, 2);
  memcpy(&h->file_type, buf+54, 2);
  if(ECAT63_TEST>10) {printf("main_header.file_type=%d\n", h->file_type); fflush(stdout);}
  if(!little) swabip(buf+66, 2);
  memcpy(&h->scan_start_day, buf+66, 2);
  if(!little) swabip(buf+68, 2);
  memcpy(&h->scan_start_month, buf+68, 2);
  if(!little) swabip(buf+70, 2);
  memcpy(&h->scan_start_year, buf+70, 2);
  if(!little) swabip(buf+72, 2);
  memcpy(&h->scan_start_hour, buf+72, 2);
  if(!little) swabip(buf+74, 2);
  memcpy(&h->scan_start_minute, buf+74, 2);
  if(!little) swabip(buf+76, 2);
  memcpy(&h->scan_start_second, buf+76, 2);
  if(!little) swabip(buf+134, 2);
  memcpy(&h->rot_source_speed, buf+134, 2);
  if(!little) swabip(buf+136, 2);
  memcpy(&h->wobble_speed, buf+136, 2);
  if(!little) swabip(buf+138, 2);
  memcpy(&h->transm_source_type, buf+138, 2);
  if(!little) swabip(buf+148, 2);
  memcpy(&h->transaxial_samp_mode, buf+148, 2);
  if(!little) swabip(buf+150, 2);
  memcpy(&h->coin_samp_mode, buf+150, 2);
  if(!little) swabip(buf+152, 2);
  memcpy(&h->axial_samp_mode, buf+152, 2);
  if(!little) swabip(buf+158, 2);
  memcpy(&h->calibration_units, buf+158, 2);
  if(!little) swabip(buf+160, 2);
  memcpy(&h->compression_code, buf+160, 2);
  if(!little) swabip(buf+350, 2);
  memcpy(&h->acquisition_type, buf+350, 2);
  if(!little) swabip(buf+352, 2);
  memcpy(&h->bed_type, buf+352, 2);
  if(!little) swabip(buf+354, 2);
  memcpy(&h->septa_type, buf+354, 2);
  if(!little) swabip(buf+376, 2);
  memcpy(&h->num_planes, buf+376, 2);
  if(!little) swabip(buf+378, 2);
  memcpy(&h->num_frames, buf+378, 2);
  if(!little) swabip(buf+380, 2);
  memcpy(&h->num_gates, buf+380, 2);
  if(!little) swabip(buf+382, 2);
  memcpy(&h->num_bed_pos, buf+382, 2);
  if(!little) swabip(buf+452, 2);
  memcpy(&h->lwr_sctr_thres, buf+452, 2);
  if(!little) swabip(buf+454, 2);
  memcpy(&h->lwr_true_thres, buf+454, 2);
  if(!little) swabip(buf+456, 2);
  memcpy(&h->upr_true_thres, buf+456, 2);
  if(!little) swabip(buf+472, 40);
  memcpy(h->fill2, buf+472, 40);
 
  /* Copy floats */
  h->isotope_halflife=ecat63rFloat(buf+86, vaxdata, little);
  h->gantry_tilt=ecat63rFloat(buf+122, vaxdata, little);
  h->gantry_rotation=ecat63rFloat(buf+126, vaxdata, little);
  h->bed_elevation=ecat63rFloat(buf+130, vaxdata, little);
  h->axial_fov=ecat63rFloat(buf+140, vaxdata, little);
  h->transaxial_fov=ecat63rFloat(buf+144, vaxdata, little);
  h->calibration_factor=ecat63rFloat(buf+154, vaxdata, little);
  h->init_bed_position=ecat63rFloat(buf+384, vaxdata, little);
  for(int i=0; i<15; i++) h->bed_offset[i]=ecat63rFloat(buf+388+i*4, vaxdata, little);
  h->plane_separation=ecat63rFloat(buf+448, vaxdata, little);
  h->collimator=ecat63rFloat(buf+458, vaxdata, little);
 
  /* Check file format and platform */
  if(ECAT63_TEST>1) {printf("ecat_format='%.14s'\n", h->ecat_format); fflush(stdout);}
  /* if format is not specified, ECAT63 is assumed */
  if(h->ecat_format[0]==(char)0) {
    strcpy(h->ecat_format, "ECAT63");
  }
  /* only ECAT63 format is approved here */
  if(ECAT63_TEST>1) {printf("ecat_format='%.14s'\n", h->ecat_format); fflush(stdout);}
  if(strncmp(h->ecat_format, "ECAT63", 6)!=0) return(3);
 
  /* Check that most important contents are ok */
  if(ECAT63_TEST>3) {
    printf("  mhdr.data_type := %s\n", ecat63Datatype(h->data_type));
    fflush(stdout);
  }
  if(h->data_type<BYTE_TYPE || h->data_type>SUN_I4) {
    if(ECAT63_TEST>1) {printf("Invalid data types; probable conversion error.\n"); fflush(stdout);}
    return(5);
  }
  if(h->calibration_factor<0.0 || h->calibration_factor>1.0e12) {
    if(ECAT63_TEST>1) {
      printf("Invalid calibration factor; possible conversion error.\n"); fflush(stdout);}
    return(6);
  }
  if(h->file_type!=RAW_DATA && h->file_type!=IMAGE_DATA &&
     h->file_type!=ATTN_DATA && h->file_type!=NORM_DATA) {
    if(ECAT63_TEST>1) {printf("Invalid file types; probable conversion error.\n"); fflush(stdout);}
    return(7);
  }
 
  return(0);
}

Referenced by atnMake(), ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecatFixMatrixlist(), imgRead(), imgReadEcat63Frame(), imgReadEcat63Header(), and imgWriteEcat63Frame().

◆ ecat63ReadMatdata()

int ecat63ReadMatdata	(	FILE *	fp,
		int	strtblk,
		int	blkNr,
		char *	data,
		int	dtype )

extern

Read ECAT 6.3 matrix data and convert byte order if necessary Remember to allocate memory for full blocks! There are differences here when compared to ecat7.c

Parameters

fp	file pointer from where data is read
strtblk	starting block [>= 1]
blkNr	number of block to be read [>= 0]
data	pointer to block where data is read
dtype	data type code

Returns: 0 if ok, 1 invalid input, 2 failed to read data, 9 failed to find starting block from file,

Definition at line 568 of file ecat63r.c.

                                                                               {
  int n, little, err=0;
  char *cptr;
  float f;
 
 
  if(ECAT63_TEST) printf("ecat63ReadMatdata(fp, %d, %d, data, %d)\n", strtblk, blkNr, dtype);
  /* Check the arguments */
  if(blkNr<=0 || strtblk<1 || data==NULL) return(1);
  /* Seek the first data block */
  fseeko(fp, (strtblk-1)*MatBLKSIZE, SEEK_SET);
  if(ftello(fp)!=(strtblk-1)*MatBLKSIZE) return(9);
  /* Read the data blocks */
  if(fread(data, MatBLKSIZE, blkNr, fp) < (unsigned int)blkNr) return(2);
  /* Translate data if necessary */
  little=little_endian();
  switch(dtype) {
    case BYTE_TYPE: /* byte format...no translation necessary */
      break;
    case VAX_I2:    /* byte conversion necessary on big endian platform */
      if(!little) {cptr=data; swabip(cptr, blkNr*MatBLKSIZE);}
      break;
    case VAX_I4:
      cptr=data;
      for(long long int i=0; i<blkNr*MatBLKSIZE; i+=4, cptr+=4) {
        n=ecat63rInt(cptr, 1, little); memcpy(cptr, &n, 4);
      }
      break;
    case VAX_R4:
      cptr=data;
      for(long long i=0; i<blkNr*MatBLKSIZE; i+=4, cptr+=4) {
        f=ecat63rFloat(cptr, 1, little); memcpy(cptr, &f, 4);
      }
      break;
    case IEEE_R4:   /* IEEE float ; byte conversion necessary on big end platforms */
    case SUN_I4:    /* SUN int ; byte conversion necessary on big end platforms */
      if(!little) swawbip(data, blkNr*MatBLKSIZE);
      break;
    case SUN_I2:    /* SUN short ; byte conversion necessary on big end platforms */
      if(!little) swabip(data, blkNr*MatBLKSIZE);
      break;
    default:  /* if something else, for now think it as an error */
      err=2;
      break;
  }
  return(err);
}

Referenced by ecat63ReadAllToImg(), ecat63ReadAttnMatrix(), ecat63ReadImageMatrix(), ecat63ReadPlaneToImg(), ecat63ReadScanMatrix(), and imgReadEcat63Frame().

◆ ecat63ReadMatlist()

int ecat63ReadMatlist	(	FILE *	fp,
		MATRIXLIST *	ml,
		int	verbose )

extern

Read ECAT 6.3 matrix list.

Matrix list must be initiated (once) before calling this.

Returns: Returns 0 if ok, 1 if invalid input, 2 first matrix is not found, 3 if failed to read matrix, 4 failed to allocate memory, 5 other error.

Parameters

fp	File pointer.
ml	Pointer to initiated matrix list.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 46 of file ecat63ml.c.

  {
  int i, err=0, little;
  int blk=MatFirstDirBlk, next_blk=0;
  size_t sn;
  unsigned int dirbuf[MatBLKSIZE/4];
 
 
  if(verbose>0) {printf("ecat63ReadMatlist(fp, mlist)\n"); fflush(stdout);}
  if(fp==NULL) return(1);
  little=little_endian();
  /* Make sure that matrix list is empty */
  ecat63EmptyMatlist(ml);
  /* Seek the first list block */
  fseek(fp, (blk-1)*MatBLKSIZE, SEEK_SET); if(ftell(fp)!=(blk-1)*MatBLKSIZE) return(2);
  do {
    /* Read the data block */
    if(verbose>1) {printf("  reading dirblock %d\n", blk); fflush(stdout);}
    sn=fread(dirbuf, sizeof(int), MatBLKSIZE/4, fp); 
    if(sn==0) { /* this never happens in valid ECAT file, but it does happen... */
      if(verbose>0) {printf("sn=%d\n", (int)sn); fflush(stdout);}
      //ml->matrixNr--;
      break;
    }
    if(sn<MatBLKSIZE/4) { /* this would be a real error in file */
      if(verbose>0) {printf("sn=%d\n", (int)sn); fflush(stdout);}
      err=2; break;
    }
    /* Allocate (more) memory for one block */
    if(ml->matrixSpace==0) {
      ml->matrixSpace=MatBLKSIZE/4;
      ml->matdir=(MatDir*)malloc(ml->matrixSpace*sizeof(MatDir));
    } else if(ml->matrixSpace<(ml->matrixNr+MatBLKSIZE/4)) {
      ml->matrixSpace+=MatBLKSIZE/4;
      ml->matdir=(MatDir*)realloc(ml->matdir, sizeof(MatDir)*ml->matrixSpace);
    }
    if(ml->matdir==NULL) return(4);
    /* Byte order conversion for ints in big endian platforms */
    if(!little) swawbip(dirbuf, MatBLKSIZE);
    /* Read "header" integers */
    /*nr_free  = dirbuf[0];*/
    next_blk = dirbuf[1];
    /*prev_blk = dirbuf[2];*/
    /*nr_used  = dirbuf[3];*/
    if(verbose>3) printf("next_blk=%d\n", next_blk);
    fpos_t current_fp; fgetpos(fp, &current_fp); // save current file position
    for(i=4; i<MatBLKSIZE/4; i+=4) if(dirbuf[i]>0) {
      ml->matdir[ml->matrixNr].matnum=dirbuf[i];
      ml->matdir[ml->matrixNr].strtblk=dirbuf[i+1];
      ml->matdir[ml->matrixNr].endblk=dirbuf[i+2];
      ml->matdir[ml->matrixNr].matstat=dirbuf[i+3];
      if(verbose>4) printf("matnum=%d strtblk=%d endblk=%d matstat=%d matrixNr=%d\n",
          ml->matdir[ml->matrixNr].matnum, ml->matdir[ml->matrixNr].strtblk,
          ml->matdir[ml->matrixNr].endblk, ml->matdir[ml->matrixNr].matstat,
          ml->matrixNr);
      /* verify that these block can be found in the file */
      int ret=fseek(fp, (ml->matdir[ml->matrixNr].endblk-1)*MatBLKSIZE, SEEK_SET);
      fsetpos(fp, &current_fp);  // back to saved file position
      if(ret==0) { // end block can be found
        ml->matrixNr++;
      } else { // not found, file probably broken
        if(verbose>0) {
          printf("matnum %d points to data outside of file.\n", ml->matdir[ml->matrixNr].matnum);
          fflush(stdout);
        }
      }
    }
    blk=next_blk;
    /* Seek the next list block */
    fseeko(fp, (blk-1)*MatBLKSIZE, SEEK_SET); if(ftello(fp)!=(blk-1)*MatBLKSIZE) err=1;
  } while(err==0 && feof(fp)==0 && blk!=MatFirstDirBlk);
  if(err) {ecat63EmptyMatlist(ml); return(5);}
  return(0);
}

Referenced by atnMake(), ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat6PrintSubheader(), ecatFixMatrixlist(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ ecat63ReadNormheader()

int ecat63ReadNormheader	(	FILE *	fp,
		int	blk,
		ECAT63_normheader *	h,
		int	verbose,
		char *	errmsg )

extern

Read ECAT 6.3 normalization header.

Note that ECAT 6.3 normalization data is usually stored in scan file format, not in normalization format.

Returns: 0 if ok, 1 invalid input, 2 failed to find block, 3 failed to read block, 4 invalid data type, 5 invalid scale factor.

Parameters

fp	File pointer to ECAT file; position is not important.
blk	Block number from matrix list [2..number of blocks].
h	Pointer to the header struct where contents are put.
verbose	Verbose level; if zero, then only warnings are printed into stderr.
errmsg	Pointer to error message, at least 128 characters; enter NULL, if not needed.

Definition at line 483 of file ecat63r.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
  int vaxdata=1; /* 1 if data is in VAX format, else 0 */
 
  if(ECAT63_TEST) printf("ecat63ReadNormheader(fp, %d, nh)\n", blk);
  if(fp==NULL || blk<2 || h==NULL) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid input");
    if(verbose>0) fprintf(stderr, "Invalid input.\n");
    return(1);
  }
  little=little_endian();
  /* Seek the subheader block */
  fseeko(fp, (blk-1)*MatBLKSIZE, SEEK_SET); 
  if(ftello(fp)!=(blk-1)*MatBLKSIZE) {
    if(errmsg!=NULL) sprintf(errmsg, "failed to find block %d", blk);
    if(verbose>0) fprintf(stderr, "Failed to find block %d.\n", blk);
    return(2);
  }
  /* Read the subheader block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) {
    if(errmsg!=NULL) sprintf(errmsg, "failed to read block %d", blk);
    if(verbose>0) fprintf(stderr, "Failed to read block %d.\n", blk);
    return(3);
  }
 
  /* Copy short ints */
  /* in big endian platform, change byte order temporarily */
  if(!little) swabip(buf, MatBLKSIZE);
  memcpy(&h->data_type, buf+126, 2); if(h->data_type>4) vaxdata=0;
  if(verbose>10) printf("data_type=%d\n", h->data_type);
  memcpy(&h->dimension_1, buf+132, 2); memcpy(&h->dimension_2, buf+134, 2);
  memcpy(&h->norm_hour, buf+186, 2); memcpy(&h->norm_minute, buf+188, 2);
  memcpy(&h->norm_second, buf+190, 2); memcpy(&h->norm_day, buf+192, 2);
  memcpy(&h->norm_month, buf+194, 2); memcpy(&h->norm_year, buf+196, 2);
  /* Change back the byte order */
  if(!little) swabip(buf, MatBLKSIZE);
 
  /* Copy floats */
  h->scale_factor=ecat63rFloat(buf+182, vaxdata, little);
  h->fov_source_width=ecat63rFloat(buf+198, vaxdata, little);
 
  /* Check that most important contents are ok */
  if(h->data_type<BYTE_TYPE || h->data_type>SUN_I4) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid data types; probable conversion error");
    if(verbose>0) fprintf(stderr, "Invalid data types; probable conversion error.\n");
    if(verbose>1) printf("data_type := %d\n", h->data_type);
    return(4);
  }
  if(h->scale_factor<=0.0 || h->scale_factor>1.0e8) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid scale factor; probable conversion error");
    if(verbose>0) fprintf(stderr, "Invalid scale factor; probable conversion error.\n");
    return(5);
  }
  if(errmsg!=NULL) strcpy(errmsg, "ok");
 
  return(0);
}

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat6PrintSubheader(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ ecat63ReadPlaneToImg()

int ecat63ReadPlaneToImg	(	const char *	fname,
		IMG *	img )

extern

Reads one CTI ECAT 6.3 plane (all frames or gates) at a time to memory. Img data must be initialized before this procedure. Existing img->_dataType is not changed. If img data structure is empty, reads the first plane. If img data structure contains data, reads the next plane. Any existing data in img is cleared and replaced by the new plane.

Parameters

fname	name of the input ECAT 6.3 file
img	data structure in which the file is read

Returns: 0 if ok, 1 next plane was requested but not found any more, 2 invalid input data, 3 failed to open file, 4 failed to read main header, 5 failed to read matrix list, 6 invalid matrix data, 7 failed to read matrix sub header, 8 failed to allocate memory, 9 failed to read matrix data

Definition at line 550 of file img_e63.c.

                                                      {
  int                 m, ret, blkNr=0, dim_x=0, dim_y=0, del_nr=0;
  int                 frameNr, planeNr, datatype=0, firstm=0, isFirst=0;
  int                 frame, plane, prev_frame, prev_plane, prev_frameNr=0;
  FILE               *fp;
  ECAT63_mainheader   main_header;
  MATRIXLIST          mlist;
  MatDir              tmpMatdir;
  Matval              matval;
  ECAT63_imageheader  image_header;
  ECAT63_scanheader   scan_header;
  ECAT63_attnheader   attn_header;
  ECAT63_normheader   norm_header;
  float               scale=1.0;
  short int          *sptr;
  char               *mdata=NULL, *mptr;
  int                *iptr;
 
 
  if(IMG_TEST) printf("ecat63ReadPlaneToImg(%s, *img)\n", fname);
  /* Check the arguments */
  if(fname==NULL) {strcpy(ecat63errmsg, "invalid ECAT filename"); return(2);}
  if(img==NULL || img->status==IMG_STATUS_UNINITIALIZED) {
    strcpy(ecat63errmsg, "image data not initialized"); return(2);}
 
  /* Open input CTI file for read */
  if((fp=fopen(fname, "rb")) == NULL) {
    strcpy(ecat63errmsg, "cannot open ECAT file"); return(3);}
 
  /* Read main header */
  if((ret=ecat63ReadMainheader(fp, &main_header))) {
    sprintf(ecat63errmsg, "cannot read main header (%d)", ret);
    fclose(fp); return(4);
  }
  if(IMG_TEST) ecat63PrintMainheader(&main_header, stdout);
 
  /* Read matrix list and nr */
  ecat63InitMatlist(&mlist);
  ret=ecat63ReadMatlist(fp, &mlist, IMG_TEST);
  if(ret) {
    sprintf(ecat63errmsg, "cannot read matrix list (%d)", ret);
    fclose(fp); return(5);
  }
  if(mlist.matrixNr<=0) {
    strcpy(ecat63errmsg, "matrix list is empty"); fclose(fp); return(5);}
  /* Sort matrix list */
  for(int i=0; i<mlist.matrixNr-1; i++) for(int j=i+1; j<mlist.matrixNr; j++) {
    if(mlist.matdir[i].matnum>mlist.matdir[j].matnum) {
      tmpMatdir=mlist.matdir[i];
      mlist.matdir[i]=mlist.matdir[j]; mlist.matdir[j]=tmpMatdir;
    }
  }
  /* Trim extra frames */
  if(main_header.num_frames>0) {
    del_nr=ecat63DeleteLateFrames(&mlist, main_header.num_frames);
    if(IMG_TEST && del_nr>0)
      printf("  %d entries in matrix list will not be used.\n", del_nr);
  }
 
  /* Decide the plane to read */
  if(img->status==IMG_STATUS_OCCUPIED) {
    /* img contains data */
    isFirst=0; prev_frameNr=img->dimt;
    /* get the current plane in there */
    prev_plane=img->planeNumber[img->dimz-1];
    /* Clear all data in img: not here but only after finding new data */
  } else {
    /* img does not contain any data */
    isFirst=1;
    /* set "current plane" to -1 */
    prev_plane=-1;
  }
  /* from sorted matrix list, find first plane larger than the current one */
  plane=-1;
  for(int m=0; m<mlist.matrixNr; m++) if(mlist.matdir[m].matstat==1) {
    mat_numdoc(mlist.matdir[m].matnum, &matval);
    if(matval.plane>prev_plane) {plane=matval.plane; break;}
  }
  /* If not found, return an error or 1 if this was not the first one */
  if(plane<0) {
    fclose(fp); ecat63EmptyMatlist(&mlist);
    if(isFirst) {
      sprintf(ecat63errmsg, "ECAT file contains no matrices");
      return(7);
    } else {
      sprintf(ecat63errmsg, "ECAT file contains no more planes");
      if(IMG_TEST) printf("%s\n", ecat63errmsg);
      return(1);
    }
  }
  if(IMG_TEST) printf("Next plane to read: %d\n", plane);
  /* Clear all data in img */
  imgEmpty(img);
 
  /* Calculate the number of frames and gates */
  prev_frame=frame=-1; frameNr=0; ret=0; planeNr=1;
  for(int m=0; m<mlist.matrixNr; m++) if(mlist.matdir[m].matstat==1) {
    /* get frame and plane; work only with current plane */
    mat_numdoc(mlist.matdir[m].matnum, &matval);
    if(matval.plane<plane) continue; else if(matval.plane>plane) break;
    if(main_header.num_frames>=main_header.num_gates) frame=matval.frame;
    else frame=matval.gate;
    frameNr++;
    /* frame (gate) numbers must be continuous */
    if(prev_frame>0 && frame!=prev_frame+1) {ret=1; break;}
    prev_frame=frame;
    /* Calculate and check the size of one data matrix */
    if(frameNr==1) {
      firstm=m;
      blkNr=mlist.matdir[m].endblk-mlist.matdir[m].strtblk;
    } else if(blkNr!=mlist.matdir[m].endblk-mlist.matdir[m].strtblk) {
      ret=2; break;
    }
    prev_frame=frame;
  } /* next matrix */
  if(ret==1) {
    strcpy(ecat63errmsg, "missing matrix");
    ecat63EmptyMatlist(&mlist); fclose(fp); return(6);
  }
  if(ret==2) {
    strcpy(ecat63errmsg, "matrix sizes are different");
    ecat63EmptyMatlist(&mlist); fclose(fp); return(6);
  }
  /* Check that frameNr is equal to the dimt in IMG */
  if(!isFirst && frameNr!=prev_frameNr) {
    strcpy(ecat63errmsg, "different frame nr in different planes");
    ecat63EmptyMatlist(&mlist); fclose(fp); return(6);
  }
 
  /* Read x,y-dimensions from 1st matrix subheader on current plane */
  m=firstm; if(main_header.file_type==IMAGE_DATA) {
    ret=ecat63ReadImageheader(fp, mlist.matdir[m].strtblk, &image_header, IMG_TEST-10, NULL);
    dim_x=image_header.dimension_1; dim_y=image_header.dimension_2;
  } else if(main_header.file_type==RAW_DATA) {
    ret=ecat63ReadScanheader(fp, mlist.matdir[m].strtblk, &scan_header, IMG_TEST-10, NULL);
    dim_x=scan_header.dimension_1; dim_y=scan_header.dimension_2;
  } else if(main_header.file_type==ATTN_DATA) {
    ret=ecat63ReadAttnheader(fp, mlist.matdir[m].strtblk, &attn_header, IMG_TEST-10, NULL);
    dim_x=attn_header.dimension_1; dim_y=attn_header.dimension_2;
  } else if(main_header.file_type==NORM_DATA) {
    ret=ecat63ReadNormheader(fp, mlist.matdir[m].strtblk, &norm_header, IMG_TEST-10, NULL);
    dim_x=norm_header.dimension_1; dim_y=norm_header.dimension_2;
  }
  if(ret) {
    sprintf(ecat63errmsg, "cannot read matrix %u subheader",
            mlist.matdir[m].matnum);
    ecat63EmptyMatlist(&mlist); fclose(fp); return(7);
  }
 
  /* Allocate memory for ECAT data matrix */
  if(IMG_TEST) printf("allocating memory for %d blocks\n", blkNr);
  mdata=(char*)malloc((size_t)blkNr*MatBLKSIZE); if(mdata==NULL) {
    strcpy(ecat63errmsg, "out of memory");
    fclose(fp); ecat63EmptyMatlist(&mlist); return(8);
  }
  /* Allocate memory for whole img data */
  ret=imgAllocate(img, planeNr, dim_y, dim_x, frameNr);
  if(ret) {
    sprintf(ecat63errmsg, "out of memory (%d)", ret);
    fclose(fp); ecat63EmptyMatlist(&mlist); free(mdata); return(8);
  }
 
  /* Fill img info with ECAT main and sub header information */
  img->scanner=main_header.system_type;
  img->unit=main_header.calibration_units; /* this continues below */
  strlcpy(img->radiopharmaceutical, main_header.radiopharmaceutical, 32);
  img->isotopeHalflife=main_header.isotope_halflife;
  img->scanStart=ecat63Scanstarttime(&main_header);
  if(img->scanStart==-1) {
    img->scanStart=0;
    if(IMG_TEST>0) printf("invalid scan_start_time in mainheader\n");
  }
  img->axialFOV=10.*main_header.axial_fov;
  img->transaxialFOV=10.*main_header.transaxial_fov;
  strlcpy(img->studyNr, main_header.study_name, MAX_STUDYNR_LEN);
  strlcpy(img->patientName, main_header.patient_name, 32);
  strlcpy(img->patientID, main_header.patient_id, 16);
  img->sizez=10.*main_header.plane_separation;
  if(main_header.file_type==IMAGE_DATA) {
    img->type=IMG_TYPE_IMAGE;
    if(img->unit<1) img->unit=image_header.quant_units;
    img->zoom=image_header.recon_scale;
    if(image_header.decay_corr_fctr>1.0) img->decayCorrection=IMG_DC_CORRECTED;
    else img->decayCorrection=IMG_DC_UNKNOWN;
    img->sizex=img->sizey=10.*image_header.pixel_size;
    if(img->sizez<10.*image_header.slice_width)
      img->sizez=10.*image_header.slice_width;
    img->xform[0]=NIFTI_XFORM_UNKNOWN; // qform
    img->xform[1]=NIFTI_XFORM_SCANNER_ANAT; // sform
    img->quatern[6]=img->sizex; img->quatern[9]=img->sizex;
    img->quatern[11]=img->sizey; img->quatern[13]=img->sizey;
    img->quatern[16]=img->sizez; img->quatern[17]=img->sizez;
  } else if(main_header.file_type==RAW_DATA) {
    img->type=IMG_TYPE_RAW;
    img->decayCorrection=IMG_DC_NONCORRECTED;
  } else if(main_header.file_type==ATTN_DATA) {
    img->type=IMG_TYPE_ATTN;
    img->decayCorrection=IMG_DC_NONCORRECTED;
  } else if(main_header.file_type==NORM_DATA) {
    img->type=IMG_TYPE_RAW;
    img->decayCorrection=IMG_DC_NONCORRECTED;
  }
  img->planeNumber[0]=plane;
  strlcpy(img->studyDescription, main_header.study_description, 32);
  strlcpy(img->userProcessCode, main_header.user_process_code, 10);
  //img->userProcessCode[10]=(char)0;
  /* If valid study number is found in user_process_code, then take it */  
  if(!img->studyNr[0] && studynr_validity_check(img->userProcessCode))
    strlcpy(img->studyNr, img->userProcessCode, MAX_STUDYNR_LEN+1);
  /* Set _fileFormat */
  img->_fileFormat=IMG_E63;
 
  /* Read one ECAT matrix at a time and put them to img */
  for(m=firstm, frame=1; m<mlist.matrixNr; m++) if(mlist.matdir[m].matstat==1) {
    /* get plane */
    mat_numdoc(mlist.matdir[m].matnum, &matval);
    if(matval.plane>plane) break; /* Quit when current plane is read */
    /* Read subheader */
    if(main_header.file_type==IMAGE_DATA) {
      ret=ecat63ReadImageheader(fp, mlist.matdir[m].strtblk, &image_header, IMG_TEST-10, NULL);
      if(ret==0 && (dim_x!=image_header.dimension_1 || dim_y!=image_header.dimension_2)) ret=1;
      scale=image_header.quant_scale;
      if(image_header.ecat_calibration_fctr>0.0 &&
         fabs(main_header.calibration_factor/image_header.ecat_calibration_fctr - 1.0)>0.0001)
        scale*=image_header.ecat_calibration_fctr;
      if(img->unit==0 && image_header.quant_units>0)
        img->unit=image_header.quant_units;
      datatype=image_header.data_type;
      img->start[frame-1]=image_header.frame_start_time/1000.;
      img->end[frame-1]=img->start[frame-1]+image_header.frame_duration/1000.;
      img->mid[frame-1]=0.5*(img->start[frame-1]+img->end[frame-1]);
      if(image_header.decay_corr_fctr>1.0)
        img->decayCorrFactor[frame-1]=image_header.decay_corr_fctr;
      else
        img->decayCorrFactor[frame-1]=0.0;
    } else if(main_header.file_type==RAW_DATA) {
      ret=ecat63ReadScanheader(fp, mlist.matdir[m].strtblk, &scan_header, IMG_TEST-10, NULL);
      if(ret==0 && (dim_x!=scan_header.dimension_1 ||dim_y!=scan_header.dimension_2)) ret=1;
      scale=scan_header.scale_factor;
      if(scan_header.loss_correction_fctr>0.0) // dead-time correction
        scale*=scan_header.loss_correction_fctr;
      datatype=scan_header.data_type;
      img->start[frame-1]=scan_header.frame_start_time/1000.;
      img->end[frame-1]=img->start[frame-1]+scan_header.frame_duration/1000.;
      img->mid[frame-1]=0.5*(img->start[frame-1]+img->end[frame-1]);
      img->sampleDistance=10.0*scan_header.sample_distance;
      img->prompts[frame-1]=(float)scan_header.prompts;
      img->randoms[frame-1]=(float)scan_header.delayed;
    } else if(main_header.file_type==ATTN_DATA) {
      ret=ecat63ReadAttnheader(fp, mlist.matdir[m].strtblk, &attn_header, IMG_TEST-10, NULL);
      if(ret==0 && (dim_x!=attn_header.dimension_1 ||dim_y!=attn_header.dimension_2)) ret=1;
      img->sampleDistance=10.0*attn_header.sample_distance;
      scale=attn_header.scale_factor;
      datatype=attn_header.data_type;
    } else if(main_header.file_type==NORM_DATA) {
      ret=ecat63ReadNormheader(fp, mlist.matdir[m].strtblk, &norm_header, IMG_TEST-10, NULL);
      if(ret==0 && (dim_x!=norm_header.dimension_1 ||dim_y!=norm_header.dimension_2)) ret=1;
      scale=norm_header.scale_factor;
      datatype=norm_header.data_type;
    } else datatype=-1;
    if(ret) {
      sprintf(ecat63errmsg, "cannot read matrix %u subheader",
        mlist.matdir[m].matnum);
      ecat63EmptyMatlist(&mlist); free(mdata); fclose(fp); return(7);
    }
    if(main_header.calibration_factor>0.0)
      scale*=main_header.calibration_factor;
    if(IMG_TEST>2) printf("scale=%e datatype=%d\n", scale, datatype);
    /* Read the pixel data */
    ret=ecat63ReadMatdata(fp, mlist.matdir[m].strtblk+1,
         mlist.matdir[m].endblk-mlist.matdir[m].strtblk,
         mdata, datatype);
    if(ret) {
      strcpy(ecat63errmsg, "cannot read matrix data");
      ecat63EmptyMatlist(&mlist); free(mdata); fclose(fp); return(9);
    }
    mptr=mdata;
    if(datatype==BYTE_TYPE) {
      for(int i=0; i<dim_y; i++) for(int j=0; j<dim_x; j++, mptr++) {
        img->m[0][i][j][frame-1]=scale*(float)(*mptr);
      }
    } else if(datatype==VAX_I2 || datatype==SUN_I2) {
      for(int i=0; i<dim_y; i++) for(int j=0; j<dim_x; j++, mptr+=2) {
        sptr=(short int*)mptr;
        img->m[0][i][j][frame-1]=scale*(float)(*sptr);
      }
    } else if(datatype==VAX_I4 || datatype==SUN_I4) {
      for(int i=0; i<dim_y; i++) for(int j=0; j<dim_x; j++, mptr+=4) {
        iptr=(int*)mptr;
        img->m[0][i][j][frame-1]=scale*(float)(*iptr);
      }
    } else if(datatype==VAX_R4 || datatype==IEEE_R4) {
      for(int i=0; i<dim_y; i++) for(int j=0; j<dim_x; j++, mptr+=4) {
        memcpy(&img->m[0][i][j][frame-1], mptr, 4);
        img->m[0][i][j][frame-1]*=scale;
      }
    }
    frame++;
  } /* next matrix (frame) */
  /* Set the unit */
  imgUnitFromEcat(img, img->unit);
 
  /* Free memory and close file */
  free(mdata);
  ecat63EmptyMatlist(&mlist);
  fclose(fp);
 
  /* Set _dataType if it has not been set before */
  if(img->_dataType<1) img->_dataType=datatype;
  /* For saving, only 2-byte VAX data types are allowed */
  if(img->_dataType==VAX_I4 || img->_dataType==VAX_R4) img->_dataType=VAX_I2;
 
  return(0);
}

◆ ecat63ReadScanheader()

int ecat63ReadScanheader	(	FILE *	fp,
		int	blk,
		ECAT63_scanheader *	h,
		int	verbose,
		char *	errmsg )

extern

Read ECAT 6.3 scan header.

Returns: 0 if ok, 1 invalid input, 2 failed to find block, 3 failed to read block, 4 invalid data type, 5 invalid scale factor, 6 invalid frame duration.

Parameters

fp	File pointer to ECAT file; position is not important.
blk	Block number from matrix list [2..number of blocks].
h	Pointer to the header struct where contents are put.
verbose	Verbose level; if zero, then only warnings are printed into stderr.
errmsg	Pointer to error message, at least 128 characters; enter NULL, if not needed.

Definition at line 377 of file ecat63r.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
  int vaxdata=1; /* 1 if data is in VAX format, else 0 */
 
  if(ECAT63_TEST) printf("ecat63ReadScanheader(fp, %d, sh)\n", blk);
  if(fp==NULL || blk<2 || h==NULL) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid input");
    if(verbose>0) fprintf(stderr, "Invalid input.\n");
    return(1);
  }
  little=little_endian();
  /* Seek the subheader block */
  fseeko(fp, (blk-1)*MatBLKSIZE, SEEK_SET); 
  if(ftello(fp)!=(blk-1)*MatBLKSIZE) {
    if(errmsg!=NULL) sprintf(errmsg, "failed to find block %d", blk);
    if(verbose>0) fprintf(stderr, "Failed to find block %d.\n", blk);
    return(2);
  }
  /* Read the subheader block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) {
    if(errmsg!=NULL) sprintf(errmsg, "failed to read block %d", blk);
    if(verbose>0) fprintf(stderr, "Failed to read block %d.\n", blk);
    return(3);
  }
 
  /* Copy char data to header structure */
  memcpy(h->fill1, buf+0, 126);
 
  /* Copy short ints */
  /* in big endian platform, change byte order temporarily */
  if(!little) swabip(buf, MatBLKSIZE);
  memcpy(&h->data_type, buf+126, 2); if(h->data_type>4) vaxdata=0;
  /*printf("data_type=%d\n", h->data_type);*/
  memcpy(&h->dimension_1, buf+132, 2); memcpy(&h->dimension_2, buf+134, 2);
  memcpy(&h->smoothing, buf+136, 2); memcpy(&h->processing_code, buf+138, 2);
  memcpy(&h->frame_duration_sec, buf+170, 2);
  memcpy(&h->scan_min, buf+192, 2); memcpy(&h->scan_max, buf+194, 2);
  memcpy(h->fill2, buf+468, 44);
  /* Change back the byte order */
  if(!little) swabip(buf, MatBLKSIZE);
 
  /* Copy ints */
  h->gate_duration=ecat63rInt(buf+172, vaxdata, little);
  h->r_wave_offset=ecat63rInt(buf+176, vaxdata, little);
  h->prompts=ecat63rInt(buf+196, vaxdata, little);
  h->delayed=ecat63rInt(buf+200, vaxdata, little);
  h->multiples=ecat63rInt(buf+204, vaxdata, little);
  h->net_trues=ecat63rInt(buf+208, vaxdata, little);
  h->total_coin_rate=ecat63rInt(buf+452, vaxdata, little);
  h->frame_start_time=ecat63rInt(buf+456, vaxdata, little);
  h->frame_duration=ecat63rInt(buf+460, vaxdata, little);
 
  /* Copy floats */
  h->sample_distance=ecat63rFloat(buf+146, vaxdata, little);
  h->isotope_halflife=ecat63rFloat(buf+166, vaxdata, little);
  h->scale_factor=ecat63rFloat(buf+182, vaxdata, little);
  for(int i=0; i<16; i++) h->cor_singles[i]=ecat63rFloat(buf+316+i*4, vaxdata, little);
  for(int i=0; i<16; i++) h->uncor_singles[i]=ecat63rFloat(buf+380+i*4, vaxdata, little);
  h->tot_avg_cor=ecat63rFloat(buf+444, vaxdata, little);
  h->tot_avg_uncor=ecat63rFloat(buf+448, vaxdata, little);
  h->loss_correction_fctr=ecat63rFloat(buf+464, vaxdata, little);
 
  /* Check that most important contents are ok */
  if(h->data_type<BYTE_TYPE || h->data_type>SUN_I4) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid data types; probable conversion error");
    if(verbose>0) fprintf(stderr, "Invalid data types; probable conversion error.\n");
    if(verbose>1) printf("data_type := %d\n", h->data_type);
    return(4);
  }
  if(h->scale_factor<=0.0 || h->scale_factor>1.0e8) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid calibration factor; probable conversion error");
    if(verbose>0) fprintf(stderr, "Invalid calibration factor; probable conversion error.\n");
    return(5);
  }
  if(h->frame_duration<0.0 || h->frame_duration>1.0e12) {
    if(errmsg!=NULL) strcpy(errmsg, "invalid frame duration; probable conversion error");
    if(verbose>0) fprintf(stderr, "Invalid frame duration; probable conversion error.\n");
    return(6);
  }
  if(errmsg!=NULL) strcpy(errmsg, "ok");
 
  return(0);
}

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat63ReadScanMatrix(), ecat6PrintSubheader(), imgReadEcat63Frame(), and imgReadEcat63Header().

◆ ecat63ReadScanMatrix()

int ecat63ReadScanMatrix	(	FILE *	fp,
		int	first_block,
		int	last_block,
		ECAT63_scanheader *	h,
		float **	fdata )

extern

Read ECAT63 scan matrix header and data.

If only header is to be read, set last_block=first_block. Note: data is not calibrated with factor in main header.

Returns: 0 if ok, 1 invalid input, 5 failed to read sub header, 6 invalid (x,y,z) dimensions, 8 failed to allocate memory for meta-data, 9 failed to read matrix data, 11 failed to allocate memory for the data

Parameters

fp	ECAT file pointer.
first_block	Subheader record number.
last_block	Last data block number.
h	Pointer to subheader data which is filled.
fdata	Double pointer to the address of the matrix data; any old contents are not freed, therefore you must free the pointer after data is copied elsewhere.

Definition at line 731 of file ecat63r.c.

  {
  int ret, blockNr;
  char *mdata, *mptr, errmsg[128];
  float *_fdata, *fptr;
  short int *sptr;
  int *iptr;
  
  
  if(ECAT63_TEST) printf("ecat63ReadScanMatrix(fp, %d, %d, hdr, fdata)\n",
    first_block, last_block);
  if(fp==NULL || first_block<=MatFirstDirBlk || h==NULL) {
    sprintf(ecat63errmsg, "invalid function parameter.\n");
    return(1);
  }
  *fdata=(float*)NULL;
  
  /* Read subheader */
  ret=ecat63ReadScanheader(fp, first_block, h, ECAT63_TEST-2, errmsg);
  if(ret) {
    strcpy(ecat63errmsg, errmsg);
    return(5);
  }
  if(ECAT63_TEST>4) ecat63PrintScanheader(h, stdout);
  long long pxlNr=h->dimension_1*h->dimension_2;
  if(pxlNr<=0) {
    sprintf(ecat63errmsg, "invalid matrix dimension.\n");
    return(6);  
  }
  
  /* Read matrix data */
  blockNr=last_block-first_block; if(blockNr<1) return(0);
  mdata=(char*)malloc((size_t)blockNr*MatBLKSIZE);
  if(mdata==NULL) {
    sprintf(ecat63errmsg, "cannot allocate memory.\n");
    return(8);  
  }
  mptr=mdata;
  ret=ecat63ReadMatdata(fp, first_block+1, blockNr, mptr, h->data_type);
  if(ret || mdata==NULL) {
    sprintf(ecat63errmsg, "cannot read matrix data (%d).\n", ret);
    free(mdata); return(9);
  }
  
  /* Allocate memory for float data */
  _fdata=(float*)malloc((size_t)pxlNr*sizeof(float));
  if(_fdata==NULL) {
    sprintf(ecat63errmsg, "cannot allocate memory.\n");
    free(mdata); return(11);  
  }
 
  /* Convert matrix data to floats */
  fptr=_fdata; mptr=mdata;
  if(h->data_type==BYTE_TYPE) {
    for(long long i=0; i<pxlNr; i++, mptr++, fptr++)
      *fptr=h->scale_factor*(float)(*mptr);
  } else if(h->data_type==VAX_I2 || h->data_type==SUN_I2) {
    for(long long i=0; i<pxlNr; i++, mptr+=2, fptr++) {
      sptr=(short int*)mptr;
      *fptr=h->scale_factor*(float)(*sptr);
    }
  } else if(h->data_type==VAX_I4 || h->data_type==SUN_I4) {
    for(long long i=0; i<pxlNr; i++, mptr+=4, fptr++) {
      iptr=(int*)mptr;
      *fptr=h->scale_factor*(float)(*iptr);
    }
  } else if(h->data_type==VAX_R4 || h->data_type==IEEE_R4) {
    memcpy(fptr, mptr, pxlNr*4);
    for(long long i=0; i<pxlNr; i++, fptr++) *fptr *= h->scale_factor;
  }
  free(mdata);
  *fdata=_fdata;
 
  return(0);
}

Referenced by atnMake().

◆ ecat63rFloat()

float ecat63rFloat	(	void *	bufi,
		int	isvax,
		int	islittle )

extern

Reading ECAT 6.3 floats

Parameters

bufi	pointer to 32-bit long data block
isvax	1 for VAX format
islittle	1 for little endian

Returns: read float value

Definition at line 928 of file ecat63r.c.

  {
  union {unsigned int ul; float f;} t;
 
  memcpy(&t.ul, bufi, 4); if(t.ul==0) {return(0.0);}
  if(isvax) { /* if input is in VAX format */
    /* Swap words on i386 and bytes on SUN */
    if(islittle) swawip(&t.ul, 4); else swabip(&t.ul, 4);
    t.ul-=(2L<<23); /* subtract 2 from exp */
  } else { /* input is in i386 format */
    if(!islittle) swawbip(&t.ul, 4); /* Switch words and bytes on SUN */
  }
  return(t.f);
}

Referenced by ecat63ReadAttnheader(), ecat63ReadImageheader(), ecat63ReadMainheader(), ecat63ReadMatdata(), ecat63ReadNormheader(), and ecat63ReadScanheader().

◆ ecat63rInt()

int ecat63rInt	(	void *	bufi,
		int	isvax,
		int	islittle )

extern

Reading and writing ECAT 6.3 32-bit ints. 32-bit int format is same in VAX and i386

Parameters

bufi	pointer to 32-bit long data block
isvax	1 for VAX format
islittle	1 for littel endian

Returns: read data as interger number

Definition at line 953 of file ecat63r.c.

  {
  int i;
 
  if(isvax==0) {}  // just to prevent compiler warning
  /* Swap both words and bytes on SUN */
  memcpy(&i, bufi, 4); if(!islittle) swawbip(&i, 4);
  return(i);
}

Referenced by ecat63ReadImageheader(), ecat63ReadMatdata(), and ecat63ReadScanheader().

◆ ecat63Scanstarttime()

time_t ecat63Scanstarttime ( const ECAT63_mainheader * h )

extern

Get calendar time from ECAT 6.3 main header.

Author: Vesa Oikonen

Returns: Returns time_t, or -1 in case of an error.

Parameters

h	Pointer to ECAT 6.3 main header

Definition at line 925 of file ecat63w.c.

  {
  if(h==NULL) return((time_t)-1);
  struct tm tm;
  tm.tm_mday=h->scan_start_day;
  tm.tm_mon=h->scan_start_month-1;
  tm.tm_year=h->scan_start_year-1900;
  tm.tm_hour=h->scan_start_hour;
  tm.tm_min=h->scan_start_minute;
  tm.tm_sec=h->scan_start_second;
  tm.tm_isdst=-1;
  return(timegm(&tm));
}

Referenced by atnMake(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecatCopy63to7mainheader(), and imgGetEcat63MHeader().

◆ ecat63ScanstarttimeInt()

char * ecat63ScanstarttimeInt	(	const ECAT63_mainheader *	h,
		char *	buf )

extern

Convert scan_start_time in ECAT 6.3 main header into a null-terminated string of the form YYYY-MM-DD hh:mm:ss, with length of 19 characters and the null.

Author: Vesa Oikonen

Returns: Returns pointer to the string, or null in case of an error.

Parameters

h	Pointer to ECAT 6.3 main header.
buf	Pointer to string where the date and time will be written. It must be pre-allocated for at least 20 characters.

Definition at line 391 of file ecat63p.c.

  {
  //printf("ecat63ScanstarttimeInt()\n");
  if(buf==NULL) return(NULL);
  buf[0]=(char)0;
  if(h==NULL) return(NULL);
  if(h->scan_start_year<0 || h->scan_start_year>9999) return(NULL);
  if(h->scan_start_month<0 || h->scan_start_month>12) return(NULL);
  if(h->scan_start_day<0 || h->scan_start_day>31) return(NULL);
  if(h->scan_start_hour<0 || h->scan_start_hour>24) return(NULL);
  if(h->scan_start_minute<0 || h->scan_start_minute>59) return(NULL);
  if(h->scan_start_second<0 || h->scan_start_second>59) return(NULL);
  sprintf(buf, "%04d-%02d-%02d %02d:%02d:%02d", 
          h->scan_start_year, h->scan_start_month, h->scan_start_day, 
          h->scan_start_hour, h->scan_start_minute, h->scan_start_second);
  return(buf);
}

Referenced by imgGetEcat63MHeader(), and imgWriteEcat63Frame().

◆ ecat63ScanstarttimeToTm()

struct tm * ecat63ScanstarttimeToTm	(	const ECAT63_mainheader *	h,
		struct tm *	tm )

extern

Convert scan_start_time in ECAT 6.3 main header into a struct tm.

Author: Vesa Oikonen

Returns: Returns pointer to the struct_tm, or null in case of an error.

Parameters

h	Pointer to ECAT 6.3 main header
tm	Pointer to pre-allocated struct tm.

Definition at line 900 of file ecat63w.c.

  {
  if(tm==NULL || h==NULL) return(NULL);
  memset(tm, 0, sizeof(struct tm));
  tm->tm_mday=h->scan_start_day;
  tm->tm_mon=h->scan_start_month-1;
  tm->tm_year=h->scan_start_year-1900;
  tm->tm_hour=h->scan_start_hour;
  tm->tm_min=h->scan_start_minute;
  tm->tm_sec=h->scan_start_second;
  tm->tm_isdst=-1;
  if(timegm(tm)==-1) return(NULL);
  return(tm);
}

◆ ecat63SortMatlistByFrame()

void ecat63SortMatlistByFrame ( MATRIXLIST * ml )

extern

Sort matrixlist by frame and plane. Bubble sorting algorithm.

Parameters

ml	matrix list

Definition at line 297 of file ecat63ml.c.

  {
  Matval mv1, mv2;
  MatDir tmpMatdir;
 
  for(int i=0; i<ml->matrixNr-1; i++) {
    mat_numdoc(ml->matdir[i].matnum, &mv1);
    for(int j=i+1; j<ml->matrixNr; j++) {
      mat_numdoc(ml->matdir[j].matnum, &mv2);
      if(mv2.frame<mv1.frame||(mv2.frame==mv1.frame&&mv2.plane<mv1.plane)) {
        tmpMatdir=ml->matdir[i];
        ml->matdir[i]=ml->matdir[j]; ml->matdir[j]=tmpMatdir;
        mat_numdoc(ml->matdir[i].matnum, &mv1);
      }
    }
  }
}

Referenced by imgReadEcat63Frame().

◆ ecat63SortMatlistByPlane()

void ecat63SortMatlistByPlane ( MATRIXLIST * ml )

extern

Sort matrixlist by plane and frame. Bubble sorting algorithm.

Parameters

ml	marix list.

Definition at line 271 of file ecat63ml.c.

  {
  Matval mv1, mv2;
  MatDir tmpMatdir;
 
  for(int i=0; i<ml->matrixNr-1; i++) {
    mat_numdoc(ml->matdir[i].matnum, &mv1);
    for(int j=i+1; j<ml->matrixNr; j++) {
      mat_numdoc(ml->matdir[j].matnum, &mv2);
      if(mv2.plane<mv1.plane||(mv2.plane==mv1.plane&&mv2.frame<mv1.frame)) {
        tmpMatdir=ml->matdir[i];
        ml->matdir[i]=ml->matdir[j]; ml->matdir[j]=tmpMatdir;
        mat_numdoc(ml->matdir[i].matnum, &mv1);
      }
    }
  }
}

Referenced by ecat63GetPlaneAndFrameNr(), and imgReadEcat63Header().

◆ ecat63Unit()

char * ecat63Unit ( short int dunit )

extern

Returns pointer to string describing the calibrated data unit (ECAT 6.3).

Parameters

dunit data unit code

Returns: pointer to static string

Definition at line 243 of file ecat63p.c.

  {
  static char *ecat63_unit[]={
  /*  0 */  "Unknown",
  /*  1 */  "Unknown",
  /*  2 */  "ECAT counts",
  /*  3 */  "uCi/ml",
  /*  4 */  "LMRGlu",
  /*  5 */  "LMRUGlu umol/min/100g",
  /*  6 */  "LMRUGlu mg/min/100g",
  /*  7 */  "nCi/mL",
  /*  8 */  "Well counts",
  /*  9 */  "Becquerels",
  /* 10 */  "kBq/mL",
  /* 11 */  "1/min",
  /* 12 */  "mL/min/100g",
  /* 13 */  "sec*kBq/mL",
  /* 14 */  "sec*nCi/mL",
  /* 15 */  "1/sec",
  /* 16 */  "Unitless",
  /* 17 */  "Unknown"
  };
  if(dunit>=0 && dunit<18) return(ecat63_unit[dunit]);
  else return(ecat63_unit[0]);
}

Referenced by ecat63PrintImageheader(), and ecat63PrintMainheader().

◆ ecat63wFloat()

void ecat63wFloat	(	float *	bufi,
		void *	bufo,
		int	tovax,
		int	islittle )

extern

Writing ECAT 6.3 floats

Parameters

bufi	pointer to 4-byte long input (float data)
bufo	pointer to 4-byte long output
tovax	1 for VAX format
islittle	1 for little endian

Definition at line 860 of file ecat63w.c.

  {
  unsigned int ul;
 
  memcpy(&ul, bufi, 4); if(ul==0) {memcpy(bufo, bufi, 4); return;}
  if(tovax) { /* If VAX format is needed */
    ul+=(2L<<23); /* increase exp by 2 */
    /* Swap words on i386 and bytes on SUN */
    if(islittle) swawip(&ul, 4); else swabip(&ul, 4);
  } else {
    if(!islittle) swawbip(&ul, 4); /* Switch words and bytes on SUN */
  }
  memcpy(bufo, &ul, 4);
}

Referenced by ecat63WriteAttnheader(), ecat63WriteImageheader(), ecat63WriteMainheader(), ecat63WriteNormheader(), and ecat63WriteScanheader().

◆ ecat63wInt()

void ecat63wInt	(	int *	bufi,
		void *	bufo,
		int	tovax,
		int	islittle )

extern

Writing ECAT 6.3 32-bit ints. 32-bit int format is same in VAX and i386

Parameters

bufi	pointer to 4-byte long input (integer data)
bufo	pointer to 4-byte long output
tovax	1 for VAX format
islittle	1 for little endian

Definition at line 884 of file ecat63w.c.

                                                                {
  int i;
 
  if(tovax==0) {} // to prevent compiler warning
  /* Swap both words and bytes on SUN */
  memcpy(&i, bufi, 4); if(!islittle) swawbip(&i, 4);
  memcpy(bufo, &i, 4);
}

Referenced by ecat63WriteImageheader(), and ecat63WriteScanheader().

◆ ecat63WriteAllImg()

int ecat63WriteAllImg	(	const char *	fname,
		IMG *	img )

extern

Write all matrices in memory to the ECAT file.

Parameters

fname	name of the output ECAT 6.3 file, If ECAT file exists, it is renamed as `filename%`
img	data structure from which the data is written

Returns: 0 if ok, 1 invalid data, 2 image status is not 'occupied', 3 failed to create file, 4 failed to allocate memory for data, 9 failed to write data

Definition at line 335 of file img_e63.c.

                                                   {
  int                 frame, plane, m, ret=0;
  float               f, fmax, fmin, g, scale;
  short int          *sdata, *sptr, smin, smax;
  FILE               *fp;
  ECAT63_mainheader   main_header;
  ECAT63_imageheader  image_header;
  ECAT63_scanheader   scan_header;
  struct tm           tm;
 
  if(IMG_TEST) printf("ecat63WriteAllImg(%s, *img)\n", fname);
  /* Check the arguments */
  if(fname==NULL) {strcpy(ecat63errmsg, "invalid ECAT filename"); return(1);}
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    strcpy(ecat63errmsg, "image data is empty"); return(2);}
  if(img->_dataType<1) img->_dataType=VAX_I2;
 
  /* Check image size */
  if(img->dimt>511 || img->dimz>255 || img->dimx>1024 || img->dimy>1024) {
    strcpy(ecat63errmsg, "too large matrix size"); return(1);}
 
  /* Initiate headers */
  memset(&main_header, 0, sizeof(ECAT63_mainheader));
  memset(&image_header,0, sizeof(ECAT63_imageheader));
  memset(&scan_header, 0, sizeof(ECAT63_scanheader));
 
  /* Make a main header */
  main_header.sw_version=2;
  main_header.num_planes=img->dimz;  
  main_header.num_frames=img->dimt;  
  main_header.num_gates=1;
  main_header.num_bed_pos=1;
  if(img->type==IMG_TYPE_IMAGE) main_header.file_type=IMAGE_DATA;
  else if(img->type==IMG_TYPE_RAW) main_header.file_type=RAW_DATA;
  else {strcpy(ecat63errmsg, "invalid filetype"); return(1);}
  main_header.data_type=img->_dataType;
  if(img->scanner>0) main_header.system_type=img->scanner;
  else main_header.system_type=ECAT63_SYSTEM_TYPE_DEFAULT;
  main_header.calibration_factor=1.0;
  main_header.axial_fov=img->axialFOV/10.0;
  main_header.transaxial_fov=img->transaxialFOV/10.0;
  main_header.plane_separation=img->sizez/10.0;
  main_header.calibration_units=imgUnitToEcat6(img);
  strncpy(main_header.radiopharmaceutical, img->radiopharmaceutical, 32);
  if(gmtime_r((time_t*)&img->scanStart, &tm)!=NULL) {
    main_header.scan_start_year=tm.tm_year+1900;
    main_header.scan_start_month=tm.tm_mon+1;
    main_header.scan_start_day=tm.tm_mday;
    main_header.scan_start_hour=tm.tm_hour;
    main_header.scan_start_minute=tm.tm_min;
    main_header.scan_start_second=tm.tm_sec;
    if(IMG_TEST>2) {
      printf("  img->scanStart := %ld\n", (long int)img->scanStart);
      printf("  -> tm_year := %d\n", tm.tm_year);
      printf("  -> tm_hour := %d\n", tm.tm_hour);
    } 
  } else {
    main_header.scan_start_year=1900;
    main_header.scan_start_month=1;
    main_header.scan_start_day=1;
    main_header.scan_start_hour=0;
    main_header.scan_start_minute=0;
    main_header.scan_start_second=0;
    if(IMG_TEST>0) printf("invalid scan_start_time in IMG\n");
  }
  main_header.isotope_halflife=img->isotopeHalflife;
  strcpy(main_header.isotope_code, imgIsotope(img));
  strlcpy(main_header.study_name, img->studyNr, 12);
  strcpy(main_header.patient_name, img->patientName);
  strcpy(main_header.patient_id, img->patientID);
  strlcpy(main_header.user_process_code, img->userProcessCode, 10);
  strncpy(main_header.study_description, img->studyDescription, 32);
  if(IMG_TEST) ecat63PrintMainheader(&main_header, stdout);
 
  /* Allocate memory for matrix data */
  sdata=(short int*)malloc((size_t)img->dimx*img->dimy*sizeof(short int));
  if(sdata==NULL) {strcpy(ecat63errmsg, "out of memory"); return(4);}
 
  /* Open output ECAT file */
  fp=ecat63Create(fname, &main_header);
  if(fp==NULL) {strcpy(ecat63errmsg, "cannot write ECAT file"); return(3);}
 
  /* Set the subheader contents, as far as possible */
  switch(main_header.file_type) {
    case RAW_DATA:
      scan_header.data_type=main_header.data_type;
      scan_header.dimension_1=img->dimx;
      scan_header.dimension_2=img->dimy;
      scan_header.frame_duration_sec=1;
      scan_header.scale_factor=1.0;
      scan_header.frame_start_time=0;
      scan_header.frame_duration=1000;
      /* Deadtime correction was done when reading, set to 1.0 to prevent
         second correction when reading again. */
      scan_header.loss_correction_fctr=1.0;
      /*if(IMG_TEST) ecat63PrintScanheader(&scan_header);*/
      break;
    case IMAGE_DATA:
      image_header.data_type=main_header.data_type;
      image_header.num_dimensions=2;
      image_header.dimension_1=img->dimx;
      image_header.dimension_2=img->dimy;
      image_header.recon_scale=img->zoom;
      image_header.quant_scale=1.0;
      image_header.slice_width=img->sizez/10.;
      image_header.pixel_size=img->sizex/10.;
      image_header.frame_start_time=0;
      image_header.frame_duration=1000;
      image_header.plane_eff_corr_fctr=1.0;
      image_header.decay_corr_fctr=1.0;
      image_header.loss_corr_fctr=1.0;
      image_header.ecat_calibration_fctr=1.0;
      image_header.well_counter_cal_fctr=1.0;
      image_header.quant_units=main_header.calibration_units;
      /*if(IMG_TEST) ecat63PrintImageheader(&image_header);*/
      break;
  }
 
  /* Write one matrix at a time */
  int n=0;
  for(plane=1; plane<=img->dimz;plane++) for(frame=1;frame<=img->dimt;frame++) {
    /* Scale data to short ints */
    /* Search min and max */
    fmin=fmax=f=img->m[plane-1][0][0][frame-1];
    for(int i=0; i<img->dimy; i++) for(int j=0; j<img->dimx; j++) {
      f=img->m[plane-1][i][j][frame-1];
      if(f>fmax) fmax=f; else if(f<fmin) fmin=f;
    }
    /* Calculate scaling factor */
    if(fabs(fmin)>fabs(fmax)) g=fabs(fmin); else g=fabs(fmax);
    if(!isfinite(g)) {
      sprintf(ecat63errmsg, "invalid pixel values on pl%02d fr%02d (%d).", plane, frame, ret);
      fclose(fp); remove(fname); free(sdata);
      return(1);
    }
    if(g>0.0) scale=32766./g; else scale=1.0;
    if(!isfinite(scale)) scale=1.0;
    // printf("fmin=%e fmax=%e g=%e scale=%e\n", fmin, fmax, g, scale);
    /* Scale matrix data to shorts */
    sptr=sdata;
    for(int i=0; i<img->dimy; i++) for(int j=0; j<img->dimx; j++) {
      *sptr=(short int)temp_roundf(scale*img->m[plane-1][i][j][frame-1]);
      sptr++;
    }
    /* Calculate and set subheader min&max and scale */
    smin=(short int)temp_roundf(scale*fmin);
    smax=(short int)temp_roundf(scale*fmax);
    if(main_header.file_type==RAW_DATA) {
      scan_header.scan_min=smin; scan_header.scan_max=smax;
      scan_header.scale_factor=1.0/scale;
      scan_header.frame_start_time=(int)temp_roundf(1000.*img->start[frame-1]);
      scan_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[frame-1]-img->start[frame-1]));
      scan_header.sample_distance=(img->sampleDistance)/10.0;
      scan_header.prompts=temp_roundf(img->prompts[frame-1]);
      scan_header.delayed=temp_roundf(img->randoms[frame-1]);
    } else if(main_header.file_type==IMAGE_DATA) {
      image_header.image_min=smin; image_header.image_max=smax;
      image_header.quant_scale=1.0/scale;
      //if(!isfinite(image_header.quant_scale))
      //  printf("g=%g scale=%g quant_scale=%g\n", g, scale, image_header.quant_scale);
      image_header.frame_start_time=(int)temp_roundf(1000.*img->start[frame-1]);
      image_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[frame-1]-img->start[frame-1]));
      /* Set decay correction factor */
      if(img->decayCorrection==IMG_DC_CORRECTED)
        image_header.decay_corr_fctr=img->decayCorrFactor[frame-1];
      else
        image_header.decay_corr_fctr=0.0;
    } 
    /* Write matrix data */
    m=mat_numcod(frame, img->planeNumber[plane-1], 1, 0, 0);
    sptr=sdata;
    if(IMG_TEST) printf("  writing matnum=%d\n", m);
    if(main_header.file_type==RAW_DATA) {
      if(IMG_TEST) ecat63PrintScanheader(&scan_header, stdout);
      ret=ecat63WriteScan(fp, m, &scan_header, sptr);
    } else if(main_header.file_type==IMAGE_DATA) {
      if(IMG_TEST) ecat63PrintImageheader(&image_header, stdout);
      ret=ecat63WriteImage(fp, m, &image_header, sptr);
    }
    if(ret) {
      sprintf(ecat63errmsg, "cannot write data on pl%02d fr%02d (%d).",
        plane, frame, ret);
      fclose(fp); remove(fname); free(sdata);
      return(9);
    }
    n++;
  } /* next matrix */
  if(IMG_TEST) printf("  %d matrices written in %s\n", n, fname);
 
  /* Close file and free memory */
  fclose(fp); free(sdata);
 
  return(0);
}

Referenced by imgWrite().

◆ ecat63WriteAttn()

int ecat63WriteAttn	(	FILE *	fp,
		int	matnum,
		ECAT63_attnheader *	h,
		void *	data )

extern

Write ECAT 6.3 attenuation matrix header and data

Parameters

fp	target file pointer
matnum	matrix number [1..number of matrixes]
h	Ecat 6.3 attenuation header
data	pointer to data that is written

Returns: 0 if ok, 1 invalid input or invalid image dimensions, 2 failed to resolve data type 3 too little data size, 4 failed to resolve next block size in file

Definition at line 563 of file ecat63w.c.

  {
  int nxtblk, blkNr, pxlSize, ret;
 
  if(ECAT63_TEST) printf("ecat63WriteAttn(fp, %d, ah, data)\n", matnum);
  if(fp==NULL || matnum<1 || h==NULL || data==NULL) return(1);
  /* nr of pixels */
  long long pxlNr=h->dimension_1*h->dimension_2; if(pxlNr<1) return(1);
  /* mem taken by one pixel */
  switch(h->data_type) {
    case BYTE_TYPE: pxlSize=1;
      break;
    case VAX_I2:
    case SUN_I2: pxlSize=2;
      break;
    case VAX_I4: return(3);
    case VAX_R4: return(3);
    case IEEE_R4:
    case SUN_I4: pxlSize=4;
      break;
    default: return(2);
  }
  /* mem taken by all pixels */
  long long data_size=pxlNr*pxlSize;
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) return(3);
  /* Get block number for matrix header and data */
  nxtblk=ecat63Matenter(fp, matnum, blkNr); if(nxtblk<1) return(4);
  if(ECAT63_TEST) printf("  block=%d\n", nxtblk);
  /* Write header */
  ret=ecat63WriteAttnheader(fp, nxtblk, h); if(ret) return(40+ret);
  /* Write matrix data */
  ret=ecat63WriteMatdata(fp, nxtblk+1, data, pxlNr, pxlSize);
  if(ret) return(50+ret);
  return 0;
}

Referenced by atnMake().

◆ ecat63WriteAttnheader()

int ecat63WriteAttnheader	(	FILE *	fp,
		int	block,
		ECAT63_attnheader *	h )

extern

Write ECAT 6.3 attenuation header

Parameters

fp	target file pointer
block	block number [>=3]
h	Ecat 6.3 attenuation header

Returns: 0 if ok, 1 invalid input, 2 failed to find block, 3 failed to write block

Definition at line 190 of file ecat63w.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little, tovax;
 
  if(ECAT63_TEST) printf("ecat63WriteAttnheader(fp, %d, ah)\n", block);
  little=little_endian();
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  /* Check arguments */
  if(fp==NULL || block<3 || h->data_type<1 || h->data_type>7) return(1);
  if(h->data_type==VAX_I2 || h->data_type==VAX_I4 || h->data_type==VAX_R4)
    tovax=1; else tovax=0;
 
  /* Copy short ints to buf */
  memcpy(buf+126, &h->data_type, 2); 
  memcpy(buf+128, &h->attenuation_type, 2);
  memcpy(buf+132, &h->dimension_1, 2); 
  memcpy(buf+134, &h->dimension_2, 2);
  /* big to little endian if necessary */
  if(!little) swabip(buf, MatBLKSIZE);
 
  /* Copy floats to buf */
  ecat63wFloat(&h->scale_factor, buf+182, tovax, little);
  ecat63wFloat(&h->x_origin, buf+186, tovax, little);
  ecat63wFloat(&h->y_origin, buf+190, tovax, little);
  ecat63wFloat(&h->x_radius, buf+194, tovax, little);
  ecat63wFloat(&h->y_radius, buf+198, tovax, little);
  ecat63wFloat(&h->tilt_angle, buf+202, tovax, little);
  ecat63wFloat(&h->attenuation_coeff, buf+206, tovax, little);
  ecat63wFloat(&h->sample_distance, buf+210, tovax, little);
 
  /* Write subheader */
  fseeko(fp, (block-1)*MatBLKSIZE, SEEK_SET);
  if(ftello(fp)!=(block-1)*MatBLKSIZE) return(2);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(3);
 
  return(0);
}

Referenced by ecat63WriteAttn().

◆ ecat63WriteImage()

int ecat63WriteImage	(	FILE *	fp,
		int	matnum,
		ECAT63_imageheader *	h,
		void *	data )

extern

Write ECAT 6.3 image matrix header and data

Parameters

fp	target file pointer
matnum	matrix number [1..number of matrixes]
h	Ecat 6.3 image header
data	pointer to data that is written

Returns: 0 if ok, 1 invalid input or invalid image dimensions, 2 failed to resolve data type 3 too little data size, 4 failed to resolve next block size in file

Definition at line 410 of file ecat63w.c.

  {
  int nxtblk, blkNr, pxlSize, ret;
 
  if(ECAT63_TEST) printf("ecat63WriteImage(fp, %d, ih, data)\n", matnum);
  if(fp==NULL || matnum<1 || h==NULL || data==NULL) return(1);
  /* nr of pixels */
  long long pxlNr=h->dimension_1*h->dimension_2; if(pxlNr<1) return(2);
  /* mem taken by one pixel */
  switch(h->data_type) {
    case BYTE_TYPE: pxlSize=1;
      break;
    case VAX_I2:
    case SUN_I2: pxlSize=2;
      break;
    case VAX_I4: return(3);
    case VAX_R4: return(3);
    case IEEE_R4:
    case SUN_I4: pxlSize=4;
      break;
    default: return(2);
  }
  /* mem taken by all pixels */
  long long data_size=pxlNr*pxlSize;
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) return(3);
  /* Get block number for matrix header and data */
  nxtblk=ecat63Matenter(fp, matnum, blkNr); if(nxtblk<1) return(4);
  if(ECAT63_TEST) printf("  block=%d\n", nxtblk);
  /* Write header */
  ret=ecat63WriteImageheader(fp, nxtblk, h); if(ret) return(40+ret);
  /* Write matrix data */
  ret=ecat63WriteMatdata(fp, nxtblk+1, data, pxlNr, pxlSize);
  if(ret) return(50+ret);
  return 0;
}

Referenced by ecat63AddImg(), and ecat63WriteAllImg().

◆ ecat63WriteImageheader()

int ecat63WriteImageheader	(	FILE *	fp,
		int	block,
		ECAT63_imageheader *	h )

extern

Write ECAT 6.3 image header

Parameters

fp	target file pointer
block	block number [>= 3]
h	Ecat 6.3 image header

Returns: 0, if ok, 1 invalid input, 2 failed to find block, 3 failed to write block

Definition at line 106 of file ecat63w.c.

  {
  char buf[MatBLKSIZE];
  int little, tovax;
 
 
  if(ECAT63_TEST) printf("ecat63WriteImageheader(fp, %d, ih)\n", block);
  little=little_endian();
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  /* Check arguments */
  if(fp==NULL || block<3 || h->data_type<1 || h->data_type>7) return(1);
  if(h->data_type==VAX_I2 || h->data_type==VAX_I4 || h->data_type==VAX_R4)
    tovax=1; else tovax=0;
 
  /* Copy short ints to buf */
  memcpy(buf+126, &h->data_type, 2); 
  memcpy(buf+128, &h->num_dimensions, 2);
  memcpy(buf+132, &h->dimension_1, 2); 
  memcpy(buf+134, &h->dimension_2, 2);
  memcpy(buf+176, &h->image_min, 2); 
  memcpy(buf+178, &h->image_max, 2);
  memcpy(buf+200, &h->slice_location, 2); 
  memcpy(buf+202, &h->recon_start_hour, 2);
  memcpy(buf+204, &h->recon_start_min, 2); 
  memcpy(buf+206, &h->recon_start_sec, 2);
  memcpy(buf+236, &h->filter_code, 2); 
  memcpy(buf+376, &h->processing_code, 2);
  memcpy(buf+380, &h->quant_units, 2); 
  memcpy(buf+382, &h->recon_start_day, 2);
  memcpy(buf+384, &h->recon_start_month, 2); 
  memcpy(buf+386, &h->recon_start_year, 2); 
  memcpy(buf+460, h->fill2, 52);
  /* big to little endian if necessary */
  if(!little) swabip(buf, MatBLKSIZE);
 
  /* Copy floats to buf */
  ecat63wFloat(&h->x_origin, buf+160, tovax, little);
  ecat63wFloat(&h->y_origin, buf+164, tovax, little);
  ecat63wFloat(&h->recon_scale, buf+168, tovax, little);
  ecat63wFloat(&h->quant_scale, buf+172, tovax, little);
  ecat63wFloat(&h->pixel_size, buf+184, tovax, little);
  ecat63wFloat(&h->slice_width, buf+188, tovax, little);
  ecat63wFloat(&h->image_rotation, buf+296, tovax, little);
  ecat63wFloat(&h->plane_eff_corr_fctr, buf+300, tovax, little);
  ecat63wFloat(&h->decay_corr_fctr, buf+304, tovax, little);
  ecat63wFloat(&h->loss_corr_fctr, buf+308, tovax, little);
  ecat63wFloat(&h->intrinsic_tilt, buf+312, tovax, little);
  ecat63wFloat(&h->ecat_calibration_fctr, buf+388, tovax, little);
  ecat63wFloat(&h->well_counter_cal_fctr, buf+392, tovax, little);
  for(int i=0; i<6; i++) 
    ecat63wFloat(&h->filter_params[i], buf+396+4*i, tovax, little);
 
  /* Copy ints to buf */
  ecat63wInt(&h->frame_duration, buf+192, tovax, little);
  ecat63wInt(&h->frame_start_time, buf+196, tovax, little);
  ecat63wInt(&h->scan_matrix_num, buf+238, tovax, little);
  ecat63wInt(&h->norm_matrix_num, buf+242, tovax, little);
  ecat63wInt(&h->atten_cor_mat_num, buf+246, tovax, little);
 
  /* Copy chars */
  memcpy(buf+0, h->fill1, 126); 
  memcpy(buf+420, h->annotation, 40);
 
  /* Write subheader */
  fseeko(fp, (block-1)*MatBLKSIZE, SEEK_SET); 
  if(ftello(fp)!=(block-1)*MatBLKSIZE) return(2);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(3);
 
  return(0);
}

Referenced by ecat63WriteImage(), and ecat63WriteImageMatrix().

◆ ecat63WriteImageMatrix()

int ecat63WriteImageMatrix	(	FILE *	fp,
		int	matnum,
		ECAT63_imageheader *	h,
		float *	fdata )

extern

Write ECAT 6.3 image matrix header and data

Parameters

fp	target file pointer
matnum
h	Ecat 6.3 image header
fdata

Returns: 0 if ok, 1 invalid input, 3 invalid matrix dimensions, 4 invalid block number, 5 failed to allocate memory, 8 failed to resolve new matrix block number, 10 failed to write image sub header, 13 failed to write matrix data

Definition at line 697 of file ecat63w.c.

  {
  int nxtblk, blkNr, ret;
  float *fptr, fmin, fmax, g, f;
  char *mdata, *mptr;
  short int *sptr;
 
 
 
  if(ECAT63_TEST) printf("ecat63WriteImageMatrix(fp, %d, h, data)\n", matnum);
  if(fp==NULL || matnum<1 || h==NULL || fdata==NULL) {
    sprintf(ecat63errmsg, "invalid function parameter.\n");
    return(1);
  }
  /* nr of pixels */
  long long pxlNr=h->dimension_1*h->dimension_2;
  if(pxlNr<1) {
    sprintf(ecat63errmsg, "invalid matrix dimension.\n");
    return(3);
  }
  /* How much memory is needed for ALL pixels */
  long long data_size=pxlNr*ecat63pxlbytes(h->data_type);
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) {
    sprintf(ecat63errmsg, "invalid block number.\n");
    return(4);
  }
  /* Allocate memory for matrix data */
  mdata=(char*)calloc(blkNr, MatBLKSIZE); if(mdata==NULL) {
    sprintf(ecat63errmsg, "out of memory.\n");
    return(5);
  }
  /* Search for min and max for calculation of scale factor */
  fMinMaxFin(fdata, pxlNr, &fmin, &fmax);
  if(fabs(fmin)>fabs(fmax)) g=fabs(fmin); else g=fabs(fmax);
  if(g>0) f=32766./g; else f=1.0;
  /* Check if pixels values can be left as such with scale_factor = 1 */
  fptr=fdata;
  if(f>=1.0 && ecat63_is_scaling_needed(g, fptr, pxlNr)==0) f=1.0;
  /* Scale matrix data to shorts */
  h->quant_scale=1.0/f;
  sptr=(short int*)mdata; fptr=fdata;
  for(long long i=0; i<pxlNr; i++, sptr++, fptr++)
    *sptr=(short int)temp_roundf(f*(*fptr));
  /* Set header short min & max */
  h->image_min=(short int)temp_roundf(f*fmin);
  h->image_max=(short int)temp_roundf(f*fmax);
  /* Get block number for matrix header and data */
  nxtblk=ecat63Matenter(fp, matnum, blkNr); if(nxtblk<1) {
    sprintf(ecat63errmsg, "cannot determine matrix block (%d).\n", -nxtblk);
    free(mdata); return(8);
  }
  if(ECAT63_TEST>2) printf("  block=%d fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
  /* Write header */
  ret=ecat63WriteImageheader(fp, nxtblk, h); if(ret) {
    sprintf(ecat63errmsg, "cannot write subheader (%d).\n", ret);
    free(mdata); return(10);
  }
  /* Write matrix data */
  mptr=mdata;
  ret=ecat63WriteMatdata(fp, nxtblk+1, mptr, pxlNr, ecat63pxlbytes(h->data_type));
  free(mdata);
  if(ret) {
    sprintf(ecat63errmsg, "cannot write matrix data (%d).\n", ret);
    return(13);
  }
  return(0);
}

Referenced by atnMake(), and imgWriteEcat63Frame().

◆ ecat63WriteMainheader()

int ecat63WriteMainheader	(	FILE *	fp,
		ECAT63_mainheader *	h )

extern

Write ECAT 6.3 main header.

Parameters

fp	target file pointer
h	Ecat 6.3 main header

Returns: 0, if ok, 1 invalid input, 2 failed to find block, 3 failed to write block

Definition at line 24 of file ecat63w.c.

  {
  char buf[MatBLKSIZE];
  int little, tovax;
 
 
  if(ECAT63_TEST) printf("ecat63WriteMainheader()\n");
  little=little_endian();
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  /* Check arguments */
  if(fp==NULL || h->data_type<1 || h->data_type>7) return(1);
  if(h->data_type==VAX_I2 || h->data_type==VAX_I4 || h->data_type==VAX_R4)
    tovax=1; else tovax=0;
 
  /* Copy short ints to buf */
  memcpy(buf+50, &h->data_type, 2); memcpy(buf+48, &h->sw_version, 2);
  memcpy(buf+52, &h->system_type, 2); memcpy(buf+54, &h->file_type, 2);
  memcpy(buf+66, &h->scan_start_day, 2); memcpy(buf+68, &h->scan_start_month, 2);
  memcpy(buf+70, &h->scan_start_year, 2); memcpy(buf+72, &h->scan_start_hour, 2);
  memcpy(buf+74, &h->scan_start_minute, 2); 
  memcpy(buf+76, &h->scan_start_second, 2);
  memcpy(buf+134, &h->rot_source_speed, 2); memcpy(buf+136, &h->wobble_speed, 2);
  memcpy(buf+138, &h->transm_source_type, 2); 
  memcpy(buf+148, &h->transaxial_samp_mode, 2);
  memcpy(buf+150, &h->coin_samp_mode, 2); memcpy(buf+152, &h->axial_samp_mode, 2);
  memcpy(buf+158, &h->calibration_units, 2); 
  memcpy(buf+160, &h->compression_code, 2);
  memcpy(buf+350, &h->acquisition_type, 2); memcpy(buf+352, &h->bed_type, 2);
  memcpy(buf+354, &h->septa_type, 2); memcpy(buf+376, &h->num_planes, 2);
  memcpy(buf+378, &h->num_frames, 2); memcpy(buf+380, &h->num_gates, 2);
  memcpy(buf+382, &h->num_bed_pos, 2); memcpy(buf+452, &h->lwr_sctr_thres, 2);
  memcpy(buf+454, &h->lwr_true_thres, 2); memcpy(buf+456, &h->upr_true_thres, 2);
  memcpy(buf+472, h->fill2, 40);
  /* big to little endian if necessary */
  if(!little) swabip(buf, MatBLKSIZE);
 
  /* Copy floats to buf */
  ecat63wFloat(&h->isotope_halflife, buf+86, tovax, little);
  ecat63wFloat(&h->gantry_tilt, buf+122, tovax, little);
  ecat63wFloat(&h->gantry_rotation, buf+126, tovax, little);
  ecat63wFloat(&h->bed_elevation, buf+130, tovax, little);
  ecat63wFloat(&h->axial_fov, buf+140, tovax, little);
  ecat63wFloat(&h->transaxial_fov, buf+144, tovax, little);
  ecat63wFloat(&h->calibration_factor, buf+154, tovax, little);
  ecat63wFloat(&h->init_bed_position, buf+384, tovax, little);
  for(int i=0; i<15; i++) ecat63wFloat(&h->bed_offset[i], buf+388+4*i, tovax, little);
  ecat63wFloat(&h->plane_separation, buf+448, tovax, little);
  ecat63wFloat(&h->init_bed_position, buf+458, tovax, little);
 
  /* Copy chars */
  /*memcpy(buf+0, h->ecat_format, 14);*/
  memcpy(buf+14, h->fill1, 14);
  memcpy(buf+28, h->original_file_name, 20); memcpy(buf+56, h->node_id, 10);
  memcpy(buf+78, h->isotope_code, 8); memcpy(buf+90, h->radiopharmaceutical, 32);
  memcpy(buf+162, h->study_name, 12); memcpy(buf+174, h->patient_id, 16);
  memcpy(buf+190, h->patient_name, 32); buf[222]=h->patient_sex;
  memcpy(buf+223, h->patient_age, 10); memcpy(buf+233, h->patient_height, 10);
  memcpy(buf+243, h->patient_weight, 10); buf[253]=h->patient_dexterity;
  memcpy(buf+254, h->physician_name, 32); memcpy(buf+286, h->operator_name, 32);
  memcpy(buf+318, h->study_description, 32); memcpy(buf+356, h->facility_name, 20);
  memcpy(buf+462, h->user_process_code, 10);
 
  /* Write main header */
  fseek(fp, 0*MatBLKSIZE, SEEK_SET); if(ftell(fp)!=0*MatBLKSIZE) return(2);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(3);
 
  return(0);
}

Referenced by ecat63AddImg(), ecat63Create(), and imgWriteEcat63Frame().

◆ ecat63WriteMatdata()

int ecat63WriteMatdata	(	FILE *	fp,
		int	strtblk,
		char *	data,
		long long	pxlNr,
		int	pxlSize )

extern

Write ECAT 6.3 matrix data to a specified file position. Data does not need to be allocated for full blocks. Data must be represented in current machines byte order, and it is always saved in big endian byte order. Give also nr of pixels and byte size of one pixel.

Parameters

fp	target file pointer
strtblk	starting image block [>=1]
data	pointer to data that is written
pxlNr	number of items to be written [>=1]
pxlSize	size of one data item in bytes [>=1]

Returns: 0 if ok, 1 invalid input, 2 failed to find starting block, 3 failed to write data

Definition at line 618 of file ecat63w.c.

  {
  unsigned char buf[MatBLKSIZE];
  char *dptr;
  int blkNr, byteNr;
 
  if(ECAT63_TEST) 
    printf("ecat63WriteMatdata(fp, %d, data, %lld, %d)\n", strtblk, pxlNr, pxlSize);
  if(fp==NULL || strtblk<1 || data==NULL || pxlNr<1 || pxlSize<1) return(1);
  memset(buf, 0, MatBLKSIZE);
  long long dataSize=pxlNr*pxlSize; if(dataSize<1) return(1);
  /* block nr taken by all pixels */
  blkNr=(dataSize+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) return(1);
  if(ECAT63_TEST>1) printf("    blkNr=%d\n", blkNr);
  /* Search the place for writing */
  fseeko(fp, (strtblk-1)*MatBLKSIZE, SEEK_SET); 
  if(ftello(fp)!=(strtblk-1)*MatBLKSIZE) return(2);
  /* Save blocks one at a time */
  dptr=data;
  for(int i=0; i<blkNr && dataSize>0; i++) {
    byteNr=(dataSize<MatBLKSIZE)?dataSize:MatBLKSIZE;
    memcpy(buf, dptr, byteNr);
    /* Change matrix byte order in big endian platforms */
    if(!little_endian()) {
      if(pxlSize==2) swabip(buf, byteNr);
      else if(pxlSize==4) swawbip(buf, byteNr);
    }
    /* Write block */
    if(fwrite(buf, 1, MatBLKSIZE, fp)!=MatBLKSIZE) return(3);
    /* Prepare for the next block */
    dptr+=byteNr;
    dataSize-=byteNr;
  } /* next block */
  return(0);
}

Referenced by ecat63WriteAttn(), ecat63WriteImage(), ecat63WriteImageMatrix(), ecat63WriteNorm(), ecat63WriteScan(), and ecat63WriteScanMatrix().

◆ ecat63WriteNorm()

int ecat63WriteNorm	(	FILE *	fp,
		int	matnum,
		ECAT63_normheader *	h,
		void *	data )

extern

Write ECAT 6.3 normalization matrix header and data

Parameters

fp	target file pointer
matnum	matrix number [1..number of matrixes]
h	Ecat 6.3 normalization header
data	pointer to data that is written

Returns: 0 if ok, 1 invalid input or invalid image dimensions, 2 failed to resolve data type 3 too little data size, 4 failed to resolve next block size in file

Definition at line 512 of file ecat63w.c.

  {
  int nxtblk, blkNr, pxlSize, ret;
 
  if(ECAT63_TEST) printf("ecat63WriteNorm(fp, %d, nh, data)\n", matnum);
  if(fp==NULL || matnum<1 || h==NULL || data==NULL) return(1);
  /* nr of pixels */
  long long pxlNr=h->dimension_1*h->dimension_2; if(pxlNr<1) return(1);
  /* mem taken by one pixel */
  switch(h->data_type) {
    case BYTE_TYPE: pxlSize=1;
      break;
    case VAX_I2:
    case SUN_I2: pxlSize=2;
      break;
    case VAX_I4: return(3);
    case VAX_R4: return(3);
    case IEEE_R4:
    case SUN_I4: pxlSize=4;
      break;
    default: return(2);
  }
  /* mem taken by all pixels */
  long long data_size=pxlNr*pxlSize;
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) return(3);
  /* Get block number for matrix header and data */
  nxtblk=ecat63Matenter(fp, matnum, blkNr); if(nxtblk<1) return(4);
  if(ECAT63_TEST) printf("  block=%d\n", nxtblk);
  /* Write header */
  ret=ecat63WriteNormheader(fp, nxtblk, h); if(ret) return(40+ret);
  /* Write matrix data */
  ret=ecat63WriteMatdata(fp, nxtblk+1, data, pxlNr, pxlSize);
  if(ret) return(50+ret);
  return 0;
}

◆ ecat63WriteNormheader()

int ecat63WriteNormheader	(	FILE *	fp,
		int	block,
		ECAT63_normheader *	h )

extern

Write ECAT 6.3 normalization header

Parameters

fp	target file pointer
block	block number [>=3]
h	Ecat 6.3 normalization header

Returns: 0 if ok, 1 invalid input, 2 failed to find block, 3 failed to write block

Definition at line 313 of file ecat63w.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little, tovax;
 
  if(ECAT63_TEST) printf("ecat63WriteNormheader(fp, %d, nh)\n", block);
  little=little_endian();
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  /* Check arguments */
  if(fp==NULL || block<3 || h->data_type<1 || h->data_type>7) return(1);
  if(h->data_type==VAX_I2 || h->data_type==VAX_I4 || h->data_type==VAX_R4)
    tovax=1; else tovax=0;
 
  /* Copy short ints to buf */
  memcpy(buf+126, &h->data_type, 2);
  memcpy(buf+132, &h->dimension_1, 2); 
  memcpy(buf+134, &h->dimension_2, 2);
  memcpy(buf+372, &h->norm_hour, 2);
  memcpy(buf+376, &h->norm_minute, 2);
  memcpy(buf+380, &h->norm_second, 2);
  memcpy(buf+384, &h->norm_day, 2);
  memcpy(buf+388, &h->norm_month, 2);
  memcpy(buf+392, &h->norm_year, 2);
  /* big to little endian if necessary */
  if(!little) swabip(buf, MatBLKSIZE);
 
  /* Copy floats to buf */
  ecat63wFloat(&h->scale_factor, buf+182, tovax, little);
  ecat63wFloat(&h->fov_source_width, buf+198, tovax, little);
 
  /* Write subheader */
  fseeko(fp, (block-1)*MatBLKSIZE, SEEK_SET);
  if(ftello(fp)!=(block-1)*MatBLKSIZE) return(2);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(3);
 
  return(0);
}

Referenced by ecat63WriteNorm().

◆ ecat63WriteScan()

int ecat63WriteScan	(	FILE *	fp,
		int	matnum,
		ECAT63_scanheader *	h,
		void *	data )

extern

Write ECAT 6.3 sinogram matrix header and data

Parameters

fp	target file pointer
matnum	matrix number [1..number of matrixes]
h	Ecat 6.3 scan header
data	pointer to data that is written

Returns: 0 if ok, 1 invalid input or invalid image dimensions, 2 failed to resolve data type 3 too little data size, 4 failed to resolve next block size in file

Definition at line 461 of file ecat63w.c.

  {
  int nxtblk, blkNr, pxlSize, ret;
 
  if(ECAT63_TEST) printf("ecat63WriteScan(fp, %d, sh, data)\n", matnum);
  if(fp==NULL || matnum<1 || h==NULL || data==NULL) return(1);
  /* nr of pixels */
  long long pxlNr=h->dimension_1*h->dimension_2; if(pxlNr<1) return(1);
  /* mem taken by one pixel */
  switch(h->data_type) {
    case BYTE_TYPE: pxlSize=1;
      break;
    case VAX_I2:
    case SUN_I2: pxlSize=2;
      break;
    case VAX_I4: return(3);
    case VAX_R4: return(3);
    case IEEE_R4:
    case SUN_I4: pxlSize=4;
      break;
    default: return(2);
  }
  /* mem taken by all pixels */
  long long data_size=pxlNr*pxlSize;
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) return(3);
  /* Get block number for matrix header and data */
  nxtblk=ecat63Matenter(fp, matnum, blkNr); if(nxtblk<1) return(4);
  if(ECAT63_TEST) printf("  block=%d\n", nxtblk);
  /* Write header */
  ret=ecat63WriteScanheader(fp, nxtblk, h); if(ret) return(40+ret);
  /* Write matrix data */
  ret=ecat63WriteMatdata(fp, nxtblk+1, data, pxlNr, pxlSize);
  if(ret) return(50+ret);
  return 0;
}

Referenced by ecat63AddImg(), and ecat63WriteAllImg().

◆ ecat63WriteScanheader()

int ecat63WriteScanheader	(	FILE *	fp,
		int	block,
		ECAT63_scanheader *	h )

extern

Write ECAT 6.3 scan header

Parameters

fp	target file pointer
block	block number [>=3]
h	Ecat 6.3 scan header

Returns: 0 if ok, 1 invalid input, 2 failed to find block, 3 failed to write block

Definition at line 242 of file ecat63w.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little, tovax;
 
 
  if(ECAT63_TEST) printf("ecat63WriteScanheader(fp, %d, ih)\n", block);
  little=little_endian();
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  /* Check arguments */
  if(fp==NULL || block<3 || h->data_type<1 || h->data_type>7) return(1);
  if(h->data_type==VAX_I2 || h->data_type==VAX_I4 || h->data_type==VAX_R4)
    tovax=1; else tovax=0;
 
  /* Copy short ints to buf */
  memcpy(buf+126, &h->data_type, 2);
  memcpy(buf+132, &h->dimension_1, 2); memcpy(buf+134, &h->dimension_2, 2);
  memcpy(buf+136, &h->smoothing, 2); memcpy(buf+138, &h->processing_code, 2);
  memcpy(buf+170, &h->frame_duration_sec, 2);
  memcpy(buf+192, &h->scan_min, 2); memcpy(buf+194, &h->scan_max, 2);
  memcpy(buf+468, h->fill2, 44);
  /* big to little endian if necessary */
  if(!little) swabip(buf, MatBLKSIZE);
 
  /* Copy floats to buf */
  ecat63wFloat(&h->sample_distance, buf+146, tovax, little);
  ecat63wFloat(&h->isotope_halflife, buf+166, tovax, little);
  ecat63wFloat(&h->scale_factor, buf+182, tovax, little);
  for(int i=0; i<16; i++) {
    ecat63wFloat(&h->cor_singles[i], buf+316+4*i, tovax, little);
    ecat63wFloat(&h->uncor_singles[i], buf+380+4*i, tovax, little);
  }
  ecat63wFloat(&h->tot_avg_cor, buf+444, tovax, little);
  ecat63wFloat(&h->tot_avg_uncor, buf+448, tovax, little);
  ecat63wFloat(&h->loss_correction_fctr, buf+464, tovax, little);
 
  /* Copy ints to buf */
  ecat63wInt(&h->gate_duration, buf+172, tovax, little);
  ecat63wInt(&h->r_wave_offset, buf+176, tovax, little);
  ecat63wInt(&h->prompts, buf+196, tovax, little);
  ecat63wInt(&h->delayed, buf+200, tovax, little);
  ecat63wInt(&h->multiples, buf+204, tovax, little);
  ecat63wInt(&h->net_trues, buf+208, tovax, little);
  ecat63wInt(&h->total_coin_rate, buf+452, tovax, little);
  ecat63wInt(&h->frame_start_time, buf+456, tovax, little);
  ecat63wInt(&h->frame_duration, buf+460, tovax, little);
 
  /* Copy chars */
  memcpy(buf+0, h->fill1, 126);
 
  /* Write subheader */
  fseeko(fp, (block-1)*MatBLKSIZE, SEEK_SET); 
  if(ftello(fp)!=(block-1)*MatBLKSIZE) return(2);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(3);
 
  return(0);
}

Referenced by ecat63WriteScan(), and ecat63WriteScanMatrix().

◆ ecat63WriteScanMatrix()

int ecat63WriteScanMatrix	(	FILE *	fp,
		int	matnum,
		ECAT63_scanheader *	h,
		float *	fdata )

extern

Write ECAT 6.3 sinogram matrix header and data

Parameters

fp	target file pointer
matnum	matrix number [1..number of matrixes]
h	Ecat 6.3 scan header
fdata	matrix data

Returns: 0 if ok, 1 invalid input, 3 invalid matrix dimension, 4 invalid block number, 5 failed to allocate memory for data, 8 failed to resolve next block number, 10 cannot write sub header, 13 failed to write data

Definition at line 781 of file ecat63w.c.

  {
  int nxtblk, blkNr, ret;
  float *fptr, fmin, fmax, g, f;
  char *mdata, *mptr;
  short int *sptr;
 
 
  if(ECAT63_TEST) printf("ecat63WriteScanMatrix(fp, %d, h, data)\n", matnum);
  if(fp==NULL || matnum<1 || h==NULL || fdata==NULL) {
    sprintf(ecat63errmsg, "invalid function parameter.\n");
    return(1);
  }
  /* nr of pixels */
  long long pxlNr=h->dimension_1*h->dimension_2;
  if(pxlNr<1) {
    sprintf(ecat63errmsg, "invalid matrix dimension.\n");
    return(3);
  }
  /* How much memory is needed for ALL pixels */
  long long data_size=pxlNr*ecat63pxlbytes(h->data_type);
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) {
    sprintf(ecat63errmsg, "invalid block number.\n");
    return(4);
  }
  /* Allocate memory for matrix data */
  mdata=(char*)calloc(blkNr, MatBLKSIZE); if(mdata==NULL) {
    sprintf(ecat63errmsg, "out of memory.\n");
    return(5);
  }
  /* Search for min and max for calculation of scale factor */
  fMinMaxFin(fdata, pxlNr, &fmin, &fmax);
  if(fabs(fmin)>fabs(fmax)) g=fabs(fmin); else g=fabs(fmax);
  if(g>0) f=32766./g; else f=1.0;
  /* Check if pixels values can be left as such with scale_factor = 1 */
  fptr=fdata;
  if(f>=1.0 && ecat63_is_scaling_needed(g, fptr, pxlNr)==0) f=1.0;
  /* Scale matrix data to shorts */
  h->scale_factor=1.0/f;
  sptr=(short int*)mdata; fptr=fdata;
  for(long long i=0; i<pxlNr; i++, sptr++, fptr++)
    *sptr=(short int)temp_roundf(f*(*fptr));
  /* Set header short min & max */
  h->scan_min=(short int)temp_roundf(f*fmin);
  h->scan_max=(short int)temp_roundf(f*fmax);
  /* Get block number for matrix header and data */
  nxtblk=ecat63Matenter(fp, matnum, blkNr); if(nxtblk<1) {
    sprintf(ecat63errmsg, "cannot determine matrix block (%d).\n", -nxtblk);
    free(mdata); return(8);
  }
  if(ECAT63_TEST>2) printf("  block=%d fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
  /* Write header */
  ret=ecat63WriteScanheader(fp, nxtblk, h); if(ret) {
    sprintf(ecat63errmsg, "cannot write subheader (%d).\n", ret);
    free(mdata); return(10);
  }
  /* Write matrix data */
  mptr=mdata;
  ret=ecat63WriteMatdata(fp, nxtblk+1, mptr, pxlNr, ecat63pxlbytes(h->data_type));
  free(mdata);
  if(ret) {
    sprintf(ecat63errmsg, "cannot write matrix data (%d).\n", ret);
    return(13);
  }
  return(0);
}

Referenced by imgWriteEcat63Frame().

◆ ecat6PrintSubheader()

int ecat6PrintSubheader	(	ECAT63_mainheader	mh,
		FILE *	fp,
		int	plane,
		int	frame,
		FILE *	ofp )

extern

Print ECAT63 subheader contents into specified file pointer.

Returns: Returns 0 when successful.

Parameters

mh	ECAT 6.3 mainheader (not printed but needed here)
fp	File pointer to ECAT 6.3 file.
plane	ECAT 6.3 plane; enter <0 to print all planes.
frame	ECAT 6.3 frame; enter <0 to print all frames.
ofp	Output is written to this file pointer; it can be stdout

Definition at line 293 of file ecat63p.c.

  {
  int                 mi, ret, nr=0;
  static MATRIXLIST   mlist;
  ECAT63_imageheader  image_header;
  ECAT63_scanheader   scan_header;
  ECAT63_attnheader   attn_header;
  ECAT63_normheader   norm_header;
  Matval              matval;
 
 
  /*  Read matrix list and nr */
  ecat63InitMatlist(&mlist);
  ret=ecat63ReadMatlist(fp, &mlist, ECAT63_TEST);
  if(ret) {
    fprintf(stderr, "Error (%d): cannot read matrix list.\n", ret);
    return 2;
  }
  if(mlist.matrixNr<=0) {
    fprintf(stderr, "Error: matrix list is empty.\n");
    return 2;
  }
  if(ECAT63_TEST>1) ecat63PrintMatlist(&mlist);
 
  /*
   *  Read and print subheaders one at a time
   */
  char errmsg[128]; int errCount=0;
  for(mi=nr=0; mi<mlist.matrixNr; mi++) {
    /* Get plane and frame nr */
    mat_numdoc(mlist.matdir[mi].matnum, &matval);
    /* Check if this is supposed to be listed or not */
    if(frame>=0 && frame!=matval.frame) continue;
    if(plane>=0 && plane!=matval.plane) continue;
    fprintf(ofp, "\nMatrix: plane %d frame %d gate %d bed %d\n",
      matval.plane, matval.frame, matval.gate, matval.bed);
    fflush(ofp);
    /* Read subheader */
    if(mh.file_type==IMAGE_DATA)
      ret=ecat63ReadImageheader(fp, mlist.matdir[mi].strtblk, &image_header, ECAT63_TEST-1, errmsg);
    else if(mh.file_type==RAW_DATA)
      ret=ecat63ReadScanheader(fp, mlist.matdir[mi].strtblk, &scan_header, ECAT63_TEST-1, errmsg);
    else if(mh.file_type==ATTN_DATA)
      ret=ecat63ReadAttnheader(fp, mlist.matdir[mi].strtblk, &attn_header, ECAT63_TEST-1, errmsg);
    else if(mh.file_type==NORM_DATA)
      ret=ecat63ReadNormheader(fp, mlist.matdir[mi].strtblk, &norm_header, ECAT63_TEST-1, errmsg);
    if(ret) {
      fprintf(stderr, "Error: %s.\n", errmsg);
      //fprintf(stderr, "Error: cannot read matrix %u subheader.\n", mlist.matdir[mi].matnum);
      //if(ECAT63_TEST>0) printf(" ret=%d\n", ret);
      /*ecat63EmptyMatlist(&mlist); return 4;*/
      errCount++;
      continue;
    }
    /* Print subheader */
    if(mh.file_type==IMAGE_DATA)
      ecat63PrintImageheader(&image_header, ofp);
    else if(mh.file_type==RAW_DATA)
      ecat63PrintScanheader(&scan_header, ofp);
    else if(mh.file_type==ATTN_DATA)
      ecat63PrintAttnheader(&attn_header, ofp);
    else if(mh.file_type==NORM_DATA)
      ecat63PrintNormheader(&norm_header, ofp);
    nr++; // counter
  } /* next matrix */
  ecat63EmptyMatlist(&mlist);
 
  if(errCount>0 && nr>0 && (plane<0 || frame<0)) {
    if(errCount==1) fprintf(stderr, "\nWarning: one matrix could not be read.\n");
    else fprintf(stderr, "\nWarning: %d matrices could not be read.\n", errCount);
  }
 
  if(nr==0 && (plane>=0 || frame>=0)) {
    fprintf(stderr, "Error: specified matrices not found.\n");
    return(11);
  }
 
  return(0);
}

◆ ecat7_id_to_val()

void ecat7_id_to_val	(	int	matrix_id,
		ECAT7_Matval *	matval )

extern

Conversion of matrix identifier to numerical values

Parameters

matrix_id	matrix identifier coding
matval	matrix values structure

Definition at line 262 of file ecat7ml.c.

                                                          {
  matval->frame = matrix_id & 0x1FF;
  matval->plane = ((matrix_id >> 16) & 0xFF) + ((matrix_id >> 1) & 0x300);
  matval->gate  = (matrix_id >> 24) & 0x3F;
  matval->data  = ((matrix_id >> 30) & 0x3) + ((matrix_id >> 9) & 0x4);
  matval->bed   = (matrix_id >> 12) & 0xF;
}

Referenced by ecat7DeleteLateFrames(), ecat7GatherMatlist(), ecat7GetNums(), ecat7GetPlaneAndFrameNr(), ecat7PrintMatlist(), ecat7PrintSubheader(), ecat7ReadHeaders(), ecat7SortMatlistByFrame(), ecat7SortMatlistByPlane(), ecat7WriteHeaders(), imgReadEcat7(), and imgReadEcat7Frame().

◆ ecat7_is_scaling_needed()

int ecat7_is_scaling_needed	(	float	amax,
		float *	data,
		long long	nr )

extern

Check if pixel float values need to be scaled to be saved as short ints, or if they are already all very close to integers.

Returns: 1, if scaling is necessary, and 0 if not.

Parameters

amax	Absolute maximum value.
data	Float array.
nr	Number of float values in float array.

Definition at line 604 of file ecat7w.c.

  {
  double d;
  
  if(nr<1 || data==NULL) return(0);
  /* scaling is necessary if all values are between -1 - 1 */
  if(amax<0.9999) return(1);
  /* Lets check first if at least the max value is close to integers or not */
  if(modf(amax, &d)>0.0001) return(1);
  /* if it is, then check all pixels */
  for(long long i=0; i<nr; i++) if(modf(*data++, &d)>0.0001) return(1);
  return(0);
}

Referenced by ecat7Write2DScanMatrix(), ecat7WriteImageMatrix(), ecat7WritePolarmapMatrix(), and ecat7WriteScanMatrix().

◆ ecat7_val_to_id()

int ecat7_val_to_id	(	int	frame,
		int	plane,
		int	gate,
		int	data,
		int	bed )

extern

Returns the matrix identifier.

Parameters

frame	frame number [0..65536]
plane	plane number [0..65536]
gate	gate number [0..64]
data	data [0..1]
bed	bed position [0..16]

Returns: matrix identifier coding

Definition at line 245 of file ecat7ml.c.

                                                                       {
  return(
    ((bed & 0xF) << 12) |    /* bed */
    (frame & 0x1FF) |        /* frame */
    ((gate & 0x3F) << 24) |  /* gate */
    ((plane & 0xFF) << 16) | /* plane low */
    ((plane & 0x300) << 1) | /* plane high */
    ((data & 0x3) << 30) |   /* data low */
    ((data & 0x4) << 9)      /* data high */
  );
}

Referenced by ecat7GatherMatlist(), imgWrite2DEcat7(), imgWriteEcat7(), imgWriteEcat7Frame(), and imgWritePolarmap().

◆ ecat7acquisitiontype()

char * ecat7acquisitiontype ( short int acquisition_type )

extern

Returns pointer to a string describing the ECAT7 acquisition_type

Parameters

acquisition_type acquisition type code

Returns: pointer to static string

Definition at line 468 of file ecat7p.c.

  {
  static char *info[] = {
  "undefined", "blank", "transmission", "static emission",
  "dynamic emission", "gated emission", "transmission rectilinear",
  "emission rectilinear",
  0};
  if(acquisition_type>=0 && acquisition_type<=7)
    return((char*)info[acquisition_type]);
  else return((char*)info[0]);
}

Referenced by ecat7PrintMainheader().

◆ ecat7CheckMatlist()

int ecat7CheckMatlist ( ECAT7_MATRIXLIST * ml )

extern

Checks that all matrixlist entries have read/write status.

Parameters

ml	checked matrix list

Returns: 0 if ok, or 1 if an entry is marked as deleted or unfinished

Definition at line 329 of file ecat7ml.c.

                                            {
  int i;
 
  if(ml==NULL) return(1);
  for(i=0; i<ml->matrixNr; i++) if(ml->matdir[i].status!=1) return(1);
  return(0);
}

Referenced by ecat7ReadHeaders(), ecat7WriteHeaders(), ecatFixMatrixlist(), imgReadEcat7(), imgReadEcat7Frame(), and imgReadEcat7Header().

◆ ecat7Create()

FILE * ecat7Create	(	const char *	fname,
		ECAT7_mainheader *	h )

extern

Create a new ECAT 7.x file. If file exists, it is renamed as fname% if possible. Directory list is written in big endian byte order.

Parameters

fname	filename
h	Ecat7 main header

Returns: file pointer or NULL in case of an error.

Definition at line 567 of file ecat7w.c.

                                                          {
  FILE *fp;
  char tmp[FILENAME_MAX];
  int buf[MatBLKSIZE/4];
 
  if(ECAT7_TEST) printf("ecat7Create(%s, h)\n", fname);
  /* Check the arguments */
  if(fname==NULL || h==NULL) return(NULL);
  /* Check if file exists; backup, if necessary */
  if(access(fname, 0) != -1) {
    strcpy(tmp, fname); strcat(tmp, BACKUP_EXTENSION);
    if(access(tmp, 0) != -1) remove(tmp);
    if(ECAT7_TEST) printf("Renaming %s -> %s\n", fname, tmp);
    rename(fname, tmp);
  }
  /* Open file */
  fp=fopen(fname, "wb+"); if(fp==NULL) return(fp);
  /* Write main header */
  if(ecat7WriteMainheader(fp, h)) return(NULL);
  /* Construct an empty matrix list ; convert to little endian if necessary */
  memset(buf, 0, MatBLKSIZE);
  buf[0]=31; buf[1]=MatFirstDirBlk; if(little_endian()) swawbip(buf, MatBLKSIZE);
  /* Write data buffer */
  fseek(fp, (MatFirstDirBlk-1)*MatBLKSIZE, SEEK_SET);
  if(ftell(fp)!=(MatFirstDirBlk-1)*MatBLKSIZE) return(NULL);
  if(fwrite(buf, 4, MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(NULL);
  /* OK, then return file pointer */
  return(fp);
}

Referenced by ecat7CopyFile(), imgWrite2DEcat7(), imgWriteEcat7(), imgWriteEcat7Frame(), and imgWritePolarmap().

◆ ecat7datatype()

char * ecat7datatype ( short int data_type )

extern

Returns pointer to a string describing the ECAT7 data_type

Parameters

data_type data type code

Returns: pointer to static string

Definition at line 489 of file ecat7p.c.

  {
  static char *info[] = {
  "unknown", "byte", "VAX 2 byte integer", "VAX 4 byte integer",
  "VAX 4 byte float", "IEEE 4 byte float", "SUN 2 byte integer",
  "SUN 4 byte integer",
  0};
  if(data_type>=0 && data_type<=7) return((char*)info[data_type]);
  else return((char*)info[0]);
}

Referenced by ecat7Print2DNormheader(), ecat7Print2DScanheader(), ecat7PrintAttenheader(), ecat7PrintImageheader(), ecat7PrintNormheader(), ecat7PrintPolmapheader(), and ecat7PrintScanheader().

◆ ecat7DeleteLateFrames()

int ecat7DeleteLateFrames	(	ECAT7_MATRIXLIST *	ml,
		int	frame_nr )

extern

Mark deleted the frames after the specified frame number.

Parameters

ml	target matrix list
frame_nr	first index to be marked as deleted [1..number of frames]

Returns: Returns the number of deleted matrices.

Definition at line 346 of file ecat7ml.c.

                                                              {
  int i, del_nr=0;
  ECAT7_Matval matval;
 
  for(i=0; i<ml->matrixNr; i++) {
    ecat7_id_to_val(ml->matdir[i].id, &matval);
    if(matval.frame>frame_nr) {del_nr++; ml->matdir[i].status=-1;}
  }
  return(del_nr);
}

◆ ecat7EditMHeader()

int ecat7EditMHeader	(	ECAT7_mainheader *	h,
		char *	field,
		char *	value,
		int	verbose )

extern

Edit ECAT 7 main header.

Returns: Returns 0, if ok, and 1 or 2, if field name or or value is invalid.

Parameters

h	Pointer to ECAT 7 mainheader structure
field	Field name to be changed
value	New value for the field
verbose	Verbose level; if <=0, then nothing is printed into stdout

Definition at line 16 of file ecat7h.c.

  {
  int yy, mm, dd;
  short int si;
  float f;
 
  if(verbose>0) printf("ecat7EditMHeader('%s', '%s')\n", field, value);
  si=atoi(value); f=atof(value);
  if(strcmp(field, "magic_number")==0) {
    strlcpy(h->magic_number, value, 14);
  } else if(strcmp(field, "original_file_name")==0) {
    strlcpy(h->original_file_name, value, 32);
  } else if(strcmp(field, "sw_version")==0) {
    if(si<=0) return(2); else h->sw_version=si;
  } else if(strcmp(field, "system_type")==0) {
    if(si<0) return(2); else h->system_type=si;
  } else if(strcmp(field, "file_type")==0) {
    if(si<0) return(2); else h->file_type=si;
  } else if(strcmp(field, "serial_number")==0) {
    strlcpy(h->serial_number, value, 10);
  } else if(strcmp(field, "scan_start_time")==0) {
    struct tm stm;
    time_t t;
    if(get_datetime(value, &stm, verbose-1)!=0) return(2);
    if(verbose>3) printf("  year=%d\n", stm.tm_year);
    if(verbose>1) printf("  hour=%d\n", stm.tm_hour);
    /* ECAT 7 main header saves int, not time_t (long int),
       therefore checking whether time can be saved correctly */
    t=timegm(&stm);
    h->scan_start_time=timegm(&stm);
    if(t!=(time_t)h->scan_start_time) {
      /* no it can't be saved as required; set negative time as time base */
      if(t<(time_t)0) h->scan_start_time=0;
      else return(2); /* if too far in future, return error */
    }
    if(verbose>1) printf("  scan_start_time := %d\n", h->scan_start_time);
    if(h->scan_start_time==-1) h->scan_start_time=0; //return(2);
  } else if(strcmp(field, "isotope_name")==0) {
    strlcpy(h->isotope_name, value, 8);
  } else if(strcmp(field, "isotope_halflife")==0) {
    if(f<=1.0E-3) return(2); else h->isotope_halflife=f;
  } else if(strcmp(field, "radiopharmaceutical")==0) {
    strlcpy(h->radiopharmaceutical, value, 32);
  } else if(strcmp(field, "gantry_tilt")==0) {
    h->gantry_tilt=f;
  } else if(strcmp(field, "gantry_rotation")==0) {
    h->gantry_rotation=f;
  } else if(strcmp(field, "bed_elevation")==0) {
    h->bed_elevation=f;
  } else if(strcmp(field, "intrinsic_tilt")==0) {
    h->intrinsic_tilt=f;
  } else if(strcmp(field, "wobble_speed")==0) {
    h->wobble_speed=si;
  } else if(strcmp(field, "transm_source_type")==0) {
    h->transm_source_type=si;
  } else if(strcmp(field, "distance_scanned")==0) {
    h->distance_scanned=f;
  } else if(strcmp(field, "transaxial_fov")==0) {
    h->transaxial_fov=f;
  } else if(strcmp(field, "angular_compression")==0) {
    h->angular_compression=si;
  } else if(strcmp(field, "coin_samp_mode")==0) {
    h->coin_samp_mode=si;
  } else if(strcmp(field, "axial_samp_mode")==0) {
    h->axial_samp_mode=si;
  } else if(strcmp(field, "ecat_calibration_factor")==0) {
    h->ecat_calibration_factor=f;
  } else if(strcmp(field, "calibration_units")==0) {
    h->calibration_units=si;
  } else if(strcmp(field, "calibration_units_label")==0) {
    h->calibration_units_label=si;
  } else if(strcmp(field, "compression_code")==0) {
    h->compression_code=si;
  } else if(strcmp(field, "study_type")==0) {
    strlcpy(h->study_type, value, 12);
  } else if(strcmp(field, "patient_id")==0) {
    strlcpy(h->patient_id, value, 16);
  } else if(strcmp(field, "patient_name")==0) {
    strlcpy(h->patient_name, value, 32);
  } else if(strcmp(field, "patient_sex")==0) {
    h->patient_sex=value[0];
  } else if(strcmp(field, "patient_dexterity")==0) {
    h->patient_dexterity=value[0];
  } else if(strcmp(field, "patient_age")==0) {
    h->patient_age=f;
  } else if(strcmp(field, "patient_height")==0) {
    h->patient_height=f;
  } else if(strcmp(field, "patient_weight")==0) {
    h->patient_weight=f;
  } else if(strcmp(field, "patient_birth_date")==0) {
    struct tm st;
    time_t timet;
    timet=time(NULL); gmtime_r(&timet, &st);
    if(sscanf(value, "%d-%d-%d", &yy, &mm, &dd)!=3) return(2);
    st.tm_mday=dd; st.tm_mon=mm-1; st.tm_year=yy-1900;
    st.tm_hour=12; st.tm_min=0; st.tm_sec=0; st.tm_isdst=-1;
    h->patient_birth_date=timegm(&st);
  } else if(strcmp(field, "physician_name")==0) {
    strlcpy(h->physician_name, value, 32);
  } else if(strcmp(field, "operator_name")==0) {
    strlcpy(h->operator_name, value, 32);
  } else if(strcmp(field, "study_description")==0) {
    strlcpy(h->study_description, value, 32);
  } else if(strcmp(field, "acquisition_type")==0) {
    h->acquisition_type=si;
  } else if(strcmp(field, "patient_orientation")==0) {
    h->patient_orientation=si;
  } else if(strcmp(field, "facility_name")==0) {
    strlcpy(h->facility_name, value, 20);
  } else if(strcmp(field, "num_planes")==0) {
    h->num_planes=si;
  } else if(strcmp(field, "num_frames")==0) {
    h->num_frames=si;
  } else if(strcmp(field, "num_gates")==0) {
    h->num_gates=si;
  } else if(strcmp(field, "num_bed_pos")==0) {
    h->num_bed_pos=si;
  } else if(strcmp(field, "init_bed_position")==0) {
    h->init_bed_position=f;
  } else if(strcmp(field, "bed_position")==0) {
    sscanf(value, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
      h->bed_position+0, h->bed_position+1, h->bed_position+2,
      h->bed_position+3, h->bed_position+4, h->bed_position+5,
      h->bed_position+6, h->bed_position+7, h->bed_position+8,
      h->bed_position+9, h->bed_position+10, h->bed_position+11,
      h->bed_position+12, h->bed_position+13, h->bed_position+14
    );
  } else if(strcmp(field, "plane_separation")==0) {
    h->plane_separation=f;
  } else if(strcmp(field, "lwr_sctr_thres")==0) {
    h->lwr_sctr_thres=si;
  } else if(strcmp(field, "lwr_true_thres")==0) {
    h->lwr_true_thres=si;
  } else if(strcmp(field, "upr_true_thres")==0) {
    h->upr_true_thres=si;
  } else if(strcmp(field, "user_process_code")==0) {
    strlcpy(h->user_process_code, value, 10);
  } else if(strcmp(field, "acquisition_mode")==0) {
    h->acquisition_mode=si;
  } else if(strcmp(field, "bin_size")==0) {
    h->bin_size=f;
  } else if(strcmp(field, "branching_fraction")==0) {
    h->branching_fraction=f;
  } else if(strcmp(field, "dose_start_time")==0) {
    struct tm stm;
    if(get_datetime(value, &stm, verbose-1)!=0) return(2);
    h->dose_start_time=timegm(&stm);
  } else if(strcmp(field, "dosage")==0) {
    h->dosage=f;
  } else if(strcmp(field, "well_counter_corr_factor")==0) {
    h->well_counter_corr_factor=f;
  } else if(strcmp(field, "data_units")==0) {
    strlcpy(h->data_units, value, 32);
  } else if(strcmp(field, "septa_state")==0) {
    h->septa_state=si;
  } else if(strncasecmp(field, "FILL_CTI", 8)==0) {
    char *cptr;
    cptr=strtok(value, " \t,;\n\r");
    for(int i=0; i<6; i++) {
      if(cptr==NULL) break;
      h->fill_cti[i]=(short int)atoi(cptr);
      cptr=strtok(NULL, " \t,;\n\r");
    }
  } else
    return(1);
 
  return(0);
}

Referenced by ecat7MainheaderFromIFT().

◆ ecat7EditSHeader()

int ecat7EditSHeader	(	ECAT7_scanheader *	h,
		char *	field,
		char *	value,
		int	verbose )

extern

Edit ECAT 7 3Dscan header.

Returns: Returns 0, if ok, and 1 or 2, if field name or or value is invalid.

Parameters

h	Pointer to ECAT 7 3D scan header structure
field	Field name to be changed
value	New value for the field
verbose	Verbose level; if <=0, then nothing is printed into stdout

Definition at line 199 of file ecat7h.c.

  {
  int i, ii;
  short int si;
  float f;
  char *cptr;
 
  if(verbose>0) printf("ecat7EditSHeader('%s', '%s')\n", field, value);
 
  si=atoi(value); ii=atoi(value); f=atof(value);
 
  if(strcasecmp(field, "DATA_TYPE")==0) {
    h->data_type=si;
  } else if(strcasecmp(field, "NUM_DIMENSIONS")==0) {
    h->num_dimensions=si;
  } else if(strcasecmp(field, "NUM_R_ELEMENTS")==0) {
    h->num_r_elements=si;
  } else if(strcasecmp(field, "NUM_ANGLES")==0) {
    h->num_angles=si;
  } else if(strcasecmp(field, "CORRECTIONS_APPLIED")==0) {
    h->corrections_applied=si;
  } else if(strncasecmp(field, "NUM_Z_ELEMENTS", 14)==0) {
    cptr=strtok(value, " \t,;\n\r");
    for(i=0; i<64; i++) {
      if(cptr==NULL) break;
      h->num_z_elements[i]=(short int)atoi(cptr);
      cptr=strtok(NULL, " \t,;\n\r");
    }
  } else if(strcasecmp(field, "RING_DIFFERENCE")==0) {
    h->ring_difference=si;
  } else if(strcasecmp(field, "STORAGE_ORDER")==0) {
    h->storage_order=si;
  } else if(strcasecmp(field, "AXIAL_COMPRESSION")==0) {
    h->axial_compression=si;
  } else if(strcasecmp(field, "X_RESOLUTION")==0) {
    h->x_resolution=f;
  } else if(strcasecmp(field, "V_RESOLUTION")==0) {
    h->v_resolution=f;
  } else if(strcasecmp(field, "Z_RESOLUTION")==0) {
    h->z_resolution=f;
  } else if(strcasecmp(field, "W_RESOLUTION")==0) {
    h->w_resolution=f;
  } else if(strncasecmp(field, "FILL_GATE", 9)==0) {
    cptr=strtok(value, " \t,;\n\r");
    for(i=0; i<6; i++) {
      if(cptr==NULL) break;
      h->fill_gate[i]=(short int)atoi(cptr);
      cptr=strtok(NULL, " \t,;\n\r");
    }
  } else if(strcasecmp(field, "GATE_DURATION")==0) {
    h->gate_duration=ii;
  } else if(strcasecmp(field, "R_WAVE_OFFSET")==0) {
    h->r_wave_offset=ii;
  } else if(strcasecmp(field, "NUM_ACCEPTED_BEATS")==0) {
    h->num_accepted_beats=ii;
  } else if(strcasecmp(field, "SCALE_FACTOR")==0) {
    h->scale_factor=f;
  } else if(strcasecmp(field, "SCAN_MIN")==0) {
    h->scan_min=si;
  } else if(strcasecmp(field, "SCAN_MAX")==0) {
    h->scan_max=si;
  } else if(strcasecmp(field, "PROMPTS")==0) {
    h->prompts=ii;
  } else if(strcasecmp(field, "DELAYED")==0) {
    h->delayed=ii;
  } else if(strcasecmp(field, "MULTIPLES")==0) {
    h->multiples=ii;
  } else if(strcasecmp(field, "NET_TRUES")==0) {
    h->net_trues=ii;
  } else if(strcasecmp(field, "TOT_AVG_COR")==0) {
    h->tot_avg_cor=f;
  } else if(strcasecmp(field, "TOT_AVG_UNCOR")==0) {
    h->tot_avg_uncor=f;
  } else if(strcasecmp(field, "TOTAL_COIN_RATE")==0) {
    h->total_coin_rate=ii;
  } else if(strcasecmp(field, "FRAME_START_TIME")==0) {
    h->frame_start_time=ii;
  } else if(strcasecmp(field, "FRAME_DURATION")==0) {
    h->frame_duration=ii;
  } else if(strcasecmp(field, "DEADTIME_CORRECTION_FACTOR")==0) {
    h->deadtime_correction_factor=f;
  } else if(strncasecmp(field, "FILL_CTI", 8)==0) {
    cptr=strtok(value, " \t,;\n\r");
    for(i=0; i<90; i++) {
      if(cptr==NULL) break;
      h->fill_cti[i]=(short int)atoi(cptr);
      cptr=strtok(NULL, " \t,;\n\r");
    }
  } else if(strncasecmp(field, "FILL_USER", 9)==0) {
    cptr=strtok(value, " \t,;\n\r");
    for(i=0; i<50; i++) {
      if(cptr==NULL) break;
      h->fill_user[i]=(short int)atoi(cptr);
      cptr=strtok(NULL, " \t,;\n\r");
    }
  } else if(strncasecmp(field, "UNCOR_SINGLES", 13)==0) {
    cptr=strtok(value, " \t,;\n\r");
    for(i=0; i<128; i++) {
      if(cptr==NULL) break;
      h->fill_user[i]=(float)atof(cptr);
      cptr=strtok(NULL, " \t,;\n\r");
    }
  } else
    return(1);
  return(0);
}

Referenced by ecat7WriteSubheaderFromIFT().

◆ ecat7EditVHeader()

int ecat7EditVHeader	(	ECAT7_imageheader *	h,
		char *	field,
		char *	value,
		int	verbose )

extern

Edit ECAT 7 image volume header.

Returns: Returns 0, if ok, and 1 or 2, if field name or or value is invalid.

Parameters

h	Pointer to ECAT 7 image volume header structure
field	Field name to be changed
value	New value for the field
verbose	Verbose level; if <=0, then nothing is printed into stdout

Definition at line 320 of file ecat7h.c.

  {
  int ii;
  short int si;
  float f;
 
  if(verbose>0) printf("ecat7EditVHeader('%s', '%s')\n", field, value);
 
  si=atoi(value); ii=atoi(value); f=atof(value);
 
  if(strcasecmp(field, "DATA_TYPE")==0) {
    h->data_type=si;
  } else if(strcasecmp(field, "NUM_DIMENSIONS")==0) {
    h->num_dimensions=si;
  } else if(strcasecmp(field, "X_DIMENSION")==0) {
    h->x_dimension=si;
  } else if(strcasecmp(field, "Y_DIMENSION")==0) {
    h->y_dimension=si;
  } else if(strcasecmp(field, "Z_DIMENSION")==0) {
    h->z_dimension=si;
  } else if(strcasecmp(field, "X_OFFSET")==0) {
    h->x_offset=f;
  } else if(strcasecmp(field, "Y_OFFSET")==0) {
    h->y_offset=f;
  } else if(strcasecmp(field, "Z_OFFSET")==0) {
    h->z_offset=f;
  } else if(strcasecmp(field, "RECON_ZOOM")==0) {
    h->recon_zoom=f;
  } else if(strcasecmp(field, "SCALE_FACTOR")==0) {
    h->scale_factor=f;
  } else if(strcasecmp(field, "IMAGE_MIN")==0) {
    h->image_min=si;
  } else if(strcasecmp(field, "IMAGE_MAX")==0) {
    h->image_max=si;
  } else if(strcasecmp(field, "X_PIXEL_SIZE")==0) {
    h->x_pixel_size=f;
  } else if(strcasecmp(field, "Y_PIXEL_SIZE")==0) {
    h->y_pixel_size=f;
  } else if(strcasecmp(field, "Z_PIXEL_SIZE")==0) {
    h->z_pixel_size=f;
  } else if(strcasecmp(field, "FRAME_DURATION")==0) {
    h->frame_duration=ii;
  } else if(strcasecmp(field, "FRAME_START_TIME")==0) {
    h->frame_start_time=ii;
  } else if(strcasecmp(field, "FILTER_CODE")==0) {
    h->filter_code=si;
  } else if(strcasecmp(field, "X_RESOLUTION")==0) {
    h->x_resolution=f;
  } else if(strcasecmp(field, "Y_RESOLUTION")==0) {
    h->y_resolution=f;
  } else if(strcasecmp(field, "Z_RESOLUTION")==0) {
    h->z_resolution=f;
  } else if(strcasecmp(field, "NUM_R_ELEMENTS")==0) {
    h->num_r_elements=f;
  } else if(strcasecmp(field, "NUM_ANGLES")==0) {
    h->num_angles=f;
  } else if(strcasecmp(field, "Z_ROTATION_ANGLE")==0) {
    h->z_rotation_angle=f;
  } else if(strcasecmp(field, "DECAY_CORR_FCTR")==0) {
    h->decay_corr_fctr=f;
  } else if(strcasecmp(field, "PROCESSING_CODE")==0) {
    h->processing_code=ii;
  } else if(strcasecmp(field, "GATE_DURATION")==0) {
    h->gate_duration=ii;
  } else if(strcasecmp(field, "R_WAVE_OFFSET")==0) {
    h->r_wave_offset=ii;
  } else if(strcasecmp(field, "NUM_ACCEPTED_BEATS")==0) {
    h->num_accepted_beats=ii;
  } else if(strcasecmp(field, "FILTER_CUTOFF_FREQUENCY")==0) {
    h->filter_cutoff_frequency=f;
  } else if(strcasecmp(field, "FILTER_RESOLUTION")==0) {
    h->filter_resolution=f;
  } else if(strcasecmp(field, "FILTER_RAMP_SLOPE")==0) {
    h->filter_ramp_slope=f;
  } else if(strcasecmp(field, "FILTER_ORDER")==0) {
    h->filter_order=f;
  } else if(strcasecmp(field, "FILTER_SCATTER_FRACTION")==0) {
    h->filter_scatter_fraction=f;
  } else if(strcasecmp(field, "FILTER_SCATTER_SLOPE")==0) {
    h->filter_scatter_slope=si;
  } else if(strcasecmp(field, "ANNOTATION")==0) {
    strlcpy(h->annotation, value, 40);
  } else if(strcasecmp(field, "MT_1_1")==0) {
    h->mt_1_1=f;
  } else if(strcasecmp(field, "MT_1_2")==0) {
    h->mt_1_2=f;
  } else if(strcasecmp(field, "MT_1_3")==0) {
    h->mt_1_3=f;
  } else if(strcasecmp(field, "MT_2_1")==0) {
    h->mt_2_1=f;
  } else if(strcasecmp(field, "MT_2_2")==0) {
    h->mt_2_2=f;
  } else if(strcasecmp(field, "MT_2_3")==0) {
    h->mt_2_3=f;
  } else if(strcasecmp(field, "MT_3_1")==0) {
    h->mt_3_1=f;
  } else if(strcasecmp(field, "MT_3_2")==0) {
    h->mt_3_2=f;
  } else if(strcasecmp(field, "MT_3_3")==0) {
    h->mt_3_3=f;
  } else if(strcasecmp(field, "RFILTER_CUTOFF")==0) {
    h->rfilter_cutoff=f;
  } else if(strcasecmp(field, "RFILTER_RESOLUTION")==0) {
    h->rfilter_resolution=f;
  } else if(strcasecmp(field, "RFILTER_CODE")==0) {
    h->rfilter_code=si;
  } else if(strcasecmp(field, "RFILTER_ORDER")==0) {
    h->rfilter_order=si;
  } else if(strcasecmp(field, "ZFILTER_CUTOFF")==0) {
    h->zfilter_cutoff=f;
  } else if(strcasecmp(field, "ZFILTER_RESOLUTION")==0) {
    h->zfilter_resolution=f;
  } else if(strcasecmp(field, "ZFILTER_CODE")==0) {
    h->zfilter_code=si;
  } else if(strcasecmp(field, "ZFILTER_ORDER")==0) {
    h->zfilter_order=si;
  } else if(strcasecmp(field, "MT_1_4")==0) {
    h->mt_1_4=f;
  } else if(strcasecmp(field, "MT_2_4")==0) {
    h->mt_2_4=f;
  } else if(strcasecmp(field, "MT_3_4")==0) {
    h->mt_3_4=f;
  } else if(strcasecmp(field, "SCATTER_TYPE")==0) {
    h->scatter_type=si;
  } else if(strcasecmp(field, "RECON_TYPE")==0) {
    h->recon_type=si;
  } else if(strcasecmp(field, "RECON_VIEWS")==0) {
    h->recon_views=si;
  } else if(strncasecmp(field, "FILL_CTI", 8)==0) {
    char *cptr;
    cptr=strtok(value, " \t,;\n\r");
    for(int i=0; i<87; i++) {
      if(cptr==NULL) break;
      h->fill_cti[i]=(short int)atoi(cptr);
      cptr=strtok(NULL, " \t,;\n\r");
    }
  } else if(strncasecmp(field, "FILL_USER", 9)==0) {
    char *cptr;
    cptr=strtok(value, " \t,;\n\r");
    for(int i=0; i<50; i++) {
      if(cptr==NULL) break;
      h->fill_user[i]=(short int)atoi(cptr);
      cptr=strtok(NULL, " \t,;\n\r");
    }
  } else
    return(1);
 
  return(0);
}

Referenced by ecat7WriteSubheaderFromIFT().

◆ ecat7EmptyMatlist()

void ecat7EmptyMatlist ( ECAT7_MATRIXLIST * mlist )

extern

Free memory allocated for ECAT matrix list.

Parameters

mlist target matrix list that has allocated memory

Definition at line 26 of file ecat7ml.c.

                                                {
  if(mlist->matrixSpace>0) free((char*)(mlist->matdir));
  mlist->matrixSpace=mlist->matrixNr=0;
}

Referenced by ecat7PrintSubheader(), ecat7ReadHeaders(), ecat7ReadMatlist(), ecat7WriteHeaders(), imgReadEcat7(), imgReadEcat7Frame(), and imgReadEcat7Header().

◆ ecat7EnterMatrix()

int ecat7EnterMatrix	(	FILE *	fp,
		int	matrix_id,
		int	block_nr )

extern

Prepare matrix list for additional matrix data and return block number for matrix header. Directory records are written in big endian byte order. Set block_nr to the number of data blocks + (nr of header blocks - 1)

Parameters

fp	file pointer
matrix_id	matrix identifier coding
block_nr	matrix number [1..number of matrixes]

Returns: returns the block number for matrix header, -1 if invalid input, -2 if first directory block is not found, -3 if failed to read first block, -9 if other directory block is not found, -10 if failed to read other block, -11 if place for new directory block is not found, -12 if failed clear new block, -15 if place for new directory block is not found, -16 if failed to write into new block

Definition at line 147 of file ecat7ml.c.

                                                            {
  unsigned int i=0, dirblk, little, busy=1, nxtblk=0, oldsize;
  /*unsigned*/ int dirbuf[MatBLKSIZE/4];
 
  if(ECAT7_TEST) printf("ecat7EnterMatrix(fp, %d, %d)\n", matrix_id, block_nr);
  /* Check the input */
  if(fp==NULL || matrix_id<1 || block_nr<1) return(-1);
  /* Is this a little endian machine? */
  little=little_endian();
  /* Read first directory record block */
  dirblk=MatFirstDirBlk;
  fseek(fp, (dirblk-1)*MatBLKSIZE, SEEK_SET);
  if(ftell(fp)!=(int)(dirblk-1)*MatBLKSIZE) return(-2);
  if(fread(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(-3);
  /* Byte order conversion for ints in little endian platforms */
  if(little) swawbip(dirbuf, MatBLKSIZE);
  /* Read through the existing directory records */
  while(busy) {
    /* Go through the directory entries in this record */
    for(i=4, nxtblk=dirblk+1; i<MatBLKSIZE/4; i+=4) {
      oldsize=dirbuf[i+2]-dirbuf[i+1]+1;
      if(dirbuf[i]==0) {  /* Check for end of matrix list */
        busy=0; break;
      } else if(dirbuf[i]==matrix_id) {  /* Maybe this matrix already exists? */
        /* yes it does; is old data smaller? */
        if(oldsize<(unsigned int)block_nr) {
          /* it was smaller, so do not use it, but mark it deleted */
          dirbuf[i] = 0xFFFFFFFF; dirbuf[i+3]=-1;
          if(little) swawbip(dirbuf, MatBLKSIZE);
          long long pos=(dirblk-1)*(long long)MatBLKSIZE;
          fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(-6);
          if(fwrite(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(-7);
          if(little) swawbip(dirbuf, MatBLKSIZE);
          nxtblk=dirbuf[i+2]+1;
        } else { /* old matrix size is ok */
          nxtblk=dirbuf[i+1]; dirbuf[0]++; dirbuf[3]--; busy=0;
          break;
        }
      } else { /* this is not the same matrix */
        /* But is deleted and of same or smaller size? */
        if(dirbuf[i+3]==-1 && (unsigned int)block_nr<=oldsize) {
          /* yes it was, so lets recycle it */
          dirbuf[i]=matrix_id;
          nxtblk=dirbuf[i+1]; dirbuf[0]++; dirbuf[3]--; busy=0;
          break;
        }
        /* nothing to be done with this entry */
        nxtblk=dirbuf[i+2]+1;
      }
    } /* next entry in this record */
    if(!busy) break; /* stop reading existing records */
    /* Read the next directory record */
    if(dirbuf[1]!=MatFirstDirBlk) {
      /* There are more records left to read */
      dirblk=dirbuf[1];
      long long pos=(dirblk-1)*(long long)MatBLKSIZE;
      fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(-9);
      if(fread(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(-10);
      if(little) swawbip(dirbuf, MatBLKSIZE);
    } else {
      /* No more records to read, so lets write a new empty one */
      dirbuf[1]=nxtblk; /* write a pointer to the new one */
      if(little) swawbip(dirbuf, MatBLKSIZE);
      long long pos=(dirblk-1)*(long long)MatBLKSIZE;
      fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(-11);
      if(fwrite(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(-12);
      /* and then initiate the contents of the next one, but do not write it */
      dirbuf[0]=31; dirbuf[1]=MatFirstDirBlk; dirbuf[2]=dirblk;
      dirbuf[3]=0; dirblk=nxtblk;
      for(i=4; i<MatBLKSIZE/4; i++) dirbuf[i]=0;
    }
  } /* next directory record */
  dirbuf[i]=matrix_id;
  dirbuf[i+1]=nxtblk;
  dirbuf[i+2]=nxtblk+block_nr;
  dirbuf[i+3]=1; /* mark the entry as read/write */
  dirbuf[0]--;
  dirbuf[3]++;
  if(little) swawbip(dirbuf, MatBLKSIZE);
  long long pos=(dirblk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(-15);
  if(fwrite(dirbuf, sizeof(int), MatBLKSIZE/4, fp) != MatBLKSIZE/4) return(-16);
  if(ECAT7_TEST) printf("returning %d from ecat7EnterMatrix()\n", nxtblk);
  return(nxtblk);
}

Referenced by ecat7CopyFile(), ecat7Write2DScanMatrix(), ecat7WriteImageMatrix(), ecat7WritePolarmapMatrix(), and ecat7WriteScanMatrix().

◆ ecat7filetype()

char * ecat7filetype ( short int file_type )

extern

Returns pointer to a string describing the ECAT7 file_type

Parameters

file_type file type code

Returns: pointer to static string

Definition at line 447 of file ecat7p.c.

  {
  static char *info[] = {
  "unknown", "2D sinogram", "image-16", "attenuation correction",
  "2D normalization", "polar map", "volume 8", "volume 16",
  "projection 8", "projection 16", "image 8", "3D sinogram 16",
  "3D sinogram 8", "3D normalization", "3D sinogram fit",
  0};
  if(file_type>=0 && file_type<=14) return((char*)info[file_type]);
  else return((char*)info[0]);
}

Referenced by ecat7PrintMainheader(), and imgRead().

◆ ecat7GatherMatlist()

int ecat7GatherMatlist	(	ECAT7_MATRIXLIST *	ml,
		short int	do_planes,
		short int	do_frames,
		short int	do_gates,
		short int	do_beds )

extern

Matrix numbers in ECAT 7 matrix list are edited, when necessary, so that plane, frame, gate and/or bed numbers are continuous, starting from one (planes, frames and gates) or from zero (beds). List order is not changed.

Parameters

ml	ECAT 7 matrix list, where the matrix numbers will be edited
do_planes	Plane numbers are gathered together (1) or not (0)
do_frames	Frame numbers are gathered together (1) or not (0)
do_gates	Gate numbers are gathered together (1) or not (0)
do_beds	Bed numbers are gathered together (1) or not (0)

Returns: 0 if successful, 1 if invalid input, 3 failed to allocate memory

Definition at line 535 of file ecat7ml.c.

                                                  {
  int i, ncurr, n;
  ECAT7_Matval* matval;
 
  if(ml==NULL) return(1);
  if(ml->matrixNr<1) return(0);
 
  /* Allocate memory for matrix values */
  matval = (ECAT7_Matval*)calloc(ml->matrixNr,sizeof(ECAT7_Matval));
  if(matval == NULL) return(3);
 
  /* And get the matrix values */
  for(i=0; i<ml->matrixNr; i++) ecat7_id_to_val(ml->matdir[i].id, matval+i);
 
  /* Planes */
  if(do_planes!=0) {
    ncurr=1;
    while(ncurr <= ml->matrixNr) {
      /* Find any matrix with this number? */
      for(i=0, n=0; i<ml->matrixNr; i++) if(matval[i].plane==ncurr) {n=1; break;}
      /* If yes, then go on to the next matrix number */
      if(n==1) {ncurr++; continue;}
      /* If not, then subtract 1 from all matrix numbers that are larger */
      for(i=0, n=0; i<ml->matrixNr; i++)
        if(matval[i].plane>ncurr) {
          /*printf("    plane %d -> plane %d\n", matval[i].plane, matval[i].plane-1);*/
          matval[i].plane--; n++;
        }
      /* If no larger values were found any more, then quit */
      if(n<1) break;
    }
  }
 
  /* Frames */
  if(do_frames!=0) {
    ncurr=1;
    while(ncurr <= ml->matrixNr) {
      /* Find any matrix with this number? */
      for(i=0, n=0; i<ml->matrixNr; i++) if(matval[i].frame==ncurr) {n=1; break;}
      /* If yes, then go on to the next matrix number */
      if(n==1) {ncurr++; continue;}
      /* If not, then subtract 1 from all matrix numbers that are larger */
      for(i=0, n=0; i<ml->matrixNr; i++)
        if(matval[i].frame>ncurr) {matval[i].frame--; n++;}
      /* If no larger values were found any more, then quit */
      if(n<1) break;
    }
  }
 
  /* Gates */
  if(do_gates!=0) {
    ncurr=1;
    while(ncurr <= ml->matrixNr) {
      /* Find any matrix with this number? */
      for(i=0, n=0; i<ml->matrixNr; i++) if(matval[i].gate==ncurr) {n=1; break;}
      /* If yes, then go on to the next matrix number */
      if(n==1) {ncurr++; continue;}
      /* If not, then subtract 1 from all matrix numbers that are larger */
      for(i=0, n=0; i<ml->matrixNr; i++)
        if(matval[i].gate>ncurr) {matval[i].gate--; n++;}
      /* If no larger values were found any more, then quit */
      if(n<1) break;
    }
  }
 
  /* Beds */
  if(do_beds!=0) {
    ncurr=1;
    while(ncurr <= ml->matrixNr) {
      /* Find any matrix with this number? */
      for(i=0, n=0; i<ml->matrixNr; i++) if(matval[i].bed==ncurr) {n=1; break;}
      /* If yes, then go on to the next matrix number */
      if(n==1) {ncurr++; continue;}
      /* If not, then subtract 1 from all matrix numbers that are larger */
      for(i=0, n=0; i<ml->matrixNr; i++)
        if(matval[i].bed>ncurr) {matval[i].bed--; n++;}
      /* If no larger values were found any more, then quit */
      if(n<1) break;
    }
  }
 
  /* Write matrix values (possibly changed) into matrix list */
  for(i=0; i<ml->matrixNr; i++) ml->matdir[i].id=ecat7_val_to_id(
            matval[i].frame, matval[i].plane,
      matval[i].gate, matval[i].data,
      matval[i].bed);
  free(matval);
  return(0);
}

Referenced by ecatFixMatrixlist(), imgReadEcat7Frame(), and imgReadEcat7Header().

◆ ecat7GetMatrixBlockSize()

int ecat7GetMatrixBlockSize	(	ECAT7_MATRIXLIST *	mlist,
		int *	blk_nr )

extern

Calculate the size of one data matrix in ECAT7 file matrix list, and check that the size is same in all matrices.

Parameters

mlist	Ecat7 matrix list; note that this list is here sorted by planes
blk_nr	number of blocks will be put here; NULL if not needed

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 418 of file ecat7ml.c.

                                                                  {
  int m, prev_blk, blk;
 
  /* Check input */
  if(mlist==NULL) return STATUS_FAULT;
  if(blk_nr!=NULL) *blk_nr=0;
 
  /* Calculate the size of first data matrix */
  m=0; prev_blk=blk=mlist->matdir[m].endblk - mlist->matdir[m].strtblk;
  for(m=1; m<mlist->matrixNr; m++) {
    blk=mlist->matdir[m].endblk - mlist->matdir[m].strtblk;
    if(blk!=prev_blk) return STATUS_VARMATSIZE;
    else prev_blk=blk;
  }
  if(blk_nr!=NULL) *blk_nr=blk;
  return STATUS_OK;
}

Referenced by imgReadEcat7Header().

◆ ecat7GetNums()

int ecat7GetNums	(	ECAT7_MATRIXLIST *	ml,
		ECAT7_mainheader *	mh,
		FILE *	fp,
		short int *	num_planes,
		short int *	num_frames,
		short int *	num_gates,
		short int *	num_bed_pos )

extern

Read the maximum plane, frame, gate and bed number from matrixlist. In case of 3D formats, num_planes is checked from the first subheader.

Parameters

ml	Pointer to matrixlist
mh	Pointer to mainheader
fp	File pointer to ECAT7 file opened in binary mode
num_planes	num_planes will be put here; NULL if not needed to be read
num_frames	num_planes will be put here; NULL if not needed to be read
num_gates	num_planes will be put here; NULL if not needed to be read
num_bed_pos	num_planes will be put here; NULL if not needed to be read

Returns: 0 if successful, 1 if invalid input, 2 if no matrixes, 3 failed to allocate memory, 5 if failed to read image/scan header information

Definition at line 452 of file ecat7ml.c.

                                                                          {
  int i, nmax, ret=0;
  ECAT7_imageheader ih;
  ECAT7_scanheader sh;
  ECAT7_Matval* matval;
 
  if(ml==NULL) return(1);
  if(ml->matrixNr<1) return(2);
 
  /* Allocate memory for matrix values */
  matval = (ECAT7_Matval*)calloc(ml->matrixNr,sizeof(ECAT7_Matval));
  if(matval == NULL) return(3);
 
  /* And get the matrix values */
  for(i=0; i<ml->matrixNr; i++) ecat7_id_to_val(ml->matdir[i].id, matval+i);
 
  /* Planes */
  if(num_planes!=NULL) {
    nmax=matval[0].plane;
    for(i=1; i<ml->matrixNr; i++) if(matval[i].plane>nmax) nmax=matval[i].plane;
    *num_planes=nmax;
  }
  /* Frames */
  if(num_frames!=NULL) {
    nmax=matval[0].frame;
    for(i=1; i<ml->matrixNr; i++) if(matval[i].frame>nmax) nmax=matval[i].frame;
    *num_frames=nmax;
  }
  /* Gates */
  if(num_gates!=NULL) {
    nmax=matval[0].gate;
    for(i=1; i<ml->matrixNr; i++) if(matval[i].gate>nmax) nmax=matval[i].gate;
    *num_gates=nmax;
  }
  /* Beds */
  if(num_bed_pos!=NULL) {
    nmax=matval[0].bed;
    for(i=1; i<ml->matrixNr; i++) if(matval[i].bed>nmax) nmax=matval[i].bed;
    *num_bed_pos=nmax;
  }
 
  /* Check the num_planes from the first subheader in 3D formats */
  if(num_planes!=NULL && *num_planes<=1) switch(mh->file_type) {
    case ECAT7_VOLUME8:
    case ECAT7_VOLUME16:
      ret=ecat7ReadImageheader(fp, ml->matdir[0].strtblk, &ih);
      if(ret!=0) {
        free(matval);
        return(5);
      }
      if(ih.num_dimensions>2 && ih.z_dimension>1) *num_planes=ih.z_dimension;
      break;
    case ECAT7_3DSCAN:
    case ECAT7_3DSCAN8:
    case ECAT7_3DSCANFIT:
      ret=ecat7ReadScanheader(fp, ml->matdir[0].strtblk, &sh);
      if(ret!=0) {
        free(matval);
        return(5);
      }
      for(i=0, *num_planes=0; i<64; i++) *num_planes+=sh.num_z_elements[i];
      break;
  }
  free(matval);
  return(0);
}

Referenced by ecatFixMatrixlist().

◆ ecat7GetPlaneAndFrameNr()

int ecat7GetPlaneAndFrameNr	(	ECAT7_MATRIXLIST *	mlist,
		ECAT7_mainheader *	h,
		int *	plane_nr,
		int *	frame_nr )

extern

Calculate the number of planes and frames/gates from ECAT7 matrix list. Check that all planes have equal nr of frames/gates, that frames/gates are sequentally numbered.

Parameters

mlist	Ecat7 matrix list; note that this list is here sorted by planes
h	Ecat7 main header structure
plane_nr	Number of planes will be put here; NULL if not needed [1..number of planes, or NULL]
frame_nr	Number of frames/gates will be put here; NULL if not needed [1..number of frames, or NULL]

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error. Note that if this is 3D image volume or sinogram, then the returned plane_nr will be one, and the actual Z dim must be read from subheader.

Definition at line 372 of file ecat7ml.c.

                                                                                                        {
  ECAT7_Matval matval;
  int m, plane, frame, prev_plane, prev_frame, fnr, pnr;
 
  /* Check input */
  if(mlist==NULL) return STATUS_FAULT;
  if(plane_nr!=NULL) *plane_nr=0;
  if(frame_nr!=NULL) *frame_nr=0;
 
  /* Sort matrices by plane so that following computation works */
  ecat7SortMatlistByPlane(mlist);
 
  prev_plane=plane=-1; prev_frame=frame=-1;
  fnr=pnr=0;
  for(m=0; m<mlist->matrixNr; m++) {
    ecat7_id_to_val(mlist->matdir[m].id, &matval);
    plane=matval.plane;
    if(h->num_frames>=h->num_gates)
      frame=matval.frame;
    else
      frame=matval.gate;
    if(plane!=prev_plane) {
      fnr=1; pnr++;
    } else {
      fnr++;
      if(prev_frame>0 && frame!=prev_frame+1) return STATUS_MISSINGMATRIX;
    }
    prev_plane=plane; prev_frame=frame;
  } /* next matrix */
  if(fnr*pnr != mlist->matrixNr) return STATUS_MISSINGMATRIX;
  if(plane_nr!=NULL) *plane_nr=pnr;
  if(frame_nr!=NULL) *frame_nr=fnr;
  return STATUS_OK;
}

Referenced by imgReadEcat7Header().

◆ ecat7ImageheaderToIFT()

int ecat7ImageheaderToIFT	(	ECAT7_imageheader *	h,
		IFT *	ift,
		int	verbose )

extern

Copy ECAT 7 image header into IFT structure.

Returns: Returns STATUS_OK when successful.

Parameters

h	Pointer to source ECAT 7 image header
ift	Pointer to initiated IFT structure
verbose	Verbose level

Definition at line 251 of file ecat7ift.c.

  {
  int i;
  char tmp[1024], tmp2[32];
 
  if(verbose>0) printf("%s(h, ift)\n", __func__);
  if(h==NULL || ift==NULL) return STATUS_FAULT;
  if(h->data_type<=0) return STATUS_UNKNOWNFORMAT;
 
  sprintf(tmp, "%d", h->data_type);
  if(iftPut(ift, "data_type", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_dimensions);
  if(iftPut(ift, "num_dimensions", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->x_dimension);
  if(iftPut(ift, "x_dimension", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->y_dimension);
  if(iftPut(ift, "y_dimension", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->z_dimension);
  if(iftPut(ift, "z_dimension", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->x_offset);
  if(iftPut(ift, "x_offset", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->y_offset);
  if(iftPut(ift, "y_offset", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->z_offset);
  if(iftPut(ift, "z_offset", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->recon_zoom);
  if(iftPut(ift, "recon_zoom", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%E", h->scale_factor);
  if(iftPut(ift, "scale_factor", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->image_min);
  if(iftPut(ift, "image_min", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->image_max);
  if(iftPut(ift, "image_max", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->x_pixel_size);
  if(iftPut(ift, "x_pixel_size", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->y_pixel_size);
  if(iftPut(ift, "y_pixel_size", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->z_pixel_size);
  if(iftPut(ift, "z_pixel_size", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->frame_duration);
  if(iftPut(ift, "frame_duration", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->frame_start_time);
  if(iftPut(ift, "frame_start_time", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->filter_code);
  if(iftPut(ift, "filter_code", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->x_resolution);
  if(iftPut(ift, "x_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->y_resolution);
  if(iftPut(ift, "y_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->z_resolution);
  if(iftPut(ift, "z_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->num_r_elements);
  if(iftPut(ift, "num_r_elements", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->num_angles);
  if(iftPut(ift, "num_angles", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->z_rotation_angle);
  if(iftPut(ift, "z_rotation_angle", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->decay_corr_fctr);
  if(iftPut(ift, "decay_corr_fctr", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->processing_code);
  if(iftPut(ift, "processing_code", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->gate_duration);
  if(iftPut(ift, "gate_duration", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->r_wave_offset);
  if(iftPut(ift, "r_wave_offset", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_accepted_beats);
  if(iftPut(ift, "num_accepted_beats", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%E", h->filter_cutoff_frequency);
  if(iftPut(ift, "filter_cutoff_frequency", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%E", h->filter_resolution);
  if(iftPut(ift, "filter_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%E", h->filter_ramp_slope);
  if(iftPut(ift, "filter_ramp_slope", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->filter_order);
  if(iftPut(ift, "filter_order", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%E", h->filter_scatter_fraction);
  if(iftPut(ift, "filter_scatter_fraction", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%E", h->filter_scatter_slope);
  if(iftPut(ift, "filter_scatter_slope", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "annotation", h->annotation, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_1_1);
  if(iftPut(ift, "mt_1_1", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_1_2);
  if(iftPut(ift, "mt_1_2", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_1_3);
  if(iftPut(ift, "mt_1_3", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_2_1);
  if(iftPut(ift, "mt_2_1", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_2_2);
  if(iftPut(ift, "mt_2_2", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_2_3);
  if(iftPut(ift, "mt_2_3", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_3_1);
  if(iftPut(ift, "mt_3_1", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_3_2);
  if(iftPut(ift, "mt_3_2", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_3_3);
  if(iftPut(ift, "mt_3_3", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->rfilter_cutoff);
  if(iftPut(ift, "rfilter_cutoff", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->rfilter_resolution);
  if(iftPut(ift, "rfilter_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->rfilter_code);
  if(iftPut(ift, "rfilter_code", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->rfilter_order);
  if(iftPut(ift, "rfilter_order", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->zfilter_cutoff);
  if(iftPut(ift, "zfilter_cutoff", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->zfilter_resolution);
  if(iftPut(ift, "zfilter_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->zfilter_code);
  if(iftPut(ift, "zfilter_code", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->zfilter_order);
  if(iftPut(ift, "zfilter_order", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_1_4);
  if(iftPut(ift, "mt_1_4", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_2_4);
  if(iftPut(ift, "mt_2_4", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->mt_3_4);
  if(iftPut(ift, "mt_3_4", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->scatter_type);
  if(iftPut(ift, "scatter_type", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->recon_type);
  if(iftPut(ift, "recon_type", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->recon_views);
  if(iftPut(ift, "recon_views", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
 
  sprintf(tmp, "%d", h->fill_cti[0]);
  for(i=1; i<87; i++) {sprintf(tmp2, " %d", h->fill_cti[i]); strcat(tmp, tmp2);}
  if(iftPut(ift, "fill_cti", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
 
  sprintf(tmp, "%d", h->fill_user[0]);
  for(i=1; i<49; i++) {sprintf(tmp2, " %d", h->fill_user[i]); strcat(tmp, tmp2);}
  if(iftPut(ift, "fill_user", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
 
/*
  if(iftPut(ift, "", h->, NULL)!=0) return STATUS_UNSUPPORTED;
 
  sprintf(tmp, "%g", h->);
  if(iftPut(ift, "", tmp, NULL)!=0) return STATUS_UNSUPPORTED;
 
  sprintf(tmp, "%d", h->);
  if(iftPut(ift, "", tmp, NULL)!=0) return STATUS_UNSUPPORTED;
  */
  return STATUS_OK;
}

Referenced by ecat7ReadSubheaderToIFT().

◆ ecat7InitMatlist()

void ecat7InitMatlist ( ECAT7_MATRIXLIST * mlist )

extern

Initiate ECAT matrix list. Call this once before first use.

Parameters

mlist target matrix list

Definition at line 15 of file ecat7ml.c.

                                               {
  mlist->matrixSpace=mlist->matrixNr=0; mlist->matdir=NULL;
}

Referenced by ecat7PrintSubheader(), ecat7ReadHeaders(), ecat7WriteHeaders(), ecatFixMatrixlist(), imgReadEcat7(), imgReadEcat7Frame(), and imgReadEcat7Header().

◆ ecat7MainheaderFromIFT()

int ecat7MainheaderFromIFT	(	ECAT7_mainheader *	h,
		IFT *	ift,
		int	verbose )

extern

Copy ECAT 7 main header from IFT structure to header structure.

Returns: Returns STATUS_OK when successful.

Parameters

h	Pointer to target ECAT 7 main header
ift	Pointer to source IFT structure
verbose	Verbose level

Definition at line 221 of file ecat7ift.c.

  {
  int ii, ret;
 
  if(verbose>0) printf("ecat7MainheaderFromIFT(mh, ift)\n");
  if(h==NULL || ift==NULL) return STATUS_FAULT;
  if(verbose>5) iftWrite(ift, "stdout", 0);
 
  for(ii=ret=0; ii<ift->keyNr; ii++) {
    if(verbose>2) printf("  key := %s\n  value := %s\n", ift->item[ii].key, ift->item[ii].value);
    ret=ecat7EditMHeader(h, ift->item[ii].key, ift->item[ii].value, verbose-1);
    if(ret!=0) {
      if(verbose>0) fprintf(stderr, "Error with key '%s'\n", ift->item[ii].key);
      break;
    }
  } 
  if(ret!=0) return STATUS_FAULT;
  return STATUS_OK;
}

Referenced by ecat7WriteHeaders().

◆ ecat7MHeaderToIFT()

int ecat7MHeaderToIFT	(	ECAT7_mainheader *	h,
		IFT *	ift,
		int	verbose )

extern

Copy ECAT 7 mainheader into IFT struct.

Returns: Returns STATUS_OK when succesful.

Parameters

h	Pointer to source ECAT 7 main header
ift	Pointer to initiated IFT struct
verbose	Verbose level

Definition at line 85 of file ecat7ift.c.

  {
  int i;
  char tmp[1024], tmp2[32];
  time_t t;
 
  if(verbose>0) printf("ecat7MHeaderToIFT(mh, ift)\n");
  if(h==NULL || ift==NULL) return STATUS_FAULT;
  if(strncmp(h->magic_number, ECAT7V_MAGICNR, 7)!=0) return STATUS_UNKNOWNFORMAT;
 
  if(iftPut(ift, "magic_number", h->magic_number, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "original_file_name", h->original_file_name, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->sw_version);
  if(iftPut(ift, "sw_version", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->system_type);
  if(iftPut(ift, "system_type", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->file_type);
  if(iftPut(ift, "file_type", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "serial_number", h->serial_number, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  t=h->scan_start_time;
  if(!ctime_r_int(&t, tmp)) strcpy(tmp, "1970-01-01 00:00:00");
  if(iftPut(ift, "scan_start_time", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "isotope_name", h->isotope_name, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->isotope_halflife);
  if(iftPut(ift, "isotope_halflife", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "radiopharmaceutical", h->radiopharmaceutical, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->gantry_tilt);
  if(iftPut(ift, "gantry_tilt", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->gantry_rotation);
  if(iftPut(ift, "gantry_rotation", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->bed_elevation);
  if(iftPut(ift, "bed_elevation", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->intrinsic_tilt);
  if(iftPut(ift, "intrinsic_tilt", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->wobble_speed);
  if(iftPut(ift, "wobble_speed", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->transm_source_type);
  if(iftPut(ift, "transm_source_type", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->distance_scanned);
  if(iftPut(ift, "distance_scanned", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->transaxial_fov);
  if(iftPut(ift, "transaxial_fov", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->angular_compression);
  if(iftPut(ift, "angular_compression", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->coin_samp_mode);
  if(iftPut(ift, "coin_samp_mode", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->axial_samp_mode);
  if(iftPut(ift, "axial_samp_mode", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%E", h->ecat_calibration_factor);
  if(iftPut(ift, "ecat_calibration_factor", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->calibration_units);
  if(iftPut(ift, "calibration_units", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->calibration_units_label);
  if(iftPut(ift, "calibration_units_label", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->compression_code);
  if(iftPut(ift, "compression_code", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "study_type", h->study_type, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "patient_id", h->patient_id, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "patient_name", h->patient_name, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%c", h->patient_sex);
  if(iftPut(ift, "patient_sex", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%c", h->patient_dexterity);
  if(iftPut(ift, "patient_dexterity", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->patient_age);
  if(iftPut(ift, "patient_age", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->patient_height);
  if(iftPut(ift, "patient_height", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->patient_weight);
  if(iftPut(ift, "patient_weight", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  t=h->patient_birth_date;
  if(!ctime_r_int(&t, tmp)) strcpy(tmp, "1970-01-01 00:00:00");
  if(iftPut(ift, "patient_birth_date", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "physician_name", h->physician_name, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "operator_name", h->operator_name, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "study_description", h->study_description, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->acquisition_type);
  if(iftPut(ift, "acquisition_type", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->patient_orientation);
  if(iftPut(ift, "patient_orientation", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "facility_name", h->facility_name, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_planes);
  if(iftPut(ift, "num_planes", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_frames);
  if(iftPut(ift, "num_frames", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_gates);
  if(iftPut(ift, "num_gates", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_bed_pos);
  if(iftPut(ift, "num_bed_pos", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->init_bed_position);
  if(iftPut(ift, "init_bed_position", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->bed_position[0]);
  for(i=1; i<15; i++) {sprintf(tmp2, " %g", h->bed_position[i]); strcat(tmp, tmp2);}
  if(iftPut(ift, "bed_position", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->plane_separation);
  if(iftPut(ift, "plane_separation", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->lwr_sctr_thres);
  if(iftPut(ift, "lwr_sctr_thres", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->lwr_true_thres);
  if(iftPut(ift, "lwr_true_thres", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->upr_true_thres);
  if(iftPut(ift, "upr_true_thres", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "user_process_code", h->user_process_code, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->acquisition_mode);
  if(iftPut(ift, "acquisition_mode", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->bin_size);
  if(iftPut(ift, "bin_size", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->branching_fraction);
  if(iftPut(ift, "branching_fraction", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  t=h->dose_start_time;
  if(!ctime_r_int(&t, tmp)) strcpy(tmp, "1970-01-01 00:00:00");
  if(iftPut(ift, "dose_start_time", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->dosage);
  if(iftPut(ift, "dosage", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%E", h->well_counter_corr_factor);
  if(iftPut(ift, "well_counter_corr_factor", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  if(iftPut(ift, "data_units", h->data_units, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->septa_state);
  if(iftPut(ift, "septa_state", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
 
  sprintf(tmp, "%d", h->fill_cti[0]);
  for(i=1; i<6; i++) {sprintf(tmp2, " %d", h->fill_cti[i]); strcat(tmp, tmp2);}
  if(iftPut(ift, "fill_cti", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
 
  return STATUS_OK;
}

Referenced by ecat7ReadHeaders().

◆ ecat7Print2DNormheader()

void ecat7Print2DNormheader	(	ECAT7_2Dnormheader *	h,
		FILE *	fp )

extern

Print ECAT 7.x 2D normalization header contents to specified file pointer

Parameters

h	Ecat7 2D normalization header
fp	target file pointer

Definition at line 415 of file ecat7p.c.

  {
  if(ECAT7_TEST) fprintf(stdout, "ecat7Print2DNormheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type,
    ecat7datatype(h->data_type) );
  fprintf(fp, "num_dimensions := %d\n", h->num_dimensions);
  fprintf(fp, "num_r_elements := %d\n", h->num_r_elements);
  fprintf(fp, "num_angles := %d\n", h->num_angles);
  fprintf(fp, "num_z_elements := %d\n", h->num_z_elements);
  fprintf(fp, "ring_difference := %d\n", h->ring_difference);
  fprintf(fp, "scale_factor := %E\n", h->scale_factor);
  fprintf(fp, "norm_min := %g\n", h->norm_min);
  fprintf(fp, "norm_max := %g\n", h->norm_max);
  fprintf(fp, "fov_source_width := %g\n", h->fov_source_width);
  fprintf(fp, "norm_quality_factor := %g\n", h->norm_quality_factor);
  fprintf(fp, "norm_quality_factor_code := %d\n", h->norm_quality_factor_code);
  fprintf(fp, "storage_order := %d\n", h->storage_order);
  fprintf(fp, "span := %d\n", h->span);
  fprintf(fp, "z_elements :=");
  for(int i=0; i<64; i++) fprintf(fp, " %d", h->z_elements[i]);
  fprintf(fp, "\n");
}

Referenced by ecat7PrintSubheader().

◆ ecat7Print2DScanheader()

void ecat7Print2DScanheader	(	ECAT7_2Dscanheader *	h,
		FILE *	fp )

extern

Print ECAT 7.x 2D sinogram header contents to specified file pointer

Parameters

h	Ecat7 2D scan header
fp	target file pointer

Definition at line 364 of file ecat7p.c.

  {
  if(ECAT7_TEST) fprintf(stdout, "ecat7Print2DScanheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type,
    ecat7datatype(h->data_type) );
  fprintf(fp, "num_dimensions := %d\n", h->num_dimensions);
  fprintf(fp, "num_r_elements := %d\n", h->num_r_elements);
  fprintf(fp, "num_angles := %d\n", h->num_angles);
  fprintf(fp, "corrections_applied := %d\n", h->corrections_applied);
  fprintf(fp, "num_z_elements := %d\n", h->num_z_elements);
  fprintf(fp, "ring_difference := %d\n", h->ring_difference);
  fprintf(fp, "x_resolution := %g\n", h->x_resolution);
  fprintf(fp, "y_resolution := %g\n", h->y_resolution);
  fprintf(fp, "z_resolution := %g\n", h->z_resolution);
  fprintf(fp, "w_resolution := %g\n", h->w_resolution);
  fprintf(fp, "gate_duration := %d\n", h->gate_duration);
  fprintf(fp, "r_wave_offset := %d\n", h->r_wave_offset);
  fprintf(fp, "num_accepted_beats := %d\n", h->num_accepted_beats);
  fprintf(fp, "scale_factor := %E\n", h->scale_factor);
  fprintf(fp, "scan_min := %d\n", h->scan_min);
  fprintf(fp, "scan_max := %d\n", h->scan_max);
  fprintf(fp, "prompts := %d\n", h->prompts);
  fprintf(fp, "delayed := %d\n", h->delayed);
  fprintf(fp, "multiples := %d\n", h->multiples);
  fprintf(fp, "net_trues := %d\n", h->net_trues);
  fprintf(fp, "cor_singles :=");
  for(int i=0; i<16; i++) fprintf(fp, " %g", h->cor_singles[i]);
  fprintf(fp, "\n");
  fprintf(fp, "uncor_singles :=");
  for(int i=0; i<16; i++) fprintf(fp, " %g", h->uncor_singles[i]);
  fprintf(fp, "\n");
  fprintf(fp, "tot_avg_cor := %g\n", h->tot_avg_cor);
  fprintf(fp, "tot_avg_uncor := %g\n", h->tot_avg_uncor);
  fprintf(fp, "total_coin_rate := %d\n", h->total_coin_rate);
  fprintf(fp, "frame_start_time := %d\n", h->frame_start_time);
  fprintf(fp, "frame_duration := %d\n", h->frame_duration);
  fprintf(fp, "deadtime_correction_factor := %E\n", h->deadtime_correction_factor);
  fprintf(fp, "physical_planes :=");
  for(int i=0; i<8; i++) fprintf(fp, " %d", h->physical_planes[i]);
  fprintf(fp, "\n");
}

Referenced by ecat7PrintSubheader(), and ecat7Read2DScanMatrix().

◆ ecat7PrintAttenheader()

void ecat7PrintAttenheader	(	ECAT7_attenheader *	h,
		FILE *	fp )

extern

Print ECAT 7.x attenuation header contents to specified file pointer

Parameters

h	Ecat7 attenuation header
fp	target file pointer

Definition at line 230 of file ecat7p.c.

  {
  if(ECAT7_TEST) fprintf(stdout, "ecat7PrintAttenheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type,
    ecat7datatype(h->data_type) );
  fprintf(fp, "num_dimensions := %d\n", h->num_dimensions);
  fprintf(fp, "attenuation_type := %d\n", h->attenuation_type);
  fprintf(fp, "num_r_elements := %d\n", h->num_r_elements);
  fprintf(fp, "num_angles := %d\n", h->num_angles);
  fprintf(fp, "num_z_elements := %d\n", h->num_z_elements);
  fprintf(fp, "ring_difference := %d\n", h->ring_difference);
  fprintf(fp, "x_resolution := %g\n", h->x_resolution);
  fprintf(fp, "y_resolution := %g\n", h->y_resolution);
  fprintf(fp, "z_resolution := %g\n", h->z_resolution);
  fprintf(fp, "w_resolution := %g\n", h->w_resolution);
  fprintf(fp, "scale_factor := %E\n", h->scale_factor);
  fprintf(fp, "x_offset := %g\n", h->x_offset);
  fprintf(fp, "y_offset := %g\n", h->y_offset);
  fprintf(fp, "x_radius := %g\n", h->x_radius);
  fprintf(fp, "y_radius := %g\n", h->y_radius);
  fprintf(fp, "tilt_angle := %g\n", h->tilt_angle);
  fprintf(fp, "attenuation_coeff := %E\n", h->attenuation_coeff);
  fprintf(fp, "attenuation_min := %E\n", h->attenuation_min);
  fprintf(fp, "attenuation_max := %E\n", h->attenuation_max);
  fprintf(fp, "skull_thickness := %g\n", h->skull_thickness);
  fprintf(fp, "num_additional_atten_coeff := %d\n", h->num_additional_atten_coeff);
  fprintf(fp, "additional_atten_coeff :=");
  for(int i=0; i<8; i++) fprintf(fp, " %E", h->additional_atten_coeff[i]);
  fprintf(fp, "\n");
  fprintf(fp, "edge_finding_threshold := %g\n", h->edge_finding_threshold);
  fprintf(fp, "storage_order := %d\n", h->storage_order);
  fprintf(fp, "span := %d\n", h->span);
  fprintf(fp, "z_elements :=");
  for(int i=0; i<64; i++) fprintf(fp, " %d", h->z_elements[i]);
  fprintf(fp, "\n");
}

Referenced by ecat7PrintSubheader().

◆ ecat7PrintImageheader()

void ecat7PrintImageheader	(	ECAT7_imageheader *	h,
		FILE *	fp )

extern

Print ECAT 7.x image header contents to specified file pointer.

Parameters

h	Ecat7 image header
fp	target file pointer

Definition at line 102 of file ecat7p.c.

  {
  if(ECAT7_TEST) fprintf(stdout, "ecat7PrintImageheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type, ecat7datatype(h->data_type) );
  fprintf(fp, "num_dimensions := %d\n", h->num_dimensions);
  fprintf(fp, "x_dimension := %d\n", h->x_dimension);
  fprintf(fp, "y_dimension := %d\n", h->y_dimension);
  fprintf(fp, "z_dimension := %d\n", h->z_dimension);
  fprintf(fp, "x_offset := %g\n", h->x_offset);
  fprintf(fp, "y_offset := %g\n", h->y_offset);
  fprintf(fp, "z_offset := %g\n", h->z_offset);
  fprintf(fp, "recon_zoom := %g\n", h->recon_zoom);
  fprintf(fp, "scale_factor := %E\n", h->scale_factor);
  fprintf(fp, "image_min := %d\n", h->image_min);
  fprintf(fp, "image_max := %d\n", h->image_max);
  fprintf(fp, "x_pixel_size := %g\n", h->x_pixel_size);
  fprintf(fp, "y_pixel_size := %g\n", h->y_pixel_size);
  fprintf(fp, "z_pixel_size := %g\n", h->z_pixel_size);
  fprintf(fp, "frame_duration := %d\n", h->frame_duration);
  fprintf(fp, "frame_start_time := %d\n", h->frame_start_time);
  fprintf(fp, "filter_code := %d\n", h->filter_code);
  fprintf(fp, "x_resolution := %g\n", h->x_resolution);
  fprintf(fp, "y_resolution := %g\n", h->y_resolution);
  fprintf(fp, "z_resolution := %g\n", h->z_resolution);
  fprintf(fp, "num_r_elements := %g\n", h->num_r_elements);
  fprintf(fp, "num_angles := %g\n", h->num_angles);
  fprintf(fp, "z_rotation_angle := %g\n", h->z_rotation_angle);
  fprintf(fp, "decay_corr_fctr := %g\n", h->decay_corr_fctr);
  fprintf(fp, "processing_code := %d\n", h->processing_code);
  fprintf(fp, "gate_duration := %d\n", h->gate_duration);
  fprintf(fp, "r_wave_offset := %d\n", h->r_wave_offset);
  fprintf(fp, "num_accepted_beats := %d\n", h->num_accepted_beats);
  fprintf(fp, "filter_cutoff_frequency := %E\n", h->filter_cutoff_frequency);
  fprintf(fp, "filter_resolution := %E\n", h->filter_resolution);
  fprintf(fp, "filter_ramp_slope := %E\n", h->filter_ramp_slope);
  fprintf(fp, "filter_order := %d\n", h->filter_order);
  fprintf(fp, "filter_scatter_fraction := %E\n", h->filter_scatter_fraction);
  fprintf(fp, "filter_scatter_slope := %E\n", h->filter_scatter_slope);
  fprintf(fp, "annotation := %.40s\n", h->annotation);
  fprintf(fp, "mt_1_1 := %g\n", h->mt_1_1);
  fprintf(fp, "mt_1_2 := %g\n", h->mt_1_2);
  fprintf(fp, "mt_1_3 := %g\n", h->mt_1_3);
  fprintf(fp, "mt_2_1 := %g\n", h->mt_2_1);
  fprintf(fp, "mt_2_2 := %g\n", h->mt_2_2);
  fprintf(fp, "mt_2_3 := %g\n", h->mt_2_3);
  fprintf(fp, "mt_3_1 := %g\n", h->mt_3_1);
  fprintf(fp, "mt_3_2 := %g\n", h->mt_3_2);
  fprintf(fp, "mt_3_3 := %g\n", h->mt_3_3);
  fprintf(fp, "rfilter_cutoff := %g\n", h->rfilter_cutoff);
  fprintf(fp, "rfilter_resolution := %g\n", h->rfilter_resolution);
  fprintf(fp, "rfilter_code := %d\n", h->rfilter_code);
  fprintf(fp, "rfilter_order := %d\n", h->rfilter_order);
  fprintf(fp, "zfilter_cutoff := %g\n", h->zfilter_cutoff);
  fprintf(fp, "zfilter_resolution := %g\n", h->zfilter_resolution);
  fprintf(fp, "zfilter_code := %d\n", h->zfilter_code);
  fprintf(fp, "zfilter_order := %d\n", h->zfilter_order);
  fprintf(fp, "mt_1_4 := %g\n", h->mt_1_4);
  fprintf(fp, "mt_2_4 := %g\n", h->mt_2_4);
  fprintf(fp, "mt_3_4 := %g\n", h->mt_3_4);
  fprintf(fp, "scatter_type := %d\n", h->scatter_type);
  fprintf(fp, "recon_type := %d\n", h->recon_type);
  fprintf(fp, "recon_views := %d\n", h->recon_views);
  fprintf(fp, "fill_cti :=");
  for(int i=0; i<87; i++) fprintf(fp, " %d", h->fill_cti[i]);
  fprintf(fp, "\n");
  fprintf(fp, "fill_user :=");
  for(int i=0; i<49; i++) fprintf(fp, " %d", h->fill_user[i]);
  fprintf(fp, "\n");
}

Referenced by ecat7PrintSubheader(), and ecat7ReadImageMatrix().

◆ ecat7PrintMainheader()

void ecat7PrintMainheader	(	ECAT7_mainheader *	h,
		FILE *	fp )

extern

Print ECAT 7.x main header contents to specified file pointer

Parameters

h	Ecat7 main header
fp	target file pointer

Definition at line 16 of file ecat7p.c.

  {
  char tmp[64];
  time_t t;
 
  if(ECAT7_TEST) fprintf(stdout, "ecat7PrintMainheader()\n");
  fprintf(fp, "magic_number := %.14s\n", h->magic_number);
  fprintf(fp, "original_file_name := %.32s\n", h->original_file_name);
  fprintf(fp, "sw_version := %d\n", h->sw_version);
  fprintf(fp, "system_type := %d\n", h->system_type);
  fprintf(fp, "file_type := %d (%s)\n", h->file_type, ecat7filetype(h->file_type) );
  fprintf(fp, "serial_number := %.10s\n", h->serial_number);
  t=(time_t)h->scan_start_time;
  if(!ctime_r_int(&t, tmp)) strcpy(tmp, "1900-01-01 00:00:00");
  fprintf(fp, "scan_start_time := %s\n", tmp);
  fprintf(fp, "isotope_name := %.8s\n", h->isotope_name);
  fprintf(fp, "isotope_halflife := %E sec\n", h->isotope_halflife);
  fprintf(fp, "radiopharmaceutical := %.32s\n", h->radiopharmaceutical);
  fprintf(fp, "gantry_tilt := %g\n", h->gantry_tilt);
  fprintf(fp, "gantry_rotation := %g\n", h->gantry_rotation);
  fprintf(fp, "bed_elevation := %g\n", h->bed_elevation);
  fprintf(fp, "intrinsic_tilt := %g\n", h->intrinsic_tilt);
  fprintf(fp, "wobble_speed := %d\n", h->wobble_speed);
  fprintf(fp, "transm_source_type := %d\n", h->transm_source_type);
  fprintf(fp, "distance_scanned := %g\n", h->distance_scanned);
  fprintf(fp, "transaxial_fov := %g\n", h->transaxial_fov);
  fprintf(fp, "angular_compression := %d\n", h->angular_compression);
  fprintf(fp, "coin_samp_mode := %d\n", h->coin_samp_mode);
  fprintf(fp, "axial_samp_mode := %d\n", h->axial_samp_mode);
  fprintf(fp, "ecat_calibration_factor := %E\n", h->ecat_calibration_factor);
  fprintf(fp, "calibration_units := %d\n", h->calibration_units);
  fprintf(fp, "calibration_units_label := %d\n", h->calibration_units_label);
  fprintf(fp, "compression_code := %d\n", h->compression_code);
  fprintf(fp, "study_type := %.12s\n", h->study_type);
  fprintf(fp, "patient_id := %.16s\n", h->patient_id);
  fprintf(fp, "patient_name := %.32s\n", h->patient_name);
  fprintf(fp, "patient_sex := %c\n", (h->patient_sex!=0)?h->patient_sex:(char)32);
  fprintf(fp, "patient_dexterity := %c\n", (h->patient_dexterity!=0)?h->patient_dexterity:(char)32 );
  fprintf(fp, "patient_age := %g\n", h->patient_age);
  fprintf(fp, "patient_height := %g\n", h->patient_height);
  fprintf(fp, "patient_weight := %g\n", h->patient_weight);
  fprintf(fp, "patient_birth_date := %d\n", h->patient_birth_date);
  fprintf(fp, "physician_name := %.32s\n", h->physician_name);
  fprintf(fp, "operator_name := %.32s\n", h->operator_name);
  fprintf(fp, "study_description := %.32s\n", h->study_description);
  fprintf(fp, "acquisition_type := %d (%s)\n", h->acquisition_type,
          ecat7acquisitiontype(h->acquisition_type));
  fprintf(fp, "patient_orientation := %d\n", h->patient_orientation);
  fprintf(fp, "facility_name := %.20s\n", h->facility_name);
  fprintf(fp, "num_planes := %d\n", h->num_planes);
  fprintf(fp, "num_frames := %d\n", h->num_frames);
  fprintf(fp, "num_gates := %d\n", h->num_gates);
  fprintf(fp, "num_bed_pos := %d\n", h->num_bed_pos);
  fprintf(fp, "init_bed_position := %g\n", h->init_bed_position);
  fprintf(fp, "bed_position :=");
  for(int i=0; i<15; i++) fprintf(fp, " %g", h->bed_position[i]);
  fprintf(fp, "\n");
  fprintf(fp, "plane_separation := %g cm\n", h->plane_separation);
  fprintf(fp, "lwr_sctr_thres := %d\n", h->lwr_sctr_thres);
  fprintf(fp, "lwr_true_thres := %d\n", h->lwr_true_thres);
  fprintf(fp, "upr_true_thres := %d\n", h->upr_true_thres);
  fprintf(fp, "user_process_code := %.10s\n", h->user_process_code);
  fprintf(fp, "acquisition_mode := %d\n", h->acquisition_mode);
  fprintf(fp, "bin_size := %g cm\n", h->bin_size);
  fprintf(fp, "branching_fraction := %g\n", h->branching_fraction);
  t=(time_t)h->dose_start_time;
  if(!ctime_r_int(&t, tmp)) strcpy(tmp, "1900-01-01 00:00:00");
  fprintf(fp, "dose_start_time := %s\n", tmp);
  fprintf(fp, "dosage := %g\n", h->dosage);
  fprintf(fp, "well_counter_corr_factor := %E\n", h->well_counter_corr_factor);
  fprintf(fp, "data_units := %.32s\n", h->data_units);
  fprintf(fp, "septa_state := %d\n", h->septa_state);
  fprintf(fp, "fill_cti :=");
  for(int i=0; i<6; i++) fprintf(fp, " %d", h->fill_cti[i]);
  fprintf(fp, "\n");
}

◆ ecat7PrintMatlist()

void ecat7PrintMatlist ( ECAT7_MATRIXLIST * ml )

extern

Print ECAT matrix list on stdout.

Parameters

ml	matrix list for Ecat7 file

Definition at line 112 of file ecat7ml.c.

                                             {
  int i;
  ECAT7_Matval matval;
 
  printf("nr   matrix   pl  fr gate bed startblk blknr  status\n");
  for(i=0; i<ml->matrixNr; i++) {
    ecat7_id_to_val(ml->matdir[i].id, &matval);
    printf("%4d %8d %3d %3d %3d %3d %8d %5d  ", i+1, ml->matdir[i].id,
      matval.plane, matval.frame, matval.gate, matval.bed,
      ml->matdir[i].strtblk, 1+ml->matdir[i].endblk-ml->matdir[i].strtblk);
    if(ml->matdir[i].status==1) printf("read/write\n");
    else if(ml->matdir[i].status==0) printf("not ready\n");
    else if(ml->matdir[i].status==-1) printf("deleted\n");
    else printf("%d\n", ml->matdir[i].status);
  }
  return;
}

Referenced by ecat7PrintSubheader(), ecatFixMatrixlist(), and imgReadEcat7().

◆ ecat7PrintNormheader()

void ecat7PrintNormheader	(	ECAT7_normheader *	h,
		FILE *	fp )

extern

Prints ECAT 7.x normalization header contents to specified file pointer

Parameters

h	Ecat7 normalization header
fp	tager file pointer

Definition at line 327 of file ecat7p.c.

  {
  if(ECAT7_TEST) fprintf(stdout, "ecat7PrintNormheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type,
    ecat7datatype(h->data_type) );
  fprintf(fp, "num_r_elements := %d\n", h->num_r_elements);
  fprintf(fp, "num_transaxial_crystals := %d\n", h->num_transaxial_crystals);
  fprintf(fp, "num_crystal_rings := %d\n", h->num_crystal_rings);
  fprintf(fp, "crystals_per_ring := %d\n", h->crystals_per_ring);
  fprintf(fp, "num_geo_corr_planes := %d\n", h->num_geo_corr_planes);
  fprintf(fp, "uld := %d\n", h->uld);
  fprintf(fp, "lld := %d\n", h->lld);
  fprintf(fp, "scatter_energy := %d\n", h->scatter_energy);
  fprintf(fp, "norm_quality_factor := %g\n", h->norm_quality_factor);
  fprintf(fp, "norm_quality_factor_code := %d\n", h->norm_quality_factor_code);
  fprintf(fp, "ring_dtcor1 :=");
  for(int i=0; i<32; i++) fprintf(fp, " %E", h->ring_dtcor1[i]);
  fprintf(fp, "\n");
  fprintf(fp, "ring_dtcor2 :=");
  for(int i=0; i<32; i++) fprintf(fp, " %E", h->ring_dtcor2[i]);
  fprintf(fp, "\n");
  fprintf(fp, "crystal_dtcor :=");
  for(int i=0; i<8; i++) fprintf(fp, " %E", h->crystal_dtcor[i]);
  fprintf(fp, "\n");
  fprintf(fp, "span := %d\n", h->span);
  fprintf(fp, "max_ring_diff := %d\n", h->max_ring_diff);
}

Referenced by ecat7PrintSubheader().

◆ ecat7PrintPolmapheader()

void ecat7PrintPolmapheader	(	ECAT7_polmapheader *	h,
		FILE *	fp )

extern

Print ECAT 7.x polar map header contents to specified file pointer

Parameters

h	Ecat7 polar map header
fp	target file pointer

Definition at line 276 of file ecat7p.c.

  {
  int i;
 
  if(ECAT7_TEST) fprintf(stdout, "ecat7PrintPolmapheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type,
    ecat7datatype(h->data_type) );
  fprintf(fp, "polar_map_type := %d\n", h->polar_map_type);
  fprintf(fp, "num_rings := %d\n", h->num_rings);
  fprintf(fp, "sectors_per_ring :=");
  for(i=0; i<32; i++) fprintf(fp, " %d", h->sectors_per_ring[i]);
  fprintf(fp, "\n");
  fprintf(fp, "ring_position :=");
  for(i=0; i<32; i++) fprintf(fp, " %g", h->ring_position[i]);
  fprintf(fp, "\n");
  fprintf(fp, "ring_angle :=");
  for(i=0; i<32; i++) fprintf(fp, " %d", h->ring_angle[i]);
  fprintf(fp, "\n");
  fprintf(fp, "start_angle := %d\n", h->start_angle);
  fprintf(fp, "long_axis_left :=");
  for(i=0; i<3; i++) fprintf(fp, " %d", h->long_axis_left[i]);
  fprintf(fp, "\n");
  fprintf(fp, "long_axis_right :=");
  for(i=0; i<3; i++) fprintf(fp, " %d", h->long_axis_right[i]);
  fprintf(fp, "\n");
  fprintf(fp, "position_data := %d\n", h->position_data);
  fprintf(fp, "image_min := %d\n", h->image_min);
  fprintf(fp, "image_max := %d\n", h->image_max);
  fprintf(fp, "scale_factor := %E\n", h->scale_factor);
  fprintf(fp, "pixel_size := %g\n", h->pixel_size);
  fprintf(fp, "frame_duration := %d\n", h->frame_duration);
  fprintf(fp, "frame_start_time := %d\n", h->frame_start_time);
  fprintf(fp, "processing_code := %d\n", h->processing_code);
  fprintf(fp, "quant_units := %d\n", h->quant_units);
  fprintf(fp, "annotation := %.40s\n", h->annotation);
  fprintf(fp, "gate_duration := %d\n", h->gate_duration);
  fprintf(fp, "r_wave_offset := %d\n", h->r_wave_offset);
  fprintf(fp, "num_accepted_beats := %d\n", h->num_accepted_beats);
  fprintf(fp, "polar_map_protocol := %.20s\n", h->polar_map_protocol);
  fprintf(fp, "database_name := %.30s\n", h->database_name);
}

Referenced by ecat7PrintSubheader(), and ecat7ReadPolarmapMatrix().

◆ ecat7PrintScanheader()

void ecat7PrintScanheader	(	ECAT7_scanheader *	h,
		FILE *	fp )

extern

Print ECAT 7.x 3D sinogram header contents to specified file pointer

Parameters

h	Ecat7 scan header
fp	target file pointer

Definition at line 181 of file ecat7p.c.

  {
  if(ECAT7_TEST) fprintf(stdout, "ecat7PrintScanheader()\n");
  fprintf(fp, "data_type := %d (%s)\n", h->data_type,
    ecat7datatype(h->data_type) );
  fprintf(fp, "num_dimensions := %d\n", h->num_dimensions);
  fprintf(fp, "num_r_elements := %d\n", h->num_r_elements);
  fprintf(fp, "num_angles := %d\n", h->num_angles);
  fprintf(fp, "corrections_applied := %d\n", h->corrections_applied);
  fprintf(fp, "num_z_elements :=");
  for(int i=0; i<64; i++) fprintf(fp, " %d", h->num_z_elements[i]);
  fprintf(fp, "\n");
  fprintf(fp, "ring_difference := %d\n", h->ring_difference);
  fprintf(fp, "storage_order := %d\n", h->storage_order);
  fprintf(fp, "axial_compression := %d (span)\n", h->axial_compression);
  fprintf(fp, "x_resolution := %g cm\n", h->x_resolution);
  fprintf(fp, "v_resolution := %g rad\n", h->v_resolution);
  fprintf(fp, "z_resolution := %g cm\n", h->z_resolution);
  fprintf(fp, "w_resolution := %g\n", h->w_resolution);
  fprintf(fp, "gate_duration := %d\n", h->gate_duration);
  fprintf(fp, "r_wave_offset := %d\n", h->r_wave_offset);
  fprintf(fp, "num_accepted_beats := %d\n", h->num_accepted_beats);
  fprintf(fp, "scale_factor := %E\n", h->scale_factor);
  fprintf(fp, "scan_min := %d\n", h->scan_min);
  fprintf(fp, "scan_max := %d\n", h->scan_max);
  fprintf(fp, "prompts := %d\n", h->prompts);
  fprintf(fp, "delayed := %d\n", h->delayed);
  fprintf(fp, "multiples := %d\n", h->multiples);
  fprintf(fp, "net_trues := %d\n", h->net_trues);
  fprintf(fp, "tot_avg_cor := %g\n", h->tot_avg_cor);
  fprintf(fp, "tot_avg_uncor := %g\n", h->tot_avg_uncor);
  fprintf(fp, "total_coin_rate := %d\n", h->total_coin_rate);
  fprintf(fp, "frame_start_time := %d\n", h->frame_start_time);
  fprintf(fp, "frame_duration := %d\n", h->frame_duration);
  fprintf(fp, "deadtime_correction_factor := %g\n", h->deadtime_correction_factor);
  fprintf(fp, "uncor_singles :=");
  for(int i=0; i<128; i++) fprintf(fp, " %g", h->uncor_singles[i]);
  fprintf(fp, "\n");
}

Referenced by ecat7PrintSubheader(), and ecat7ReadScanMatrix().

◆ ecat7PrintSubheader()

int ecat7PrintSubheader	(	ECAT7_mainheader	mh,
		FILE *	fp,
		int	plane,
		int	frame,
		FILE *	ofp )

extern

Print ECAT7 subheader contents into specified file pointer.

Returns: Returns 0 when successful.

Parameters

mh	ECAT7 mainheader (not printed but needed here)
fp	File pointer to ECAT7 file
plane	ECAT7 plane
frame	ECAT7 frame
ofp	Output is written to this file pointer; it can be stdout

Definition at line 506 of file ecat7p.c.

  {
  int                     mi, ret, nr=0;
  ECAT7_imageheader       image_header;
  ECAT7_scanheader        scan_header;
  ECAT7_2Dscanheader      scan2D_header;
  ECAT7_2Dnormheader      norm2D_header;
  ECAT7_normheader        norm_header;
  ECAT7_attenheader       atten_header;
  ECAT7_polmapheader      polmap_header;
  static ECAT7_MATRIXLIST mlist;
  ECAT7_Matval            matval;
 
 
  /*
   *  Read matrix list
   */
  ecat7InitMatlist(&mlist);
  ret=ecat7ReadMatlist(fp, &mlist, ECAT7_TEST);
  if(ret) {
    fprintf(stderr, "Error (%d): cannot read matrix list.\n", ret);
    return(2);
  }
  if(mlist.matrixNr<=0) {
    fprintf(stderr, "Error: matrix list is empty.\n");
    return(2);
  }
  if(ECAT7_TEST>1) ecat7PrintMatlist(&mlist);
 
  /*
   *  Read and print subheaders one at a time
   */
  for(mi=nr=0; mi<mlist.matrixNr; mi++) {
    /* Get frame nr */
    ecat7_id_to_val(mlist.matdir[mi].id, &matval);
    /* Check if this is supposed to be listed or not */
    if(frame>=0 && frame!=matval.frame) continue;
    if(plane>=0 && plane!=matval.plane) continue;
    fprintf(fp, "Matrix: plane %d frame %d gate %d bed %d\n",
      matval.plane, matval.frame, matval.gate, matval.bed);
    /* Read and print subheader */
    ret=0;
    switch(mh.file_type) {
      case ECAT7_ATTEN:
        ret=ecat7ReadAttenheader(fp, mlist.matdir[mi].strtblk, &atten_header);
        if(ret==0) ecat7PrintAttenheader(&atten_header, ofp);
        break;
      case ECAT7_3DNORM:
        ret=ecat7ReadNormheader(fp, mlist.matdir[mi].strtblk, &norm_header);
        if(ret==0) ecat7PrintNormheader(&norm_header, ofp);
        break;
      case ECAT7_IMAGE8:
      case ECAT7_IMAGE16:
      case ECAT7_VOLUME8:
      case ECAT7_VOLUME16:
        ret=ecat7ReadImageheader(fp, mlist.matdir[mi].strtblk, &image_header);
        if(ret==0) ecat7PrintImageheader(&image_header, ofp);
        break;
      case ECAT7_3DSCAN:
      case ECAT7_3DSCAN8:
      case ECAT7_3DSCANFIT:
        ret=ecat7ReadScanheader(fp, mlist.matdir[mi].strtblk, &scan_header);
        if(ret==0) ecat7PrintScanheader(&scan_header, ofp);
        break;
      case ECAT7_POLARMAP:
        ret=ecat7ReadPolmapheader(fp, mlist.matdir[mi].strtblk, &polmap_header);
        if(ret==0) ecat7PrintPolmapheader(&polmap_header, ofp);
        break;
      case ECAT7_2DSCAN:
        ret=ecat7Read2DScanheader(fp, mlist.matdir[mi].strtblk, &scan2D_header);
        if(ret==0) ecat7Print2DScanheader(&scan2D_header, ofp);
        break;
      case ECAT7_2DNORM:
        ret=ecat7Read2DNormheader(fp, mlist.matdir[mi].strtblk, &norm2D_header);
        if(ret==0) ecat7Print2DNormheader(&norm2D_header, ofp);
        break;
      default:
        fprintf(stderr, "Error: matrix filetype %d is not yet supported.\n",
          mh.file_type);
        ecat7EmptyMatlist(&mlist);
        return(8);
    }
    if(ret) {
      fprintf(stderr, "Error %d in reading subheader.\n", ret);
      ecat7EmptyMatlist(&mlist); return(5);
    }
    nr++; // counter
  } /* next matrix */
  ecat7EmptyMatlist(&mlist);
  
  if(nr==0 && (plane>=0 || frame>=0)) {
    fprintf(stderr, "Error: specified matrices not found.\n");
    return(11);
  }
 
  return(0);
}

◆ ecat7pxlbytes()

int ecat7pxlbytes ( short int data_type )

extern

Returns the nr of bytes required for storage of one pixel of specified data_type

Parameters

data_type defined value for data type

Returns: number of bytes (1,2 or 4) or 0 if type not recognized

Definition at line 1274 of file ecat7r.c.

                                       {
  int byteNr=0;
  switch(data_type) {
    case ECAT7_BYTE: byteNr=1; break;
    case ECAT7_VAXI2:
    case ECAT7_SUNI2: byteNr=2; break;
    case ECAT7_VAXI4:
    case ECAT7_VAXR4:
    case ECAT7_IEEER4:
    case ECAT7_SUNI4: byteNr=4; break;
  }
  return(byteNr);
}

Referenced by ecat7ReadScanMatrix(), ecat7Write2DScanMatrix(), ecat7WriteImageMatrix(), ecat7WritePolarmapMatrix(), and ecat7WriteScanMatrix().

◆ ecat7Read2DNormheader()

int ecat7Read2DNormheader	(	FILE *	fp,
		int	blk,
		ECAT7_2Dnormheader *	h )

extern

Read ECAT 7.x 2D normalization header

Parameters

fp	input file pointer
blk	block number [1..number of blocks]
h	Ecat7 normalization header

Returns: 0 if ok, 1 == invalid parameters, 2 == first header block not found, 3 == header block not read properly

Definition at line 725 of file ecat7r.c.

                                                                    {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7Read2Dnormheader()\n");
  if(fp==NULL || h==NULL) return(1);
  little=little_endian();
 
  /* Seek the subheader block */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(2);
  /* Read the header block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) return(3);
  /* Copy the header fields and swap if necessary */
  if(little) swabip(buf+0, 2);
  memcpy(&h->data_type, buf+0, 2);
  if(little) swabip(buf+2, 2);
  memcpy(&h->num_dimensions, buf+2, 2);
  if(little) swabip(buf+4, 2);
  memcpy(&h->num_r_elements, buf+4, 2);
  if(little) swabip(buf+6, 2);
  memcpy(&h->num_angles, buf+6, 2);
  if(little) swabip(buf+8, 2);
  memcpy(&h->num_z_elements, buf+8, 2);
  if(little) swabip(buf+10, 2);
  memcpy(&h->ring_difference, buf+10, 2);
  if(little) swawbip(buf+12, 4);
  memcpy(&h->scale_factor, buf+12, 4);
  if(little) swawbip(buf+16, 4);
  memcpy(&h->norm_min, buf+16, 4);
  if(little) swawbip(buf+20, 4);
  memcpy(&h->norm_max, buf+20, 4);
  if(little) swawbip(buf+24, 4);
  memcpy(&h->fov_source_width, buf+24, 4);
  if(little) swawbip(buf+28, 4);
  memcpy(&h->norm_quality_factor, buf+28, 4);
  if(little) swabip(buf+32, 2);
  memcpy(&h->norm_quality_factor_code, buf+32, 2);
  if(little) swabip(buf+34, 2);
  memcpy(&h->storage_order, buf+34, 2);
  if(little) swabip(buf+36, 2);
  memcpy(&h->span, buf+36, 2);
  if(little) swabip(buf+38, 64*2);
  memcpy(h->fill_cti, buf+38, 64*2);
  if(little) swabip(buf+166, 123*2);
  memcpy(h->fill_cti, buf+166, 123*2);
  if(little) swabip(buf+412, 50*2);
  memcpy(h->fill_user, buf+412, 50*2);
  return(0);
}

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), and ecat7WriteSubheaderFromIFT().

◆ ecat7Read2DScanheader()

int ecat7Read2DScanheader	(	FILE *	fp,
		int	blk,
		ECAT7_2Dscanheader *	h )

extern

Read ECAT 7.x 2D scan header

Parameters

fp	input file pointer
blk	block number [1..number of blocks]
h	Ecat7 2D scan header

Returns: 0 if ok, 1 == invalid parameters, 2 == first header block not found, 3 == header block not read properly

Definition at line 631 of file ecat7r.c.

                                                                    {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7Read2DScanheader()\n");
  if(fp==NULL || h==NULL) return(1);
  little=little_endian();
 
  /* Seek the subheader block */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(2);
  /* Read the header block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) return(3);
  /* Copy the header fields and swap if necessary */
  if(little) swabip(buf+0, 2);
  memcpy(&h->data_type, buf+0, 2);
  if(little) swabip(buf+2, 2);
  memcpy(&h->num_dimensions, buf+2, 2);
  if(little) swabip(buf+4, 2);
  memcpy(&h->num_r_elements, buf+4, 2);
  if(little) swabip(buf+6, 2);
  memcpy(&h->num_angles, buf+6, 2);
  if(little) swabip(buf+8, 2);
  memcpy(&h->corrections_applied, buf+8, 2);
  if(little) swabip(buf+10, 2);
  memcpy(&h->num_z_elements, buf+10, 2);
  if(little) swabip(buf+12, 2);
  memcpy(&h->ring_difference, buf+12, 2);
  if(little) swawbip(buf+14, 4);
  memcpy(&h->x_resolution, buf+14, 4);
  if(little) swawbip(buf+18, 4);
  memcpy(&h->y_resolution, buf+18, 4);
  if(little) swawbip(buf+22, 4);
  memcpy(&h->z_resolution, buf+22, 4);
  if(little) swawbip(buf+26, 4);
  memcpy(&h->w_resolution, buf+26, 4);
  if(little) swabip(buf+30, 6*2);
  memcpy(h->fill_gate, buf+30, 6*2);
  if(little) swawbip(buf+42, 4);
  memcpy(&h->gate_duration, buf+42, 4);
  if(little) swawbip(buf+46, 4);
  memcpy(&h->r_wave_offset, buf+46, 4);
  if(little) swawbip(buf+50, 4);
  memcpy(&h->num_accepted_beats, buf+50, 4);
  if(little) swawbip(buf+54, 4);
  memcpy(&h->scale_factor, buf+54, 4);
  if(little) swabip(buf+58, 2);
  memcpy(&h->scan_min, buf+58, 2);
  if(little) swabip(buf+60, 2);
  memcpy(&h->scan_max, buf+60, 2);
  if(little) swawbip(buf+62, 4);
  memcpy(&h->prompts, buf+62, 4);
  if(little) swawbip(buf+66, 4);
  memcpy(&h->delayed, buf+66, 4);
  if(little) swawbip(buf+70, 4);
  memcpy(&h->multiples, buf+70, 4);
  if(little) swawbip(buf+74, 4);
  memcpy(&h->net_trues, buf+74, 4);
  if(little) swawbip(buf+78, 16*4);
  memcpy(h->cor_singles, buf+78, 16*4);
  if(little) swawbip(buf+142, 16*4);
  memcpy(h->uncor_singles, buf+142, 16*4);
  if(little) swawbip(buf+206, 4);
  memcpy(&h->tot_avg_cor, buf+206, 4);
  if(little) swawbip(buf+210, 4);
  memcpy(&h->tot_avg_uncor, buf+210, 4);
  if(little) swawbip(buf+214, 4);
  memcpy(&h->total_coin_rate, buf+214, 4);
  if(little) swawbip(buf+218, 4);
  memcpy(&h->frame_start_time, buf+218, 4);
  if(little) swawbip(buf+222, 4);
  memcpy(&h->frame_duration, buf+222, 4);
  if(little) swawbip(buf+226, 4);
  memcpy(&h->deadtime_correction_factor, buf+226,4);
  if(little) swabip(buf+230, 8*2);
  memcpy(h->physical_planes, buf+230, 8*2);
  if(little) swabip(buf+246, 83*2);
  memcpy(h->fill_cti, buf+246, 83*2);
  if(little) swabip(buf+412, 50*2);
  memcpy(h->fill_user, buf+412, 50*2);
  return(0);
}

Referenced by ecat7PrintSubheader(), ecat7Read2DScanMatrix(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), imgReadEcat7(), and imgReadEcat7Header().

◆ ecat7Read2DScanMatrix()

int ecat7Read2DScanMatrix	(	FILE *	fp,
		int	first_block,
		int	last_block,
		ECAT7_2Dscanheader *	h,
		float **	fdata )

extern

Read ECAT7 2D sinogram matrix header and data Memory for fdata[] is allocated here, remember to free memory after usage. Note: data is not calibrated with factor in main header. Note: data is not multiplied with deadtime_correction_factor.

Parameters

fp	ECAT file pointer
first_block	Subheader record number
last_block	Last data block number
h	Ptr to subheader data which is filled
fdata	Ptr to the address of the matrix data

Returns: 0 if ok, 1 invalid input, 5 failed to read scan header, 6 invalid image (x,y,z) dimensions, 8 failed to allocate memory for meta-data, 9 failed to read matrix data, 11 failed to allocate memory for voxel data

Definition at line 959 of file ecat7r.c.

                                              {
  int ret;
  long long i, blockNr, pxlNr;
  char *mdata, *mptr;
  float *_fdata, *fptr;
  short int *sptr;
  int *iptr;
 
 
  if(ECAT7_TEST) printf("ecat7Read2DScanMatrix(fp, %d, %d, hdr, fdata)\n",
    first_block, last_block);
  if(fp==NULL || first_block<=MatFirstDirBlk || h==NULL) {
    sprintf(ecat7errmsg, "invalid function parameter.\n");
    return(1);
  }
  *fdata=(float*)NULL;
  
  /* Read subheader */
  ret=ecat7Read2DScanheader(fp, first_block, h);
  if(ret) {
    sprintf(ecat7errmsg, "cannot read subheader (%d).\n", ret);
    return(5);
  }
  if(ECAT7_TEST>4) ecat7Print2DScanheader(h, stdout);
  pxlNr=h->num_r_elements*h->num_angles;
  if(h->num_dimensions>2) pxlNr*=h->num_z_elements;
  if(pxlNr<=0) {
    sprintf(ecat7errmsg, "invalid matrix dimension.\n");
    return(6);  
  }
  
  /* Read matrix data */
  blockNr=last_block-first_block; if(blockNr<1) return(0);
  mdata=(char*)malloc((size_t)blockNr*MatBLKSIZE);
  if(mdata==NULL) {
    sprintf(ecat7errmsg, "cannot allocate memory.\n");
    return(8);  
  }
  mptr=mdata;
  ret=ecat7ReadMatrixdata(fp, first_block+1, blockNr, mptr, h->data_type);
  if(ret || mdata==NULL) {
    sprintf(ecat7errmsg, "cannot read matrix data (%d).\n", ret);
    free(mdata); return(9);
  }
  
  /* Allocate memory for float data */
  _fdata=(float*)malloc(pxlNr*sizeof(float));
  if(_fdata==NULL) {
    sprintf(ecat7errmsg, "cannot allocate memory.\n");
    free(mdata); return(11);  
  }
 
  /* Convert matrix data to floats */
  fptr=_fdata; mptr=mdata;
  if(h->data_type==ECAT7_BYTE) {
    for(i=0; i<pxlNr; i++, mptr++, fptr++)
      *fptr=h->scale_factor*(float)(*mptr);
  } else if(h->data_type==ECAT7_VAXI2 || h->data_type==ECAT7_SUNI2) {
    for(i=0; i<pxlNr; i++, mptr+=2, fptr++) {
      sptr=(short int*)mptr;
      *fptr=h->scale_factor*(float)(*sptr);
    }
  } else if(h->data_type==ECAT7_VAXI4 || h->data_type==ECAT7_SUNI4) {
    for(i=0; i<pxlNr; i++, mptr+=4, fptr++) {
      iptr=(int*)mptr;
      *fptr=h->scale_factor*(float)(*iptr);
    }
  } else if(h->data_type==ECAT7_VAXR4 || h->data_type==ECAT7_IEEER4) {
    memcpy(fptr, mptr, pxlNr*4);
    for(i=0; i<pxlNr; i++, fptr++) *fptr *= h->scale_factor;
  }
  free(mdata);
  *fdata=_fdata;
 
  return(0);
}

Referenced by imgReadEcat7(), and imgReadEcat7Frame().

◆ ecat7ReadAttenheader()

int ecat7ReadAttenheader	(	FILE *	fp,
		int	blk,
		ECAT7_attenheader *	h )

extern

Read ECAT 7.x attenuation header

Parameters

fp	input file pointer
blk	block number [1..number of blocks]
h	Ecat7 attenuation header

Returns: 0 if ok, 1 == invalid parameters, 2 == first header block not found, 3 == header block not read properly

Definition at line 311 of file ecat7r.c.

                                                                  {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7ReadAttenheader()\n");
  if(fp==NULL || h==NULL) return(1);
  little=little_endian();
 
  /* Seek the subheader block */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(2);
  /* Read the header block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) return(3);
  /* Copy the header fields and swap if necessary */
  if(little) swabip(buf+0, 2);
  memcpy(&h->data_type, buf+0, 2);
  if(little) swabip(buf+2, 2);
  memcpy(&h->num_dimensions, buf+2, 2);
  if(little) swabip(buf+4, 2);
  memcpy(&h->attenuation_type, buf+4, 2);
  if(little) swabip(buf+6, 2);
  memcpy(&h->num_r_elements, buf+6, 2);
  if(little) swabip(buf+8, 2);
  memcpy(&h->num_angles, buf+8, 2);
  if(little) swabip(buf+10, 2);
  memcpy(&h->num_z_elements, buf+10, 2);
  if(little) swabip(buf+12, 2);
  memcpy(&h->ring_difference, buf+12, 2);
  if(little) swawbip(buf+14, 4);
  memcpy(&h->x_resolution, buf+14, 4);
  if(little) swawbip(buf+18, 4);
  memcpy(&h->y_resolution, buf+18, 4);
  if(little) swawbip(buf+22, 4);
  memcpy(&h->z_resolution, buf+22, 4);
  if(little) swawbip(buf+26, 4);
  memcpy(&h->w_resolution, buf+26, 4);
  if(little) swawbip(buf+30, 4);
  memcpy(&h->scale_factor, buf+30, 4);
  if(little) swawbip(buf+34, 4);
  memcpy(&h->x_offset, buf+34, 4);
  if(little) swawbip(buf+38, 4);
  memcpy(&h->y_offset, buf+38, 4);
  if(little) swawbip(buf+42, 4);
  memcpy(&h->x_radius, buf+42, 4);
  if(little) swawbip(buf+46, 4);
  memcpy(&h->y_radius, buf+46, 4);
  if(little) swawbip(buf+50, 4);
  memcpy(&h->tilt_angle, buf+50, 4);
  if(little) swawbip(buf+54, 4);
  memcpy(&h->attenuation_coeff, buf+54, 4);
  if(little) swawbip(buf+58, 4);
  memcpy(&h->attenuation_min, buf+58, 4);
  if(little) swawbip(buf+62, 4);
  memcpy(&h->attenuation_max, buf+62, 4);
  if(little) swawbip(buf+66, 4);
  memcpy(&h->skull_thickness, buf+66, 4);
  if(little) swabip(buf+70, 2);
  memcpy(&h->num_additional_atten_coeff, buf+70, 2);
  if(little) swawbip(buf+72, 8*4);
  memcpy(h->additional_atten_coeff, buf+72, 8*4);
  if(little) swawbip(buf+104, 4);
  memcpy(&h->edge_finding_threshold, buf+104, 4);
  if(little) swabip(buf+108, 2);
  memcpy(&h->storage_order, buf+108, 2);
  if(little) swabip(buf+110, 2);
  memcpy(&h->span, buf+110, 2);
  if(little) swabip(buf+112, 64*2);
  memcpy(h->z_elements, buf+112, 64*2);
  if(little) swabip(buf+240, 86*2);
  memcpy(h->fill_cti, buf+240, 86*2);
  if(little) swabip(buf+412, 50*2);
  memcpy(h->fill_user, buf+412, 50*2);
  return(0);
}

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), and ecat7WriteSubheaderFromIFT().

◆ ecat7ReadHeaders()

int ecat7ReadHeaders	(	const char *	fname,
		ECAT_HEADERS *	ehdr,
		int	verbose )

extern

Read ECAT7 header contents (both main header and subheaders).

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fname	Image or sinogram file name
ehdr	Pointer to empty headers structure
verbose	Verbose level

Definition at line 687 of file ecat7ift.c.

  {
  ECAT7_mainheader main_header;
  ECAT7_MATRIXLIST mlist;
  FILE *fp;
  int ret, mi;
 
 
  if(verbose>0) printf("ecat7ReadHeaders(%s, ehdr)\n", fname);
  /* Check the arguments */
  if(ehdr==NULL) return STATUS_FAULT;
  if(fname==NULL) return STATUS_FAULT;
 
  /* Open the file */
  if(verbose>1) printf("open %s\n", fname);
  if((fp=fopen(fname, "rb")) == NULL) return STATUS_NOFILE;
 
  /* Read main header */
  ret=ecat7ReadMainheader(fp, &main_header);
  if(ret) {fclose(fp); return STATUS_NOMAINHEADER;}
  /* Check for magic number */
  if(verbose>1) printf("check magic number in %s\n", fname);
  if(strncmp(main_header.magic_number, ECAT7V_MAGICNR, 7)!=0) {fclose(fp); return STATUS_UNKNOWNFORMAT;}
  /* Copy main header information into IFT */
  ret=ecat7MHeaderToIFT(&main_header, &ehdr->mh, verbose);
  if(ret!=STATUS_OK) {fclose(fp); return ret;}
  if(verbose>5) iftWrite(&ehdr->mh, "stdout", 0);
 
  /* Read matrix list */
  ecat7InitMatlist(&mlist);
  ret=ecat7ReadMatlist(fp, &mlist, verbose-1);
  if(ret || mlist.matrixNr<1 || ecat7CheckMatlist(&mlist)) {fclose(fp); return STATUS_INVALIDMATLIST;}
  /* Allocate space for each matrix */
  ret=ehdrAllocate(ehdr, mlist.matrixNr);
  if(ret!=STATUS_OK) {fclose(fp); ecat7EmptyMatlist(&mlist); return ret;}
  /* Read one subheader at a time */ 
  for(mi=0; mi<mlist.matrixNr; mi++) {
    ehdr->m[mi].mnum=mlist.matdir[mi].id;
    ecat7_id_to_val(mlist.matdir[mi].id, &ehdr->m[mi].matval);
    if(verbose>2) {
        printf("frame := %d\n", ehdr->m[mi].matval.frame);
        printf("plane := %d\n", ehdr->m[mi].matval.plane);
        printf("gate := %d\n", ehdr->m[mi].matval.gate);
        printf("data := %d\n", ehdr->m[mi].matval.data);
        printf("bed := %d\n", ehdr->m[mi].matval.bed);
    }
    ret=ecat7ReadSubheaderToIFT(fp, &main_header, mlist.matdir[mi].strtblk, 
                                &ehdr->m[mi].sh, verbose);
    if(ret!=STATUS_OK) {fclose(fp); ecat7EmptyMatlist(&mlist); return ret;}
    //iftWrite(&ehdr->m[mi].sh, "stdout");
  } // next matrix
  fclose(fp); ecat7EmptyMatlist(&mlist);
  
  return STATUS_OK;
}

Referenced by ecat7CopyHeadersNoQuant().

◆ ecat7ReadImageheader()

int ecat7ReadImageheader	(	FILE *	fp,
		int	blk,
		ECAT7_imageheader *	h )

extern

Read ECAT 7.x image header

Parameters

fp	input file pointer
blk	block number [1..number of blocks]
h	Ecat7 image header

Returns: 0 if ok, 1 == invalid parameters, 2 == first header block not found, 3 == header block not read properly

Definition at line 162 of file ecat7r.c.

                                                                  {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7ReadImageheader()\n");
  if(fp==NULL || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
 
  /* Seek the subheader block */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(2);
  /* Read the header block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) return(3);
 
  /* Copy the header fields and swap if necessary */
  if(little) swabip(buf+0, 2);
  memcpy(&h->data_type, buf+0, 2);
  if(little) swabip(buf+2, 2);
  memcpy(&h->num_dimensions, buf+2, 2);
  if(little) swabip(buf+4, 2);
  memcpy(&h->x_dimension, buf+4, 2);
  if(little) swabip(buf+6, 2);
  memcpy(&h->y_dimension, buf+6, 2);
  if(little) swabip(buf+8, 2);
  memcpy(&h->z_dimension, buf+8, 2);
  if(little) swawbip(buf+10, 4);
  memcpy(&h->x_offset, buf+10, 4);
  if(little) swawbip(buf+14, 4);
  memcpy(&h->y_offset, buf+14, 4);
  if(little) swawbip(buf+18, 4);
  memcpy(&h->z_offset, buf+18, 4);
  if(little) swawbip(buf+22, 4);
  memcpy(&h->recon_zoom, buf+22, 4);
  if(little) swawbip(buf+26, 4);
  memcpy(&h->scale_factor, buf+26, 4);
  if(little) swabip(buf+30, 2);
  memcpy(&h->image_min, buf+30, 2);
  if(little) swabip(buf+32, 2);
  memcpy(&h->image_max, buf+32, 2);
  if(little) swawbip(buf+34, 4);
  memcpy(&h->x_pixel_size, buf+34, 4);
  if(little) swawbip(buf+38, 4);
  memcpy(&h->y_pixel_size, buf+38, 4);
  if(little) swawbip(buf+42, 4);
  memcpy(&h->z_pixel_size, buf+42, 4);
  if(little) swawbip(buf+46, 4);
  memcpy(&h->frame_duration, buf+46, 4);
  if(little) swawbip(buf+50, 4);
  memcpy(&h->frame_start_time, buf+50, 4);
  if(little) swabip(buf+54, 2);
  memcpy(&h->filter_code, buf+54, 2);
  if(little) swawbip(buf+56, 4);
  memcpy(&h->x_resolution, buf+56, 4);
  if(little) swawbip(buf+60, 4);
  memcpy(&h->y_resolution, buf+60, 4);
  if(little) swawbip(buf+64, 4);
  memcpy(&h->z_resolution, buf+64, 4);
  if(little) swawbip(buf+68, 4);
  memcpy(&h->num_r_elements, buf+68, 4);
  if(little) swawbip(buf+72, 4);
  memcpy(&h->num_angles, buf+72, 4);
  if(little) swawbip(buf+76, 4);
  memcpy(&h->z_rotation_angle, buf+76, 4);
  if(little) swawbip(buf+80, 4);
  memcpy(&h->decay_corr_fctr, buf+80, 4);
  if(little) swawbip(buf+84, 4);
  memcpy(&h->processing_code, buf+84, 4);
  if(little) swawbip(buf+88, 4);
  memcpy(&h->gate_duration, buf+88, 4);
  if(little) swawbip(buf+92, 4);
  memcpy(&h->r_wave_offset, buf+92, 4);
  if(little) swawbip(buf+96, 4);
  memcpy(&h->num_accepted_beats, buf+96, 4);
  if(little) swawbip(buf+100, 4);
  memcpy(&h->filter_cutoff_frequency, buf+100, 4);
  if(little) swawbip(buf+104, 4);
  memcpy(&h->filter_resolution, buf+104, 4);
  if(little) swawbip(buf+108, 4);
  memcpy(&h->filter_ramp_slope, buf+108, 4);
  if(little) swabip(buf+112, 2);
  memcpy(&h->filter_order, buf+112, 2);
  if(little) swawbip(buf+114, 4);
  memcpy(&h->filter_scatter_fraction, buf+114, 4);
  if(little) swawbip(buf+118, 4);
  memcpy(&h->filter_scatter_slope, buf+118, 4);
  memcpy(&h->annotation, buf+122, 40);
  if(little) swawbip(buf+162, 4);
  memcpy(&h->mt_1_1, buf+162, 4);
  if(little) swawbip(buf+166, 4);
  memcpy(&h->mt_1_2, buf+166, 4);
  if(little) swawbip(buf+170, 4);
  memcpy(&h->mt_1_3, buf+170, 4);
  if(little) swawbip(buf+174, 4);
  memcpy(&h->mt_2_1, buf+174, 4);
  if(little) swawbip(buf+178, 4);
  memcpy(&h->mt_2_2, buf+178, 4);
  if(little) swawbip(buf+182, 4);
  memcpy(&h->mt_2_3, buf+182, 4);
  if(little) swawbip(buf+186, 4);
  memcpy(&h->mt_3_1, buf+186, 4);
  if(little) swawbip(buf+190, 4);
  memcpy(&h->mt_3_2, buf+190, 4);
  if(little) swawbip(buf+194, 4);
  memcpy(&h->mt_3_3, buf+194, 4);
  if(little) swawbip(buf+198, 4);
  memcpy(&h->rfilter_cutoff, buf+198, 4);
  if(little) swawbip(buf+202, 4);
  memcpy(&h->rfilter_resolution, buf+202, 4);
  if(little) swabip(buf+206, 2);
  memcpy(&h->rfilter_code, buf+206, 2);
  if(little) swabip(buf+208, 2);
  memcpy(&h->rfilter_order, buf+208, 2);
  if(little) swawbip(buf+210, 4);
  memcpy(&h->zfilter_cutoff, buf+210, 4);
  if(little) swawbip(buf+214, 4);
  memcpy(&h->zfilter_resolution, buf+214, 4);
  if(little) swabip(buf+218, 2);
  memcpy(&h->zfilter_code, buf+218, 2);
  if(little) swabip(buf+220, 2);
  memcpy(&h->zfilter_order, buf+220, 2);
  if(little) swawbip(buf+222, 4);
  memcpy(&h->mt_1_4, buf+222, 4);
  if(little) swawbip(buf+226, 4);
  memcpy(&h->mt_2_4, buf+226, 4);
  if(little) swawbip(buf+230, 4);
  memcpy(&h->mt_3_4, buf+230, 4);
  if(little) swabip(buf+234, 2);
  memcpy(&h->scatter_type, buf+234, 2);
  if(little) swabip(buf+236, 2);
  memcpy(&h->recon_type, buf+236, 2);
  if(little) swabip(buf+238, 2);
  memcpy(&h->recon_views, buf+238, 2);
  memcpy(&h->fill_cti, buf+240, 174);
  memcpy(&h->fill_user, buf+414, 96);
 
  return(0);
}

Referenced by ecat7GetNums(), ecat7PrintSubheader(), ecat7ReadImageMatrix(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), imgReadEcat7(), and imgReadEcat7Header().

◆ ecat7ReadImageMatrix()

int ecat7ReadImageMatrix	(	FILE *	fp,
		int	first_block,
		int	last_block,
		ECAT7_imageheader *	h,
		float **	fdata )

extern

Read ECAT7 image matrix header and data. If only header is to be read, set last_block=first_block. Note: data is not calibrated with factor in main header.

Parameters

fp	ECAT file pointer
first_block	Subheader record number
last_block	Last data block number
h	Ptr to subheader data which is filled
fdata	Ptr to the address of the matrix data

Returns: 0 if ok, 1 invalid input, 5 failed to read subheader, 6 invalid image (x,y,z) dimensions, 8 failed to allocate memory for meta-data, 9 failed to read matrix data, 11 failed to allocate memory for voxel data

Definition at line 858 of file ecat7r.c.

  {
  int ret;
  long long i, blockNr, pxlNr;
  char *mdata, *mptr;
  float *_fdata, *fptr;
  short int *sptr;
  int *iptr;
  
  
  if(ECAT7_TEST) printf("ecat7ReadImageMatrix(fp, %d, %d, hdr, fdata)\n",
    first_block, last_block);
  if(fp==NULL || first_block<=MatFirstDirBlk || h==NULL) {
    sprintf(ecat7errmsg, "invalid function parameter.\n");
    return(1);
  }
  *fdata=(float*)NULL;
  
  /* Read subheader */
  ret=ecat7ReadImageheader(fp, first_block, h);
  if(ret) {
    sprintf(ecat7errmsg, "cannot read subheader (%d).\n", ret);
    return(5);
  }
  if(ECAT7_TEST>4) ecat7PrintImageheader(h, stdout);
  pxlNr=h->x_dimension*h->y_dimension;
  if(h->num_dimensions>2) pxlNr*=h->z_dimension;
  if(pxlNr<=0) {
    sprintf(ecat7errmsg, "invalid matrix dimension.\n");
    return(6);  
  }
  
  /* Read matrix data */
  blockNr=last_block-first_block; if(blockNr<1) return(0);
  mdata=(char*)malloc((size_t)blockNr*MatBLKSIZE);
  if(mdata==NULL) {
    sprintf(ecat7errmsg, "cannot allocate memory.\n");
    return(8);  
  }
  mptr=mdata;
  ret=ecat7ReadMatrixdata(fp, first_block+1, blockNr, mptr, h->data_type);
  if(ret || mdata==NULL) {
    sprintf(ecat7errmsg, "cannot read matrix data (%d).\n", ret);
    free(mdata); return(9);
  }
  
  /* Allocate memory for float data */
  _fdata=(float*)malloc(pxlNr*sizeof(float));
  if(_fdata==NULL) {
    sprintf(ecat7errmsg, "cannot allocate memory.\n");
    free(mdata); return(11);  
  }
 
  /* Convert matrix data to floats */
  fptr=_fdata; mptr=mdata;
  if(h->data_type==ECAT7_BYTE) {
    for(i=0; i<pxlNr; i++, mptr++, fptr++)
      *fptr=h->scale_factor*(float)(*mptr);
  } else if(h->data_type==ECAT7_VAXI2 || h->data_type==ECAT7_SUNI2) {
    for(i=0; i<pxlNr; i++, mptr+=2, fptr++) {
      sptr=(short int*)mptr;
      *fptr=h->scale_factor*(float)(*sptr);
      if(!(*fptr>-1.0E+22 && *fptr<1.0E+22)) *fptr=0.0;
    }
  } else if(h->data_type==ECAT7_VAXI4 || h->data_type==ECAT7_SUNI4) {
    for(i=0; i<pxlNr; i++, mptr+=4, fptr++) {
      iptr=(int*)mptr;
      *fptr=h->scale_factor*(float)(*iptr);
      if(!(*fptr>-1.0E+22 && *fptr<1.0E+22)) *fptr=0.0;
    }
  } else if(h->data_type==ECAT7_VAXR4 || h->data_type==ECAT7_IEEER4) {
    memcpy(fptr, mptr, pxlNr*4);
    for(i=0; i<pxlNr; i++, fptr++) {
      *fptr *= h->scale_factor;
      if(!(*fptr>-1.0E+22 && *fptr<1.0E+22)) *fptr=0.0;
    }
  }
  free(mdata);
  *fdata=_fdata;
 
  return(0);
}

Referenced by imgReadEcat7(), and imgReadEcat7Frame().

◆ ecat7ReadMainheader()

int ecat7ReadMainheader	(	FILE *	fp,
		ECAT7_mainheader *	h )

extern

Read ECAT 7.x main header

Returns: 0 if ok, 1 == invalid parameters, 2 == first header block not found, 3 == header block not read properly

Parameters

fp	input file pointer
h	Ecat7 main header

Definition at line 15 of file ecat7r.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
  struct tm st;
 
  if(ECAT7_TEST) printf("ecat7ReadMainheader()\n");
  if(fp==NULL || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
 
  /* Seek the first block */
  fseek(fp, 0, SEEK_SET); if(ftell(fp)!=0) return(2); 
  /* Read the header block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) return(3);
  
  /* Copy the header fields and swap if necessary */
  memcpy(&h->magic_number, buf+0, 14);
  memcpy(&h->original_file_name, buf+14, 32);
  if(little) swabip(buf+46, 2);
  memcpy(&h->sw_version, buf+46, 2);
  if(little) swabip(buf+48, 2);
  memcpy(&h->system_type, buf+48, 2);
  if(little) swabip(buf+50, 2);
  memcpy(&h->file_type, buf+50, 2);
  memcpy(&h->serial_number, buf+52, 10);
  if(little) swawbip(buf+62, 4);
  memcpy(&h->scan_start_time, buf+62, 4);
  //printf("ecat7ReadMainheader(): scan_start_time := %d\n", h->scan_start_time);
  memcpy(&h->isotope_name, buf+66, 8);
  if(little) swawbip(buf+74, 4);
  memcpy(&h->isotope_halflife, buf+74, 4);
  memcpy(&h->radiopharmaceutical, buf+78, 32);
  if(little) swawbip(buf+110, 4);
  memcpy(&h->gantry_tilt, buf+110, 4);
  if(little) swawbip(buf+114, 4);
  memcpy(&h->gantry_rotation, buf+114, 4);
  if(little) swawbip(buf+118, 4);
  memcpy(&h->bed_elevation, buf+118, 4);
  if(little) swawbip(buf+122, 4);
  memcpy(&h->intrinsic_tilt, buf+122, 4);
  if(little) swabip(buf+126, 2);
  memcpy(&h->wobble_speed, buf+126, 2);
  if(little) swabip(buf+128, 2);
  memcpy(&h->transm_source_type, buf+128, 2);
  if(little) swawbip(buf+130, 4);
  memcpy(&h->distance_scanned, buf+130, 4);
  if(little) swawbip(buf+134, 4);
  memcpy(&h->transaxial_fov, buf+134, 4);
  if(little) swabip(buf+138, 2);
  memcpy(&h->angular_compression, buf+138, 2);
  if(little) swabip(buf+140, 2);
  memcpy(&h->coin_samp_mode, buf+140, 2);
  if(little) swabip(buf+142, 2);
  memcpy(&h->axial_samp_mode, buf+142, 2);
  if(little) swawbip(buf+144, 4);
  memcpy(&h->ecat_calibration_factor, buf+144, 4);
  if(little) swabip(buf+148, 2);
  memcpy(&h->calibration_units, buf+148, 2);
  if(little) swabip(buf+150, 2);
  memcpy(&h->calibration_units_label, buf+150, 2);
  if(little) swabip(buf+152, 2);
  memcpy(&h->compression_code, buf+152, 2);
  memcpy(&h->study_type, buf+154, 12);
  memcpy(&h->patient_id, buf+166, 16);
  memcpy(&h->patient_name, buf+182, 32);
  memcpy(&h->patient_sex, buf+214, 1);
  memcpy(&h->patient_dexterity, buf+215, 1);
  if(little) swawbip(buf+216, 4);
  memcpy(&h->patient_age, buf+216, 4);
  if(little) swawbip(buf+220, 4);
  memcpy(&h->patient_height, buf+220, 4);
  if(little) swawbip(buf+224, 4);
  memcpy(&h->patient_weight, buf+224, 4);
  if(little) swawbip(buf+228, 4);
  memcpy(&h->patient_birth_date, buf+228, 4);
  memcpy(&h->physician_name, buf+232, 32);
  memcpy(&h->operator_name, buf+264, 32);
  memcpy(&h->study_description, buf+296, 32);
  if(little) swabip(buf+328, 2);
  memcpy(&h->acquisition_type, buf+328, 2);
  if(little) swabip(buf+330, 2);
  memcpy(&h->patient_orientation, buf+330, 2);
  memcpy(&h->facility_name, buf+332, 20);
  if(little) swabip(buf+352, 2);
  memcpy(&h->num_planes, buf+352, 2);
  if(little) swabip(buf+354, 2);
  memcpy(&h->num_frames, buf+354, 2);
  if(little) swabip(buf+356, 2);
  memcpy(&h->num_gates, buf+356, 2);
  if(little) swabip(buf+358, 2);
  memcpy(&h->num_bed_pos, buf+358, 2);
  if(little) swawbip(buf+360, 4);
  memcpy(&h->init_bed_position, buf+360, 4);
  if(little) swawbip(buf+364, 15*4);
  memcpy(h->bed_position, buf+364, 15*4);
  if(little) swawbip(buf+424, 4);
  memcpy(&h->plane_separation, buf+424, 4);
  if(little) swabip(buf+428, 2);
  memcpy(&h->lwr_sctr_thres, buf+428, 2);
  if(little) swabip(buf+430, 2);
  memcpy(&h->lwr_true_thres, buf+430, 2);
  memcpy(&h->upr_true_thres, buf+432, 2); if(little) swabip(&h->upr_true_thres,2);
  memcpy(&h->user_process_code, buf+434, 10);
  if(little) swabip(buf+444, 2);
  memcpy(&h->acquisition_mode, buf+444, 2);
  if(little) swawbip(buf+446, 4);
  memcpy(&h->bin_size, buf+446, 4);
  if(little) swawbip(buf+450, 4);
  memcpy(&h->branching_fraction, buf+450, 4);
  if(little) swawbip(buf+454, 4);
  memcpy(&h->dose_start_time, buf+454, 4);
  if(little) swawbip(buf+458, 4);
  memcpy(&h->dosage, buf+458, 4);
  if(little) swawbip(buf+462, 4);
  memcpy(&h->well_counter_corr_factor, buf+462,4);
  memcpy(&h->data_units, buf+466, 32);
  if(little) swabip(buf+498, 2);
  memcpy(&h->septa_state, buf+498, 2);
  memcpy(&h->fill_cti, buf+500, 12);
 
  /* Patient birth date can have been saved in two different int formats,
     either YYYYMMDD or as seconds from start of year 1970. In latter case
     the number can be negative. */
  /* Seconds from start of year 1970 are converted to YYYYMMDD format */
  if(isdate4(h->patient_birth_date, NULL, NULL, NULL)!=0) {
    time_t t=h->patient_birth_date; gmtime_r(&t, &st);
    h->patient_birth_date=10000*(st.tm_year+1900)+100*(st.tm_mon+1)+st.tm_mday;
  }
 
  return(0);
}

Referenced by ecat7ReadHeaders(), ecat7WriteHeaders(), ecatFixMatrixlist(), imgRead(), imgReadEcat7(), imgReadEcat7Frame(), imgReadEcat7Header(), and imgWriteEcat7Frame().

◆ ecat7ReadMatlist()

int ecat7ReadMatlist	(	FILE *	fp,
		ECAT7_MATRIXLIST *	ml,
		int	verbose )

extern

Read ECAT matrix list.

Matrix list must be initiated (once) before calling this.

Returns: returns 0 if ok, 1 if invalid input, 2 if first matrix is not found, 3 if failed to read matrix, 4 if data allocation failed for matrix, 5 if other error occurred.

Parameters

fp	File pointer.
ml	Pointer to initiated matrix list.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 41 of file ecat7ml.c.

  {
  int err=0, little;
  int blk=MatFirstDirBlk, next_blk=0, nr_free, prev_blk, nr_used;
  size_t sn;
  unsigned int dirbuf[MatBLKSIZE/4];
 
 
  if(verbose>0) printf("ecat7ReadMatlist(fp, mlist)\n");
  if(fp==NULL) return(1);
  little=little_endian();
  /* Make sure that matrix list is empty */
  ecat7EmptyMatlist(ml);
  /* Seek the first list block */
  fseek(fp, (blk-1)*MatBLKSIZE, SEEK_SET); if(ftell(fp)!=(blk-1)*MatBLKSIZE) return(2);
  do {
    /* Read the data block */
    if(verbose>1) printf("  reading dirblock %d\n", blk);
    sn=fread(dirbuf, sizeof(int), MatBLKSIZE/4, fp); if(sn<MatBLKSIZE/4) return(3);
    /* Allocate (more) memory for one block */
    if(ml->matrixSpace==0) {
      ml->matrixSpace=MatBLKSIZE/4;
      ml->matdir=(ECAT7_MatDir*)malloc(ml->matrixSpace*sizeof(ECAT7_MatDir));
    } else if(ml->matrixSpace<(ml->matrixNr+MatBLKSIZE/4)) {
      ml->matrixSpace+=MatBLKSIZE/4;
      ml->matdir=(ECAT7_MatDir*)realloc(ml->matdir, sizeof(ECAT7_MatDir)*ml->matrixSpace);
    }
    if(ml->matdir==NULL) return(4);
    /* Byte order conversion for ints in little endian platforms */
    if(little) swawbip(dirbuf, MatBLKSIZE);
    /* Read "header" integers */
    nr_free  = dirbuf[0];
    next_blk = dirbuf[1];
    prev_blk = dirbuf[2];
    nr_used  = dirbuf[3];
    if(verbose>2) printf("nr_free=%d next_blk=%d prev_blk=%d nr_used=%d\n", nr_free, next_blk, prev_blk, nr_used);
    for(int i=4; i<MatBLKSIZE/4; i+=4) if(dirbuf[i]>0) {
      ml->matdir[ml->matrixNr].id=dirbuf[i];
      ml->matdir[ml->matrixNr].strtblk=dirbuf[i+1];
      ml->matdir[ml->matrixNr].endblk=dirbuf[i+2];
      ml->matdir[ml->matrixNr].status=dirbuf[i+3];
      if(verbose>3) {
        printf("matnum=%d strtblk=%d endblk=%d matstat=%d matrixNr=%d\n",
          ml->matdir[ml->matrixNr].id, ml->matdir[ml->matrixNr].strtblk,
          ml->matdir[ml->matrixNr].endblk, ml->matdir[ml->matrixNr].status,
          ml->matrixNr);
      }
      ml->matrixNr++;
    }
    blk=next_blk;
    /* Seek the next list block */
    long long pos=(blk-1)*(long long)MatBLKSIZE;
    fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) err=1;
  } while(err==0 && feof(fp)==0 && blk!=MatFirstDirBlk);
  if(err) {ecat7EmptyMatlist(ml); return(5);}
  return(0);
}

Referenced by ecat7PrintSubheader(), ecat7ReadHeaders(), ecat7WriteHeaders(), ecatFixMatrixlist(), imgReadEcat7(), imgReadEcat7Frame(), and imgReadEcat7Header().

◆ ecat7ReadMatrixdata()

int ecat7ReadMatrixdata	(	FILE *	fp,
		int	start_block,
		int	block_nr,
		char *	data,
		int	dtype )

extern

Read ECAT7 matrix data and convert byte order if necessary Remember to allocate memory for full blocks! There are differences here when compared to ecat63.c

Parameters

fp	input file pointer
start_block	starting block index
block_nr	number of blocks to be read
data	target buffer
dtype	data type of target buffer

Returns: 0 if ok, 1 == invalid parameters, 9 == start block not found, 2 == data blocks read properly

Definition at line 791 of file ecat7r.c.

  {
  int i, n, little, err=0;
  char *cptr;
  float f;
 
  if(ECAT7_TEST) printf("ecat7ReadMatrixdata(fp, %d, %d, data, %d)\n",
    start_block, block_nr, dtype);
  /* Check the arguments */
  if(block_nr<=0 || start_block<1 || data==NULL) return(1);
  /* Seek the first data block */
  long long pos=(start_block-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(9);
  /* Read the data blocks */
  if(fread(data, MatBLKSIZE, block_nr, fp) < (unsigned int)block_nr) return(2);
  /* Translate data if necessary */
  little=little_endian();
  switch(dtype) {
    case ECAT7_BYTE: /* byte format...no translation necessary */
      break;
    case ECAT7_VAXI2:  /* byte conversion necessary on big endian platform */
      if(!little) {cptr=data; swabip(cptr, block_nr*MatBLKSIZE);}
      break;
    case ECAT7_VAXI4:
      for(i=0, cptr=data; i<block_nr*MatBLKSIZE; i+=4, cptr+=4) {
        n=ecat7rInt(cptr, 1, little); memcpy(cptr, &n, 4);
      }
      break;
    case ECAT7_VAXR4:
      for(i=0, cptr=data; i<block_nr*MatBLKSIZE; i+=4, cptr+=4) {
        f=ecat7rFloat(cptr, 1, little); memcpy(cptr, &f, 4);
      }
      break;
    case ECAT7_IEEER4: /* IEEE float ; byte conversion necessary on
                          little endian platforms */
    case ECAT7_SUNI4:  /* SUN int ; byte conversion necessary on
                          little endian platforms */
      if(little) swawbip(data, block_nr*MatBLKSIZE);
      break;
    case ECAT7_SUNI2:  /* SUN short ; byte conversion necessary on
                          little endian platforms */
      if(little) swabip(data, block_nr*MatBLKSIZE);
      break;
    default:  /* if something else, for now think it as an error */ 
      err=2;
      break;
  }
  return(err);
}

Referenced by ecat7Read2DScanMatrix(), ecat7ReadImageMatrix(), ecat7ReadPolarmapMatrix(), and ecat7ReadScanMatrix().

◆ ecat7ReadNormheader()

int ecat7ReadNormheader	(	FILE *	fp,
		int	blk,
		ECAT7_normheader *	h )

extern

Read ECAT 7.x 3D normalization header

Parameters

fp	input file pointer
blk	block number [1..number of blocks]
h	Ecat7 normalization header

Returns: 0 if ok, 1 == invalid parameters, 2 == first header block not found, 3 == header block not read properly

Definition at line 472 of file ecat7r.c.

                                                                {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7ReadNormheader()\n");
  if(fp==NULL || h==NULL) return(1);
  little=little_endian();
 
  /* Seek the subheader block */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(2);
  /* Read the header block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) return(3);
  /* Copy the header fields and swap if necessary */
  if(little) swabip(buf+0, 2);
  memcpy(&h->data_type, buf+0, 2);
  if(little) swabip(buf+2, 2);
  memcpy(&h->num_r_elements, buf+2, 2);
  if(little) swabip(buf+4, 2);
  memcpy(&h->num_transaxial_crystals, buf+4, 2);
  if(little) swabip(buf+6, 2);
  memcpy(&h->num_crystal_rings, buf+6, 2);
  if(little) swabip(buf+8, 2);
  memcpy(&h->crystals_per_ring, buf+8, 2);
  if(little) swabip(buf+10, 2);
  memcpy(&h->num_geo_corr_planes, buf+10, 2);
  if(little) swabip(buf+12, 2);
  memcpy(&h->uld, buf+12, 2);
  if(little) swabip(buf+14, 2);
  memcpy(&h->lld, buf+14, 2);
  if(little) swabip(buf+16, 2);
  memcpy(&h->scatter_energy, buf+16, 2);
  if(little) swawbip(buf+18, 4);
  memcpy(&h->norm_quality_factor, buf+18, 4);
  if(little) swabip(buf+22, 2);
  memcpy(&h->norm_quality_factor_code, buf+22, 2);
  if(little) swawbip(buf+24, 32*4);
  memcpy(h->ring_dtcor1, buf+24, 32*4);
  if(little) swawbip(buf+152, 32*4);
  memcpy(h->ring_dtcor2, buf+152, 32*4);
  if(little) swawbip(buf+280, 8*4);
  memcpy(h->crystal_dtcor, buf+280, 8*4);
  if(little) swabip(buf+312, 2);
  memcpy(&h->span, buf+312, 2);
  if(little) swabip(buf+314, 2);
  memcpy(&h->max_ring_diff, buf+314, 2);
  if(little) swabip(buf+316, 48*2);
  memcpy(h->fill_cti, buf+316, 48*2);
  if(little) swabip(buf+412, 50*2);
  memcpy(h->fill_user, buf+412, 50*2);
  return(0);
}

Referenced by ecat7PrintSubheader(), ecat7ReadSubheaderToIFT(), and ecat7WriteSubheaderFromIFT().

◆ ecat7ReadPolarmapMatrix()

int ecat7ReadPolarmapMatrix	(	FILE *	fp,
		int	first_block,
		int	last_block,
		ECAT7_polmapheader *	h,
		float **	fdata )

extern

Read ECAT7 polar map matrix header and data. If only header is to be read, set last_block=first_block. Note: data is not calibrated with factor in main header.

Parameters

fp	ECAT file pointer
first_block	Subheader record number
last_block	Last data block number
h	Ptr to subheader data which is filled
fdata	Ptr to the address of the matrix data

Returns: 0 if ok, 1 invalid input, 5 failed to read scan header, 6 invalid image (x,y,z) dimensions, 8 failed to allocate memory for meta-data, 9 failed to read matrix data, 11 failed to allocate memory for voxel data

Definition at line 1154 of file ecat7r.c.

  {
  int ret;
  long long i, blockNr, pxlNr;
  char *mdata, *mptr;
  float *_fdata, *fptr;
  short int *sptr;
  int *iptr;
 
 
  if(ECAT7_TEST) printf("ecat7ReadPolarmapMatrix(fp, %d, %d, hdr, fdata)\n",
    first_block, last_block);
  if(fp==NULL || first_block<=MatFirstDirBlk || h==NULL) return 1;
  *fdata=(float*)NULL;
 
  /* Read subheader */
  ret=ecat7ReadPolmapheader(fp, first_block, h);
  if(ret) {
    sprintf(ecat7errmsg, "cannot read subheader (%d).\n", ret);
    return 2;
  }
  if(ECAT7_TEST>4) ecat7PrintPolmapheader(h, stdout);
  for(i=pxlNr=0; i<h->num_rings; i++) pxlNr+=h->sectors_per_ring[i];
  if(pxlNr<=0) return 3;
 
  /* Read matrix data */
  blockNr=last_block-first_block; if(blockNr<1) return 0;
  mdata=(char*)malloc((size_t)blockNr*MatBLKSIZE);
  if(mdata==NULL) return 4;
  mptr=mdata;
  ret=ecat7ReadMatrixdata(fp, first_block+1, blockNr, mptr, h->data_type);
  if(ret || mdata==NULL) {
    if(mdata!=NULL) free(mdata);
    return 5;
  }
 
  /* Allocate memory for float data */
  _fdata=(float*)malloc(pxlNr*sizeof(float));
  if(_fdata==NULL) {
    sprintf(ecat7errmsg, "cannot allocate memory.\n");
    free(mdata); return 4;
  }
 
  /* Convert matrix data to floats */
  fptr=_fdata; mptr=mdata;
  if(h->data_type==ECAT7_BYTE) {
    for(i=0; i<pxlNr; i++, mptr++, fptr++)
      *fptr=h->scale_factor*(float)(*mptr);
  } else if(h->data_type==ECAT7_VAXI2 || h->data_type==ECAT7_SUNI2) {
    for(i=0; i<pxlNr; i++, mptr+=2, fptr++) {
      sptr=(short int*)mptr;
      *fptr=h->scale_factor*(float)(*sptr);
    }
  } else if(h->data_type==ECAT7_VAXI4 || h->data_type==ECAT7_SUNI4) {
    for(i=0; i<pxlNr; i++, mptr+=4, fptr++) {
      iptr=(int*)mptr;
      *fptr=h->scale_factor*(float)(*iptr);
    }
  } else if(h->data_type==ECAT7_VAXR4 || h->data_type==ECAT7_IEEER4) {
    memcpy(fptr, mptr, pxlNr*4);
    for(i=0; i<pxlNr; i++, fptr++) *fptr *= h->scale_factor;
  }
  free(mdata);
  *fdata=_fdata;
 
  return 0;
}

Referenced by imgReadEcat7(), and imgReadEcat7Frame().

◆ ecat7ReadPolmapheader()

int ecat7ReadPolmapheader	(	FILE *	fp,
		int	blk,
		ECAT7_polmapheader *	h )

extern

Read ECAT 7.x polar map header

Parameters

fp	input file pointer
blk	block number [1..number of blocks]
h	Ecat7 polar map header

Returns: 0 if ok, 1 == invalid parameters, 2 == first header block not found, 3 == header block not read properly

Definition at line 397 of file ecat7r.c.

                                                                    {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7ReadPolarmapheader()\n");
  if(fp==NULL || h==NULL) return(1);
  little=little_endian();
 
  /* Seek the subheader block */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(2);
  /* Read the header block */
  if(fread(buf, MatBLKSIZE, 1, fp)<1) return(3);
  /* Copy the header fields and swap if necessary */
  if(little) swabip(buf+0, 2);
  memcpy(&h->data_type, buf+0, 2);
  if(little) swabip(buf+2, 2);
  memcpy(&h->polar_map_type, buf+2, 2);
  if(little) swabip(buf+4, 2);
  memcpy(&h->num_rings, buf+4, 2);
  if(little) swabip(buf+6, 32*2);
  memcpy(h->sectors_per_ring, buf+6, 32*2);
  if(little) swawbip(buf+70, 32*4);
  memcpy(h->ring_position, buf+70, 32*4);
  if(little) swabip(buf+198, 32*2);
  memcpy(h->ring_angle, buf+198, 32*2);
  if(little) swabip(buf+262, 2);
  memcpy(&h->start_angle, buf+262, 2);
  if(little) swabip(buf+264, 3*2);
  memcpy(h->long_axis_left, buf+264, 3*2);
  if(little) swabip(buf+270, 3*2);
  memcpy(h->long_axis_right, buf+270, 3*2);
  if(little) swabip(buf+276, 2);
  memcpy(&h->position_data, buf+276, 2);
  if(little) swabip(buf+278, 2);
  memcpy(&h->image_min, buf+278, 2);
  if(little) swabip(buf+280, 2);
  memcpy(&h->image_max, buf+280, 2);
  if(little) swawbip(buf+282, 4);
  memcpy(&h->scale_factor, buf+282, 4);
  if(little) swawbip(buf+286, 4);
  memcpy(&h->pixel_size, buf+286, 4);
  if(little) swawbip(buf+290, 4);
  memcpy(&h->frame_duration, buf+290, 4);
  if(little) swawbip(buf+294, 4);
  memcpy(&h->frame_start_time, buf+294, 4);
  if(little) swabip(buf+298, 2);
  memcpy(&h->processing_code, buf+298, 2);
  if(little) swabip(buf+300, 2);
  memcpy(&h->quant_units, buf+300, 2);
  memcpy(h->annotation, buf+302, 40);
  if(little) swawbip(buf+342, 4);
  memcpy(&h->gate_duration, buf+342, 4);
  if(little) swawbip(buf+346, 4);
  memcpy(&h->r_wave_offset, buf+346, 4);
  if(little) swawbip(buf+350, 4);
  memcpy(&h->num_accepted_beats, buf+350, 4);
  memcpy(h->polar_map_protocol, buf+354, 20);
  memcpy(h->database_name, buf+374, 30);
  if(little) swabip(buf+404, 27*2);
  memcpy(h->fill_cti, buf+404, 27*2);
  return(0);
}

Referenced by ecat7PrintSubheader(), ecat7ReadPolarmapMatrix(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), imgReadEcat7(), and imgReadEcat7Header().

◆ ecat7ReadScanheader()

int ecat7ReadScanheader	(	FILE *	fp,
		int	blk,
		ECAT7_scanheader *	h )

extern

Read ECAT 7.x 3D scan header (512 bytes)

Parameters

fp	input file pointer
blk	block number [1..number of blocks]
h	Ecat7 scan header

Returns: 0 if ok, 1 == invalid parameters, 2 == first header block not found, 3 == header block not read properly

Definition at line 536 of file ecat7r.c.

                                                                {
  unsigned char buf[2*MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7ReadScanheader()\n");
  if(fp==NULL || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
 
  /* Seek the subheader block */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(2);
  /* Read the header block */
  if(fread(buf, MatBLKSIZE, 2, fp)<1) return(3);
 
  /* Copy the header fields and swap if necessary */
  if(little) swabip(buf+0, 2);
  memcpy(&h->data_type, buf+0, 2);
  if(little) swabip(buf+2, 2);
  memcpy(&h->num_dimensions, buf+2, 2);
  if(little) swabip(buf+4, 2);
  memcpy(&h->num_r_elements, buf+4, 2);
  if(little) swabip(buf+6, 2);
  memcpy(&h->num_angles, buf+6, 2);
  if(little) swabip(buf+8, 2);
  memcpy(&h->corrections_applied, buf+8, 2);
  if(little) swabip(buf+10, 64*2);
  memcpy(h->num_z_elements, buf+10, 64*2);
  if(little) swabip(buf+138, 2);
  memcpy(&h->ring_difference, buf+138, 2);
  if(little) swabip(buf+140, 2);
  memcpy(&h->storage_order, buf+140, 2);
  if(little) swabip(buf+142, 2);
  memcpy(&h->axial_compression, buf+142, 2);
  if(little) swawbip(buf+144, 4);
  memcpy(&h->x_resolution, buf+144, 4);
  if(little) swawbip(buf+148, 4);
  memcpy(&h->v_resolution, buf+148, 4);
  if(little) swawbip(buf+152, 4);
  memcpy(&h->z_resolution, buf+152, 4);
  if(little) swawbip(buf+156, 4);
  memcpy(&h->w_resolution, buf+156, 4);
  if(little) swabip(buf+160, 6*2);
  memcpy(h->fill_gate, buf+160, 6*2);
  if(little) swawbip(buf+172, 4);
  memcpy(&h->gate_duration, buf+172, 4);
  if(little) swawbip(buf+176, 4);
  memcpy(&h->r_wave_offset, buf+176, 4);
  if(little) swawbip(buf+180, 4);
  memcpy(&h->num_accepted_beats, buf+180, 4);
  if(little) swawbip(buf+184, 4);
  memcpy(&h->scale_factor, buf+184, 4);
  if(little) swabip(buf+188, 2);
  memcpy(&h->scan_min, buf+188, 2);
  if(little) swabip(buf+190, 2);
  memcpy(&h->scan_max, buf+190, 2);
  if(little) swawbip(buf+192, 4);
  memcpy(&h->prompts, buf+192, 4);
  if(little) swawbip(buf+196, 4);
  memcpy(&h->delayed, buf+196, 4);
  if(little) swawbip(buf+200, 4);
  memcpy(&h->multiples, buf+200, 4);
  if(little) swawbip(buf+204, 4);
  memcpy(&h->net_trues, buf+204, 4);
  if(little) swawbip(buf+208, 4);
  memcpy(&h->tot_avg_cor, buf+208, 4);
  if(little) swawbip(buf+212, 4);
  memcpy(&h->tot_avg_uncor, buf+212, 4);
  if(little) swawbip(buf+216, 4);
  memcpy(&h->total_coin_rate, buf+216, 4);
  if(little) swawbip(buf+220, 4);
  memcpy(&h->frame_start_time, buf+220, 4);
  if(little) swawbip(buf+224, 4);
  memcpy(&h->frame_duration, buf+224, 4);
  if(little) swawbip(buf+228, 4);
  memcpy(&h->deadtime_correction_factor, buf+228,4);
  if(little) swabip(buf+232, 90*2);
  memcpy(h->fill_cti, buf+232, 90*2);
  if(little) swabip(buf+412, 50*2);
  memcpy(h->fill_user, buf+412, 50*2);
  if(little) swawbip(buf+512, 128*4);
  memcpy(h->uncor_singles, buf+512, 128*4);
  return(0);
}

Referenced by ecat7GetNums(), ecat7PrintSubheader(), ecat7ReadScanMatrix(), ecat7ReadSubheaderToIFT(), ecat7WriteSubheaderFromIFT(), imgReadEcat7(), and imgReadEcat7Header().

◆ ecat7ReadScanMatrix()

int ecat7ReadScanMatrix	(	FILE *	fp,
		int	first_block,
		int	last_block,
		ECAT7_scanheader *	h,
		float **	fdata )

extern

Read ECAT7 3D sinogram matrix header and data. Memory for fdata[] is allocated here, remember to free memory after usage. Note: data is converted to floats with scale_factor in the scan matrix header. Note: data is not calibrated with ecat_calibration_factor in main header. Note: data is not multiplied with deadtime_correction_factor.

Parameters

fp	ECAT file pointer
first_block	Subheader record number
last_block	Last data block number
h	Ptr to subheader data which is filled
fdata	Ptr to the address of the matrix data

Returns: 0 if ok, 1 invalid input, 5 failed to read scan header, 6 invalid image (x,y,z) dimensions, 8 failed to allocate memory for meta-data, 9 failed to read matrix data, 11 failed to allocate memory for voxel data

Definition at line 1055 of file ecat7r.c.

  {
  int ret;
  long long i, blockNr, trueblockNr, pxlNr, dimz;
  char *mdata, *mptr;
  float *_fdata, *fptr;
  short int *sptr;
  int *iptr;
  
  
  if(ECAT7_TEST) printf("ecat7ReadScanMatrix(fp, %d, %d, hdr, fdata)\n",
    first_block, last_block);
  if(fp==NULL || first_block<=MatFirstDirBlk || h==NULL) {
    sprintf(ecat7errmsg, "invalid function parameter.\n");
    return(1);
  }
  *fdata=(float*)NULL;
  
  /* Read subheader */
  ret=ecat7ReadScanheader(fp, first_block, h);
  if(ret) {
    sprintf(ecat7errmsg, "cannot read subheader (%d).\n", ret);
    return(5);
  }
  if(ECAT7_TEST>4) ecat7PrintScanheader(h, stdout);
  pxlNr=h->num_r_elements*h->num_angles;
  for(i=dimz=0; i<64; i++) dimz+=h->num_z_elements[i];
  pxlNr*=dimz;
  if(pxlNr<=0) {
    sprintf(ecat7errmsg, "invalid matrix dimension.\n");
    return(6);  
  }
  trueblockNr=pxlNr*ecat7pxlbytes(h->data_type);
  trueblockNr=(trueblockNr+MatBLKSIZE-1)/MatBLKSIZE;
 
  /* Read matrix data; note that header takes 2 blocks */
  blockNr=last_block-first_block-1; if(blockNr<1) return(0);
  if(blockNr<trueblockNr) trueblockNr=blockNr;
  mdata=(char*)malloc((size_t)blockNr*MatBLKSIZE);
  if(mdata==NULL) {
    sprintf(ecat7errmsg, "cannot allocate memory.\n");
    return(8);  
  }
  mptr=mdata; /* note that only true block nr is read! */
  ret=ecat7ReadMatrixdata(fp, first_block+2, trueblockNr, mptr, h->data_type);
  if(ret || mdata==NULL) {
    sprintf(ecat7errmsg, "cannot read matrix data (%d).\n", ret);
    free(mdata); return(9);
  }
  
  /* Allocate memory for float data */
  _fdata=(float*)malloc(pxlNr*sizeof(float));
  if(_fdata==NULL) {
    sprintf(ecat7errmsg, "cannot allocate memory.\n");
    free(mdata); return(11);  
  }
 
  /* Convert matrix data to floats */
  fptr=_fdata; mptr=mdata;
  if(h->data_type==ECAT7_BYTE) {
    for(i=0; i<pxlNr; i++, mptr++, fptr++)
      *fptr=h->scale_factor*(float)(*mptr);
  } else if(h->data_type==ECAT7_VAXI2 || h->data_type==ECAT7_SUNI2) {
    for(i=0; i<pxlNr; i++, mptr+=2, fptr++) {
      sptr=(short int*)mptr;
      *fptr=h->scale_factor*(float)(*sptr);
    }
  } else if(h->data_type==ECAT7_VAXI4 || h->data_type==ECAT7_SUNI4) {
    for(i=0; i<pxlNr; i++, mptr+=4, fptr++) {
      iptr=(int*)mptr;
      *fptr=h->scale_factor*(float)(*iptr);
    }
  } else if(h->data_type==ECAT7_VAXR4 || h->data_type==ECAT7_IEEER4) {
    memcpy(fptr, mptr, pxlNr*4);
    for(i=0; i<pxlNr; i++, fptr++) *fptr *= h->scale_factor;
  }
  free(mdata);
  *fdata=_fdata;
 
  return(0);
}

Referenced by imgReadEcat7(), and imgReadEcat7Frame().

◆ ecat7ReadSubheaderToIFT()

int ecat7ReadSubheaderToIFT	(	FILE *	fp,
		ECAT7_mainheader *	h,
		int	strtblk,
		IFT *	ift,
		int	verbose )

extern

Read ECAT 7 subheader from file and store in IFT struct.

Returns: Returns STATUS_OK when succesful.

Parameters

fp	File pointer to opened ECAT7 file
h	ECAT7 mainheader
strtblk	Subheader location
ift	Preallocated location for header data
verbose	Verbose level

Definition at line 502 of file ecat7ift.c.

  {
  ECAT7_imageheader       image_header;
  ECAT7_scanheader        scan_header;
  ECAT7_2Dscanheader      scan2D_header;
  ECAT7_2Dnormheader      norm2D_header;
  ECAT7_normheader        norm_header;
  ECAT7_attenheader       atten_header;
  ECAT7_polmapheader      polmap_header;
  int                     ret;
 
  if(verbose>0) printf("ecat7ReadSubheaderToIFT(fp, mh, %d, ift)\n", strtblk);
  /* Check input */
  if(fp==NULL || h==NULL || strtblk<3 || ift==NULL) return STATUS_FAULT;
 
  /* Read subheader and copy into IFT */
  //if(iftPut(ift, "test_key", "test_value", NULL)!=0) return STATUS_UNSUPPORTED;
  switch(h->file_type) {
    case ECAT7_ATTEN:
      ret=ecat7ReadAttenheader(fp, strtblk, &atten_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    case ECAT7_3DNORM:
      ret=ecat7ReadNormheader(fp, strtblk, &norm_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    case ECAT7_IMAGE8:
    case ECAT7_IMAGE16:
    case ECAT7_VOLUME8:
    case ECAT7_VOLUME16:
      ret=ecat7ReadImageheader(fp, strtblk, &image_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      ret=ecat7ImageheaderToIFT(&image_header, ift, verbose); 
      if(ret!=STATUS_OK) return ret;
      break;
    case ECAT7_3DSCAN:
    case ECAT7_3DSCAN8:
    case ECAT7_3DSCANFIT:
      ret=ecat7ReadScanheader(fp, strtblk, &scan_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      ret=ecat7ScanheaderToIFT(&scan_header, ift, verbose); 
      if(ret!=STATUS_OK) return ret;
      ret=ecat7WriteScanheader(fp, strtblk, &scan_header);
      break;
    case ECAT7_POLARMAP:
      ret=ecat7ReadPolmapheader(fp, strtblk, &polmap_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    case ECAT7_2DSCAN:
      ret=ecat7Read2DScanheader(fp, strtblk, &scan2D_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    case ECAT7_2DNORM:
      ret=ecat7Read2DNormheader(fp, strtblk, &norm2D_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    default:
      return STATUS_UNSUPPORTED;
  }
  return STATUS_OK;
}

Referenced by ecat7ReadHeaders().

◆ ecat7rFloat()

float ecat7rFloat	(	void *	bufi,
		int	isvax,
		int	islittle )

extern

Read ECAT7 floats

Parameters

bufi	pointer to 32-bit data block
isvax	!= 0 for VAX format
islittle	!= 0 for little endian conversion

Returns: data in bufi as float value

Definition at line 1233 of file ecat7r.c.

                                                       {
  union {unsigned int ul; float f;} t;
 
  memcpy(&t.ul, bufi, 4); if(t.ul==0) {return(0.0);}
  if(isvax) { /* if input is in VAX format */
    /* Swap words on i386 and bytes on SUN */
    if(islittle) swawip(&t.ul, 4); else swabip(&t.ul, 4);
    t.ul-=(2L<<23); /* subtract 2 from exp */
  } else { /* input is in i386 format */
    if(!islittle) swawbip(&t.ul, 4); /* Switch words and bytes on SUN */
  }
  return(t.f);
}

Referenced by ecat7ReadMatrixdata().

◆ ecat7rInt()

int ecat7rInt	(	void *	bufi,
		int	isvax,
		int	islittle )

extern

Reading and writing ECAT7 32-bit ints 32-bit int format is same in VAX and i386

Parameters

bufi	pointer to one 32-bit data block
isvax	ignored
islittle	!= 0 for little endian conversion

Returns: converted 32-bit integer

Definition at line 1256 of file ecat7r.c.

                                                   {
  int i;
 
  if(isvax==0) {} // prevent compiler warning
  /* Swap both words and bytes on SUN */
  memcpy(&i, bufi, 4); if(!islittle) swawbip(&i, 4);
  return(i);
}

Referenced by ecat7ReadMatrixdata().

◆ ecat7ScanheaderToIFT()

int ecat7ScanheaderToIFT	(	ECAT7_scanheader *	h,
		IFT *	ift,
		int	verbose )

extern

Copy ECAT 7 scan header into IFT struct.

Returns: Returns STATUS_OK when succesful.

Parameters

h	Pointer to source ECAT 7 scan header
ift	Pointer to initiated IFT struct. Any previous contents are preserved.
verbose	Verbose level

Definition at line 408 of file ecat7ift.c.

  {
  int i;
  char tmp[1024], tmp2[32];
 
  if(verbose>0) printf("ecat7ScanheaderToIFT(h, ift)\n");
  if(h==NULL || ift==NULL) return STATUS_FAULT;
  if(h->data_type<=0) return STATUS_UNKNOWNFORMAT;
 
  sprintf(tmp, "%d", h->data_type);
  if(iftPut(ift, "data_type", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_dimensions);
  if(iftPut(ift, "num_dimensions", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_r_elements);
  if(iftPut(ift, "num_r_elements", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_angles);
  if(iftPut(ift, "num_angles", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->corrections_applied);
  if(iftPut(ift, "corrections_applied", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_z_elements[0]);
  for(i=1; i<64; i++) {sprintf(tmp2, " %d", h->fill_cti[i]); strcat(tmp, tmp2);}
  if(iftPut(ift, "num_z_elements", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->ring_difference);
  if(iftPut(ift, "ring_difference", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->storage_order);
  if(iftPut(ift, "storage_order", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->axial_compression);
  if(iftPut(ift, "axial_compression", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->x_resolution);
  if(iftPut(ift, "x_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->v_resolution);
  if(iftPut(ift, "v_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->z_resolution);
  if(iftPut(ift, "z_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->w_resolution);
  if(iftPut(ift, "w_resolution", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->gate_duration);
  if(iftPut(ift, "gate_duration", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->r_wave_offset);
  if(iftPut(ift, "r_wave_offset", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->num_accepted_beats);
  if(iftPut(ift, "num_accepted_beats", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%E", h->scale_factor);
  if(iftPut(ift, "scale_factor", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->scan_min);
  if(iftPut(ift, "scan_min", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->scan_max);
  if(iftPut(ift, "scan_max", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->prompts);
  if(iftPut(ift, "prompts", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->delayed);
  if(iftPut(ift, "delayed", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->multiples);
  if(iftPut(ift, "multiples", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->net_trues);
  if(iftPut(ift, "net_trues", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->tot_avg_cor);
  if(iftPut(ift, "tot_avg_cor", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->tot_avg_uncor);
  if(iftPut(ift, "tot_avg_uncor", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->total_coin_rate);
  if(iftPut(ift, "total_coin_rate", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->frame_start_time);
  if(iftPut(ift, "frame_start_time", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%d", h->frame_duration);
  if(iftPut(ift, "frame_duration", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->deadtime_correction_factor);
  if(iftPut(ift, "deadtime_correction_factor", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
  sprintf(tmp, "%g", h->uncor_singles[0]);
  for(i=1; i<128; i++) {sprintf(tmp2, " %g", h->uncor_singles[i]); strcat(tmp, tmp2);}
  if(iftPut(ift, "uncor_singles", tmp, NULL, 0)!=0) return STATUS_UNSUPPORTED;
 
/*
  if(iftPut(ift, "", h->, NULL)!=0) return STATUS_UNSUPPORTED;
 
  sprintf(tmp, "%g", h->);
  if(iftPut(ift, "", tmp, NULL)!=0) return STATUS_UNSUPPORTED;
 
  sprintf(tmp, "%d", h->);
  if(iftPut(ift, "", tmp, NULL)!=0) return STATUS_UNSUPPORTED;
  */
  return STATUS_OK;
}

Referenced by ecat7ReadSubheaderToIFT().

◆ ecat7SortMatlistByFrame()

void ecat7SortMatlistByFrame ( ECAT7_MATRIXLIST * ml )

extern

Sort matrixlist by frame and plane. Bubble sorting algorithm.

Parameters

ml	target matrix list

Definition at line 303 of file ecat7ml.c.

                                                   {
  int i, j;
  ECAT7_Matval mv1, mv2;
  ECAT7_MatDir tmpMatdir;
 
  for(i=0; i<ml->matrixNr-1; i++) {
    ecat7_id_to_val(ml->matdir[i].id, &mv1);
    for(j=i+1; j<ml->matrixNr; j++) {
      ecat7_id_to_val(ml->matdir[j].id, &mv2);
      if(mv2.frame<mv1.frame||(mv2.frame==mv1.frame&&mv2.plane<mv1.plane)) {
        tmpMatdir=ml->matdir[i];
        ml->matdir[i]=ml->matdir[j]; ml->matdir[j]=tmpMatdir;
        ecat7_id_to_val(ml->matdir[i].id, &mv1);
      }
    }
  }
}

Referenced by imgReadEcat7Frame().

◆ ecat7SortMatlistByPlane()

void ecat7SortMatlistByPlane ( ECAT7_MATRIXLIST * ml )

extern

Sort matrixlist by plane and frame. Bubble sorting algorithm.

Parameters

ml	target matrix list

Definition at line 277 of file ecat7ml.c.

                                                   {
  int i, j;
  ECAT7_Matval mv1, mv2;
  ECAT7_MatDir tmpMatdir;
 
  for(i=0; i<ml->matrixNr-1; i++) {
    ecat7_id_to_val(ml->matdir[i].id, &mv1);
    for(j=i+1; j<ml->matrixNr; j++) {
      ecat7_id_to_val(ml->matdir[j].id, &mv2);
      if(mv2.plane<mv1.plane||(mv2.plane==mv1.plane&&mv2.frame<mv1.frame)) {
        tmpMatdir=ml->matdir[i];
        ml->matdir[i]=ml->matdir[j];
  ml->matdir[j]=tmpMatdir;
        ecat7_id_to_val(ml->matdir[i].id, &mv1);
      }
    }
  }
}

Referenced by ecat7GetPlaneAndFrameNr(), and imgReadEcat7().

◆ ecat7Write2DNormheader()

int ecat7Write2DNormheader	(	FILE *	fp,
		int	blk,
		ECAT7_2Dnormheader *	h )

extern

Write ECAT 7.x 2D normalization header.

Parameters

fp	file pointer
blk	header block number, blk >= 2
h	Ecat7 2D normalization header

Returns: 0 in case of success, 1 == invalid parameters, 4 == file pointer is at wrong position, 5 == writing of MatBLKSIZE bytes was not success

Definition at line 517 of file ecat7w.c.

                                                                     {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7Write2DNormheader()\n");
  if(fp==NULL || blk<2 || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  if(h->data_type==ECAT7_VAXI2) h->data_type=ECAT7_SUNI2;
  else if(h->data_type==ECAT7_VAXI4) h->data_type=ECAT7_SUNI4;
  else if(h->data_type==ECAT7_VAXR4) h->data_type=ECAT7_IEEER4;
 
  /* Copy the header fields and swap if necessary */
  memcpy(buf+0, &h->data_type, 2); if(little) swabip(buf+0, 2);
  memcpy(buf+2, &h->num_dimensions, 2); if(little) swabip(buf+2, 2);
  memcpy(buf+4, &h->num_r_elements, 2); if(little) swabip(buf+4, 2);
  memcpy(buf+6, &h->num_angles, 2); if(little) swabip(buf+6, 2);
  memcpy(buf+8, &h->num_z_elements, 2); if(little) swabip(buf+8, 2);
  memcpy(buf+10, &h->ring_difference, 2); if(little) swabip(buf+10, 2);
  memcpy(buf+12, &h->scale_factor, 4); if(little) swawbip(buf+12, 4);
  memcpy(buf+16, &h->norm_min, 4); if(little) swawbip(buf+16, 4);
  memcpy(buf+20, &h->norm_max, 4); if(little) swawbip(buf+20, 4);
  memcpy(buf+24, &h->fov_source_width, 4); if(little) swawbip(buf+24, 4);
  memcpy(buf+28, &h->norm_quality_factor, 4); if(little) swawbip(buf+28, 4);
  memcpy(buf+32, &h->norm_quality_factor_code, 2); if(little) swabip(buf+32, 2);
  memcpy(buf+34, &h->storage_order, 2); if(little) swabip(buf+34, 2);
  memcpy(buf+36, &h->span, 2); if(little) swabip(buf+36, 2);
  memcpy(buf+38, h->fill_cti, 64*2); if(little) swabip(buf+38, 64*2);
  memcpy(buf+166, h->fill_cti, 123*2); if(little) swabip(buf+166, 123*2);
  memcpy(buf+412, h->fill_user, 50*2); if(little) swabip(buf+412, 50*2);
 
  /* Write header */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(4);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(5);
 
  return(0);
}

◆ ecat7Write2DScanheader()

int ecat7Write2DScanheader	(	FILE *	fp,
		int	blk,
		ECAT7_2Dscanheader *	h )

extern

Write ECAT 7.x 2D scan header

Parameters

fp	output file pointer
blk	header block number, blk >= 2
h	Ecat7 2D scan header

Returns: 0 in case of success, 1 == invalid parameters, 4 == file pointer is at wrong position, 5 == writing of MatBLKSIZE bytes was not success

Definition at line 450 of file ecat7w.c.

                                                                     {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7Write2DScanheader()\n");
  if(fp==NULL || blk<2 || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  if(h->data_type==ECAT7_VAXI2) h->data_type=ECAT7_SUNI2;
  else if(h->data_type==ECAT7_VAXI4) h->data_type=ECAT7_SUNI4;
  else if(h->data_type==ECAT7_VAXR4) h->data_type=ECAT7_IEEER4;
 
  /* Copy the header fields and swap if necessary */
  memcpy(buf+0, &h->data_type, 2); if(little) swabip(buf+0, 2);
  memcpy(buf+2, &h->num_dimensions, 2); if(little) swabip(buf+2, 2);
  memcpy(buf+4, &h->num_r_elements, 2); if(little) swabip(buf+4, 2);
  memcpy(buf+6, &h->num_angles, 2); if(little) swabip(buf+6, 2);
  memcpy(buf+8, &h->corrections_applied, 2); if(little) swabip(buf+8, 2);
  memcpy(buf+10, &h->num_z_elements, 2); if(little) swabip(buf+10, 2);
  memcpy(buf+12, &h->ring_difference, 2); if(little) swabip(buf+12, 2);
  memcpy(buf+14, &h->x_resolution, 4); if(little) swawbip(buf+14, 4);
  memcpy(buf+18, &h->y_resolution, 4); if(little) swawbip(buf+18, 4);
  memcpy(buf+22, &h->z_resolution, 4); if(little) swawbip(buf+22, 4);
  memcpy(buf+26, &h->w_resolution, 4); if(little) swawbip(buf+26, 4);
  memcpy(buf+30, h->fill_gate, 6*2); if(little) swabip(buf+30, 6*2);
  memcpy(buf+42, &h->gate_duration, 4); if(little) swawbip(buf+42, 4);
  memcpy(buf+46, &h->r_wave_offset, 4); if(little) swawbip(buf+46, 4);
  memcpy(buf+50, &h->num_accepted_beats, 4); if(little) swawbip(buf+50, 4);
  memcpy(buf+54, &h->scale_factor, 4); if(little) swawbip(buf+54, 4);
  memcpy(buf+58, &h->scan_min, 2); if(little) swabip(buf+58, 2);
  memcpy(buf+60, &h->scan_max, 2); if(little) swabip(buf+60, 2);
  memcpy(buf+62, &h->prompts, 4); if(little) swawbip(buf+62, 4);
  memcpy(buf+66, &h->delayed, 4); if(little) swawbip(buf+66, 4);
  memcpy(buf+70, &h->multiples, 4); if(little) swawbip(buf+70, 4);
  memcpy(buf+74, &h->net_trues, 4); if(little) swawbip(buf+74, 4);
  memcpy(buf+78, h->cor_singles, 16*4); if(little) swawbip(buf+78, 16*4);
  memcpy(buf+142, h->uncor_singles, 16*4); if(little) swawbip(buf+142, 16*4);
  memcpy(buf+206, &h->tot_avg_cor, 4); if(little) swawbip(buf+206, 4);
  memcpy(buf+210, &h->tot_avg_uncor, 4); if(little) swawbip(buf+210, 4);
  memcpy(buf+214, &h->total_coin_rate, 4); if(little) swawbip(buf+214, 4);
  memcpy(buf+218, &h->frame_start_time, 4); if(little) swawbip(buf+218, 4);
  memcpy(buf+222, &h->frame_duration, 4); if(little) swawbip(buf+222, 4);
  memcpy(buf+226, &h->deadtime_correction_factor, 4); if(little) swawbip(buf+226, 4);
  memcpy(buf+230, h->physical_planes, 8*2); if(little) swabip(buf+230, 8*2);
  memcpy(buf+246, h->fill_cti, 83*2); if(little) swabip(buf+246, 83*2);
  memcpy(buf+412, h->fill_user, 50*2); if(little) swabip(buf+412, 50*2);
 
  /* Write header */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(4);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(5);
 
  return(0);
}

Referenced by ecat7Write2DScanMatrix().

◆ ecat7Write2DScanMatrix()

int ecat7Write2DScanMatrix	(	FILE *	fp,
		int	matrix_id,
		ECAT7_2Dscanheader *	h,
		float *	fdata )

extern

Write ECAT 7.x 2D sinogram matrix header and data

Parameters

fp	output file pointer
matrix_id	coded matrix id
h	Ecat7 2D image scan header
fdata	float data to be written

Returns: 0 if ok.

Definition at line 719 of file ecat7w.c.

                                                                                         {
  int ret;
  long long i, data_size, nxtblk, blkNr, pxlNr;
  float *fptr, fmin, fmax, g, f;
  char *mdata, *mptr;
  short int *sptr;
 
 
  if(ECAT7_TEST) printf("ecat7Write2DScanMatrix(fp, %d, h, data)\n", matrix_id);
  if(fp==NULL || matrix_id<1 || h==NULL || fdata==NULL) {
    sprintf(ecat7errmsg, "invalid function parameter.\n");
    return(1);
  }
  if(h->data_type!=ECAT7_SUNI2) {
    sprintf(ecat7errmsg, "invalid data_type.\n");
    return(2);
  }
  /* nr of pixels */
  pxlNr=h->num_r_elements*h->num_angles;
  if(h->num_dimensions>2) pxlNr*=h->num_z_elements;
  if(pxlNr<1) {
    sprintf(ecat7errmsg, "invalid matrix dimension.\n");
    return(3);
  }
  /* How much memory is needed for ALL pixels */
  data_size=pxlNr*ecat7pxlbytes(h->data_type);
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) {
    sprintf(ecat7errmsg, "invalid block number.\n");
    return(4);
  }
  /* Allocate memory for matrix data */
  mdata=(char*)calloc(blkNr, MatBLKSIZE); if(mdata==NULL) {
    sprintf(ecat7errmsg, "out of memory.\n");
    return(5);
  }
  /* Search for min and max for calculation of scale factor */
  fMinMaxFin(fdata, pxlNr, &fmin, &fmax);
  if(fabs(fmin)>fabs(fmax)) g=fabs(fmin); else g=fabs(fmax);
  if(g>0) f=32766./g; else f=1.0;
  /* Check if pixels values can be left as such with scale_factor = 1 */
  fptr=fdata;
  if(f>=1.0 && ecat7_is_scaling_needed(g, fptr, pxlNr)==0) f=1.0;
  /* Scale matrix data to shorts */
  h->scale_factor=1.0/f;
  sptr=(short int*)mdata; fptr=fdata;
  for(i=0; i<pxlNr; i++, sptr++, fptr++) *sptr=(short int)temp_roundf(f*(*fptr));
  /* Set header short min & max */
  h->scan_min=(short int)temp_roundf(f*fmin);
  h->scan_max=(short int)temp_roundf(f*fmax);
  /* Get block number for matrix header and data */
  nxtblk=ecat7EnterMatrix(fp, matrix_id, blkNr); if(nxtblk<1) {
    sprintf(ecat7errmsg, "cannot determine matrix block (%lld).\n", -nxtblk);
    free(mdata); return(8);
  }
  if(ECAT7_TEST>2) printf("  block=%lld fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
  /* Write header */
  ret=ecat7Write2DScanheader(fp, nxtblk, h); if(ret) {
    sprintf(ecat7errmsg, "cannot write subheader (%d).\n", ret);
    free(mdata); return(10);
  }
  /* Write matrix data */
  mptr=mdata;
  ret=ecat7WriteMatrixdata(fp, nxtblk+1, mptr, pxlNr, ecat7pxlbytes(h->data_type));
  free(mdata);
  if(ret) {
    sprintf(ecat7errmsg, "cannot write matrix data (%d).\n", ret);
    return(13);
  }
  return(0);
}

Referenced by imgWrite2DEcat7(), and imgWriteEcat7Frame().

◆ ecat7WriteAttenheader()

int ecat7WriteAttenheader	(	FILE *	fp,
		int	blk,
		ECAT7_attenheader *	h )

extern

Write ECAT 7.x attenuation header

Parameters

fp	output file pointer
blk	header block number, blk >= 2
h	Ecat7 attenuation header

Returns: 0 in case of success, 1 == invalid parameters, 4 == file pointer is at wrong position, 5 == writing of MatBLKSIZE bytes was not success

Definition at line 208 of file ecat7w.c.

                                                                   {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7WriteAttenheader()\n");
  if(fp==NULL || blk<2 || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  if(h->data_type==ECAT7_VAXI2) h->data_type=ECAT7_SUNI2;
  else if(h->data_type==ECAT7_VAXI4) h->data_type=ECAT7_SUNI4;
  else if(h->data_type==ECAT7_VAXR4) h->data_type=ECAT7_IEEER4;
  
  /* Copy the header fields and swap if necessary */
  memcpy(buf+0, &h->data_type, 2); if(little) swabip(buf+0, 2);
  memcpy(buf+2, &h->num_dimensions, 2); if(little) swabip(buf+2, 2);
  memcpy(buf+4, &h->attenuation_type, 2); if(little) swabip(buf+4, 2);
  memcpy(buf+6, &h->num_r_elements, 2); if(little) swabip(buf+6, 2);
  memcpy(buf+8, &h->num_angles, 2); if(little) swabip(buf+8, 2);
  memcpy(buf+10, &h->num_z_elements, 2); if(little) swabip(buf+10, 2);
  memcpy(buf+12, &h->ring_difference, 2); if(little) swabip(buf+12, 2);
  memcpy(buf+14, &h->x_resolution, 4); if(little) swawbip(buf+14, 4);
  memcpy(buf+18, &h->y_resolution, 4); if(little) swawbip(buf+18, 4);
  memcpy(buf+22, &h->z_resolution, 4); if(little) swawbip(buf+22, 4);
  memcpy(buf+26, &h->w_resolution, 4); if(little) swawbip(buf+26, 4);
  memcpy(buf+30, &h->scale_factor, 4); if(little) swawbip(buf+30, 4);
  memcpy(buf+34, &h->x_offset, 4); if(little) swawbip(buf+34, 4);
  memcpy(buf+38, &h->y_offset, 4); if(little) swawbip(buf+38, 4);
  memcpy(buf+42, &h->x_radius, 4); if(little) swawbip(buf+42, 4);
  memcpy(buf+46, &h->y_radius, 4); if(little) swawbip(buf+46, 4);
  memcpy(buf+50, &h->tilt_angle, 4); if(little) swawbip(buf+50, 4);
  memcpy(buf+54, &h->attenuation_coeff, 4); if(little) swawbip(buf+54, 4);
  memcpy(buf+58, &h->attenuation_min, 4); if(little) swawbip(buf+58, 4);
  memcpy(buf+62, &h->attenuation_max, 4); if(little) swawbip(buf+62, 4);
  memcpy(buf+66, &h->skull_thickness, 4); if(little) swawbip(buf+66, 4);
  memcpy(buf+70, &h->num_additional_atten_coeff, 2); if(little) swabip(buf+70, 2);
  memcpy(buf+72, h->additional_atten_coeff, 8*4); if(little) swawbip(buf+72, 8*4);
  memcpy(buf+104, &h->edge_finding_threshold, 4); if(little) swawbip(buf+104, 4);
  memcpy(buf+108, &h->storage_order, 2); if(little) swabip(buf+108, 2);
  memcpy(buf+110, &h->span, 2); if(little) swabip(buf+110, 2);
  memcpy(buf+112, h->z_elements, 64*2); if(little) swabip(buf+112, 64*2);
  memcpy(buf+240, h->fill_cti, 86*2); if(little) swabip(buf+240, 86*2);
  memcpy(buf+412, h->fill_user, 50*2); if(little) swabip(buf+412, 50*2);
 
  /* Write header */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(4);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(5);
 
  return(0);
}

◆ ecat7WriteHeaders()

int ecat7WriteHeaders	(	const char *	fname,
		ECAT_HEADERS *	ehdr,
		int	verbose )

extern

Write ECAT7 header contents (both main header and subheaders).

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fname	Image or sinogram filename
ehdr	Pointer to filled headers structure
verbose	Verbose level

Definition at line 755 of file ecat7ift.c.

  {
  ECAT7_mainheader main_header;
  ECAT7_MATRIXLIST mlist;
  FILE *fp;
  int ret, mi;
 
 
  if(verbose>0) printf("ecat7WriteHeaders(%s, ehdr)\n", fname);
  /* Check the arguments */
  if(ehdr==NULL) return STATUS_FAULT;
  if(fname==NULL) return STATUS_FAULT;
 
  /* Open the file */
  if((fp=fopen(fname, "r+b")) == NULL) return STATUS_NOFILE;
 
  /* Read main header */
  ret=ecat7ReadMainheader(fp, &main_header);
  if(ret) {fclose(fp); return STATUS_NOMAINHEADER;}
  /* Check for magic number */
  if(strncmp(main_header.magic_number, ECAT7V_MAGICNR, 7)!=0) {fclose(fp); return STATUS_UNKNOWNFORMAT;}
  /* Copy IFT contents into main header */
  //iftWrite(&ehdr->mh, "stdout");
  ret=ecat7MainheaderFromIFT(&main_header, &ehdr->mh, verbose);
  if(ret!=STATUS_OK) {fclose(fp); return ret;}
  //if(HEADER_TEST>5) iftWrite(&ehdr->mh, "stdout");
  /* Write mainheader */
  ret=ecat7WriteMainheader(fp, &main_header);
  if(ret!=0) {fclose(fp); return STATUS_CANNOTWRITE;}
  /* Read matrix list */
  ecat7InitMatlist(&mlist);
  ret=ecat7ReadMatlist(fp, &mlist, verbose-1);
  if(ret || mlist.matrixNr<1 || ecat7CheckMatlist(&mlist)) {fclose(fp); return STATUS_INVALIDMATLIST;}
#if(0)
  /* Allocate space for each matrix */
  ret=ehdrAllocate(ehdr, mlist.matrixNr);
  if(ret!=STATUS_OK) {fclose(fp); ecat7EmptyMatlist(&mlist); return ret;}
#endif
  /* Edit one subheader at a time */
  for(mi=0; mi<mlist.matrixNr; mi++) {
    ehdr->m[mi].mnum=mlist.matdir[mi].id;
    ecat7_id_to_val(mlist.matdir[mi].id, &ehdr->m[mi].matval);
    if(verbose>2) {
        printf("frame := %d\n", ehdr->m[mi].matval.frame);
        printf("plane := %d\n", ehdr->m[mi].matval.plane);
        printf("gate := %d\n", ehdr->m[mi].matval.gate);
        printf("data := %d\n", ehdr->m[mi].matval.data);
        printf("bed := %d\n", ehdr->m[mi].matval.bed);
    }
    ret=ecat7WriteSubheaderFromIFT(fp, &main_header, mlist.matdir[mi].strtblk, 
      &ehdr->m[mi].sh, verbose);
    if(ret!=STATUS_OK) {fclose(fp); ecat7EmptyMatlist(&mlist); return ret;}
    //iftWrite(&ehdr->m[mi].sh, "stdout");
  } // next matrix
  fclose(fp); ecat7EmptyMatlist(&mlist);
 
  return STATUS_OK;
}

Referenced by ecat7CopyHeadersNoQuant().

◆ ecat7WriteImageheader()

int ecat7WriteImageheader	(	FILE *	fp,
		int	blk,
		ECAT7_imageheader *	h )

extern

Write ECAT 7.x image header. Changes data type to big endian.

Parameters

fp	output file pointer
blk	header block number, blk >= 2
h	Ecat7 image header

Returns: 0 in case of success, 1 == invalid parameters, 4 == file pointer is at wrong position, 5 == writing of MatBLKSIZE bytes was not success

Definition at line 113 of file ecat7w.c.

                                                                   {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7WriteImageheader(%d)\n", blk);
  if(fp==NULL || blk<2 || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  if(h->data_type==ECAT7_VAXI2) h->data_type=ECAT7_SUNI2;
  else if(h->data_type==ECAT7_VAXI4) h->data_type=ECAT7_SUNI4;
  else if(h->data_type==ECAT7_VAXR4) h->data_type=ECAT7_IEEER4;
 
  /* Copy the header fields and swap if necessary */
  memcpy(buf+0, &h->data_type, 2); if(little) swabip(buf+0, 2);
  memcpy(buf+2, &h->num_dimensions, 2); if(little) swabip(buf+2, 2);
  memcpy(buf+4, &h->x_dimension, 2); if(little) swabip(buf+4, 2);
  memcpy(buf+6, &h->y_dimension, 2); if(little) swabip(buf+6, 2);
  memcpy(buf+8, &h->z_dimension, 2); if(little) swabip(buf+8, 2);
  memcpy(buf+10, &h->x_offset, 4); if(little) swawbip(buf+10, 4);
  memcpy(buf+14, &h->y_offset, 4); if(little) swawbip(buf+14, 4);
  memcpy(buf+18, &h->z_offset, 4); if(little) swawbip(buf+18, 4);
  memcpy(buf+22, &h->recon_zoom, 4); if(little) swawbip(buf+22, 4);
  memcpy(buf+26, &h->scale_factor, 4); if(little) swawbip(buf+26, 4);
  memcpy(buf+30, &h->image_min, 2); if(little) swabip(buf+30, 2);
  memcpy(buf+32, &h->image_max, 2); if(little) swabip(buf+32, 2);
  memcpy(buf+34, &h->x_pixel_size, 4); if(little) swawbip(buf+34, 4);
  memcpy(buf+38, &h->y_pixel_size, 4); if(little) swawbip(buf+38, 4);
  memcpy(buf+42, &h->z_pixel_size, 4); if(little) swawbip(buf+42, 4);
  memcpy(buf+46, &h->frame_duration, 4); if(little) swawbip(buf+46, 4);
  memcpy(buf+50, &h->frame_start_time, 4); if(little) swawbip(buf+50, 4);
  memcpy(buf+54, &h->filter_code, 2); if(little) swabip(buf+54, 2);
  memcpy(buf+56, &h->x_resolution, 4); if(little) swawbip(buf+56, 4);
  memcpy(buf+60, &h->y_resolution, 4); if(little) swawbip(buf+60, 4);
  memcpy(buf+64, &h->z_resolution, 4); if(little) swawbip(buf+64, 4);
  memcpy(buf+68, &h->num_r_elements, 4); if(little) swawbip(buf+68, 4);
  memcpy(buf+72, &h->num_angles, 4); if(little) swawbip(buf+72, 4);
  memcpy(buf+76, &h->z_rotation_angle, 4); if(little) swawbip(buf+76, 4);
  memcpy(buf+80, &h->decay_corr_fctr, 4); if(little) swawbip(buf+80, 4);
  memcpy(buf+84, &h->processing_code, 4); if(little) swawbip(buf+84, 4);
  memcpy(buf+88, &h->gate_duration, 4); if(little) swawbip(buf+88, 4);
  memcpy(buf+92, &h->r_wave_offset, 4); if(little) swawbip(buf+92, 4);
  memcpy(buf+96, &h->num_accepted_beats, 4); if(little) swawbip(buf+96, 4);
  memcpy(buf+100, &h->filter_cutoff_frequency, 4); if(little) swawbip(buf+100, 4);
  memcpy(buf+104, &h->filter_resolution, 4); if(little) swawbip(buf+104, 4);
  memcpy(buf+108, &h->filter_ramp_slope, 4); if(little) swawbip(buf+108, 4);
  memcpy(buf+112, &h->filter_order, 2); if(little) swabip(buf+112, 2);
  memcpy(buf+114, &h->filter_scatter_fraction, 4); if(little) swawbip(buf+114, 4);
  memcpy(buf+118, &h->filter_scatter_slope, 4); if(little) swawbip(buf+118, 4);
  memcpy(buf+122, &h->annotation, 40);
  memcpy(buf+162, &h->mt_1_1, 4); if(little) swawbip(buf+162, 4);
  memcpy(buf+166, &h->mt_1_2, 4); if(little) swawbip(buf+166, 4);
  memcpy(buf+170, &h->mt_1_3, 4); if(little) swawbip(buf+170, 4);
  memcpy(buf+174, &h->mt_2_1, 4); if(little) swawbip(buf+174, 4);
  memcpy(buf+178, &h->mt_2_2, 4); if(little) swawbip(buf+178, 4);
  memcpy(buf+182, &h->mt_2_3, 4); if(little) swawbip(buf+182, 4);
  memcpy(buf+186, &h->mt_3_1, 4); if(little) swawbip(buf+186, 4);
  memcpy(buf+190, &h->mt_3_2, 4); if(little) swawbip(buf+190, 4);
  memcpy(buf+194, &h->mt_3_3, 4); if(little) swawbip(buf+194, 4);
  memcpy(buf+198, &h->rfilter_cutoff, 4); if(little) swawbip(buf+198, 4);
  memcpy(buf+202, &h->rfilter_resolution, 4); if(little) swawbip(buf+202, 4);
  memcpy(buf+206, &h->rfilter_code, 2); if(little) swabip(buf+206, 2);
  memcpy(buf+208, &h->rfilter_order, 2); if(little) swabip(buf+208, 2);
  memcpy(buf+210, &h->zfilter_cutoff, 4); if(little) swawbip(buf+210, 4);
  memcpy(buf+214, &h->zfilter_resolution, 4); if(little) swawbip(buf+214, 4);
  memcpy(buf+218, &h->zfilter_code, 2); if(little) swabip(buf+218, 2);
  memcpy(buf+220, &h->zfilter_order, 2); if(little) swabip(buf+220, 2);
  memcpy(buf+222, &h->mt_1_4, 4); if(little) swawbip(buf+222, 4);
  memcpy(buf+226, &h->mt_2_4, 4); if(little) swawbip(buf+226, 4);
  memcpy(buf+230, &h->mt_3_4, 4); if(little) swawbip(buf+230, 4);
  memcpy(buf+234, &h->scatter_type, 2); if(little) swabip(buf+234, 2);
  memcpy(buf+236, &h->recon_type, 2); if(little) swabip(buf+236, 2);
  memcpy(buf+238, &h->recon_views, 2); if(little) swabip(buf+238, 2);
  memcpy(buf+240, &h->fill_cti, 87);
  memcpy(buf+414, &h->fill_user, 48);
 
  /* Write header */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(4);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(5);
 
  return(0);
}

Referenced by ecat7WriteImageMatrix(), and ecat7WriteSubheaderFromIFT().

◆ ecat7WriteImageMatrix()

int ecat7WriteImageMatrix	(	FILE *	fp,
		int	matrix_id,
		ECAT7_imageheader *	h,
		float *	fdata )

extern

Write ECAT 7.x image or volume matrix header and data

Parameters

fp	output file pointer
matrix_id	coded matrix id
h	Ecat7 image header
fdata	float data to be written

Returns: 0 if ok.

Definition at line 635 of file ecat7w.c.

                                                                                       {
  int ret;
  long long pxlNr, blkNr, nxtblk, data_size;
  float *fptr, fmin, fmax, g, f;
  char *mdata, *mptr;
  short int *sptr;
  
  
  if(ECAT7_TEST) printf("ecat7WriteImageMatrix(fp, %d, h, data)\n", matrix_id);
  if(fp==NULL || matrix_id<1 || h==NULL || fdata==NULL) {
    sprintf(ecat7errmsg, "invalid function parameter.\n");
    return(1);
  }
  if(h->data_type!=ECAT7_SUNI2) {
    sprintf(ecat7errmsg, "invalid data_type.\n");
    return(2);
  }
  /* nr of pixels */
  pxlNr=h->x_dimension*h->y_dimension;
  if(h->num_dimensions>2) pxlNr*=h->z_dimension;
  if(pxlNr<1) {
    sprintf(ecat7errmsg, "invalid matrix dimension.\n");
    return(3);
  }
 
  /* How much memory is needed for ALL pixels */
  data_size=pxlNr*ecat7pxlbytes(h->data_type);
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) {
    sprintf(ecat7errmsg, "invalid block number.\n");
    return(4);
  }
  /* Allocate memory for matrix data */
  mdata=(char*)calloc(blkNr, MatBLKSIZE); if(mdata==NULL) {
    sprintf(ecat7errmsg, "out of memory.\n");
    return(5);
  }
  /* Search for min and max for calculation of scale factor */
  fMinMaxFin(fdata, pxlNr, &fmin, &fmax);
  if(fabs(fmin)>fabs(fmax)) g=fabs(fmin); else g=fabs(fmax);
  if(g>0) f=32766./g; else f=1.0;
  /* Check if pixels values can be left as such with scale_factor = 1 */
  fptr=fdata;
  if(f>=1.0 && ecat7_is_scaling_needed(g, fptr, pxlNr)==0) f=1.0;
  /* Scale matrix data to shorts */
  h->scale_factor=1.0/f;
  sptr=(short int*)mdata; fptr=fdata;
  for(long long i=0; i<pxlNr; i++, sptr++, fptr++) *sptr=(short int)temp_roundf(f*(*fptr));
  /* Set header short min & max */
  h->image_min=(short int)temp_roundf(f*fmin);
  h->image_max=(short int)temp_roundf(f*fmax);
  /* Get block number for matrix header and data */
  nxtblk=ecat7EnterMatrix(fp, matrix_id, blkNr); if(nxtblk<1) {
    sprintf(ecat7errmsg, "cannot determine matrix block (%lld).\n", -nxtblk);
    free(mdata); return(8);
  }
  if(ECAT7_TEST>2) printf("  block=%lld fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
  /* Write header */
  ret=ecat7WriteImageheader(fp, nxtblk, h); if(ret) {
    sprintf(ecat7errmsg, "cannot write subheader (%d).\n", ret);
    free(mdata); return(10);
  }
  /* Write matrix data */
  mptr=mdata;
  ret=ecat7WriteMatrixdata(fp, nxtblk+1, mptr, pxlNr, ecat7pxlbytes(h->data_type));
  free(mdata);
  if(ret) {
    sprintf(ecat7errmsg, "cannot write matrix data (%d).\n", ret);
    return(13);
  }
  return(0);
}

Referenced by imgWrite2DEcat7(), imgWriteEcat7(), and imgWriteEcat7Frame().

◆ ecat7WriteMainheader()

int ecat7WriteMainheader	(	FILE *	fp,
		ECAT7_mainheader *	h )

extern

Write ECAT 7.x main header.

Writes header always in big endian byte order.

Returns: 0 in case of success, 1 == invalid parameters, 4 == file pointer is at wrong position, 5 == writing of MatBLKSIZE bytes was not success

Parameters

fp	output file pointer
h	Ecat7 main header

Definition at line 16 of file ecat7w.c.

  {
  unsigned char buf[MatBLKSIZE];
  int little;
 
  if(ECAT7_TEST) printf("ecat7WriteMainheader()\n");
  /* Check arguments */
  if(fp==NULL || h==NULL) return(1);
  little=little_endian();
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
 
  /* Copy header contents into buffer and change byte order if necessary */
  memcpy(buf+0, &h->magic_number, 14);
  memcpy(buf+14, &h->original_file_name, 32);
  memcpy(buf+46, &h->sw_version, 2); if(little) swabip(buf+46, 2);
  memcpy(buf+48, &h->system_type, 2); if(little) swabip(buf+48, 2);
  memcpy(buf+50, &h->file_type, 2); if(little) swabip(buf+50, 2);
  memcpy(buf+52, &h->serial_number, 10);
  //printf("ecat7WriteMainheader(): scan_start_time := %d\n", h->scan_start_time);
  memcpy(buf+62, &h->scan_start_time, 4); if(little) swawbip(buf+62, 4);
  memcpy(buf+66, &h->isotope_name, 8);
  memcpy(buf+74, &h->isotope_halflife, 4); if(little) swawbip(buf+74, 4);
  memcpy(buf+78, &h->radiopharmaceutical, 32);
  memcpy(buf+110, &h->gantry_tilt, 4); if(little) swawbip(buf+110, 4);
  memcpy(buf+114, &h->gantry_rotation, 4); if(little) swawbip(buf+114, 4);
  memcpy(buf+118, &h->bed_elevation, 4); if(little) swawbip(buf+118, 4);
  memcpy(buf+122, &h->intrinsic_tilt, 4); if(little) swawbip(buf+122, 4);
  memcpy(buf+126, &h->wobble_speed, 2); if(little) swabip(buf+126, 2);
  memcpy(buf+128, &h->transm_source_type, 2); if(little) swabip(buf+128, 2);
  memcpy(buf+130, &h->distance_scanned, 4); if(little) swawbip(buf+130, 4);
  memcpy(buf+134, &h->transaxial_fov, 4); if(little) swawbip(buf+134, 4);
  memcpy(buf+138, &h->angular_compression, 2); if(little) swabip(buf+138, 2);
  memcpy(buf+140, &h->coin_samp_mode, 2); if(little) swabip(buf+140, 2);
  memcpy(buf+142, &h->axial_samp_mode, 2); if(little) swabip(buf+142, 2);
  memcpy(buf+144, &h->ecat_calibration_factor, 4); if(little) swawbip(buf+144, 4);
  memcpy(buf+148, &h->calibration_units, 2); if(little) swabip(buf+148, 2);
  memcpy(buf+150, &h->calibration_units_label, 2); if(little) swabip(buf+150, 2);
  memcpy(buf+152, &h->compression_code, 2); if(little) swabip(buf+152, 2);
  memcpy(buf+154, &h->study_type, 12);
  memcpy(buf+166, &h->patient_id, 16);
  memcpy(buf+182, &h->patient_name, 32);
  memcpy(buf+214, &h->patient_sex, 1);
  memcpy(buf+215, &h->patient_dexterity, 1);
  memcpy(buf+216, &h->patient_age, 4); if(little) swawbip(buf+216, 4);
  memcpy(buf+220, &h->patient_height, 4); if(little) swawbip(buf+220, 4);
  memcpy(buf+224, &h->patient_weight, 4); if(little) swawbip(buf+224, 4);
  memcpy(buf+228, &h->patient_birth_date, 4); if(little) swawbip(buf+228, 4);
  memcpy(buf+232, &h->physician_name, 32);
  memcpy(buf+264, &h->operator_name, 32);
  memcpy(buf+296, &h->study_description, 32);
  memcpy(buf+328, &h->acquisition_type, 2); if(little) swabip(buf+328, 2);
  memcpy(buf+330, &h->patient_orientation, 2); if(little) swabip(buf+330, 2);
  memcpy(buf+332, &h->facility_name, 20);
  memcpy(buf+352, &h->num_planes, 2); if(little) swabip(buf+352, 2);
  memcpy(buf+354, &h->num_frames, 2); if(little) swabip(buf+354, 2);
  memcpy(buf+356, &h->num_gates, 2); if(little) swabip(buf+356, 2);
  memcpy(buf+358, &h->num_bed_pos, 2); if(little) swabip(buf+358, 2);
  memcpy(buf+360, &h->init_bed_position, 4); if(little) swawbip(buf+360, 4);
  memcpy(buf+364, h->bed_position, 15*4); if(little) swawbip(buf+364, 15*4);
  memcpy(buf+424, &h->plane_separation, 4); if(little) swawbip(buf+424, 4);
  memcpy(buf+428, &h->lwr_sctr_thres, 2); if(little) swabip(buf+428, 2);
  memcpy(buf+430, &h->lwr_true_thres, 2); if(little) swabip(buf+430, 2);
  memcpy(buf+432, &h->upr_true_thres, 2); if(little) swabip(buf+432, 2);
  memcpy(buf+434, &h->user_process_code, 10);
  memcpy(buf+444, &h->acquisition_mode, 2); if(little) swabip(buf+444, 2);
  memcpy(buf+446, &h->bin_size, 4); if(little) swawbip(buf+446, 4);
  memcpy(buf+450, &h->branching_fraction, 4); if(little) swawbip(buf+450, 4);
  memcpy(buf+454, &h->dose_start_time, 4); if(little) swawbip(buf+454, 4);
  memcpy(buf+458, &h->dosage, 4); if(little) swawbip(buf+458, 4);
  memcpy(buf+462, &h->well_counter_corr_factor, 4); if(little) swawbip(buf+462, 4);
  memcpy(buf+466, &h->data_units, 32);
  memcpy(buf+498, &h->septa_state, 2); if(little) swabip(buf+498, 2);
  memcpy(buf+500, &h->fill_cti, 12);
 
  /* Write main header */
  fseek(fp, 0*MatBLKSIZE, SEEK_SET); if(ftell(fp)!=0*MatBLKSIZE) return(4);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(5);
 
  return(0);
}

Referenced by ecat7Create(), ecat7WriteHeaders(), and imgWriteEcat7Frame().

◆ ecat7WriteMatrixdata()

int ecat7WriteMatrixdata	(	FILE *	fp,
		int	start_block,
		char *	data,
		long long	pxl_nr,
		int	pxl_size )

extern

Write ECAT 7.x matrix data to a specified file position. Data does not need to be allocated for full blocks. Data must be represented in current machines byte order, and it is always saved in big endian byte order.

Parameters

fp	Pointer to an opened ECAT file
start_block	Block number where matrix data is written
data	Pointer to matrix data
pxl_nr	Number of pixels
pxl_size	Size of data for one pixel in bytes

Returns: >0 in case of an error.

Definition at line 974 of file ecat7w.c.

                                                                                                {
  unsigned char buf[MatBLKSIZE];
  char *dptr;
  int little;
  long long i, dataSize, byteNr, blkNr;
 
  if(ECAT7_TEST) printf("ecat7WriteMatrixdata(fp, %d, data, %lld, %d)\n",
                        start_block, pxl_nr, pxl_size);
  if(fp==NULL || start_block<1 || data==NULL || pxl_nr<1 || pxl_size<1) return(1);
  little=little_endian(); memset(buf, 0, MatBLKSIZE);
  dataSize=pxl_nr*pxl_size;
  /* block nr taken by all pixels */
  blkNr=(dataSize+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) return(1);
  if(ECAT7_TEST>2) printf("    blkNr=%lld\n", blkNr);
  /* Search the place for writing */
  long long pos=(start_block-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(2);
  /* Save blocks one at a time */
  for(i=0, dptr=data; i<blkNr && dataSize>0; i++) {
    byteNr=(dataSize<MatBLKSIZE)?dataSize:MatBLKSIZE;
    memcpy(buf, dptr, byteNr);
    /* Change matrix byte order in little endian platforms */
    if(little) {
      if(pxl_size==2) swabip(buf, byteNr);
      else if(pxl_size==4) swawbip(buf, byteNr);
    }
    /* Write block */
    if(fwrite(buf, 1, MatBLKSIZE, fp)!=MatBLKSIZE) return(3);
    /* Prepare for the next block */
    dptr+=byteNr; dataSize-=byteNr;
  } /* next block */
  return(0);
}

Referenced by ecat7Write2DScanMatrix(), ecat7WriteImageMatrix(), ecat7WritePolarmapMatrix(), and ecat7WriteScanMatrix().

◆ ecat7WriteNormheader()

int ecat7WriteNormheader	(	FILE *	fp,
		int	blk,
		ECAT7_normheader *	h )

extern

Write ECAT 7.x 3D normalization header

Parameters

fp	output file pointer
blk	header block number, blk >= 2
h	Ecat7 normalization header

Returns: 0 in case of success, 1 == invalid parameters, 4 == file pointer is at wrong position, 5 == writing of MatBLKSIZE bytes was not success

Definition at line 330 of file ecat7w.c.

                                                                 {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7WriteNormheader()\n");
  if(fp==NULL || blk<2 || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  if(h->data_type==ECAT7_VAXI2) h->data_type=ECAT7_SUNI2;
  else if(h->data_type==ECAT7_VAXI4) h->data_type=ECAT7_SUNI4;
  else if(h->data_type==ECAT7_VAXR4) h->data_type=ECAT7_IEEER4;
  
  /* Copy the header fields and swap if necessary */
  memcpy(buf+0, &h->data_type, 2); if(little) swabip(buf+0, 2);
  memcpy(buf+2, &h->num_r_elements, 2); if(little) swabip(buf+2, 2);
  memcpy(buf+4, &h->num_transaxial_crystals, 2); if(little) swabip(buf+4, 2);
  memcpy(buf+6, &h->num_crystal_rings, 2); if(little) swabip(buf+6, 2);
  memcpy(buf+8, &h->crystals_per_ring, 2); if(little) swabip(buf+8, 2);
  memcpy(buf+10, &h->num_geo_corr_planes, 2); if(little) swabip(buf+10, 2);
  memcpy(buf+12, &h->uld, 2); if(little) swabip(buf+12, 2);
  memcpy(buf+14, &h->lld, 2); if(little) swabip(buf+14, 2);
  memcpy(buf+16, &h->scatter_energy, 2); if(little) swabip(buf+16, 2);
  memcpy(buf+18, &h->norm_quality_factor, 4); if(little) swawbip(buf+18, 4);
  memcpy(buf+22, &h->norm_quality_factor_code, 2); if(little) swabip(buf+22, 2);
  memcpy(buf+24, h->ring_dtcor1, 32*4); if(little) swawbip(buf+24, 32*4);
  memcpy(buf+152, h->ring_dtcor2, 32*4); if(little) swawbip(buf+152, 32*4);
  memcpy(buf+280, h->crystal_dtcor, 8*4); if(little) swawbip(buf+280, 8*4);
  memcpy(buf+312, &h->span, 2); if(little) swabip(buf+312, 2);
  memcpy(buf+314, &h->max_ring_diff, 2); if(little) swabip(buf+314, 2);
  memcpy(buf+316, h->fill_cti, 48*2); if(little) swabip(buf+316, 48*2);
  memcpy(buf+412, h->fill_user, 50*2); if(little) swabip(buf+412, 50*2);
 
  /* Write header */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(4);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(5);
 
  return(0);
}

◆ ecat7WritePolarmapMatrix()

int ecat7WritePolarmapMatrix	(	FILE *	fp,
		int	matrix_id,
		ECAT7_polmapheader *	h,
		float *	fdata )

extern

Write ECAT 7.x polarmap matrix header and data

Parameters

fp	output file pointer
matrix_id	coded matrix information
h	Ecat7 polar map header
fdata	float data

Returns: 0 if ok.

Definition at line 888 of file ecat7w.c.

                                                                                           {
  int ret;
  long long i, nxtblk, blkNr, data_size, pxlNr;
  float *fptr, fmin, fmax, g, f;
  char *mdata, *mptr;
  short int *sptr;
  
  
  if(ECAT7_TEST) printf("ecat7WritePolarmapMatrix(fp, %d, h, data)\n", matrix_id);
  if(fp==NULL || matrix_id<1 || h==NULL || fdata==NULL) {
    sprintf(ecat7errmsg, "invalid function parameter.\n");
    return(1);
  }
  if(h->data_type!=ECAT7_SUNI2) {
    sprintf(ecat7errmsg, "invalid data_type.\n");
    return(2);
  }
  /* nr of pixels */
  for(i=pxlNr=0; i<h->num_rings; i++) pxlNr+=h->sectors_per_ring[i];
  if(pxlNr<1) {
    sprintf(ecat7errmsg, "invalid matrix dimension.\n");
    return(3);
  }
  /* How much memory is needed for ALL pixels */
  data_size=pxlNr*ecat7pxlbytes(h->data_type);
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) {
    sprintf(ecat7errmsg, "invalid block number.\n");
    return(4);
  }
  /* Allocate memory for matrix data */
  mdata=(char*)calloc(blkNr, MatBLKSIZE); if(mdata==NULL) {
    sprintf(ecat7errmsg, "out of memory.\n");
    return(5);
  }
  /* Search for min and max for calculation of scale factor */
  fMinMaxFin(fdata, pxlNr, &fmin, &fmax);
  if(fabs(fmin)>fabs(fmax)) g=fabs(fmin); else g=fabs(fmax);
  if(g>0) f=32766./g; else f=1.0;
  /* Check if pixels values can be left as such with scale_factor = 1 */
  fptr=fdata;
  if(f>=1.0 && ecat7_is_scaling_needed(g, fptr, pxlNr)==0) f=1.0;
  /* Scale matrix data to shorts */
  h->scale_factor=1.0/f;
  sptr=(short int*)mdata; fptr=fdata;
  for(i=0; i<pxlNr; i++, sptr++, fptr++) *sptr=(short int)temp_roundf(f*(*fptr));
  /* Set header short min & max */
  h->image_min=(short int)temp_roundf(f*fmin);
  h->image_max=(short int)temp_roundf(f*fmax);
  /* Get block number for matrix header and data */
  nxtblk=ecat7EnterMatrix(fp, matrix_id, blkNr); if(nxtblk<1) {
    sprintf(ecat7errmsg, "cannot determine matrix block (%lld).\n", -nxtblk);
    free(mdata); return(8);
  }
  if(ECAT7_TEST>2) printf("  block=%lld fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
  /* Write header */
  ret=ecat7WritePolmapheader(fp, nxtblk, h); if(ret) {
    sprintf(ecat7errmsg, "cannot write subheader (%d).\n", ret);
    free(mdata); return(10);
  }
  /* Write matrix data */
  mptr=mdata;
  ret=ecat7WriteMatrixdata(fp, nxtblk+1, mptr, pxlNr, ecat7pxlbytes(h->data_type));
  free(mdata);
  if(ret) {
    sprintf(ecat7errmsg, "cannot write matrix data (%d).\n", ret);
    return(13);
  }
  return(0);
}

Referenced by imgWriteEcat7Frame(), and imgWritePolarmap().

◆ ecat7WritePolmapheader()

int ecat7WritePolmapheader	(	FILE *	fp,
		int	blk,
		ECAT7_polmapheader *	h )

extern

Write ECAT 7.x polar map header

Parameters

fp	output file pointer
blk	header block number, blk >= 2
h	Ecat7 polar map header

Returns: 0 in case of success, 1 == invalid parameters, 4 == file pointer is at wrong position, 5 == writing of MatBLKSIZE bytes was not success

Definition at line 271 of file ecat7w.c.

                                                                     {
  unsigned char buf[MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7WritePolmapheader()\n");
  if(fp==NULL || blk<2 || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
  /* Clear buf */
  memset(buf, 0, MatBLKSIZE);
  if(h->data_type==ECAT7_VAXI2) h->data_type=ECAT7_SUNI2;
  else if(h->data_type==ECAT7_VAXI4) h->data_type=ECAT7_SUNI4;
  else if(h->data_type==ECAT7_VAXR4) h->data_type=ECAT7_IEEER4;
  
  /* Copy the header fields and swap if necessary */
  memcpy(buf+0, &h->data_type, 2); if(little) swabip(buf+0, 2);
  memcpy(buf+2, &h->polar_map_type, 2); if(little) swabip(buf+2, 2);
  memcpy(buf+4, &h->num_rings, 2); if(little) swabip(buf+4, 2);
  memcpy(buf+6, h->sectors_per_ring, 32*2); if(little) swabip(buf+6, 32*2);
  memcpy(buf+70, h->ring_position, 32*4); if(little) swawbip(buf+70, 32*4);
  memcpy(buf+198, h->ring_angle, 32*2); if(little) swabip(buf+198, 32*2);
  memcpy(buf+262, &h->start_angle, 2); if(little) swabip(buf+262, 2);
  memcpy(buf+264, h->long_axis_left, 3*2); if(little) swabip(buf+264, 3*2);
  memcpy(buf+270, h->long_axis_right, 3*2); if(little) swabip(buf+270, 3*2);
  memcpy(buf+276, &h->position_data, 2); if(little) swabip(buf+276, 2);
  memcpy(buf+278, &h->image_min, 2); if(little) swabip(buf+278, 2);
  memcpy(buf+280, &h->image_max, 2); if(little) swabip(buf+280, 2);
  memcpy(buf+282, &h->scale_factor, 4); if(little) swawbip(buf+282, 4);
  memcpy(buf+286, &h->pixel_size, 4); if(little) swawbip(buf+286, 4);
  memcpy(buf+290, &h->frame_duration, 4); if(little) swawbip(buf+290, 4);
  memcpy(buf+294, &h->frame_start_time, 4); if(little) swawbip(buf+294, 4);
  memcpy(buf+298, &h->processing_code, 2); if(little) swabip(buf+298, 2);
  memcpy(buf+300, &h->quant_units, 2); if(little) swabip(buf+300, 2);
  memcpy(buf+302, h->annotation, 40);
  memcpy(buf+342, &h->gate_duration, 4); if(little) swawbip(buf+342, 4);
  memcpy(buf+346, &h->r_wave_offset, 4); if(little) swawbip(buf+346, 4);
  memcpy(buf+350, &h->num_accepted_beats, 4); if(little) swawbip(buf+350, 4);
  memcpy(buf+354, h->polar_map_protocol, 20);
  memcpy(buf+374, h->database_name, 30);
  memcpy(buf+404, h->fill_cti, 27*2); if(little) swabip(buf+404, 27*2);
 
  /* Write header */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(4);
  if(fwrite(buf, 1, 1*MatBLKSIZE, fp) != 1*MatBLKSIZE) return(5);
 
  return(0);
}

Referenced by ecat7WritePolarmapMatrix().

◆ ecat7WriteScanheader()

int ecat7WriteScanheader	(	FILE *	fp,
		int	blk,
		ECAT7_scanheader *	h )

extern

Write ECAT 7.x 3D scan header (512 bytes) Changes data type to big endian.

Parameters

fp	pointer to output file
blk	block number, blk >= 2
h	Ecat7 scan header

Returns: 0 in case of success, 1 == invalid parameters, 4 == file pointer is at wrong position, 5 == writing of MatBLKSIZE bytes was not success

Definition at line 383 of file ecat7w.c.

                                                                 {
  unsigned char buf[2*MatBLKSIZE];
  int little; /* 1 if current platform is little endian (i386), else 0 */
 
  if(ECAT7_TEST) printf("ecat7WriteScanheader()\n");
  if(fp==NULL || blk<2 || h==NULL) return(1);
  little=little_endian(); if(ECAT7_TEST) printf("little=%d\n", little);
  /* Clear buf */
  memset(buf, 0, 2*MatBLKSIZE);
  if(h->data_type==ECAT7_VAXI2) h->data_type=ECAT7_SUNI2;
  else if(h->data_type==ECAT7_VAXI4) h->data_type=ECAT7_SUNI4;
  else if(h->data_type==ECAT7_VAXR4) h->data_type=ECAT7_IEEER4;
 
  /* Copy the header fields and swap if necessary */
  memcpy(buf+0, &h->data_type, 2); if(little) swabip(buf+0, 2);
  memcpy(buf+2, &h->num_dimensions, 2); if(little) swabip(buf+2, 2);
  memcpy(buf+4, &h->num_r_elements, 2); if(little) swabip(buf+4, 2);
  memcpy(buf+6, &h->num_angles, 2); if(little) swabip(buf+6, 2);
  memcpy(buf+8, &h->corrections_applied, 2); if(little) swabip(buf+8, 2);
  memcpy(buf+10, h->num_z_elements, 64*2); if(little) swabip(buf+10, 64*2);
  memcpy(buf+138, &h->ring_difference, 2); if(little) swabip(buf+138, 2);
  memcpy(buf+140, &h->storage_order, 2); if(little) swabip(buf+140, 2);
  memcpy(buf+142, &h->axial_compression, 2); if(little) swabip(buf+142, 2);
  memcpy(buf+144, &h->x_resolution, 4); if(little) swawbip(buf+144, 4);
  memcpy(buf+148, &h->v_resolution, 4); if(little) swawbip(buf+148, 4);
  memcpy(buf+152, &h->z_resolution, 4); if(little) swawbip(buf+152, 4);
  memcpy(buf+156, &h->w_resolution, 4); if(little) swawbip(buf+156, 4);
  memcpy(buf+160, h->fill_gate, 6*2); if(little) swabip(buf+160, 6*2);
  memcpy(buf+172, &h->gate_duration, 4); if(little) swawbip(buf+172, 4);
  memcpy(buf+176, &h->r_wave_offset, 4); if(little) swawbip(buf+176, 4);
  memcpy(buf+180, &h->num_accepted_beats, 4); if(little) swawbip(buf+180, 4);
  memcpy(buf+184, &h->scale_factor, 4); if(little) swawbip(buf+184, 4);
  memcpy(buf+188, &h->scan_min, 2); if(little) swabip(buf+188, 2);
  memcpy(buf+190, &h->scan_max, 2); if(little) swabip(buf+190, 2);
  memcpy(buf+192, &h->prompts, 4); if(little) swawbip(buf+192, 4);
  memcpy(buf+196, &h->delayed, 4); if(little) swawbip(buf+196, 4);
  memcpy(buf+200, &h->multiples, 4); if(little) swawbip(buf+200, 4);
  memcpy(buf+204, &h->net_trues, 4); if(little) swawbip(buf+204, 4);
  memcpy(buf+208, &h->tot_avg_cor, 4); if(little) swawbip(buf+208, 4);
  memcpy(buf+212, &h->tot_avg_uncor, 4); if(little) swawbip(buf+212, 4);
  memcpy(buf+216, &h->total_coin_rate, 4); if(little) swawbip(buf+216, 4);
  memcpy(buf+220, &h->frame_start_time, 4); if(little) swawbip(buf+220, 4);
  memcpy(buf+224, &h->frame_duration, 4); if(little) swawbip(buf+224, 4);
  memcpy(buf+228, &h->deadtime_correction_factor, 4); if(little) swawbip(buf+228, 4);
  memcpy(buf+232, h->fill_cti, 90*2); if(little) swabip(buf+232, 90*2);
  memcpy(buf+412, h->fill_user, 50*2); if(little) swabip(buf+412, 50*2);
  memcpy(buf+512, h->uncor_singles, 128*4); if(little) swawbip(buf+512, 128*4);
 
  /* Write 3D scan header */
  long long pos=(blk-1)*(long long)MatBLKSIZE;
  fseeko(fp, pos, SEEK_SET); if(ftello(fp)!=pos) return(4);
  if(fwrite(buf, 1, 2*MatBLKSIZE, fp) != 2*MatBLKSIZE) return(5);
 
  return(0);
}

Referenced by ecat7ReadSubheaderToIFT(), ecat7WriteScanMatrix(), and ecat7WriteSubheaderFromIFT().

◆ ecat7WriteScanMatrix()

int ecat7WriteScanMatrix	(	FILE *	fp,
		int	matrix_id,
		ECAT7_scanheader *	h,
		float *	fdata )

extern

Write ECAT 7.x 3D sinogram matrix header and data

Parameters

fp	output file pointer
matrix_id	coded matrix id
h	Ecat7 scan header
fdata	float data

Returns: 0 if ok.

Definition at line 802 of file ecat7w.c.

                                                                                     {
  int ret;
  long long i, nxtblk, blkNr, data_size, pxlNr, dimz;
  float *fptr, fmin, fmax, g, f;
  char *mdata, *mptr;
  short int *sptr;
 
 
  if(ECAT7_TEST) printf("ecat7WriteScanMatrix(fp, %d, h, data)\n", matrix_id);
  if(fp==NULL || matrix_id<1 || h==NULL || fdata==NULL) {
    sprintf(ecat7errmsg, "invalid function parameter.\n");
    return(1);
  }
  if(h->data_type!=ECAT7_SUNI2) {
    sprintf(ecat7errmsg, "invalid data_type.\n");
    return(2);
  }
  /* nr of pixels */
  pxlNr=h->num_r_elements*h->num_angles;
  for(i=dimz=0; i<64; i++) dimz+=h->num_z_elements[i];
  pxlNr*=dimz;
  if(pxlNr<1) {
    sprintf(ecat7errmsg, "invalid matrix dimension.\n");
    return(3);
  }
  /* How much memory is needed for ALL pixels */
  data_size=pxlNr*ecat7pxlbytes(h->data_type);
  /* block nr taken by all pixels */
  blkNr=(data_size+MatBLKSIZE-1)/MatBLKSIZE; if(blkNr<1) {
    sprintf(ecat7errmsg, "invalid block number.\n");
    return(4);
  }
  /* Allocate memory for matrix data */
  mdata=(char*)calloc(blkNr, MatBLKSIZE); if(mdata==NULL) {
    sprintf(ecat7errmsg, "out of memory.\n");
    return(5);
  }
  /* Search for min and max for calculation of scale factor */
  fMinMaxFin(fdata, pxlNr, &fmin, &fmax);
  if(fabs(fmin)>fabs(fmax)) g=fabs(fmin); else g=fabs(fmax);
  if(g>0) f=32766./g; else f=1.0;
  /* Check if pixels values can be left as such with scale_factor = 1 */
  fptr=fdata;
  if(f>=1.0 && ecat7_is_scaling_needed(g, fptr, pxlNr)==0) f=1.0;
  /* Scale matrix data to shorts */
  h->scale_factor=1.0/f;
  sptr=(short int*)mdata; fptr=fdata;
  for(i=0; i<pxlNr; i++, sptr++, fptr++) *sptr=(short int)temp_roundf(f*(*fptr));
  /* Set header short min & max */
  h->scan_min=(short int)temp_roundf(f*fmin);
  h->scan_max=(short int)temp_roundf(f*fmax);
  /* Get block number for matrix header and data */
  /* Note that one extra block (blkNr+1) is needed for 3D scan header */
  nxtblk=ecat7EnterMatrix(fp, matrix_id, blkNr+1); if(nxtblk<1) {
    sprintf(ecat7errmsg, "cannot determine matrix block (%lld).\n", -nxtblk);
    free(mdata); return(8);
  }
  if(ECAT7_TEST>2) printf("  block=%lld fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
  /* Write header */
  ret=ecat7WriteScanheader(fp, nxtblk, h); if(ret) {
    sprintf(ecat7errmsg, "cannot write subheader (%d).\n", ret);
    free(mdata); return(10);
  }
  /* Write matrix data */
  /* Note that 3D scan header takes TWO blocks */
  mptr=mdata;
  ret=ecat7WriteMatrixdata(fp, nxtblk+2, mptr, pxlNr, ecat7pxlbytes(h->data_type));
  free(mdata);
  if(ret) {
    sprintf(ecat7errmsg, "cannot write matrix data (%d).\n", ret);
    return(13);
  }
  return(0);
}

Referenced by imgWriteEcat7(), and imgWriteEcat7Frame().

◆ ecat7WriteSubheaderFromIFT()

int ecat7WriteSubheaderFromIFT	(	FILE *	fp,
		ECAT7_mainheader *	h,
		int	strtblk,
		IFT *	ift,
		int	verbose )

extern

Write ECAT 7 subheader from IFT struct into ECAT 7 file.

Returns: Returns STATUS_OK when succesful.

Parameters

fp	File pointer to opened ECAT7 file
h	ECAT7 mainheader
strtblk	Subheader location
ift	Header data
verbose	Verbose level

Definition at line 583 of file ecat7ift.c.

  {
  ECAT7_imageheader       image_header;
  ECAT7_scanheader        scan_header;
  ECAT7_2Dscanheader      scan2D_header;
  ECAT7_2Dnormheader      norm2D_header;
  ECAT7_normheader        norm_header;
  ECAT7_attenheader       atten_header;
  ECAT7_polmapheader      polmap_header;
  int ii, ret;
 
  if(verbose>0) printf("ecat7WriteSubheaderFromIFT(fp, mh, %d, ift)\n", strtblk);
  /* Check input */
  if(fp==NULL || h==NULL || strtblk<3 || ift==NULL) return STATUS_FAULT;
 
  /* Read subheader, set its contents from IFT, write subheader back */
  switch(h->file_type) {
    case ECAT7_ATTEN:
      ret=ecat7ReadAttenheader(fp, strtblk, &atten_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    case ECAT7_3DNORM:
      ret=ecat7ReadNormheader(fp, strtblk, &norm_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    case ECAT7_IMAGE8:
    case ECAT7_IMAGE16:
    case ECAT7_VOLUME8:
    case ECAT7_VOLUME16:
/*
      ret=ecat7ImageheaderToIFT(&image_header, ift); if(ret!=STATUS_OK) return ret;
*/
      ret=ecat7ReadImageheader(fp, strtblk, &image_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      for(ii=ret=0; ii<ift->keyNr; ii++) {
        if(verbose>7) 
          printf("  key := %s\n  value := %s\n", 
                 ift->item[ii].key, ift->item[ii].value);
        ret=ecat7EditVHeader(&image_header, ift->item[ii].key, ift->item[ii].value, verbose-2);
        if(ret!=0) {
          if(verbose>0) fprintf(stderr, "Error with key '%s'\n", ift->item[ii].key);
          break;
        }
      } 
      if(ret!=0) return STATUS_FAULT;
      ret=ecat7WriteImageheader(fp, strtblk, &image_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      break;
    case ECAT7_3DSCAN:
    case ECAT7_3DSCAN8:
    case ECAT7_3DSCANFIT:
      ret=ecat7ReadScanheader(fp, strtblk, &scan_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      for(ii=ret=0; ii<ift->keyNr; ii++) {
        if(verbose>7) printf("  key := %s\n  value := %s\n", ift->item[ii].key, ift->item[ii].value);
        ret=ecat7EditSHeader(&scan_header, ift->item[ii].key, ift->item[ii].value, verbose-2);
        if(ret!=0) {
          if(verbose>0) fprintf(stderr, "Error with key '%s'\n", ift->item[ii].key);
          break;
        }
      } 
      if(ret!=0) return STATUS_FAULT;
      ret=ecat7WriteScanheader(fp, strtblk, &scan_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      break;
    case ECAT7_POLARMAP:
      ret=ecat7ReadPolmapheader(fp, strtblk, &polmap_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    case ECAT7_2DSCAN:
      ret=ecat7Read2DScanheader(fp, strtblk, &scan2D_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    case ECAT7_2DNORM:
      ret=ecat7Read2DNormheader(fp, strtblk, &norm2D_header);
      if(ret!=0) return STATUS_NOSUBHEADER;
      return STATUS_UNSUPPORTED;
      break;
    default:
      return STATUS_UNSUPPORTED;
  }
  return STATUS_OK;
}

Referenced by ecat7WriteHeaders().

◆ ehdrAllocate()

int ehdrAllocate	(	ECAT_HEADERS *	ehdr,
		int	nr )

extern

Removes previous matrix contents but preserves the main header.

Returns: Returns STATUS_OK when succesful.

Parameters

ehdr	Pointer to list of ECAT headers
nr	Nr of headers to allocate

Definition at line 63 of file ecat7ift.c.

  {
  int i;
 
  if(ehdr==NULL || nr<1) return STATUS_FAULT;
  for(i=0; i<ehdr->nr; i++) {ematEmpty(&ehdr->m[i]);}
  free(ehdr->m); ehdr->m=NULL; ehdr->nr=0;
  ehdr->m=(ECAT_MATRIX*)malloc(nr*sizeof(ECAT_MATRIX));
  if(ehdr->m==NULL) return STATUS_NOMEMORY;
  for(i=0; i<nr; i++) ematInitiate(&ehdr->m[i]);
  ehdr->nr=nr;
  return STATUS_OK;
}

Referenced by ecat7ReadHeaders(), and ecat7WriteHeaders().

◆ ehdrEmpty()

void ehdrEmpty ( ECAT_HEADERS * ehdr )

extern

Free memory allocated in ECAT_HEADERS

Parameters

ehdr	Pointer to header list struct

Definition at line 47 of file ecat7ift.c.

  {
  int i;
 
  if(ehdr==NULL) return;
  iftEmpty(&ehdr->mh);
  for(i=0; i<ehdr->nr; i++) {ematEmpty(&ehdr->m[i]);}
  free(ehdr->m); ehdr->m=NULL; ehdr->nr=0;
}

Referenced by ecat7CopyHeadersNoQuant().

◆ ehdrInitiate()

void ehdrInitiate ( ECAT_HEADERS * ehdr )

extern

Initiate ECAT_HEADERS struct

Parameters

ehdr	Pointer to struct

Definition at line 21 of file ecat7ift.c.

{
  iftInit(&ehdr->mh);
  ehdr->nr=0;
  ehdr->m=(ECAT_MATRIX*)NULL;  
}

Referenced by ecat7CopyHeadersNoQuant().

◆ ematEmpty()

void ematEmpty ( ECAT_MATRIX * emat )

extern

Free memory allocated in ECAT_MATRIX

Parameters

emat	Pointer to ECAT matrix list

Definition at line 33 of file ecat7ift.c.

  {
  if(emat==NULL) return;
  emat->mnum=0;
  iftEmpty(&emat->sh);
  if(emat->f!=NULL) free(emat->f);
  emat->f=NULL;
}

Referenced by ehdrAllocate(), and ehdrEmpty().

◆ ematInitiate()

void ematInitiate ( ECAT_MATRIX * emat )

extern

Initiate image data inside ECAT_MATRIX struct

Parameters

emat	Pointer to struct

Definition at line 12 of file ecat7ift.c.

  {
  emat->mnum=0;
  iftInit(&emat->sh);
  emat->f=(float*)NULL;
}

Referenced by ehdrAllocate().

◆ f_kth_smallest()

float f_kth_smallest	(	float *	data,
		long long int	n,
		long long int	k )

extern

Returns the kth smallest value in data[0..n-1].

Array is partially sorted. Algorithm is based on the book Wirth N. Algorithms + data structures = programs. Englewood Cliffs, Prentice-Hall, 1976.

See also: fmedian

Returns: Returns the kth smallest value in data[0..n-1].

Parameters

data	Pointer to data; array is partially sorted
n	Length of data array
k	kth smallest value will be returned

Definition at line 558 of file imgminmax.c.

  {
  long long int i, j, l, m;
  float x, s;
 
  l=0; m=n-1;
  while(l<m) {
    x=data[k]; i=l; j=m;
    do {
      while(data[i]<x) i++;
      while(x<data[j]) j--;
      if(i<=j) {s=data[i]; data[i]=data[j]; data[j]=s; i++; j--;}
    } while(i<=j);
    if(j<k) l=i;
    if(k<i) m=j;
  }
  return(data[k]);
}

Referenced by fmedian().

◆ float2parts()

void float2parts ( float * buf )

extern

Printfs separately the sign, mantissa, and exp part of a 32-bit float, which is pointed to by the argument. Code is not optimized; do not use this in routine operations!

Parameters

buf	printed float

Definition at line 277 of file ecat63p.c.

  {
  unsigned int u, exp, mantissa;
  char sign;
 
  memcpy(&u, buf, 4); if(u & 1L<<31) sign='-'; else sign='+';
  exp=u<<1; exp=exp>>24; mantissa=u<<9; mantissa=mantissa>>9;
  printf("%e = %c (%u/8388608 + 1)*2^(%u-127)\n", *buf, sign, mantissa, exp);
}

◆ fmean()

float fmean	(	float *	data,
		long long int	n,
		float *	sd )

extern

Returns the mean in array data[0..n-1], and optionally calculates also the (sample) standard deviation of the mean.

See also: dmean, fmedian, mean, dmean_nan

Returns: Returns the mean in array data[0..n-1].

Parameters

data	Pointer to data; data is not changed in any way.
n	Length of data array.
sd	Pointer to variable where SD will be written; enter NULL if not needed.

Definition at line 618 of file imgminmax.c.

  {
  long long int i;
  float sumsqr=0.0, sqrsum=0.0, avg;
 
  if(n<1 || data==NULL) {if(sd!=NULL) *sd=0.0; return(0.0);}
 
  for(i=0; i<n; i++) {sumsqr+=data[i]*data[i]; sqrsum+=data[i];}
  avg=sqrsum/(float)n; if(sd==NULL) return(avg);
  if(n==1) {
    *sd=0.0;
  } else {
    sqrsum*=sqrsum;
    *sd=sqrt( (sumsqr - sqrsum/(float)n) / (float)(n-1) );
  }
  return(avg);
}

Referenced by imgBorderAverageTAC().

◆ fmedian()

float fmedian	(	float *	data,
		long long int	n )

extern

Returns the median in array data[0..n-1].

Array is partially sorted. Algorithm is based on the book Wirth N. Algorithms + data structures = programs. Englewood Cliffs, Prentice-Hall, 1976.

See also: fMinMax, imgAvg, dmedian

Returns: Returns the median in array data[0..n-1].

Parameters

data	Pointer to data; array is partially sorted
n	Length of data array

Definition at line 593 of file imgminmax.c.

  {
  long long int k;
  float d1, d2;
 
  if(n<1) return(0.0);
  if(n%2) {
    k=(n-1)/2; return(f_kth_smallest(data, n, k));
  } else {
    k=n/2; d1=f_kth_smallest(data, n, k-1); d2=f_kth_smallest(data, n, k);
    return(0.5*(d1+d2));
  }
}

Referenced by imgBorderAverageTAC(), med21(), and med9().

◆ fMinMaxFin()

void fMinMaxFin	(	float *	data,
		long long int	n,
		float *	fmin,
		float *	fmax )

extern

Finds the minimum and maximum value in a float array.

Only finite values are considered.

See also: imgMinMax, imgAbsMax, imgAvg

Parameters

data	Pointer to float array of size n.
n	Array length.
fmin	Pointer to float value for minimum; enter NULL if not needed.
fmax	Pointer to float value for maximum; enter NULL if not needed.

Definition at line 649 of file imgminmax.c.

  {
  if(fmin!=NULL) *fmin=nanf("");
  if(fmax!=NULL) *fmax=nanf("");
 
  long long int i;
  for(i=0; i<n; i++) if(isfinite(data[i])) break;
  if(i==n) return; // no finite values found
  float mi, ma;
  mi=ma=data[i++];
  for(; i<n; i++) if(isfinite(data[i])) {
    if(data[i]>ma) ma=data[i];
    else if(data[i]<mi) mi=data[i];
  }
  if(fmin!=NULL) *fmin=mi;
  if(fmax!=NULL) *fmax=ma;
  return;
}

Referenced by ecat63WriteImageMatrix(), ecat63WriteScanMatrix(), ecat7Write2DScanMatrix(), ecat7WriteImageMatrix(), ecat7WritePolarmapMatrix(), ecat7WriteScanMatrix(), mrp(), and trmrp().

◆ img2sif()

int img2sif	(	IMG *	img,
		SIF *	sif,
		int	copy_header,
		int	copy_frames,
		int	copy_counts,
		int	verbose )

extern

Set SIF contents based on data in IMG.

Returns: Returns 0 if successful.

Parameters

img	Pointer to IMG struct from which content is copied to SIF.
sif	Pointer to SIF. Must be initiated with sifInit(), but SIF is allocated here if necessary.
copy_header	Select whether header contents are copied (1) or not copied (0) to SIF.
copy_frames	Select whether frame times are copied (1) or not copied (0) to SIF.
copy_counts	Select whether counts are copied (1) or not copied (0) to SIF, or created if they do not exist (2).
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 71 of file img_sif.c.

  {
  if(verbose>0)
    printf("img2sif(img, sif, %d, %d, %d, ...)\n", copy_header, copy_frames, copy_counts);
 
  /* Check the arguments */
  if(img==NULL || sif==NULL) return(1);
  if(img->dimt<1) return(1);
 
  /* Verify that IMG contains frame times */
  if(!imgExistentTimes(img)) {
    if(verbose>0) printf("  image does not contain frame times.\n");
    /* If not, then frame times cannot be copied */
    copy_frames=0;
    /* and counts can not be created */
    if(copy_counts==2) copy_counts=1;
  }
 
  /* Check if count data needs to be created */
  if(copy_counts==2 && imgExistentCounts(img)!=0)
    copy_counts=1;
 
  /* Verify that IMG contains isotope information */
  if(img->isotopeHalflife<=0.0) {
    if(verbose>0) printf("  image does not contain isotope halflife.\n");
    /* not, then count data can not be created */
    if(copy_counts==2) copy_counts=1;
  }
 
  /* Allocate memory for SIF if necessary */
  if((copy_frames || copy_counts) && sif->frameNr!=img->dimt) {
    if(sifSetmem(sif, img->dimt)!=0) return(3);
  }
 
  /* copy SIF header */
  if(copy_header) {
    if(verbose>1) printf("  copying header fields.\n");
    sif->scantime=img->scanStart;
    sif->colNr=4;
    sif->version=1;
    strcpy(sif->isotope_name, imgIsotope(img));
    if(strlen(img->studyNr)>0 && strcmp(img->studyNr, ".")!=0)
      strlcpy(sif->studynr, img->studyNr, MAX_STUDYNR_LEN+1);
    else
      strcpy(sif->studynr, "");
  }
 
  /* copy frame times */
  if(copy_frames) {
    if(verbose>1) printf("  copying frame times.\n");
    for(int fi=0; fi<img->dimt; fi++) {
      sif->x1[fi]=img->start[fi]; sif->x2[fi]=img->end[fi];
    }
  }
 
  /* copy or create counts, if required */
  if(copy_counts==2) {
    if(verbose>1) printf("  creating count data.\n");
    /* Calculate average of pixel values */
    long long pxlNr=0;
    for(int fi=0; fi<img->dimt; fi++) {
      double v=0.0;
      for(int k=0; k<img->dimz; k++)
        for(int j=0; j<img->dimy; j++)
          for(int i=0; i<img->dimx; i++) if(isfinite(img->m[k][j][i][fi])) {
            v+=img->m[k][j][i][fi];
            pxlNr++;
          }
      if(pxlNr>0) v/=(double)pxlNr;
      sif->trues[fi]=v;
    }
    /* Multiply by frame durations, unless we have raw data */
    if(img->type!=IMG_TYPE_RAW)
      for(int fi=0; fi<img->dimt; fi++)
        sif->trues[fi]*=(img->end[fi]-img->start[fi]);
    /* Remove decay correction, unless we have raw data */
    if(img->type!=IMG_TYPE_RAW 
         && (img->decayCorrection==IMG_DC_UNKNOWN || img->decayCorrection==IMG_DC_CORRECTED)) {
      double lambda, cf, dur;
      lambda=-hl2lambda(img->isotopeHalflife);
      for(int fi=0; fi<img->dimt; fi++) {
        dur=img->end[fi]-img->start[fi];
        cf=hlLambda2factor(lambda, img->start[fi], dur);
        if(cf>0.0) sif->trues[fi]*=cf;
      }
    }
    /* Scale values to a realistic level */
    double v=sif->trues[0];
    for(int fi=1; fi<sif->frameNr; fi++) if(sif->trues[fi]>v) v=sif->trues[fi];
    v=2.0E+07/v;
    for(int fi=0; fi<sif->frameNr; fi++) sif->trues[fi]*=v;
    /* Prompts are set to Trues and Randoms are set to zero */
    for(int fi=0; fi<sif->frameNr; fi++) {
      sif->prompts[fi]=sif->trues[fi];
      sif->randoms[fi]=0.0;
      if(sif->trues[fi]<1.0) sif->trues[fi]=1.0;
      sif->weights[fi]=img->weight[fi];
    }
  } else if(copy_counts!=0) {
    if(verbose>1) printf("  copying count data.\n");
    for(int fi=0; fi<img->dimt; fi++) {
      sif->prompts[fi]=img->prompts[fi];
      sif->randoms[fi]=img->randoms[fi];
      sif->trues[fi]=sif->prompts[fi]-sif->randoms[fi];
      if(sif->trues[fi]<1.0) sif->trues[fi]=1.0;
      sif->weights[fi]=img->weight[fi];
    }
  }
 
  return(0);
}

Referenced by imgWriteAnalyze(), and imgWriteNifti().

◆ img2svol()

int img2svol	(	IMG *	img,
		SVOL *	svol,
		int	frame )

extern

Copy one time frame (1..dimt) from 4D image to 3D short int volume. Svol can be but need not to be allocated.

Parameters

img	image structure
svol	short volume structure
frame	frame number [1..number of frames]

Returns: 0 if ok, 1 invalid image status, 2 invalid input

Definition at line 305 of file vol.c.

                                              {
  int ret;
  unsigned short int zi, yi, xi, fi;
  float fmin, fmax, g;
 
  if(VOL_TEST) printf("img2svol(img, %d, svol)\n", frame);
  /* Check input */
  if(svol==NULL) return(1);
  svol->statmsg=_volStatusMessage[1];
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(frame<1 || img->dimt<frame) return(2);
  if(svol->status==IMG_STATUS_UNINITIALIZED) return(1);
 
  /* Allocate memory (if needed) for volume */
  ret=svolAllocate(svol, img->dimz, img->dimy, img->dimx);
  if(ret) return(ret);
 
  /* Copy data */
  fi=frame-1;
  svol->orientation=img->orientation;
  svol->sizex=img->sizex; svol->sizey=img->sizey; svol->sizez=img->sizez;
  ret=imgFrameMinMax(img, frame, &fmin, &fmax); if(ret) return(10+ret);
  if(fabs(fmin)>fabs(fmax)) g=fabs(fmin); else g=fabs(fmax);
  if(g!=0) g=32766./g; else g=1.0;
  for(zi=0; zi<svol->dimz; zi++)
    for(yi=0; yi<svol->dimy; yi++)
      for(xi=0; xi<svol->dimx; xi++)
        svol->v[zi][yi][xi]=(short int)temp_roundf(g*img->m[zi][yi][xi][fi]);
  svol->scale_factor=1.0/g;
 
  return(0);
}

◆ img2vol()

int img2vol	(	IMG *	img,
		VOL *	vol,
		int	frame )

extern

Copy one time frame (1..dimt) from 4D image to 3D volume. Vol can be but need not to be allocated.

Parameters

img	image structure
vol	volume structure
frame	frame number [1..number of frames]

Returns: 0 if ok, 1 invalid image status, 2 invalid input

Definition at line 267 of file vol.c.

                                           {
  int ret;
  unsigned short int zi, yi, xi, fi;
 
  if(VOL_TEST) printf("img2vol(img, %d, vol)\n", frame);
  /* Check input */
  if(vol==NULL) return(1);
  vol->statmsg=_volStatusMessage[1];
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(frame<1 || img->dimt<frame) return(2);
  if(vol->status==IMG_STATUS_UNINITIALIZED) return(1);
 
  /* Allocate memory (if needed) for volume */
  ret=volAllocate(vol, img->dimz, img->dimy, img->dimx);
  if(ret) return(ret);
 
  /* Copy data */
  fi=frame-1;
  vol->orientation=img->orientation;
  vol->sizex=img->sizex; vol->sizey=img->sizey; vol->sizez=img->sizez;
  for(zi=0; zi<vol->dimz; zi++)
    for(yi=0; yi<vol->dimy; yi++)
      for(xi=0; xi<vol->dimx; xi++)
        vol->v[zi][yi][xi]=img->m[zi][yi][xi][fi];
 
  return(0);
}

◆ imgAbsMax()

int imgAbsMax	(	IMG *	img,
		float *	maxvalue )

extern

Searches the max absolute pixel value in the IMG data.

Sets maxvalue to the absolute max value with sign.

See also: imgFrameMinMax, imgMinMax, imgMax, imgSmoothMax

Returns: 0 if ok, 1 invalid image status, 2 invalid output pointer, 3 invalid image dimensions.

Parameters

img	Pointer to IMG structure.
maxvalue	Pointer to output.

Definition at line 44 of file imgminmax.c.

  {
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(maxvalue==NULL) return(2); else *maxvalue=0.0;
  if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
  float f=nanf("");
  for(int pi=0; pi<img->dimz; pi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++)
        for(int fi=0; fi<img->dimt; fi++) {
          if(!isfinite(f) || fabs(img->m[pi][yi][xi][fi])>fabs(f)) f=img->m[pi][yi][xi][fi];
        }
  *maxvalue=f;
  return(0);
}

◆ imgAllocate()

int imgAllocate	(	IMG *	image,
		int	planes,
		int	rows,
		int	columns,
		int	frames )

extern

Allocates memory for img data. Old contents are not saved.

See also: imgAllocateWithHeader, imgDup, imgEmpty, imgInit

Returns: 0 if ok, 1 image is not initialized, 2 invalid input dimension(s), 3 failed to allocate header, 4 - 8 failed to allocate image data

Parameters

image	Pointer to initialized image struct; old contents are deleted.
planes	Nr of image planes (dim z) to allocate.
rows	Nr of image rows (dim y) to allocate.
columns	Nr of image columns (dim x) to allocate.
frames	Nr of image time frames (dim t) to allocate.

Definition at line 194 of file img.c.

  {
  if(IMG_TEST) printf("imgAllocate(*image, %d, %d, %d, %d)\n", planes, rows, columns, frames);
  /* Check arguments */
  if(image==NULL) return(1);
  imgSetStatus(image, STATUS_FAULT);
  if(image->status==IMG_STATUS_UNINITIALIZED) return(1);
  if(planes<1 || rows<1 || columns<1 || frames<1) return(2);
  if(image->status>=IMG_STATUS_OCCUPIED) imgEmpty(image);
  /* Allocate memory for header data */
  imgSetStatus(image, STATUS_NOMEMORY);
  image->_header=(float*)calloc(8*frames, sizeof(float));
  if(image->_header==NULL) return(3);
  image->planeNumber=(int*)calloc(planes, sizeof(int));
  if(image->planeNumber==NULL) {free(image->_header); return(4);}
  /* Allocate memory for image data */
  image->_pln=(float****)calloc((size_t)planes, sizeof(float***));
  if(image->_pln==NULL) {
    free(image->_header); free(image->planeNumber);
    return(5);
  }
  image->_row=(float***)calloc((size_t)planes*rows, sizeof(float**));
  if(image->_row==NULL) {
    free(image->_header); free(image->planeNumber);
    free(image->_pln); return(6);
  }
  image->_col=(float**)calloc((size_t)planes*rows*columns, sizeof(float*));
  if(image->_col==NULL) {
    free(image->_header); free(image->planeNumber);
    free(image->_pln); free(image->_row); return(7);
  }
  image->_pxl=(float*)calloc((size_t)planes*rows*columns*frames, sizeof(float));
  if(image->_pxl==NULL) {
    free(image->_header); free(image->planeNumber);
    free(image->_pln); free(image->_row); free(image->_col); return(8);
  }
  /* Set data pointers */
  float ***rptr, **cptr, *pptr;
  rptr=image->_row; cptr=image->_col; pptr=image->_pxl;
  for(unsigned short int zi=0; zi<planes; zi++) {
    image->_pln[zi]=rptr;
    for(unsigned short int ri=0; ri<rows; ri++) {
      *rptr++=cptr;
      for(unsigned short int ci=0; ci<columns; ci++) {
        *cptr++=pptr; pptr+=frames;
      }
    }
  }
  image->m=image->_pln;
  image->plane=image->_pln;
  image->column=image->_col;
  image->row=image->_row;
  image->pixel=image->_pxl;
  /* Set header pointers */
  image->start=          image->_header+0*frames;
  image->end=            image->_header+1*frames;
  image->mid=            image->_header+2*frames;
  image->weight=         image->_header+3*frames;
  image->sd=             image->_header+4*frames;
  image->prompts=        image->_header+5*frames;
  image->randoms=        image->_header+6*frames;
  image->decayCorrFactor=image->_header+7*frames;
  /* Ok */
  image->dimz=planes; image->dimy=rows; image->dimx=columns; image->dimt=frames;
  imgSetStatus(image, STATUS_OK);
  image->status=IMG_STATUS_OCCUPIED;
  return(0);
}

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), img2cube(), img_k1_using_ki(), imgAllocateWithHeader(), imgAUMC(), imgExtractRange(), imgFBP(), imgGetFrameDiff(), imgGetFrameDyn(), imgGetMaxFrame(), imgGetMaxTime(), imgMicropetCTToEcat7(), imgMicropetPETToEcat7(), imgMRP(), imgMRT(), imgOutlierFilter(), imgReadAnalyze(), imgReadAnalyzeFirstFrame(), imgReadEcat63FirstFrame(), imgReadEcat7(), imgReadEcat7FirstFrame(), imgReadFrame(), imgReadMicropetFirstFrame(), imgReadNifti(), imgReadNiftiFirstFrame(), imgReprojection(), imgStructuringElement(), imgThresholdingLowHigh(), and imgThresholdMaskCount().

◆ imgAllocateWithHeader()

int imgAllocateWithHeader	(	IMG *	image,
		int	planes,
		int	rows,
		int	columns,
		int	frames,
		IMG *	image_from )

extern

This functions just combines imgAllocate() and imgCopyhdr().

See also: imgAllocate, imgCopyhdr, imgDup

Returns: Returns 0 if successful, otherwise returns <>0.

Parameters

image	Pointer to IMG struct which will be allocated here.
planes	Image matrix dimensions; z.
rows	Image matrix dimensions; y.
columns	Image matrix dimensions; x.
frames	Image matrix dimensions; t.
image_from	Pointer to IMG struct where header contents will be copied from.

Definition at line 279 of file img.c.

  {
  int ret;
  ret=imgAllocate(image, planes, rows, columns, frames); if(ret) return ret;
  ret=imgCopyhdr(image_from, image); return ret;
}

Referenced by img_logan(), img_patlak(), imgDup(), imgFlipAbove(), imgFlipRight(), imgFrameIntegral(), imgMeanZ(), imgNoiseTemplate(), imgPVCRRL(), imgPVCRVC(), imgsegmSimilar(), imgsegmThresholdMask(), imgShrink(), imgSwell(), and imgTimeIntegral().

◆ imgAvg()

int imgAvg	(	IMG *	img,
		IMG_RANGE *	r,
		float *	avg )

extern

Calculates average voxel value inside specified image range.

See also: imgMinMax, imgMax, fmedian, imgTimeIntegral

Returns: Returns 0 when successful.

Parameters

img	Pointer to IMG image structure
r	Pointer to range inside IMG; enter NULL if whole IMG is used
avg	Target for mean value

Definition at line 503 of file imgminmax.c.

  {
  int zi, yi, xi, fi;
  long long n=0;
 
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(r!=NULL) {
    if(r->z1<1 || r->y1<1 || r->x1<1 || r->f1<1) return(2);
    if(r->z2<r->z1 || r->y2<r->y1 || r->x2<r->x1 || r->f2<r->f1) return(3);
    if(r->z2>img->dimz || r->y2>img->dimy || r->x2>img->dimx || r->f2>img->dimt) return(4);
  }
  if(avg==NULL) return(5);
 
  *avg=0.0;
  if(r!=NULL) {
    for(zi=r->z1-1; zi<r->z2; zi++) {
      for(yi=r->y1-1; yi<r->y2; yi++) {
        for(xi=r->x1-1; xi<r->x2; xi++) {
          for(fi=r->f1-1; fi<r->f2; fi++) if(!isnan(img->m[zi][yi][xi][fi])) {
            *avg+=img->m[zi][yi][xi][fi]; n++;
          }
        }
      }
    }
  } else {
    for(zi=0; zi<img->dimz; zi++) {
      for(yi=0; yi<img->dimy; yi++) {
        for(xi=0; xi<img->dimx; xi++) {
          for(fi=0; fi<img->dimt; fi++) if(!isnan(img->m[zi][yi][xi][fi])) {
            *avg+=img->m[zi][yi][xi][fi]; n++;
          }
        }
      }
    }
  }
  if(n>0) *avg/=(float)n;
  return(0);
}

◆ imgBranchingCorrection()

int imgBranchingCorrection	(	IMG *	image,
		int	mode,
		int	verbose,
		char *	status )

extern

Corrects image data for branching fraction (mode=1) or removes correction (mode=0). Removal is primarily based on branching factor stored in IMG structure, secondarily on isotope; after removal, branching factor is set to 1, and pixel values and calibration factor are multiplied with it. Correction is based on branching fractions in branch.h; pixel values and calibration factor are divided by it, and its value is stored in IMG structure.

Note: This function can not know if branching fraction correction is included in the data (as it usually is) or not.

Returns: Returns 0 if ok.

See also: imgDecayCorrection, imgSetDecayCorrFactors, imgIsotope

Parameters

image	Pointer to IMG data
mode	Branching fraction correction (1) or removal of correction (0)
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr
status	Pointer to allocated string where error message will be written; NULL, if not needed.

Definition at line 132 of file imgdecayc.c.

  {
  int isotope;
  float bf;
  float cf;
 
  if(verbose>0) printf("imgBranchingCorrection(*img, %d, %d, *status)\n",
    mode, verbose);
  /* Check for arguments */
  if(status!=NULL) strcpy(status, "invalid input");
  if(image->status!=IMG_STATUS_OCCUPIED) return(1);
  if(image->isotopeHalflife<=0.0) {
    if(verbose>0) printf("Error: unknown isotope.\n");
    if(status!=NULL) strcpy(status, "unknown isotope");
    return(2);
  }
 
  /* If branching factor not found in IMG, then get it based on half-life */
  bf=image->branchingFraction;
  if(bf<=0.0 || bf>=1.0) {
    isotope=hlIsotopeFromHalflife(image->isotopeHalflife/60.0);
    if(verbose>2) printf("isotope := %d\n", isotope);
    bf=branchingFraction(isotope);
  }
  if(bf<=0.0 || bf>=1.0) {
    if(verbose>0) printf("Error: branching fraction unknown for the isotope.\n");
    if(status!=NULL) strcpy(status, "branching fraction unknown for the isotope");
    return(3);
  }
 
  /* Multiply with BF to remove correction, and divide to correct */ 
  if(mode==0) cf=bf; else cf=1.0/bf;
  /* Process pixel values */
  if(verbose>1) printf("multiplying data by %g\n", cf);
  for(int fi=0; fi<image->dimt; fi++) {
    for(int pi=0; pi<image->dimz; pi++)
      for(int i=0; i<image->dimy; i++)
        for(int j=0; j<image->dimx; j++)
          image->m[pi][i][j][fi]*=cf;
  }
 
  /* Fix header contents, too */
  if(image->calibrationFactor>0.0) image->calibrationFactor*=cf;
  if(mode==0) image->branchingFraction=0.0;
  else image->branchingFraction=bf;
 
  if(status!=NULL) strcpy(status, "ok");
  return(0);
}

◆ imgCopyhdr()

int imgCopyhdr	(	IMG *	image1,
		IMG *	image2 )

extern

Copy the header fields from one image struct to another.

Does not copy memory addresses or IMG sizes. Frame times, decay correction factors etc are copied, when possible. Plane numbers are copied, when possible.

See also: imgAllocateWithHeader, imgDup

Returns: 0 if successful, 1 invalid input, 2 pointers are to the same image

Parameters

image1	Pointer to input IMG data.
image2	Pointer to output IMG data.

Definition at line 471 of file img.c.

  {
  if(IMG_TEST) printf("imgCopyhdr()\n");
  /* check */
  if(image1==NULL || image2==NULL) return(1);
  if(image1==image2) return(2);
  /* copy */
  image2->type=image1->type;
  image2->unit=image1->unit;
  image2->calibrationFactor=image1->calibrationFactor;
  strcpy(image2->studyNr, image1->studyNr);
  strcpy(image2->patientName, image1->patientName);
  strcpy(image2->patientID, image1->patientID);
  strcpy(image2->userProcessCode, image1->userProcessCode);
  strcpy(image2->studyDescription, image1->studyDescription);
  image2->zoom=image1->zoom;
  strcpy(image2->radiopharmaceutical, image1->radiopharmaceutical);
  image2->isotopeHalflife=image1->isotopeHalflife;
  image2->decayCorrection=image1->decayCorrection;
  image2->branchingFraction=image1->branchingFraction;
  image2->scanStart=image1->scanStart;
  image2->axialFOV=image1->axialFOV;
  image2->transaxialFOV=image1->transaxialFOV;
  image2->sampleDistance=image1->sampleDistance;
  image2->sizex=image1->sizex;
  image2->sizey=image1->sizey;
  image2->sizez=image1->sizez;
  image2->gapx=image1->gapx;
  image2->gapy=image1->gapy;
  image2->gapz=image1->gapz;
  image2->resolutionx=image1->resolutionx;
  image2->resolutiony=image1->resolutiony;
  image2->resolutionz=image1->resolutionz;
  image2->_dataType=image1->_dataType;
  image2->_fileFormat=image1->_fileFormat;
  image2->orientation=image1->orientation;
  image2->scanner=image1->scanner;
  image2->modality=image1->modality;
  for(int i=0; i<2; i++) image2->xform[i]=image1->xform[i];
  for(int i=0; i<18; i++) image2->quatern[i]=image1->quatern[i];
  for(int i=0; i<12; i++) image2->mt[i]=image1->mt[i];
  if(iftdup(&image1->ift, &image2->ift, 0)!=0) return(8);
  image2->polarmap_num_rings=image1->polarmap_num_rings;
  for(int i=0; i<MAX_POLARMAP_NUM_RINGS; i++) {
    image2->polarmap_sectors_per_ring[i]=image1->polarmap_sectors_per_ring[i];
    image2->polarmap_ring_position[i]=image1->polarmap_ring_position[i];
    image2->polarmap_ring_angle[i]=image1->polarmap_ring_angle[i];
  }
  image2->polarmap_start_angle=image1->polarmap_start_angle;
  if(image1->dimz==image2->dimz) for(int i=0; i<image1->dimz; i++) {
    image2->planeNumber[i]=image1->planeNumber[i];
  }
  if(image1->dimt==image2->dimt) for(int i=0; i<image1->dimt; i++) {
    image2->start[i]=image1->start[i]; image2->end[i]=image1->end[i];
    image2->mid[i]=image1->mid[i];
    image2->weight[i]=image1->weight[i]; image2->sd[i]=image1->sd[i];
    image2->prompts[i]=image1->prompts[i];
    image2->randoms[i]=image1->randoms[i];
    image2->decayCorrFactor[i]=image1->decayCorrFactor[i];
  }
  image2->isWeight=image1->isWeight;
  return(0);
}

Referenced by img2cube(), img_k1_using_ki(), imgAllocateWithHeader(), imgAUMC(), imgExtractRange(), imgGetFrameDiff(), imgGetFrameDyn(), imgGetMaxFrame(), imgGetMaxTime(), imgMRT(), imgThresholdingLowHigh(), and imgThresholdMaskCount().

◆ imgDecayCorrection()

int imgDecayCorrection	(	IMG *	image,
		int	mode )

extern

Corrects (mode=1) or removes correction (mode=0) for physical decay. Removal is based on existing decay correction factors, when possible.

Returns: 0 if ok, 1 image status is not 'occupied', 2 decay already corrected/not corrected, 3 image frame times missing

See also: imgSetDecayCorrFactors, imgBranchingCorrection, imgIsotope

Parameters

image	Pointer to IMG data.
mode	0=Remove decay correction; 1=Correct for decay.

Definition at line 16 of file imgdecayc.c.

  {
  float lambda;
  float cf, dur;
 
  /* Check for arguments */
  if(image->status!=IMG_STATUS_OCCUPIED) return(1);
  if(image->isotopeHalflife<=0.0) return(1);
  /* Existing/nonexisting decay correction is an error */
  if(mode==1 && image->decayCorrection!=IMG_DC_NONCORRECTED) return(2);
  if(mode==0 && image->decayCorrection!=IMG_DC_CORRECTED) return(2);
 
  /* All time frames */
  for(int fi=0; fi<image->dimt; fi++) {
    dur=image->end[fi]-image->start[fi];
    if(image->end[fi]>0.0) {
      if(mode==0 && image->decayCorrFactor[fi]>1.000001) {
        /* if decay correction is to be removed, and factor is known,
           then use it */
        cf=1.0/image->decayCorrFactor[fi];
      } else {
        lambda=hl2lambda(image->isotopeHalflife); if(lambda<0.0) return(1);
        /* remove decay correction by giving negative lambda */
        if(mode==0) lambda=-lambda;
        if(fi==image->dimt-1 && image->end[fi]<=0.0) return(3);
        cf=hlLambda2factor_float(lambda, image->start[fi], dur);
      }
      if(IMG_TEST) printf("applied_dc_factor[%d] := %g\n", fi+1, cf);
      /* Set decay correction factor inside IMG for future */
      if(mode==0) {
        image->decayCorrFactor[fi]=1.0;
      } else {
        image->decayCorrFactor[fi]=cf;
      }
      /* All planes, all matrices */
      for(int pi=0; pi<image->dimz; pi++)
        for(int i=0; i<image->dimy; i++)
          for(int j=0; j<image->dimx; j++)
            image->m[pi][i][j][fi]*=cf;
      if(mode==0) image->decayCorrection=IMG_DC_NONCORRECTED;
      else image->decayCorrection=IMG_DC_CORRECTED;
      /* in some cases left unchanged! */
    }
  } /* next frame */
  return(0);
}

◆ imgDup()

int imgDup	(	IMG *	img1,
		IMG *	img2 )

extern

Duplicate IMG struct. Any existing contents in img2 will be deleted.

See also: imgAllocate, imgAllocateWithHeader, imgExtractRange

Returns: Returns 0 if successful.

Parameters

img1	Pointer to IMG struct which will be duplicated
img2	Pointer to initiated IMG struct into which the duplicate will be made

Definition at line 304 of file img.c.

  {
  if(img1==NULL || img2==NULL) return(1);
  /* Delete any old contents */
  imgEmpty(img2);
  /* Allocate memory and copy headers */
  int ret=imgAllocateWithHeader(img2, img1->dimz, img1->dimy, img1->dimx, img1->dimt, img1);
  if(ret!=0) return(10+ret);
  /* Copy voxel contents */
  unsigned long long int n=img1->dimx*img1->dimy*img1->dimz*img1->dimt;
  for(unsigned long long int i=0; i<n; i++) img2->pixel[i]=img1->pixel[i];
  return 0;
}

Referenced by imgFlipAbove(), imgFlipRight(), imgMaskDilate(), imgMaskErode(), and imgMeanZ().

◆ imgEcat63Supported()

int imgEcat63Supported ( ECAT63_mainheader * h )

extern

Check whether read functions in IMG library support this ECAT 6.3 file_type.

Parameters

h	Ecat 6.3 main header

Returns: 1 if supported, 0 if not.

Definition at line 1155 of file img_e63.c.

                                             {
  if(h==NULL) return(0);
  if(h->file_type==IMAGE_DATA) return(1);
  if(h->file_type==RAW_DATA)   return(1);
  if(h->file_type==ATTN_DATA)  return(1);
  if(h->file_type==NORM_DATA)  return(1);
  return(0);
}

Referenced by imgReadEcat63Header().

◆ imgEcat7Supported()

int imgEcat7Supported ( ECAT7_mainheader * h )

extern

Check whether read functions in IMG library support this ECAT 7.x file_type.

Parameters

h	Ecat7 main header

Returns: 1 if supported, 0 if not.

Definition at line 1036 of file img_e7.c.

                                           {
  if(h==NULL) return(0);
  if(h->file_type==ECAT7_VOLUME8) return(1);
  if(h->file_type==ECAT7_VOLUME16) return(1);
  if(h->file_type==ECAT7_IMAGE8) return(1);
  if(h->file_type==ECAT7_IMAGE16) return(1);
  if(h->file_type==ECAT7_2DSCAN) return(1);
  if(h->file_type==ECAT7_3DSCAN) return(1);
  if(h->file_type==ECAT7_3DSCAN8) return(1);
  if(h->file_type==ECAT7_3DSCANFIT) return(1);
  if(h->file_type==ECAT7_POLARMAP) return(1);
  return(0);
}

Referenced by imgRead(), imgReadEcat7(), imgReadEcat7Frame(), and imgReadEcat7Header().

◆ imgEmpty()

void imgEmpty ( IMG * image )

extern

Free memory that is allocated for IMG.

See also: imgInit, imgAllocate, imgRead

Parameters

image Pointer to IMG struct

Definition at line 121 of file img.c.

  {
  if(IMG_TEST) printf("imgEmpty()\n");
  if(image==NULL || image->status<IMG_STATUS_OCCUPIED) return;
  /* Free up memory */
  if(image->_pxl!=NULL) free(image->_pxl);
  if(image->_col!=NULL) free(image->_col);
  if(image->_row!=NULL) free(image->_row);
  if(image->_pln!=NULL) free(image->_pln);
  if(image->dimz>0) {free(image->planeNumber);}
  if(image->dimt>0) free(image->_header);
  /* Set variables */
  imgSetStatus(image, STATUS_OK);
  image->type=0;
  image->unit=0;
  image->calibrationFactor=0;
  image->zoom=0.0;
  image->radiopharmaceutical[0]=(char)0;
  image->isotopeHalflife=0.0;
  image->decayCorrection=(char)IMG_DC_UNKNOWN;
  image->branchingFraction=0.0;
  image->unit=0;
  image->scanStart=0;
  image->orientation=0;
  image->axialFOV=image->transaxialFOV=image->sampleDistance=0.0;
  image->studyNr[0]=image->patientName[0]=image->patientID[0]=(char)0;
  image->userProcessCode[0]=image->studyDescription[0]=(char)0;
  image->sizex=image->sizey=image->sizez=0;
  image->gapx=image->gapy=image->gapz=0.0;
  image->resolutionx=image->resolutiony=image->resolutionz=0.0;
  image->_dataType=0;
  image->_fileFormat=0;
  image->scanner=0;
  image->modality=0;
  for(int i=0; i<2; i++) image->xform[i]=NIFTI_XFORM_UNKNOWN;
  for(int i=0; i<18; i++) image->quatern[i]=0.0;
  for(int i=0; i<12; i++) image->mt[i]=0.0;
  iftEmpty(&image->ift);
  image->polarmap_num_rings=0;
  for(int i=0; i<MAX_POLARMAP_NUM_RINGS; i++) {
    image->polarmap_sectors_per_ring[i]=0;
    image->polarmap_ring_position[i]=0.0;
    image->polarmap_ring_angle[i]=0;
  }
  image->polarmap_start_angle=0;
  image->dimt=image->dimx=image->dimy=image->dimz=0;
  image->m=(float****)NULL;
  image->_header=(float*)NULL;
  image->pixel=(float*)NULL;
  image->column=(float**)NULL;
  image->row=(float***)NULL;
  image->plane=(float****)NULL;
  image->planeNumber=(int*)NULL;
  image->start=image->end=image->mid=(float*)NULL;
  image->isWeight=0;
  image->weight=image->sd=(float*)NULL;
  image->decayCorrFactor=(float*)NULL;
  /* Set status */
  image->status=IMG_STATUS_INITIALIZED;
  image->errstatus=STATUS_OK;
}

Referenced by ecat63ReadPlaneToImg(), img2cube(), img_k1_using_ki(), img_logan(), img_patlak(), imgAllocate(), imgAnalyzeToEcat(), imgAUMC(), imgDup(), imgExtractRange(), imgFBP(), imgFlipAbove(), imgFlipRight(), imgFormatDetermine(), imgFrameIntegral(), imgGetFrameDiff(), imgGetFrameDyn(), imgGetMaxFrame(), imgGetMaxTime(), imgMaskDilate(), imgMaskErode(), imgMaskRegionLabeling(), imgMicropetCTToEcat7(), imgMicropetPETToEcat7(), imgMRP(), imgMRT(), imgNiftiToEcat(), imgOutlierFilter(), imgPVCRRL(), imgPVCRVC(), imgReadFrame(), imgReadMicropet(), imgReadMinMax(), imgReadModelingData(), imgReprojection(), imgsegmSimilar(), imgStructuringElement(), imgThresholding(), imgThresholdingLowHigh(), imgWriteAnalyzeFrame(), imgWriteEcat63Frame(), imgWriteEcat7Frame(), and imgWriteNiftiFrame().

◆ imgExistentCounts()

int imgExistentCounts ( IMG * img )

extern

Verify that IMG contains prompts and randoms.

See also: imgExistentTimes

Returns: Returns 0 if neither prompts or randoms can be found, 1 or 2 if prompts or randoms can be found, and 3 if both prompts and randoms are there.

Parameters

img	Pointer to IMG struct

Definition at line 630 of file img.c.

  {
  int p=0, r=0;
  float v1, v2;
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED || img->dimt<1) return 0;
  /* If just one frame, then value > 0 is fine */
  if(img->dimt==1) {
    if(img->prompts[0]>0.00000001) p=1;
    if(img->randoms[0]>0.00000001) r=2;
    return(p+r);
  }
  /* Otherwise, check also that frames have different count level */
  for(int fi=1; fi<img->dimt; fi++) {
    v1=img->prompts[fi]-img->prompts[fi-1]; if(fabs(v1)>0.001) p=1;
    v2=img->randoms[fi]-img->randoms[fi-1]; if(fabs(v2)>0.001) r=2;
    if((p+r)>2) break;
  }
  return(p+r);
}

Referenced by img2sif().

◆ imgExistentTimes()

int imgExistentTimes ( IMG * img )

extern

Verify that IMG contains frame times.

See also: imgExistentCounts, imgFramesCheck

Returns: Returns nonzero if frame times are there, and 0 if not.

Parameters

img	Pointer to IMG struct.

Definition at line 613 of file img.c.

  {
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED || img->dimt<1) return 0;
  for(int fi=0; fi<img->dimt; fi++) if(img->end[fi]>0.00000001) return 1;
  return 0;  
}

Referenced by img2sif(), imgAUMC(), imgFrameIntegral(), imgMRT(), imgNoiseTemplate(), and imgReadModelingData().

◆ imgExtractRange()

int imgExtractRange	(	IMG *	img1,
		IMG_RANGE	r,
		IMG *	img2 )

extern

Extract a smaller 4D image from inside an IMG.

Any existing data is overwritten.

See also: imgInit, imgEmpty, imgDup

Returns: 0 if ok, 1 invalid input, 2 failed to allocate memory for target image

Parameters

img1	Source image structure, 'occupied' (has allocated data).
r	Image range structure.
img2	Target image structure 'initialized' (has not allocated data).

Definition at line 548 of file img.c.

  {
  int zi, yi, xi, fi, zj, yj, xj, fj;
 
  if(IMG_TEST) {
    printf("imgExtractRange(*img1, r, *img2)\n");
    printf("  z=[%d,%d] y=[%d,%d] x=[%d,%d] f=[%d,%d]\n",
      r.z1, r.z2, r.y1, r.y2, r.x1, r.x2, r.f1, r.f2);
  }
  /* Check arguments */
  if(img2==NULL) return(1); else imgSetStatus(img2, STATUS_FAULT);
  if(img1->status!=IMG_STATUS_OCCUPIED) return(1);
  if(img2->status==IMG_STATUS_UNINITIALIZED) return(1);
  if(r.z1<1 || r.z2>img1->dimz || r.z1>r.z2) return(1);
  if(r.y1<1 || r.y2>img1->dimy || r.y1>r.y2) return(1);
  if(r.x1<1 || r.x2>img1->dimx || r.x1>r.x2) return(1);
  if(r.f1<1 || r.f2>img1->dimt || r.f1>r.f2) return(1);
 
  /* Allocate memory unless the same size was previously allocated */
  imgSetStatus(img2, STATUS_NOMEMORY);
  zi=r.z2-r.z1+1; yi=r.y2-r.y1+1; xi=r.x2-r.x1+1; fi=r.f2-r.f1+1;
  if(img2->status>=IMG_STATUS_OCCUPIED)
    if(img2->dimz!=zi || img2->dimy!=yi || img2->dimx!=xi || img2->dimt!=fi)
      imgEmpty(img2);
  if(img2->status!=IMG_STATUS_OCCUPIED) {
    if(imgAllocate(img2, zi, yi, xi, fi)!=0) return(2);
  }
 
  /* Copy data */
  imgCopyhdr(img1, img2);
  for(fi=r.f1-1, fj=0; fi<r.f2; fi++, fj++) {
    img2->start[fj]=img1->start[fi];
    img2->end[fj]=img1->end[fi];
    img2->mid[fj]=img1->mid[fi];
    img2->weight[fj]=img1->weight[fi];
    img2->sd[fj]=img1->sd[fi];
    img2->prompts[fj]=img1->prompts[fi];
    img2->randoms[fj]=img1->randoms[fi];
    img2->decayCorrFactor[fj]=img1->decayCorrFactor[fi];
  }
  for(zi=r.z1-1, zj=0; zi<r.z2; zi++, zj++) {
    img2->planeNumber[zj]=img1->planeNumber[zi];
  }
  for(zi=r.z1-1, zj=0; zi<r.z2; zi++, zj++)
    for(yi=r.y1-1, yj=0; yi<r.y2; yi++, yj++)
      for(xi=r.x1-1, xj=0; xi<r.x2; xi++, xj++)
        for(fi=r.f1-1, fj=0; fi<r.f2; fi++, fj++)
          img2->m[zj][yj][xj][fj]=img1->m[zi][yi][xi][fi];
 
  imgSetStatus(img2, STATUS_OK);
  return(0);
}

◆ imgFormatDetermine()

int imgFormatDetermine	(	const char *	fname,
		char *	basename,
		char *	hdrfile,
		char *	imgfile,
		char *	siffile,
		int *	file_format,
		int *	scanner,
		int *	type,
		int *	modality,
		int	verbose )

extern

Determine the file format and type of an existing PET image data.

Note that this function only identifies those formats and types that were needed in TPC at the time of writing this function. Note also that this function does not care whether the format is fully or not at all supported by other library functions.

See also: imgRead, imgWrite, imgReadHeader

Returns: Returns 0 when no errors occurred, which does not mean that format was identified.

Parameters

fname	Full name of image file. In case of Analyze or microPET image, hdr or img file name, or basename without extension is accepted. Pathname is not accepted.
basename	Pointer to allocated string where image file name without extensions is written (only for Analyze and microPET); enter NULL, if not needed.
hdrfile	Pointer to allocated string where header file name without extensions is written (only for Analyze and microPET); enter NULL, if not needed.
imgfile	Pointer to allocated string where image data file name without extensions is written (only for Analyze and microPET); enter NULL, if not needed.
siffile	Pointer to allocated string where SIF file name without extensions is written (only for Analyze), if available; enter NULL, if not needed.
file_format	Pointer to int where image format ID is written; 0=unknown, for other formats see definitions in img.h
scanner	Pointer to int where scanner ID is written; 0=unknown, for other formats see definitions in img.h
type	Pointer to int where image type is written; 0=unknown, 1=image, 2=sinogram, 3=polarmap, please check definitions in img.h
modality	Pointer to int where modality is written; 0=unknown, 1=PET, 2=MRI, 3=CT, ..., please check definitions in img.h
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 536 of file imgfile.c.

  {
  char *cptr, temp[FILENAME_MAX];
  int ret, fformat=IMG_UNKNOWN;
  NIFTI_DSR nifti_dsr;
  IMG img;
 
  if(verbose>0) {printf("imgFormatDetermine(\"%s\", ...)\n", fname); fflush(stdout);}
  /* Initiate results */
  if(basename!=NULL) strcpy(basename, "");
  if(hdrfile!=NULL) strcpy(hdrfile, "");
  if(imgfile!=NULL) strcpy(imgfile, "");
  if(siffile!=NULL) strcpy(siffile, "");
  if(file_format!=NULL) *file_format=IMG_UNKNOWN;
  if(scanner!=NULL) *scanner=SCANNER_UNKNOWN;
  if(type!=NULL) *type=IMG_TYPE_UNKNOWN;
  if(modality!=NULL) *modality=IMG_MODALITY_UNKNOWN;
  if(fname==NULL) return STATUS_FAULT;
  if(strlen(fname)<1) return STATUS_NOFILE;
 
  /* Check the image data exists and is accessible */
  strcpy(temp, fname);
  if(access(temp, 0) == -1) {
    if(verbose>1) printf("  file is not directly accessible.\n");
    /* Try to add .nii to the name */
    sprintf(temp, "%s.nii", fname);
    if(access(temp, 0) == -1) {
      if(verbose>1) printf("  file is not accessible with .nii extension.\n");
      /* Try to add .img to the name */
      sprintf(temp, "%s.img", fname);
      if(access(temp, 0) == -1) {
        if(verbose>1) printf("  file is not accessible with .img extension.\n");
        /* Try to add .hdr to the name */
        sprintf(temp, "%s.hdr", fname);
        if(access(temp, 0) == -1) sprintf(temp, "%s.i.hdr", fname);
        if(access(temp, 0) == -1) sprintf(temp, "%s.img.hdr", fname);
        if(access(temp, 0) == -1) {
          if(verbose>1) printf("  file is not accessible with .hdr extension.\n");
          /* Try to add .dcm to the name */
          sprintf(temp, "%s.dcm", fname);
          if(access(temp, 0) == -1) {
            if(verbose>1) printf("  file is not accessible with .dcm extension.\n");
            return STATUS_NOFILE;
          }
        }
      }
    }
  }
  if(verbose>1) {printf("'%s' is accessible.\n", temp); fflush(stdout);}
 
  /* DICOM is identified from the file name extension, and not processed any further */
  cptr=strrchr(temp, '.');
  if(cptr!=NULL && strcasecmp(cptr, ".DCM")==0) {
    fformat=IMG_DICOM; if(file_format!=NULL) *file_format=fformat;
    if(verbose>1) printf("file was identified to be in DICOM format.\n");
    return STATUS_OK;
  }
 
  /* Try to read it as ECAT file first, because images which consist of 
     more than one file may reside in the same folder with
     other formats */
  imgInit(&img);
  /* Is this an ECAT7 file */
  ret=imgReadEcat7Header(fname, &img);
  if(ret==STATUS_OK) {
    fformat=img._fileFormat; if(file_format!=NULL) *file_format=fformat;
    if(verbose>1) printf("file was identified to be in ECAT7 format.\n");
  } else if(ret==STATUS_VARMATSIZE) {
    fformat=img._fileFormat; if(file_format!=NULL) *file_format=fformat;
    if(verbose>1) printf("file is ECAT7 but matrix sizes are different\n.");
  } else if(ret==STATUS_UNKNOWNFORMAT || ret==STATUS_NOFILE) {
    /* If main header was read but format was not identified as Ecat7, 
       it might be in Ecat6 format */
    ret=imgReadEcat63Header(fname, &img);
    /* if necessary, try also with .img added */
    if(ret!=STATUS_OK && ret!=STATUS_VARMATSIZE && ret!=STATUS_MISSINGMATRIX) {
      sprintf(temp, "%s.img", fname); ret=imgReadEcat63Header(temp, &img);}
    if(ret==STATUS_OK) {
      /* Is this an ECAT6 file; however this is rather uncertain step, because
         ECAT6 files don't contain any magic number */
      fformat=img._fileFormat; if(file_format!=NULL) *file_format=fformat;
      if(verbose>1) printf("file was identified to be in ECAT6 format.\n");
    } else if(ret==STATUS_VARMATSIZE || ret==STATUS_MISSINGMATRIX) {
      fformat=img._fileFormat; if(file_format!=NULL) *file_format=fformat;
      if(verbose>1) printf("file is ECAT63 but matrix sizes are different\n.");
    }
  }
 
  /* If format was not yet identified, then try to read it as NIfTI;
     this must be done before trying Analyze, because dual format NIfTI
     is compatible with Analyze format */
  if(fformat==IMG_UNKNOWN &&
     niftiExists(fname, hdrfile, imgfile, siffile, &nifti_dsr, verbose-2, NULL)>0)
  {
    if(verbose>1) printf("file was identified to be in NIfTI format.\n");
    /* Read NIfTI header information into IMG struct */
    ret=imgGetNiftiHeader(&img, &nifti_dsr, verbose-2);
    if(ret==STATUS_OK) {
      fformat=img._fileFormat; if(file_format!=NULL) *file_format=fformat;
    }
  }
 
  /* If format was not yet identified, then try to read it as microPET */
  if(fformat==IMG_UNKNOWN && upetExists(fname, hdrfile, imgfile, verbose-1)==2) {
    fformat=IMG_MICROPET; if(file_format!=NULL) *file_format=fformat;
    if(verbose>1) printf("file was identified to be in microPET format\n.");
    /* Read header information from file */
    ret=imgReadMicropetHeader(fname, &img);
    if(ret==STATUS_OK) {
      fformat=img._fileFormat; if(file_format!=NULL) *file_format=fformat;
    }
  }
 
  /* If format was not yet identified, then try to read it as Analyze */
  if(fformat==IMG_UNKNOWN && anaDatabaseExists(fname, hdrfile, imgfile, siffile)>0) {
    if(verbose>1) printf("file was identified to be in Analyze format.\n");
    fformat=IMG_ANA; if(file_format!=NULL) *file_format=fformat;
    /* Read Analyze header information */
    ret=imgReadAnalyzeHeader(hdrfile, &img);
    if(ret==STATUS_OK) {
      fformat=img._fileFormat; if(file_format!=NULL) *file_format=fformat;
    }
  }
 
  /* If format was not yet identified, check if it is DICOM (without .dcm extension
     that was checked previously) */
  if(dcmVerifyMagic(fname, NULL)) {
    fformat=IMG_DICOM; if(file_format!=NULL) *file_format=fformat;
    if(verbose>1) printf("file was identified to be in DICOM format.\n");
    return STATUS_OK;
  }
 
  /* If format was not yet identified, check if it is Interfile */
  if(fformat==IMG_UNKNOWN && interfileExists(fname, hdrfile, imgfile, verbose-1)!=0) {
    fformat=IMG_INTERFILE; if(file_format!=NULL) *file_format=fformat;
    if(verbose>1) printf("file was identified to be in Interfile format\n.");
  }
 
  /* Fill other information */
  if(scanner!=NULL) *scanner=img.scanner;
  if(type!=NULL) *type=img.type;
  if(modality!=NULL) *modality=img.modality;
 
  /* Quit */
  imgEmpty(&img);
  if(verbose>1) printf("fformat := %d\n", fformat);
  return STATUS_OK;
}

Referenced by imgReadHeader().

◆ imgFormatFromFName()

void imgFormatFromFName	(	IMG *	img,
		const char *	fname )

extern

Determine IMG _fileFormat from file name extension, if not already defined. Default is ECAT 7 image volume, if nothing else can be guessed.

Note that NIfTI dual file format, Analyze, and microPET files can not be separated by file naming, thus all of these formats will be identified as Analyze by this function (default may be changed to NIfTI in future).

See also: imgRead, imgWrite

Parameters

img	Target image structure where file format is saved; should have IMG_UNKNOWN as file type.
fname	Name of file that is used to determine format.

Definition at line 483 of file imgfile.c.

  {
  char *cptr=NULL, *cptr2=NULL, temp[FILENAME_MAX];
 
  if(IMG_TEST>2) printf("imgFormatFromFName(img, %s)\n", fname);
  if(img->_fileFormat!=IMG_UNKNOWN && img->_fileFormat>0) {
    if(IMG_TEST>3) printf("  _fileFormat := %d, not changed\n", img->_fileFormat);
    return;
  }
  img->_fileFormat=IMG_E7; /* default */
  /* get extensions */
  strcpy(temp, fname); cptr=strrchr(temp, '.');
  if(cptr!=NULL) {
    *cptr=(char)0; cptr++;
    cptr2=strrchr(temp, '.'); if(cptr2!=NULL) {*cptr2=(char)0; cptr2++;}
  }
  if(cptr2!=NULL) {
    if(strcasecmp(cptr2, "i.hdr")==0) { img->_fileFormat=IMG_INTERFILE; return;}
    if(strcasecmp(cptr2, "i.img")==0) { img->_fileFormat=IMG_INTERFILE; return;}
  }
  if(cptr!=NULL) {
    if(strcasecmp(cptr, "hdr")==0) { img->_fileFormat=IMG_ANA; return;}
    if(strcasecmp(cptr, "polmap")==0) { img->_fileFormat=IMG_POLARMAP; return;}
    if(strcasecmp(cptr, "img")==0 ||
       strcasecmp(cptr, "scn")==0 ||
       strcasecmp(cptr, "nrm")==0 ||
       strcasecmp(cptr, "atn")==0) {
      img->_fileFormat=IMG_E63; return;
    }
    if(strcasecmp(cptr, "dcm")==0) { img->_fileFormat=IMG_DICOM; return;}
    if(strcasecmp(cptr, "i")==0) { img->_fileFormat=IMG_INTERFILE; return;}
    if(strcasecmp(cptr, "nii")==0) { img->_fileFormat=IMG_NIFTI_1S; return;}
  } else { /* no extension at all */
    img->_fileFormat=IMG_ANA;
  }
}

Referenced by imgWrite(), and imgWriteFrame().

◆ imgFrameMinMax()

int imgFrameMinMax	(	IMG *	img,
		int	frame,
		float *	minvalue,
		float *	maxvalue )

extern

Searches the min and max pixel value in one frame (1..dimt) of the IMG data.

Returns: 0 if ok, 1 invalid image status, 2 invalid output pointer, 3 invalid image dimensions.

See also: imgMinMax, imgRangeMinMax, imgReadMinMax, imgGetMaxFrame

Parameters

img	Pointer to IMG data.
frame	Frame number [1..number of frames].
minvalue	Pointer to float value where minimum is written.
maxvalue	Pointer to float value where maximum is written.

Definition at line 171 of file imgminmax.c.

  {
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(minvalue==NULL || maxvalue==NULL) return(2);
  *minvalue=*maxvalue=0.0; 
  int fi=frame-1;
  if(img->dimt<frame || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
  if(frame<1) return(4);
 
  float mi, ma;
  mi=ma=nanf("");
  for(int pi=0; pi<img->dimz; pi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++) {
        if(!isfinite(ma) || img->m[pi][yi][xi][fi]>ma) ma=img->m[pi][yi][xi][fi];
        if(!isfinite(mi) || img->m[pi][yi][xi][fi]<mi) mi=img->m[pi][yi][xi][fi];
      }
  *minvalue=mi; *maxvalue=ma;
  if(!isfinite(mi) || !isfinite(ma)) return(5);
  return(0);
}

Referenced by img2svol().

◆ imgGetAnalyzeHeader()

int imgGetAnalyzeHeader	(	IMG *	img,
		ANALYZE_DSR *	h )

extern

Copy Analyze 7.5 header information into IMG.

Parameters

img	image structure
h	Analyze header structure

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 427 of file img_ana.c.

{
  int dimNr, dimx, dimy, dimz=1, dimt=1;
 
  if(IMG_TEST) printf("\nimgGetAnalyzeHeader(*img, *dsr)\n");
  
  /* Check the input */
  
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED && img->status!=IMG_STATUS_OCCUPIED)
    return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(h==NULL) return STATUS_FAULT;
    
  imgSetStatus(img, STATUS_INVALIDHEADER);
 
  /* Get the image dimensions from header */
  dimNr=h->dime.dim[0];
  if(dimNr<2) return STATUS_INVALIDHEADER;
  dimx=h->dime.dim[1]; dimy=h->dime.dim[2];
  if(dimNr>2) {dimz=h->dime.dim[3]; if(dimNr>3) dimt=h->dime.dim[4];}
  long long pxlNr=dimx*dimy*dimz;
  if(pxlNr<1) return STATUS_INVALIDHEADER;
  img->dimx=dimx; img->dimy=dimy; img->dimz=dimz; img->dimt=dimt;
 
  /* Copy information from Analyze header */
  img->type=IMG_TYPE_IMAGE;
  strlcpy(img->studyNr, h->hist.patient_id, MAX_STUDYNR_LEN+1);
  if(strcmp(img->studyNr, ".")==0) strcpy(img->studyNr, "");
  strcpy(img->patientName, h->hist.patient_id);
  img->sizex=h->dime.pixdim[1];
  img->sizey=h->dime.pixdim[2];
  img->sizez=h->dime.pixdim[3];
  /*if(h->dime.funused2>1.E-5) img->zoom=h->dime.funused2;*/
  if(h->dime.funused3>1.E-5) img->isotopeHalflife=h->dime.funused3;
  if(h->little) img->_fileFormat=IMG_ANA_L; else img->_fileFormat=IMG_ANA;
  
  /* Decay correction */
  if(strstr(h->hist.descrip, "Decay corrected.")!=NULL)
    img->decayCorrection=IMG_DC_CORRECTED;
  else if(strstr(h->hist.descrip, "No decay correction.")!=NULL)
    img->decayCorrection=IMG_DC_NONCORRECTED;
  else
    img->decayCorrection=IMG_DC_CORRECTED; // just assumed so
 
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgReadAnalyzeHeader().

◆ imgGetEcat63Fileformat()

int imgGetEcat63Fileformat ( ECAT63_mainheader * h )

extern

Return the IMG fileformat based on ECAT 6.3 file_type.

Parameters

h	Ecat 6.3 main header

Returns: IMG._fileFormat value.

Definition at line 1288 of file img_e63.c.

                                                 {
  int fileFormat=IMG_UNKNOWN;
  switch(h->file_type) {
    case IMAGE_DATA:
    case RAW_DATA:
    case ATTN_DATA:
    case NORM_DATA:
      fileFormat=IMG_E63; break;
    default:
      fileFormat=IMG_UNKNOWN; break;
  }
  return fileFormat;
}

Referenced by imgReadEcat63Header().

◆ imgGetEcat63MHeader()

void imgGetEcat63MHeader	(	IMG *	img,
		ECAT63_mainheader *	h )

extern

Copy ECAT 6.3 main header information into IMG

Parameters

img	target image structure
h	source Ecat 6.3 main header

Definition at line 1172 of file img_e63.c.

{
  if(IMG_TEST>0) printf("imgGetEcat63MHeader()\n");
  img->_dataType=h->data_type; /* again in subheaders*/
  /* For saving IMG data, only 2-byte VAX data types are allowed,
     so change it now */
  if(img->_dataType==VAX_I4 || img->_dataType==VAX_R4) img->_dataType=VAX_I2;
  img->scanner=h->system_type;
  strlcpy(img->radiopharmaceutical, h->radiopharmaceutical, 32);
  img->isotopeHalflife=h->isotope_halflife;
  img->scanStart=ecat63Scanstarttime(h); 
  if(img->scanStart==-1) {
    img->scanStart=0;
    if(IMG_TEST>0) printf("invalid scan_start_time in mainheader\n");
  }
  if(IMG_TEST>1) {
    char buf1[32], buf2[32];
    printf(" %s -> %s\n", ecat63ScanstarttimeInt(h, buf1), 
                          ctime_r_int(&img->scanStart, buf2));
  }
  img->axialFOV=10.0*h->axial_fov;
  img->transaxialFOV=10.0*h->transaxial_fov;
  strlcpy(img->studyNr, h->study_name, MAX_STUDYNR_LEN+1);
  strlcpy(img->patientName, h->patient_name, 32);
  strlcpy(img->patientID, h->patient_id, 16);
  img->sizez=10.0*h->plane_separation;
  switch(h->file_type) {
    case IMAGE_DATA: img->type=IMG_TYPE_IMAGE; break;
    case RAW_DATA:
    case ATTN_DATA:
    case NORM_DATA: 
    default: img->type=IMG_TYPE_RAW;
  }
  strlcpy(img->studyDescription, h->study_description, 32);
  strncpy(img->userProcessCode, h->user_process_code, 10);
  img->userProcessCode[10]=(char)0;
  /* If valid study number is found in user_process_code, then take it */  
  if(!img->studyNr[0] && studynr_validity_check(img->userProcessCode))
    strlcpy(img->studyNr, img->userProcessCode, MAX_STUDYNR_LEN+1);
  /* Set calibration unit (this may have to be read from subheader later) */
  imgUnitFromEcat(img, h->calibration_units);
}

Referenced by imgReadEcat63Header().

◆ imgGetEcat7Fileformat()

int imgGetEcat7Fileformat ( ECAT7_mainheader * h )

extern

Return the IMG fileformat based on ECAT7 file_type.

Parameters

h	Ecat7 main header

Returns: IMG._fileFormat code value

Definition at line 827 of file img_e7.c.

                                               {
  int fileFormat=IMG_UNKNOWN;
  switch(h->file_type) {
    case ECAT7_IMAGE8:
    case ECAT7_IMAGE16:
      fileFormat=IMG_E7_2D; break;
    case ECAT7_VOLUME8:
    case ECAT7_VOLUME16:
      fileFormat=IMG_E7; break;
    case ECAT7_2DSCAN:
      fileFormat=IMG_E7_2D; break;
    case ECAT7_3DSCAN:
    case ECAT7_3DSCAN8:
    case ECAT7_3DSCANFIT:
      fileFormat=IMG_E7; break;
    case ECAT7_POLARMAP:
      fileFormat=IMG_POLARMAP; break;
    default:
      fileFormat=IMG_UNKNOWN; break;
  }
  return fileFormat;
}

Referenced by imgReadEcat7Header().

◆ imgGetEcat7MHeader()

void imgGetEcat7MHeader	(	IMG *	img,
		ECAT7_mainheader *	h )

extern

Copy ECAT 7 main header information into IMG

Parameters

img	target structure
h	source structure

Definition at line 742 of file img_e7.c.

{
  img->scanner=h->system_type;
  imgUnitFromEcat7(img, h);
  strlcpy(img->radiopharmaceutical, h->radiopharmaceutical, 32);
  img->isotopeHalflife=h->isotope_halflife;
  img->scanStart=h->scan_start_time;
  img->axialFOV=10.0*h->distance_scanned;
  img->transaxialFOV=10.0*h->transaxial_fov;
  strlcpy(img->studyNr, h->study_type, MAX_STUDYNR_LEN+1);
  strlcpy(img->patientName, h->patient_name, 32);
  strncpy(img->patientID, h->patient_id, 16);
  img->sizez=10.0*h->plane_separation;
  switch(h->file_type) {
    case ECAT7_IMAGE8:
    case ECAT7_IMAGE16:
    case ECAT7_VOLUME8:
    case ECAT7_VOLUME16: img->type=IMG_TYPE_IMAGE; break;
    case ECAT7_POLARMAP: img->type=IMG_TYPE_POLARMAP; break;
    default: img->type=IMG_TYPE_RAW;
  }
  img->orientation=h->patient_orientation;
  strlcpy(img->studyDescription, h->study_description, 32);
  strncpy(img->userProcessCode, h->user_process_code, 10);
  img->userProcessCode[10]=(char)0;
  /* If valid study number is found in user_process_code, then take it */  
  if(!img->studyNr[0] && studynr_validity_check(img->userProcessCode))
    strlcpy(img->studyNr, img->userProcessCode, MAX_STUDYNR_LEN+1);
  img->branchingFraction=h->branching_fraction;
}

Referenced by imgReadEcat7(), and imgReadEcat7Header().

◆ imgGetMaxFrame()

int imgGetMaxFrame	(	IMG *	img,
		IMG *	mimg,
		int	verbose )

extern

Search the frame with maximum pixel value for each image pixel separately.

See also: imgGetPeak, imgGetMaxTime

Returns: Returns 0, if ok.

Parameters

img	Image to search for max frames; not modified
mimg	Pointer to empty IMG struct in which the nr of frame with max pixel value will be written; 0 is written if max value is <= 0; any old contents are deleted.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 454 of file imgminmax.c.

  {
  if(verbose>0) printf("imgGetMaxFrame()\n");
  
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(mimg==NULL) return(2);
  if(mimg->status==IMG_STATUS_OCCUPIED) imgEmpty(mimg);
 
  /* Allocate memory for one frame */
  int ret;
  if(verbose>1) printf("allocating memory for %dx%dx%d pixels\n", img->dimz, img->dimy, img->dimx);
  ret=imgAllocate(mimg, img->dimz, img->dimy, img->dimx, 1); if(ret) return(ret);
  /* set image header information */
  imgCopyhdr(img, mimg);
  mimg->start[0]=img->start[0]; mimg->end[0]=img->end[img->dimt-1];
  mimg->mid[0]=(mimg->start[0]+mimg->end[0])/2.0;
 
  /* Go through every pixel */
  int ti, zi, xi, yi;
  double mv; int mi;
  for(zi=0; zi<img->dimz; zi++) {
    for(yi=0; yi<img->dimy; yi++) for(xi=0; xi<img->dimx; xi++) {
      ti=mi=0; mv=img->m[zi][yi][xi][ti];
      for(ti=1; ti<img->dimt; ti++) {
        if(img->m[zi][yi][xi][ti]<mv) continue;
        mi=ti; mv=img->m[zi][yi][xi][ti];
      }
      if(mv>1.0E-008) mimg->m[zi][yi][xi][0]=1.0+mi;
      else mimg->m[zi][yi][xi][0]=0.0;
    }
  }
 
  return(0);
}

◆ imgGetMaxTime()

int imgGetMaxTime	(	IMG *	img,
		IMG *	mimg,
		const int	w,
		int	verbose )

extern

Search the time of maximum value for each image pixel separately.

See also: imgGetPeak, imgGetMaxFrame

Returns: Returns 0, if ok.

Parameters

img	Image to search for max frames; not modified.
mimg	Pointer to empty IMG struct in which the max time (sec) will be written; any old contents are deleted.
w	Just save the frame middle time (0), or compute value weighted average time of all frames (1), or, value weighted average time of 3 or 5 subsequent frames (2). Option (1) uses the equation for mean residence time (MRT) for PTACs in pharmacokinetics.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 345 of file imgminmax.c.

  {
  if(verbose>0) printf("imgGetMaxTime(*img, *mimg, %d)\n", w);
  
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(mimg==NULL) return(2);
  if(mimg->status==IMG_STATUS_OCCUPIED) imgEmpty(mimg);
 
  /* Allocate memory for one frame */
  int ret;
  if(verbose>1) printf("allocating memory for %dx%dx%d pixels\n", img->dimz, img->dimy, img->dimx);
  ret=imgAllocate(mimg, img->dimz, img->dimy, img->dimx, 1);
  if(ret) return(ret);
  /* set image header information */
  imgCopyhdr(img, mimg);
  mimg->start[0]=img->start[0]; mimg->end[0]=img->end[img->dimt-1];
  mimg->mid[0]=(mimg->start[0]+mimg->end[0])/2.0;
  mimg->unit=CUNIT_UNKNOWN;
 
  if(w==0) {
    for(int zi=0; zi<img->dimz; zi++) {
      for(int yi=0; yi<img->dimy; yi++) {
        for(int xi=0; xi<img->dimx; xi++) {
          /* Find the frame with max value */
          int ti=0, mi=0; 
          double mv=img->m[zi][yi][xi][ti];
          for(ti=1; ti<img->dimt; ti++) {
            if(img->m[zi][yi][xi][ti]<mv) continue;
            mi=ti; mv=img->m[zi][yi][xi][ti];
          }
          if(mv>0.0) mimg->m[zi][yi][xi][0]=img->mid[mi];
          else mimg->m[zi][yi][xi][0]=0.0;
        }
      }
    }
    return(0);
  }
 
  if(w==1) { // Same as the equation for mean residence time (MRT) for PTACs in pharmacokinetics
    for(int zi=0; zi<img->dimz; zi++) {
      for(int yi=0; yi<img->dimy; yi++) {
        for(int xi=0; xi<img->dimx; xi++) {
          /* Compute the value weighted time */
          double sumw=0.0, sumt=0.0;
          for(int ti=0; ti<img->dimt; ti++) {
            if(isnan(img->m[zi][yi][xi][ti])) continue;
            float fdur=img->end[ti]-img->start[ti]; if(fdur<=0.0) fdur=1.0;
            sumt+=img->m[zi][yi][xi][ti]*img->mid[ti]*fdur;
            sumw+=img->m[zi][yi][xi][ti]*fdur;
          }
          sumt/=sumw;
          if(sumt>0.0 && sumw>0.0) mimg->m[zi][yi][xi][0]=sumt;
          else mimg->m[zi][yi][xi][0]=0.0;
        }
      }
    }
    return(0);
  }
 
  if(w>1) {
    for(int zi=0; zi<img->dimz; zi++) {
      for(int yi=0; yi<img->dimy; yi++) {
        for(int xi=0; xi<img->dimx; xi++) {
          /* Find the frame with max value */
          int ti=0, mi=0; 
          double mv=img->m[zi][yi][xi][ti];
          for(ti=1; ti<img->dimt; ti++) {
            if(img->m[zi][yi][xi][ti]<mv) continue;
            mi=ti; mv=img->m[zi][yi][xi][ti];
          }
          /* calculate weighted mean from subsequent frames, if possible */
          if(mi<1 || mi>img->dimt-2) continue;
          int i1, i2; i1=mi-1; i2=mi+1; if(i1>0 && i2<img->dimt-1) {i1--; i2++;}
          double sumw=0.0, sumt=0.0;
          for(int i=i1; i<=i2; i++) {
            if(!(img->m[zi][yi][xi][i]>0.0)) continue;
            sumt+=img->m[zi][yi][xi][i]*img->mid[i];
            sumw+=img->m[zi][yi][xi][i];
          }
          sumt/=sumw;
          if(sumt>0.0) mimg->m[zi][yi][xi][0]=sumt;
          else mimg->m[zi][yi][xi][0]=0.0;
        }
      }
    }
    return(0);
  }
 
  return(0);
}

◆ imgGetMicropetFrameHeader()

int imgGetMicropetFrameHeader	(	FILE *	fp,
		IMG *	img,
		int	frame_index,
		int	verbose )

extern

Read frame information from MicroPET header into one-frame-IMG.

Returns: Returns 0 when successful, otherwise >0.

Parameters

fp	File pointer to Concorde/MicroPET header.
img	Pointer to IMG struct, allocated for one frame; frame information is written in frame 0.
frame_index	Frame index [0..tdim-1].
verbose	Verbose level.

Definition at line 457 of file img_upet.c.

  {
  char tmp[MAX_MICROPET_LINE_LEN];
  float f;
 
 
  if(verbose>0) printf("%s(*fp, *img, %d)\n", __func__, frame_index);
  if(fp==NULL) return 1;
  if(img==NULL) return 2;
  if(frame_index<0) return 3;
 
  /* Search required frame from the beginning of header file */
  rewind(fp);
 
  /* Find correct frame index */
  sprintf(tmp, "frame %d", frame_index);
  if(verbose>1) printf("  reading '%s'\n", tmp);
  if(upetHeaderReadParameter(fp, tmp, tmp)!=0) return 5;
 
  /* frame start time */
  if(verbose>1) printf("  reading 'frame_start'\n");
  if(upetHeaderReadParameter(fp, "frame_start", tmp)!=0) return 11;
  f=-1.0; (void)sscanf(tmp, "%f", &f); if(f<0.0) return 11;
  img->start[0]=f;
 
  /* frame duration; can be 0 at least in single-frame image */
  if(verbose>1) printf("  reading 'frame_duration'\n");
  if(upetHeaderReadParameter(fp, "frame_duration", tmp)!=0) return 12;
  f=-1.0; (void)sscanf(tmp, "%f", &f); if(f<0.0) return 12;
  img->end[0]=img->start[0]+f;
  img->mid[0]=0.5*(img->end[0]+img->start[0]);
 
  /* scale factor (written in 'weight' since there is no better place) */
  if(verbose>1) printf("  reading 'scale_factor'\n");
  if(upetHeaderReadParameter(fp, "scale_factor", tmp)!=0) return 13;
  f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 13;
  img->weight[0]=f;
 
  /* decay correction */
  if(verbose>1) printf("  reading 'decay_correction'\n");
  if(upetHeaderReadParameter(fp, "decay_correction", tmp)!=0) return 14;
  f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 14;
  img->decayCorrFactor[0]=f;
 
  return 0;
}

Referenced by imgMicropetPETToEcat7().

◆ imgGetMicropetHeader()

int imgGetMicropetHeader ( IMG * img )

extern

Copy microPET header information from IFT structure to IMG structure.

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

img	Pointer to initiated IMG struct

Definition at line 583 of file img_upet.c.

  {
  int i, n;
  float f;
  char key[MAX_MICROPET_LINE_LEN], tmp2[64], tmp3[64];
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
  struct tm scanstart={0};
#pragma clang diagnostic pop
  
  if(MICROPET_TEST) printf("\n%s(*img)\n", __func__);
  
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED && img->status!=IMG_STATUS_OCCUPIED)
    return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(img->ift.keyNr<10) return STATUS_FAULT;
    
  imgSetStatus(img, STATUS_INVALIDHEADER);
 
  /* Check image format */
  i=iftGetIntValue(&img->ift, 0, "file_type", &n, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  if(n!=5) {imgSetStatus(img, STATUS_UNSUPPORTED); return STATUS_UNSUPPORTED;}
 
  i=iftGetIntValue(&img->ift, 0, "acquisition_mode", &n, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  if(n!=2 && n!=3) { // CT (9) not yet supported
    imgSetStatus(img, STATUS_UNSUPPORTED); return STATUS_UNSUPPORTED;}
 
  i=iftGetIntValue(&img->ift, 0, "data_type", &n, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  if(n!=4 && n!=2) {
    imgSetStatus(img, STATUS_UNSUPPORTED); return STATUS_UNSUPPORTED;}
 
  /* scanner model */
  i=iftGetIntValue(&img->ift, 0, "model", &img->scanner, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  if(img->scanner<0) return STATUS_INVALIDHEADER;
 
  /* image dimensions */
  i=iftGetIntValue(&img->ift, 0, "total_frames", &n, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  img->dimt=n; if(img->dimt<1) return STATUS_INVALIDHEADER;
  i=iftGetIntValue(&img->ift, 0, "x_dimension", &n, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  img->dimx=n; if(img->dimx<1) return STATUS_INVALIDHEADER;
  i=iftGetIntValue(&img->ift, 0, "y_dimension", &n, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  img->dimy=n; if(img->dimy<1) return STATUS_INVALIDHEADER;
  i=iftGetIntValue(&img->ift, 0, "z_dimension", &n, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  img->dimz=n; if(img->dimz<1) return STATUS_INVALIDHEADER;
 
  /* zoom */
  i=iftGetFloatValue(&img->ift, 0, "zoom", &img->zoom, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  if(img->zoom<0.0) return STATUS_INVALIDHEADER;
 
  /* pixel size x */
  i=iftGetFloatValue(&img->ift, 0, "pixel_size_x", &img->sizex, 0);
  if(i>=0) {
    if(img->sizex<0.0) return STATUS_INVALIDHEADER;
  } else {
    i=iftGetFloatValue(&img->ift, 0, "pixel_size", &img->sizex, 0);
    if(i<0 || img->sizex<0.0) return STATUS_INVALIDHEADER;
    img->sizex*=10.0;
  }
 
  /* pixel size y */
  i=iftGetFloatValue(&img->ift, 0, "pixel_size_y", &img->sizey, 0);
  if(i>=0) {
    if(img->sizey<0.0) return STATUS_INVALIDHEADER;
  } else {
    i=iftGetFloatValue(&img->ift, 0, "pixel_size", &img->sizey, 0);
    if(i<0 || img->sizey<0.0) return STATUS_INVALIDHEADER;
    img->sizey*=10.0;
  }
 
  /* pixel size z, replaced by transaxial_bin_size, if available */
  /* transaxial_bin_size */
  i=iftGetFloatValue(&img->ift, 0, "pixel_size_z", &img->sizez, 0);
  if(i>=0) {
    if(img->sizez<0.0) return STATUS_INVALIDHEADER;
  } else {
    i=iftGetFloatValue(&img->ift, 0, "axial_plane_size", &img->sizez, 0);
    if(i<0 || img->sizez<0.0) return STATUS_INVALIDHEADER;
    img->sizez*=10.0;
  }
  i=iftGetFloatValue(&img->ift, 0, "transaxial_bin_size", &f, 0);
  if(i>=0 && f>0.0) img->sizez=10.0*f;
 
  /* isotope halflife */
  i=iftGetFloatValue(&img->ift, 0, "isotope_half_life", &img->isotopeHalflife, 0);
  if(i<0 || img->isotopeHalflife<0.0) return STATUS_INVALIDHEADER;
 
  /* branching_fraction */
  i=iftGetFloatValue(&img->ift, 0, "isotope_branching_fraction", &img->branchingFraction, 0);
  if(i<0 || img->branchingFraction<0.0) return STATUS_INVALIDHEADER;
 
  /* decay correction applied */
  i=iftGetIntValue(&img->ift, 0, "decay_correction_applied", &n, 0);
  if(i<0 || n<0.0) return STATUS_INVALIDHEADER;
  if(n==0) img->decayCorrection=IMG_DC_NONCORRECTED;
  else img->decayCorrection=IMG_DC_CORRECTED;
 
  /* calibration units */
  i=iftGetIntValue(&img->ift, 0, "calibration_units", &n, 0);
  if(i<0 || n<0.0) return STATUS_INVALIDHEADER;
  switch(n) {
    case 1: img->unit=CUNIT_NCI_PER_ML; break;
    case 2: img->unit=CUNIT_BQ_PER_ML; break;
    case 3: img->unit=CUNIT_HU; break;
    case 0:
    default: img->unit=CUNIT_UNKNOWN; break;
  }
 
  /* calibration factor */
  i=iftGetFloatValue(&img->ift, 0, "calibration_factor", &img->calibrationFactor, 0);
  if(i<0 || img->calibrationFactor<0.0) return STATUS_INVALIDHEADER;
  if(img->branchingFraction>0.0) img->calibrationFactor/=img->branchingFraction;
 
  /* FOV */
  i=iftGetFloatValue(&img->ift, 0, "radial_fov", &img->transaxialFOV, 0);
  if(i<0) return STATUS_INVALIDHEADER;
  img->transaxialFOV*=10.0;
 
  /* General */
  img->_fileFormat=IMG_MICROPET;
  img->type=IMG_TYPE_IMAGE;
 
  /* Studynumber, if possible */
  strcpy(key, "study"); n=1;
  if((i=iftGet(&img->ift, key, 0))>=0) 
    n=studynr_from_fname2(img->ift.item[i].value, img->studyNr, 0);
  if(n!=0) {
    strcpy(key, "file_name");
    if((i=iftGet(&img->ift, key, 0))>=0)
      n=studynr_from_fname2(img->ift.item[i].value, img->studyNr, 0);
  }
  if(n!=0 && MICROPET_TEST>1) printf("Valid studyNr could not be read.\n");
 
  /* Scan start */
  strcpy(key, "scan_time");
  if((i=iftGet(&img->ift, key, 0))<0) return STATUS_INVALIDHEADER;
  n=sscanf(img->ift.item[i].value, "%s %s %d %d:%d:%d %d",
           tmp2, tmp3, &scanstart.tm_mday,
           &scanstart.tm_hour, &scanstart.tm_min, &scanstart.tm_sec, &i);
  if(n==7) {
    scanstart.tm_year=i-1900;
    if(strcasecmp(tmp3, "Jan")==0)      scanstart.tm_mon=0;
    else if(strcasecmp(tmp3, "Feb")==0) scanstart.tm_mon=1;
    else if(strcasecmp(tmp3, "Mar")==0) scanstart.tm_mon=2;
    else if(strcasecmp(tmp3, "Apr")==0) scanstart.tm_mon=3;
    else if(strcasecmp(tmp3, "May")==0) scanstart.tm_mon=4;
    else if(strcasecmp(tmp3, "Jun")==0) scanstart.tm_mon=5;
    else if(strcasecmp(tmp3, "Jul")==0) scanstart.tm_mon=6;
    else if(strcasecmp(tmp3, "Aug")==0) scanstart.tm_mon=7;
    else if(strcasecmp(tmp3, "Sep")==0) scanstart.tm_mon=8;
    else if(strcasecmp(tmp3, "Oct")==0) scanstart.tm_mon=9;
    else if(strcasecmp(tmp3, "Nov")==0) scanstart.tm_mon=10;
    else if(strcasecmp(tmp3, "Dec")==0) scanstart.tm_mon=11;
    scanstart.tm_isdst=-1;
    img->scanStart=timegm(&scanstart); //mktime(&scanstart);
    if(img->scanStart<0) img->scanStart=0;
  } else return STATUS_INVALIDHEADER;
 
 
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgReadMicropetHeader().

◆ imgGetMicropetMainHeader()

int imgGetMicropetMainHeader	(	FILE *	fp,
		IMG *	img,
		float *	calibration_factor,
		int	verbose )

extern

Read main header information from MicroPET header into one-frame-IMG.

Returns: Returns 0 when successful and >0 in case of an error.

Parameters

fp	MicroPET header file pointer.
img	Pointer to allocated IMG structure.
calibration_factor	Calibration factor / Branching fraction.
verbose	Verbose level.

Definition at line 300 of file img_upet.c.

  {
  char tmp[MAX_MICROPET_LINE_LEN];
  int n;
  float f;
 
 
  if(verbose>0) printf("%s(*fp, *img, *f)\n", __func__);
  if(fp==NULL) return 1;
  if(img==NULL) return 2;
 
  /* scanner model */
  rewind(fp);
  if(verbose>1) printf("  reading 'model'\n");
  if(upetHeaderReadParameter(fp, "model", tmp)!=0) return 11;
  n=-1; (void)sscanf(tmp, "%d", &n); if(n<0) return 11;
  img->scanner=n;
 
  /* zoom */
  rewind(fp);
  if(verbose>1) printf("  reading 'zoom'\n");
  if(upetHeaderReadParameter(fp, "zoom", tmp)!=0) return 11;
  f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 11;
  img->zoom=f;
 
  /* If 'pixel_size' is found, use it as initial value for pixel x, y, and z size */
  rewind(fp);
  if(verbose>1) printf("  reading 'pixel_size'\n");
  if(upetHeaderReadParameter(fp, "pixel_size", tmp)==0) {
    f=-1; (void)sscanf(tmp, "%f", &f);
    if(f>0.0) {
      if(verbose>2) printf("  pixel_size := %g cm\n", f);
      img->sizex=img->sizey=img->sizez=10.0*f;
    }
  }
 
  /* pixel size x */
  rewind(fp);
  if(verbose>1) printf("  reading 'pixel_size_x'\n");
  if(upetHeaderReadParameter(fp, "pixel_size_x", tmp)==0) {
    f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 12;
    if(verbose>2) printf("  pixel_size_x := %g\n", f);
    img->sizex=f;
  }
 
  /* pixel size y */
  rewind(fp);
  if(verbose>1) printf("  reading 'pixel_size_y'\n");
  if(upetHeaderReadParameter(fp, "pixel_size_y", tmp)==0) {
    f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 13;
    if(verbose>2) printf("  pixel_size_y := %g\n", f);
    img->sizey=f;
  }
 
  /* pixel size z; note that transaxial_bin_size may be better in case of plane gaps */
  rewind(fp);
  if(verbose>1) printf("  reading 'pixel_size_z'\n");
  if(upetHeaderReadParameter(fp, "pixel_size_z", tmp)==0) {
    f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 14;
    if(verbose>2) printf("  pixel_size_z := %g\n", f);
    img->sizez=f;
  } else {
    if(verbose>0) printf("  cannot find 'pixel_size_z'\n");
    rewind(fp);
    if(verbose>1) printf("  reading 'axial_plane_size'\n");
    if(upetHeaderReadParameter(fp, "axial_plane_size", tmp)!=0) {
      if(verbose>0) printf("  cannot find 'axial_plane_size'\n");
      img->sizez=0.0;
    } else {
      f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 14;
      if(verbose>2) printf("  axial_pixel_size := %g cm\n", f);
      img->sizez=10.*f;
    }
  }
  /* transaxial_bin_size; in case of plane gaps this could be better than pixel_size_z */
  rewind(fp);
  if(verbose>1) printf("  reading 'transaxial_bin_size'\n");
  if(upetHeaderReadParameter(fp, "transaxial_bin_size", tmp)==0) {
    f=-1; (void)sscanf(tmp, "%f", &f); 
    if(verbose>2) printf("  transaxial_pixel_size := %g cm\n", f);
    //if(f>0) img->sizez=10.0*f;
  }
 
  /* isotope halflife */
  rewind(fp);
  if(verbose>1) printf("  reading 'isotope_half_life'\n");
  if(upetHeaderReadParameter(fp, "isotope_half_life", tmp)==0) {
    f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 15;
    img->isotopeHalflife=f;
  }
 
  /* branching_fraction */
  rewind(fp);
  if(verbose>1) printf("  reading 'isotope_branching_fraction'\n");
  if(upetHeaderReadParameter(fp, "isotope_branching_fraction", tmp)==0) {
    f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 16;
    img->branchingFraction=f;
  }
 
  /* decay correction applied */
  rewind(fp);
  if(verbose>1) printf("  reading 'decay_correction_applied'\n");
  if(upetHeaderReadParameter(fp, "decay_correction_applied", tmp)==0) {
    n=-1; (void)sscanf(tmp, "%d", &n); if(n<0) return 17;
    if(n==0) img->decayCorrection=IMG_DC_NONCORRECTED;
    else img->decayCorrection=IMG_DC_CORRECTED;
  }
 
  /* calibration units */
  rewind(fp);
  if(verbose>1) printf("  reading 'calibration_units'\n");
  if(upetHeaderReadParameter(fp, "calibration_units", tmp)==0) {
    n=-1; (void)sscanf(tmp, "%d", &n); if(n<0) return 18;
    switch(n) {
      case 1: img->unit=CUNIT_NCI_PER_ML; break;
      case 2: img->unit=CUNIT_BQ_PER_ML; break;
      case 3: img->unit=CUNIT_HU; break;
      case 0:
      default: img->unit=CUNIT_UNKNOWN; break;
    }
  }
 
  /* calibration factor */
  rewind(fp);
  if(verbose>1) printf("  reading 'calibration_factor'\n");
  if(calibration_factor!=NULL &&
     upetHeaderReadParameter(fp, "calibration_factor", tmp)==0)
  {
    f=-1; (void)sscanf(tmp, "%f", &f); if(f<=0.0) return 19;
    *calibration_factor=f;
    if(img->branchingFraction>0.0) *calibration_factor/=img->branchingFraction;
  }
 
  /* FOV */
  rewind(fp);
  if(verbose>1) printf("  reading 'radial_fov'\n");
  if(upetHeaderReadParameter(fp, "radial_fov", tmp)==0) {
    f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 20;
    img->transaxialFOV=10.0*f;
  }
 
  return 0;
}

Referenced by imgMicropetCTToEcat7(), and imgMicropetPETToEcat7().

◆ imgGetMicropetSIF()

int imgGetMicropetSIF	(	FILE *	fp,
		SIF *	sif )

extern

Read Scan Information from Concorde/MicroPET header file.

Returns: Returns 0 if successful.

Parameters

fp	File pointer to Concorde/MicroPET header file.
sif	Pointer to initiated but non-allocated SIF struct; Studynr should be filled afterwards.

Definition at line 517 of file img_upet.c.

  {
  char tmp[MAX_MICROPET_LINE_LEN], tmp2[64], tmp3[64];
  int n, i, ret;
 
 
  if(fp==NULL) return 1;
  if(sif==NULL) return 2;
 
 
  /* Get frame number */
  rewind(fp);
  if(upetHeaderReadParameter(fp, "total_frames", tmp)!=0) return 11;
  n=-1; (void)sscanf(tmp, "%d", &n); if(n<1) return 11;
 
  /* Allocate memory for SIF */
  ret=sifSetmem(sif, n); if(ret!=0) return 4;
  sif->frameNr=n;
  sif->colNr=4;
  sif->version=1;
 
  /* Scan time */
  upetScanStart(fp, &sif->scantime);
 
  /* Isotope */
  rewind(fp);
  if(upetHeaderReadParameter(fp, "isotope", tmp)!=0) return 13;
  strlcpy(sif->isotope_name, tmp, 8);
 
  /* Frames */
  for(i=0; i<sif->frameNr; i++) {
    /* Find correct frame index */
    sprintf(tmp, "frame %d", i);
    if(upetHeaderReadParameter(fp, tmp, tmp)!=0) return 21;
    /* frame start time */
    if(upetHeaderReadParameter(fp, "frame_start", tmp)!=0) return 22;
    n=-1; (void)sscanf(tmp, "%d", &n); if(n<0) return 22;
    sif->x1[i]=n;
    /* frame duration */
    if(upetHeaderReadParameter(fp, "frame_duration", tmp)!=0) return 23;
    n=-1; (void)sscanf(tmp, "%d", &n); if(n<0) return 23;
    sif->x2[i]=sif->x1[i]+n;
    /* prompts */
    if(upetHeaderReadParameter(fp, "prompts", tmp)!=0) return 24;
    n=-1; (void)sscanf(tmp, "%s %s %d", tmp2, tmp3, &n); if(n<0) return 24;
    sif->prompts[i]=n;
    /* delays */
    if(upetHeaderReadParameter(fp, "delays", tmp)!=0) return 25;
    n=-1; (void)sscanf(tmp, "%s %s %d", tmp2, tmp3, &n); if(n<0) return 25;
    sif->randoms[i]=n;
    /* trues */
    sif->trues[i]=sif->prompts[i]-sif->randoms[i];
  }
  return 0;
}

◆ imgGetNiftiHeader()

int imgGetNiftiHeader	(	IMG *	img,
		NIFTI_DSR *	dsr,
		int	verbose )

extern

Copy Nifti header information into IMG.

Returns: Returns IMG status, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

See also: imgSetNiftiHeader, imgReadNiftiHeader

Parameters

img	Pointer to IMG struct
dsr	Pointer to Nifti header contents
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 218 of file img_nii.c.

  {
  if(verbose>0) {printf("imgGetNiftiHeader()\n"); fflush(stdout);}
  
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED && img->status!=IMG_STATUS_OCCUPIED)
    return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(dsr==NULL) return STATUS_FAULT;
    
  imgSetStatus(img, STATUS_INVALIDHEADER);
 
  /* Get the image dimensions from header */
  int dimNr=dsr->h.dim[0];
  if(dimNr<2 || dimNr>4) {
    if(verbose>0)
      fprintf(stderr, "Error: Nifti image dimension %d is not supported\n", dimNr);
    return STATUS_UNSUPPORTED;
  }
  int dimx, dimy, dimz=1, dimt=1;
  dimx=dsr->h.dim[1]; dimy=dsr->h.dim[2];
  if(dimNr>2) {dimz=dsr->h.dim[3]; if(dimNr>3) dimt=dsr->h.dim[4];}
  long long pxlNr=dimx*dimy*dimz;
  if(pxlNr<1) {
    if(verbose>0) fprintf(stderr, "Error: invalid Nifti image dimensions.\n");
    return STATUS_INVALIDHEADER;
  }
  img->dimx=dimx; img->dimy=dimy; img->dimz=dimz; img->dimt=dimt;
 
  /* Copy information from header */
  img->type=IMG_TYPE_IMAGE;
  strcpy(img->studyNr, "");
  strcpy(img->patientName, "");
  /* NIfTI file format */
  if(strcmp(dsr->h.magic, "ni1")==0) img->_fileFormat=IMG_NIFTI_1D;
  else if(strcmp(dsr->h.magic, "n+1")==0) img->_fileFormat=IMG_NIFTI_1S;
  else {
    if(verbose>0) fprintf(stderr, "Error: invalid Nifti magic number.\n");
    return STATUS_INVALIDHEADER;
  }
  /* NIfTI datatype is not needed, because currently saved as floats anyway */
  //img->_dataType=dsr->h.datatype;
  /* Pixel x,y,z sizes, converting units if necessary */
  float f=1.0;
  if(dsr->h.xyzt_units & NIFTI_UNITS_METER) f=1000.;
  else if(dsr->h.xyzt_units & NIFTI_UNITS_MICRON) f=0.001;
  else if(dsr->h.xyzt_units & NIFTI_UNITS_MM) f=1.0;
  if(verbose>2) printf("pixel size conversion factor := %g\n", f);
  for(int i=1; i<=3; i++) {
    if(i==1) img->sizex=f*dsr->h.pixdim[i];
    else if(i==2) img->sizey=f*dsr->h.pixdim[i];
    else if(i==3) img->sizez=f*dsr->h.pixdim[i];
  }
  /* Orientation, quaternion, and transformation parameters */
  img->xform[0]=dsr->h.qform_code;
  img->xform[1]=dsr->h.sform_code;
  img->quatern[0]=dsr->h.quatern_b;
  img->quatern[1]=dsr->h.quatern_c;
  img->quatern[2]=dsr->h.quatern_d;
  img->quatern[3]=dsr->h.qoffset_x;
  img->quatern[4]=dsr->h.qoffset_y;
  img->quatern[5]=dsr->h.qoffset_z;
  for(int i=0; i<4; i++) img->quatern[6+i]=dsr->h.srow_x[i];
  for(int i=0; i<4; i++) img->quatern[10+i]=dsr->h.srow_y[i];
  for(int i=0; i<4; i++) img->quatern[14+i]=dsr->h.srow_z[i];
 
  /* Assumptions */
  img->decayCorrection=IMG_DC_CORRECTED;
 
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgFormatDetermine(), imgReadNiftiHeader(), and imgWriteNiftiFrame().

◆ imgGetPeak()

int imgGetPeak	(	IMG *	img,
		float	beforeTime,
		IMG_PIXEL *	p,
		int	verbose )

extern

Searches the max pixel value in the IMG data, which occurs before specified time.

See also: imgGetMaxTime, imgGetMaxFrame

Returns: Returns 0 if successful.

Parameters

img	Pointer to IMG struct
beforeTime	Time (sec) after which max value is not searched
p	Pointer to struct where max pixel position is written
verbose	Verbose level; 0 if nothing is to be printed in stdout

Definition at line 294 of file imgminmax.c.

  {
  int zi, yi, xi, fi, mf;
  float f;
 
  if(verbose>0) printf("imgGetPeak(img, %g, p, %d)\n", beforeTime, verbose);
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(p==NULL) return(2);
  if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
  if(beforeTime<img->mid[0]) {
    if(verbose>0) fprintf(stderr, "Error: invalid max search time setting.\n");
    return(4);
  }
  f=nanf(""); mf=img->dimt; p->x=p->y=p->z=p->f=1;
  for(zi=0; zi<img->dimz; zi++) {
    for(yi=0; yi<img->dimy; yi++) {
      for(xi=0; xi<img->dimx; xi++) {
        for(fi=0; fi<img->dimt; fi++) if(img->mid[fi]<=beforeTime) {
          if(!isfinite(img->m[zi][yi][xi][fi])) continue;
          if(isfinite(f) && img->m[zi][yi][xi][fi]<f) // lower
            continue;
          if(isfinite(f) && img->m[zi][yi][xi][fi]==f) { // equal
            // only use this if earlier than in prev max
            if(fi>=mf) continue;
          } 
          f=img->m[zi][yi][xi][fi];
          p->x=xi+1; p->y=yi+1; p->z=zi+1; p->f=fi+1;
          mf=fi;
        }
      }
    }
  }
  if(!isfinite(f)) return(5);
  if(verbose>2) printf("maxval := %g\n", f);
  return(0);
}

◆ imgInfo()

void imgInfo ( IMG * image )

extern

Prints img information to stdout; mainly for testing purposes.

Parameters

image Pointer to IMG data.

Definition at line 359 of file img.c.

  {
  char buf[64];
 
  if(IMG_TEST) printf("imgInfo()\n");
  if(image==NULL) {
    fprintf(stdout, "image := NULL\n"); return;
  } else if(image->status<=IMG_STATUS_UNINITIALIZED) {
    fprintf(stdout, "image_status := not initialized\n"); return;
  } else if(image->status==IMG_STATUS_INITIALIZED) {
    fprintf(stdout, "image_status := initialized but empty\n"); /* return; */
  } else if(image->status==IMG_STATUS_ERROR) {
    fprintf(stdout, "image_status := error\n");
  }
  fprintf(stdout, "image_error_status := %s\n", image->statmsg);
  fprintf(stdout, "image_type := %d\n", image->type);
  fprintf(stdout, "saved_data_type := %d\n", image->_dataType);
  fprintf(stdout, "file_format := %d\n", image->_fileFormat);
  fprintf(stdout, "scanner := %d\n", image->scanner);
  fprintf(stdout, "modality := %d\n", image->modality);
 
  fprintf(stdout, "qform := %d\n", image->xform[0]);
  fprintf(stdout, "sform := %d\n", image->xform[1]);
  fprintf(stdout, "quatern_b := %g\n", image->quatern[0]);
  fprintf(stdout, "quatern_c := %g\n", image->quatern[1]);
  fprintf(stdout, "quatern_d := %g\n", image->quatern[2]);
  fprintf(stdout, "quatern_x_shift := %g\n", image->quatern[3]);
  fprintf(stdout, "quatern_y_shift := %g\n", image->quatern[4]);
  fprintf(stdout, "quatern_z_shift := %g\n", image->quatern[5]);
  for(int i=0; i<4; i++)
    fprintf(stdout, "srow_x[%d] := %g\n", 1+i, image->quatern[6+i]);
  for(int i=0; i<4; i++)
    fprintf(stdout, "srow_y[%d] := %g\n", 1+i, image->quatern[10+i]);
  for(int i=0; i<4; i++)
    fprintf(stdout, "srow_z[%d] := %g\n", 1+i, image->quatern[14+i]);
  for(int i=0; i<12; i++)
    fprintf(stdout, "matrix_transformation[%d] := %g\n", 1+i, image->mt[i]);
 
  fprintf(stdout, "ift.keyNr := %d\n", image->ift.keyNr);
  fprintf(stdout, "identification_code := %.*s\n",
                   MAX_STUDYNR_LEN, image->studyNr);
  fprintf(stdout, "data_unit := %s\n", imgUnit((int)image->unit));
  fprintf(stdout, "image_zoom := %g\n", image->zoom);
  fprintf(stdout, "radiopharmaceutical := %.32s\n", image->radiopharmaceutical);
  fprintf(stdout, "isotope_halflife := %e [sec]\n", image->isotopeHalflife);
  fprintf(stdout, "branching_fraction := %f\n", image->branchingFraction);
  fprintf(stdout, "calibration_factor := %e\n", image->calibrationFactor);
  if(!ctime_r_int(&image->scanStart, buf)) strcpy(buf, "1900-01-01 00:00:00");
  fprintf(stdout, "scan_start_time := %s\n", buf);
  fprintf(stdout, "patient_name := %s\n", image->patientName);
  fprintf(stdout, "patient_id := %s\n", image->patientID);
  fprintf(stdout, "patient_orientation := %d\n", image->orientation);
  fprintf(stdout, "FOV_axial := %g [mm]\n", image->axialFOV);
  fprintf(stdout, "FOV_transaxial := %g [mm]\n", image->transaxialFOV);
  fprintf(stdout, "sample_distance := %g [mm]\n", image->sampleDistance);
  fprintf(stdout, "pixel_size_x := %g [mm]\n", image->sizex);
  fprintf(stdout, "pixel_size_y := %g [mm]\n", image->sizey);
  fprintf(stdout, "pixel_size_z := %g [mm]\n", image->sizez);
  fprintf(stdout, "dimension_x := %d\n", image->dimx);
  fprintf(stdout, "dimension_y := %d\n", image->dimy);
  fprintf(stdout, "dimension_z := %d\n", image->dimz);
  fprintf(stdout, "dimension_t := %d\n", image->dimt);
  /* Polar map */
  fprintf(stdout, "polarmap_num_rings := %d\n", image->polarmap_num_rings);
  if(image->polarmap_num_rings>0) {
    fprintf(stdout, "polarmap_sectors_per_ring :=");
    for(int i=0; i<image->polarmap_num_rings; i++)
      fprintf(stdout, " %d", image->polarmap_sectors_per_ring[i]);
    fprintf(stdout, "\n");
    fprintf(stdout, "polarmap_ring_position :=");
    for(int i=0; i<image->polarmap_num_rings; i++)
      fprintf(stdout, " %g", image->polarmap_ring_position[i]);
    fprintf(stdout, "\n");
    fprintf(stdout, "polarmap_ring_angle :=");
    for(int i=0; i<image->polarmap_num_rings; i++)
      fprintf(stdout, " %d", image->polarmap_ring_angle[i]);
    fprintf(stdout, "\n");
    fprintf(stdout, "polarmap_start_angle := %d\n", image->polarmap_start_angle);
  }
  /* Check if the rest is available */
  if(image->status==IMG_STATUS_INITIALIZED) return;
 
  fprintf(stdout, "actual_plane_numbers := %d", image->planeNumber[0]);
  for(int i=1; i<image->dimz; i++) fprintf(stdout, " %d", image->planeNumber[i]);
  fprintf(stdout, "\n");
  fprintf(stdout, "Frame times (sec):\n");
  for(int i=0; i<image->dimt; i++) fprintf(stdout, "  %e %e %e\n",
    image->start[i], image->end[i], image->mid[i]);
  if(image->isWeight) fprintf(stdout, "Frames are weighted.\n");
  else fprintf(stdout, "Frames are not weighted.\n");
  if(image->decayCorrection==IMG_DC_CORRECTED) {
    fprintf(stdout, "Decay correction factors for each frame:\n");
    for(int i=0; i<image->dimt; i++)
      fprintf(stdout, "%03i  %e\n", i+1, image->decayCorrFactor[i]);
  } else
    fprintf(stdout, "Image is not decay corrected.\n");
  return;
}

Referenced by ecat63AddImg(), img_k1_using_ki(), img_logan(), img_patlak(), imgAnalyzeToEcat(), imgNiftiToEcat(), imgReadAnalyzeFirstFrame(), imgReadEcat63FirstFrame(), imgReadEcat7FirstFrame(), imgReadFrame(), imgReadMicropetFirstFrame(), imgReadNifti(), and imgReadNiftiFirstFrame().

◆ imgInit()

void imgInit ( IMG * image )

extern

Call this once before any use of IMG data.

See also: imgAllocate, imgEmpty

Parameters

image Pointer to IMG struct.

Definition at line 60 of file img.c.

  {
  if(IMG_TEST) printf("imgInit()\n");
  if(image==NULL) return;
  memset(image, 0, sizeof(IMG));
  /*if(image->status!=IMG_STATUS_UNINITIALIZED) return;*/
  image->status=IMG_STATUS_INITIALIZED;
  imgSetStatus(image, STATUS_OK);
  image->type=0;
  image->unit=0;
  image->calibrationFactor=0.0;
  image->zoom=0.0;
  image->radiopharmaceutical[0]=(char)0;
  image->isotopeHalflife=0.0;
  image->decayCorrection=(char)IMG_DC_UNKNOWN;
  image->branchingFraction=0.0;
  image->unit=0;
  image->scanStart=0;
  image->orientation=0;
  image->axialFOV=image->transaxialFOV=image->sampleDistance=0.0;
  image->studyNr[0]=image->patientName[0]=(char)0;
  image->sizex=image->sizey=image->sizez=0;
  image->_dataType=0;
  image->_fileFormat=0;
  image->scanner=0;
  image->modality=0;
  for(int i=0; i<2; i++) image->xform[i]=NIFTI_XFORM_UNKNOWN;
  for(int i=0; i<18; i++) image->quatern[i]=0.0;
  for(int i=0; i<12; i++) image->mt[i]=0.0;
  iftInit(&image->ift);
  image->polarmap_num_rings=0;
  for(int i=0; i<MAX_POLARMAP_NUM_RINGS; i++) {
    image->polarmap_sectors_per_ring[i]=0;
    image->polarmap_ring_position[i]=0.0;
    image->polarmap_ring_angle[i]=0;
  }
  image->polarmap_start_angle=0;
  image->dimt=image->dimx=image->dimy=image->dimz=0;
  image->gapx=image->gapy=image->gapz=0.0;
  image->resolutionx=image->resolutiony=image->resolutionz=0.0;
  image->m=(float****)NULL;
  image->_header=(float*)NULL;
  image->pixel=(float*)NULL;
  image->column=(float**)NULL;
  image->row=(float***)NULL;
  image->plane=(float****)NULL;
  image->planeNumber=(int*)NULL;
  image->start=image->end=image->mid=(float*)NULL;
  image->isWeight=0;
  image->weight=image->sd=image->prompts=image->randoms=(float*)NULL;
  image->decayCorrFactor=(float*)NULL;
  image->errstatus=STATUS_OK;
}

Referenced by imgAnalyzeToEcat(), imgFlipAbove(), imgFlipRight(), imgFormatDetermine(), imgMaskDilate(), imgMaskErode(), imgMicropetCTToEcat7(), imgMicropetPETToEcat7(), imgNiftiToEcat(), imgOutlierFilter(), imgPVCRRL(), imgPVCRVC(), imgReadFrame(), imgReadMinMax(), imgReadModelingData(), imgsegmSimilar(), imgThresholding(), imgThresholdingLowHigh(), imgWriteAnalyzeFrame(), imgWriteEcat63Frame(), imgWriteEcat7Frame(), and imgWriteNiftiFrame().

◆ imgIsotope()

char * imgIsotope ( IMG * img )

extern

Returns pointer to string describing the isotope in image data

Parameters

img	image structure

Returns: pointer to string

See also: imgDecayCorrection

Definition at line 76 of file imgdecayc.c.

                           {
  return(hlIsotopeCode(hlIsotopeFromHalflife(img->isotopeHalflife/60.0)));
}

Referenced by ecat63AddImg(), ecat63WriteAllImg(), img2sif(), imgSetEcat63MHeader(), imgSetEcat7MHeader(), and sifAllocateWithIMG().

◆ imgMatch()

int imgMatch	(	IMG *	img1,
		IMG *	img2,
		float	accuracy )

extern

Checks if two IMG data contents are similar (header information, frame times, data dimensions, matrix contents inside specified accuracy).

Returns: Returns 0 if match was found, and >0 if not.

See also: imgMatchMatrix, imgMatchHeader, imgMaxDifference, imgConvertUnit

Parameters

img1	Pointer to the first IMG data.
img2	Pointer to the second IMG data to be compared against the first one.
accuracy	Pixel values must satisfy condition abs(x1-x2)/abs(mean(x1,x2)) <= accuracy (for example 0.01). If you want exact match, set accuracy=0.0.

Definition at line 15 of file imgcomp.c.

  {
  int ret=0;
  
  if(img1==NULL || img2==NULL) return(1);
  ret=imgMatchHeader(img1, img2); if(ret!=0) return(100+ret);
  ret=imgMatchFrames(img1, img2); if(ret!=0) return(200+ret);
  ret=imgMatchPlanes(img1, img2); if(ret!=0) return(300+ret);
  ret=imgMatchMatrix(img1, img2, (double)accuracy); if(ret!=0) return(400+ret);
  ret=imgMatchTransform(img1, img2); if(ret!=0) return(500+ret);
  return(0);
}

◆ imgMatchFrames()

int imgMatchFrames	(	IMG *	img1,
		IMG *	img2 )

extern

Checks if the frame times of two IMG data do match:

Returns: Returns 0 if match was found, and >0 if they do not match.

See also: imgMatchPlanes

Parameters

img1	Pointer to the first IMG structure.
img2	Pointer to the second IMG structure.

Definition at line 286 of file imgcomp.c.

  {
  if(img1->dimt!=img2->dimt) return(1);
  for(int fi=0; fi<img1->dimt; fi++) {
    if(fabs(img1->start[fi]-img2->start[fi])>0.001) return(11);
    if(fabs(img1->end[fi]-img2->end[fi])>0.001) return(12);
    if(fabs(img1->mid[fi]-img2->mid[fi])>0.001) return(13);
  }
  return(0);
}

Referenced by imgMatch().

◆ imgMatchHeader()

int imgMatchHeader	(	IMG *	img1,
		IMG *	img2 )

extern

Checks if two image headers match.

Returns: Returns 0 if headers match, 1 if headers do not match.

See also: imgMatchPlanes, imgMatchFrames, imgMatchTransform

Parameters

img1	Pointer to the first IMG structure.
img2	Pointer to the second IMG structure.

Definition at line 128 of file imgcomp.c.

  {
 
  if(img1->unit!=img2->unit){
    fprintf(stderr, "In the header: Mismatching unit.\n");
    return 1;
  }
 
  // Not always preserved in read&write, therefore tested if present in both 
  if(img1->calibrationFactor>0.0 && img2->calibrationFactor>0.0 && 
     img1->calibrationFactor!=img2->calibrationFactor) 
  {
    fprintf(stderr, "In the header: Mismatching calibration factor.\n");
    return 1;
  }
 
  if(img1->zoom!=img2->zoom){
    fprintf(stderr, "In the header: Mismatching zoom.\n");
    return 1;
  }
  if(strcasecmp(img1->radiopharmaceutical,img2->radiopharmaceutical)){
    fprintf(stderr, "In the header: Mismatching radiopharmaceutical.\n");
    return 1;
  }
  if(img1->isotopeHalflife!=img2->isotopeHalflife){
    fprintf(stderr, "In the header: Mismatching isotope halflife.\n");
    return 1;
  }
  if(img1->decayCorrection!=img2->decayCorrection){
    fprintf(stderr, "In the header: One of the images is not corrected for decay.\n");
    return 1;
  }
  if(img1->branchingFraction!=img2->branchingFraction){
    fprintf(stderr, "In the header: Mismatching branching ratio.\n");
    return 1;
  }
  if(img1->scanStart!=img2->scanStart){
    fprintf(stderr, "In the header: Mismatching scan start times.\n");
    fprintf(stderr, "difftime := %g s\n", difftime(img1->scanStart, img2->scanStart));
    return 1;
  }
  if(img1->orientation!=img2->orientation){
    fprintf(stderr, "In the header: Mismatching orientation.\n");
    return 1;
  }
  if(img1->axialFOV!=img2->axialFOV){
    fprintf(stderr, "In the header: Mismatching axial FOV.\n");
    return 1;
  }
  if(img1->transaxialFOV!=img2->transaxialFOV){
    fprintf(stderr, "In the header: Mismatching transaxial FOV.\n");
    return 1;
  }
  if(img1->sampleDistance!=img2->sampleDistance){
    fprintf(stderr, "In the header: Mismatching sample distance.\n");
    return 1;
  } 
 
  if(strcasecmp(img1->studyNr,img2->studyNr)){
    fprintf(stderr, "In the header: Mismatching study number.\n");
    return 1;
  }
  if(strcmp(img1->userProcessCode,img2->userProcessCode)){
    fprintf(stderr, "In the header: Mismatching user process code.\n");
    return 1;
  }
  if(strcmp(img1->studyDescription,img2->studyDescription)){
    fprintf(stderr, "In the header: Mismatching study description.\n");
    return 1;
  }
  if(strcasecmp(img1->patientName,img2->patientName)){
    fprintf(stderr, "In the header: Mismatching patient name.\n");
    return 1;
  }
  if(strcasecmp(img1->patientID,img2->patientID)){
    fprintf(stderr, "In the header: Mismatching patient ID.\n");
    return 1;
  }
 
  if(img1->type!=IMG_TYPE_UNKNOWN && img2->type!=IMG_TYPE_UNKNOWN &&
     img1->type!=img2->type)
  {
    fprintf(stderr, "In the header: Mismatching image type.\n");
    return 1;
  }
 
  if(img1->sizex!=img2->sizex){
    fprintf(stderr, "In the header: Mismatching size (x-axis).\n");
    return 1;
  }
  if(img1->sizey!=img2->sizey){
    fprintf(stderr, "In the header: Mismatching size (y-axis).\n");
    return 1;
  }
  if(img1->sizez!=img2->sizez){
    fprintf(stderr, "In the header: Mismatching size (z-axis).\n");
    return 1;
  }
  if(img1->gapx!=img2->gapx){
    fprintf(stderr, "In the header: Mismatching x gap.\n");
    return 1;
  }
  if(img1->gapy!=img2->gapy){
    fprintf(stderr, "In the header: Mismatching y gap.\n");
    return 1;
  }
  if(img1->gapz!=img2->gapz){
    fprintf(stderr, "In the header: Mismatching z gap.\n");
    return 1;
  }
 
  if(img1->resolutionx!=img2->resolutionx){
    fprintf(stderr, "In the header: Mismatching resolution (x-axis).\n");
    return 1;
  }
  if(img1->resolutiony!=img2->resolutiony){
    fprintf(stderr, "In the header: Mismatching resolution (y-axis).\n");
    return 1;
  }
  if(img1->resolutionz!=img2->resolutionz){
    fprintf(stderr, "In the header: Mismatching resolution (z-axis).\n");
    return 1;
  }
 
  if(img1->scanner!=img2->scanner){
    fprintf(stderr, "In the header: Mismatching scanner.\n");
    return 1;
  }
  if(img1->modality!=img2->modality){
    fprintf(stderr, "In the header: Mismatching modality.\n");
    return 1;
  }
  if(img1->_dataType!=img2->_dataType){
    fprintf(stderr, "In the header: Mismatching data type.\n");
    return 1;
  }
  if(img1->_fileFormat!=img2->_fileFormat){
    fprintf(stderr, "In the header: Mismatching file format.\n");
    return 1;
  }
  if(img1->isWeight!=img2->isWeight){
    fprintf(stderr, "In the header: Mismatching in weights.\n");
    return 1;
  }
  
  return 0;
}

Referenced by imgMatch().

◆ imgMatchMatrix()

int imgMatchMatrix	(	IMG *	img1,
		IMG *	img2,
		double	accuracy )

extern

Checks if two image matrices match in the accuracy of argument "accuracy".

For example, set accuracy=0.99 and you will get match if all matrix values satisfy abs(x1-x2)/abs(mean(x1,x2))<=0.01). If you want exact match, set accuracy=0.0.

Returns: Returns 0 if matrices match, 1 if matrices do not match.

See also: imgMatch, imgMatchHeader, imgMaxDifference, imgSS

Parameters

img1	Pointer to the first IMG structure.
img2	Pointer to the second IMG structure.
accuracy	Required accuracy

Definition at line 47 of file imgcomp.c.

  {
  
  int xi, yi, pi, fi;
  double s;
 
  for(pi=0; pi<img1->dimz; pi++) for(yi=0; yi<img1->dimy; yi++)
  for(xi=0; xi<img1->dimx; xi++) for(fi=0; fi<img1->dimt; fi++) {
    s=fabs(img1->m[pi][yi][xi][fi]+img2->m[pi][yi][xi][fi])/2.0;
    if(accuracy==0.0 || s==0.0) {
      if(img1->m[pi][yi][xi][fi]!=img2->m[pi][yi][xi][fi]){
        fprintf(stderr, "Mismatch in image matrix.\n");
        return(1);
      }
    } else {
      if(fabs(img1->m[pi][yi][xi][fi]-img2->m[pi][yi][xi][fi])/s > (1.0-accuracy)) {
        fprintf(stderr, "Mismatch in image matrix.\n");
        printf("img[%d][%d][%d][%d]: %g vs %g\n", pi, yi, xi, fi,
                 img1->m[pi][yi][xi][fi], img2->m[pi][yi][xi][fi]);
        return(1);
      }
    }            
  }
  return 0;
}

Referenced by imgMatch().

◆ imgMatchMatrixSize()

int imgMatchMatrixSize	(	IMG *	d1,
		IMG *	d2 )

extern

Check whether two IMG data have the same matrix (x,y,z) size.

Returns: 0 in case of match, 1 otherwise.

See also: imgMatch, imgMatchFrames

Author: Vesa Oikonen

Parameters

d1	Pointer to IMG structure.
d2	Pointer to IMG structure.

Definition at line 447 of file imgcomp.c.

  {
  if(d1==NULL || d2==NULL) return(1);
  if(d1->dimz!=d2->dimz) return(1);
  if(d1->dimy!=d2->dimy) return(1);
  if(d1->dimx!=d2->dimx) return(1);
  return(0);
}

◆ imgMatchPlanes()

int imgMatchPlanes	(	IMG *	img1,
		IMG *	img2 )

extern

Checks if the planes of two IMG data do match: number of planes and plane numbers.

Returns: Returns 0 if match was found, and >0 if no match.

See also: imgMatchFrames

Parameters

img1	Pointer to the first IMG structure.
img2	Pointer to the second IMG structure.

Definition at line 307 of file imgcomp.c.

  {
  if(img1->dimz!=img2->dimz) return(1);
  for(int zi=0; zi<img1->dimz; zi++) {
    if(img1->planeNumber[zi]!=img2->planeNumber[zi]) return(11);
  }
  return(0);
}

Referenced by imgMatch().

◆ imgMatchTransform()

int imgMatchTransform	(	IMG *	img1,
		IMG *	img2 )

extern

Checks if the transform parameters of two image headers match.

Returns: Returns 0 if headers match, 1 if headers do not match.

See also: imgMatchHeader

Parameters

img1	Pointer to the first IMG structure.
img2	Pointer to the second IMG structure.

Definition at line 85 of file imgcomp.c.

  {
  int i;
  float f;
 
  if(img1->xform[0]!=img2->xform[0]) {
    fprintf(stderr, "In the header: Mismatching qform.\n");
    return 1;
  }
  if(img1->xform[1]!=img2->xform[1]) {
    fprintf(stderr, "In the header: Mismatching sform.\n");
    return 1;
  }
 
  for(i=0; i<18; i++) {
    f=img1->quatern[i]-img2->quatern[i];
    if(fabs(f)>1.0E-05) {
      fprintf(stderr, "In the header: Mismatching transformation parameter.\n");
      return 1;
    }
  }
 
  for(i=0; i<12; i++) {
    f=img1->mt[i]-img2->mt[i];
    if(fabs(f)>1.0E-05) {
      fprintf(stderr, "In the header: Mismatching matrix transformation.\n");
      return 1;
    }
  }
  
  return 0;
}

Referenced by imgMatch().

◆ imgMax()

int imgMax	(	IMG *	img,
		float *	maxvalue )

extern

Search the max pixel value in the IMG data.

See also: imgFrameMinMax, imgMinMax, imgSmoothMax, imgAvg

Returns: 0 if ok, 1 invalid image status, 2 invalid output pointer, 3 invalid image dimensions.

Parameters

img	Pointer to IMG structure.
maxvalue	Pointer to output.

Definition at line 15 of file imgminmax.c.

  {
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(maxvalue==NULL) return(2); else *maxvalue=0.0;
  if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
  float f=nanf("");
  for(int pi=0; pi<img->dimz; pi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++)
        for(int fi=0; fi<img->dimt; fi++) {
          if(!isfinite(f) || img->m[pi][yi][xi][fi]>f) f=img->m[pi][yi][xi][fi];
        }
  *maxvalue=f;
  return(0);
}

Referenced by imgThresholding(), and imgThresholdingLowHigh().

◆ imgMaxDifference()

int imgMaxDifference	(	IMG *	img1,
		IMG *	img2,
		VOXEL_4D *	absdiff,
		float *	abs_max,
		VOXEL_4D *	reldiff,
		float *	rel_max )

extern

Calculates the maximal pixel value differences (absolute and relational) between two image matrices.

Returns: Returns 0 if successful, and some difference was found, -1 if no difference at all was found, and >0 in case of an error.

See also: imgSS, imgMatch, imgMatchMatrix, imgMatchHeader, imgMRT

Parameters

img1	Pointer to the first IMG structure.
img2	Pointer to the second IMG, with the same dimensions as img1.
absdiff	Voxel where absolute difference was found largest; enter NULL if not needed; returns [0,0,0,0] if no difference was found.
abs_max	Pointer where max absolute difference is written; NULL if not needed.
reldiff	Voxel where relational difference was found largest; enter NULL if not needed; returns [0,0,0,0] if no difference was found.
rel_max	Pointer where max relational difference is written; NULL if not needed.

Definition at line 328 of file imgcomp.c.

  {
  
  int xi, yi, zi, ti;
  float s, v, absmax=0.0, relmax=0.0;
 
  /* Initiate result voxels */
  if(absdiff!=NULL) absdiff->x=absdiff->y=absdiff->z=absdiff->t=0;
  if(abs_max!=NULL) *abs_max=0;
  if(reldiff!=NULL) reldiff->x=reldiff->y=reldiff->z=reldiff->t=0;
  if(rel_max!=NULL) *rel_max=0;
 
  /* Check input */
  if(img1==NULL || img2==NULL) return 1;
  if(img1->dimx!=img2->dimx) return 2;
  if(img1->dimy!=img2->dimy) return 3;
  if(img1->dimz!=img2->dimz) return 4;
  if(img1->dimt!=img2->dimt) return 5;
 
 
  /* Search for max absolute difference */
  for(zi=0; zi<img1->dimz; zi++) for(yi=0; yi<img1->dimy; yi++)
  for(xi=0; xi<img1->dimx; xi++) for(ti=0; ti<img1->dimt; ti++) {
    s=fabs(img1->m[zi][yi][xi][ti]-img2->m[zi][yi][xi][ti]);
    if(s>absmax) {
      absmax=s;
      if(absdiff!=NULL) {absdiff->x=xi+1; absdiff->y=yi+1; absdiff->z=zi+1; absdiff->t=ti+1;}
    }
  }
  //printf("absmax := %g\n", absmax);
  if(abs_max!=NULL) *abs_max=absmax;
 
 
  /* Search for max relational difference.
     If relational difference is Inf (image average is zero), then relmax
     is set to FLT_MAX, and from those pixels the one where
     absolute difference is highest is searched */
  float local_absmax=0.0;
  for(zi=0; zi<img1->dimz; zi++) for(yi=0; yi<img1->dimy; yi++)
  for(xi=0; xi<img1->dimx; xi++) for(ti=0; ti<img1->dimt; ti++) {
    s=fabs(img1->m[zi][yi][xi][ti]-img2->m[zi][yi][xi][ti]);
    v=0.5*fabs(img1->m[zi][yi][xi][ti]+img2->m[zi][yi][xi][ti]);
    if(v>0.0) {
      s/=v; 
      if(s>relmax && local_absmax==0.0) {
        relmax=s;
        if(reldiff!=NULL) {reldiff->x=xi+1; reldiff->y=yi+1; reldiff->z=zi+1; reldiff->t=ti+1;}
      }
    } else if(s>0.0) { // if relational max is find out the pixel where 
      if(s>local_absmax) {
        local_absmax=s;
        if(reldiff!=NULL) {reldiff->x=xi+1; reldiff->y=yi+1; reldiff->z=zi+1; reldiff->t=ti+1;}
      }
    }
  }
  if(local_absmax>0.0) relmax=FLT_MAX;
  //printf("relmax := %g\n", relmax);
  if(rel_max!=NULL) *rel_max=relmax;
 
  /* Was there any difference? 0=yes, -1=no */
  if(absmax>0.0 || relmax>0.0) return 0; else return -1;
}

◆ imgMicropetCTToEcat7()

int imgMicropetCTToEcat7	(	FILE *	fph,
		FILE *	fpi,
		char *	ecatfile,
		int	verbose )

extern

Read MicroPET CT image and write ECAT 7 image volume.

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fph	MicroPET header file pointer
fpi	MicroPET image datafile pointer
ecatfile	ECAT image file name
verbose	Verbose level

Definition at line 196 of file img_upet.c.

  {
  IMG img;
  int n, zi, xi, yi, zdim, xdim, ydim, ret;
  float scale_factor;
  char *mdata, *mptr;
  char tmp[MAX_MICROPET_LINE_LEN];
  short int *si;
 
 
  if(verbose>1) printf("%s(*fph, *fpi, %s, %d)\n", __func__, ecatfile, verbose);
  /* Check input */
  if(fph==NULL || fpi==NULL || ecatfile==NULL) return STATUS_FAULT;
 
  /*
   *  Read image dimensions from header
   */
  ret=upetGetImageDimensions(fph, &zdim, &xdim, &ydim, NULL);
  if(ret) {return(STATUS_INVALIDHEADER);}
  if(verbose>2) {
    printf("z_dim := %d\n", zdim);
    printf("x_dim := %d\n", xdim);
    printf("y_dim := %d\n", ydim);
  }
 
  /* Read scale factor */
  rewind(fph);
  if(upetHeaderReadParameter(fph, "scale_factor", tmp)!=0) {
    return(STATUS_INVALIDHEADER);}
  scale_factor=-1; (void)sscanf(tmp, "%f", &scale_factor);
  if(scale_factor<=0) return(STATUS_INVALIDHEADER);
  if(verbose>2) {
    printf("scale_factor := %g\n", scale_factor);
  }
 
  /* Remove existing ECAT file */
  if(access(ecatfile, 0)!=-1 && remove(ecatfile)!=0) {
    return(STATUS_CANNOTERASE);
  }
 
  /*
   *  Read and write image
   */
  imgInit(&img);
  /* Allocate memory for one frame */
  ret=imgAllocate(&img, zdim, ydim, xdim, 1);
  if(ret) {return(STATUS_NOMEMORY);}
  /* Fill header with what we now can */
  ret=imgGetMicropetMainHeader(fph, &img, NULL, verbose-2);
  if(ret) {
    if(verbose>1) printf("ret := %d\n", ret);
    imgEmpty(&img); return(STATUS_INVALIDHEADER);
  }
  img._fileFormat=IMG_E7;
  img.type=IMG_TYPE_IMAGE;
  studynr_from_fname(ecatfile, img.studyNr);
  upetScanStart(fph, &img.scanStart);
  /* Allocate memory for the binary data */
  long long pxlNr=xdim*ydim;
  mdata=(char*)malloc(pxlNr*sizeof(short int)); if(mdata==NULL) {
    imgEmpty(&img); return(STATUS_NOMEMORY);
  }
  /* Read image data, plane-by-plane */
  for(zi=0; zi<zdim; zi++) {
    mptr=mdata;
    if((n=fread(mptr, 2, pxlNr, fpi)) < pxlNr) {
      if(verbose==0) {fprintf(stdout, "\n"); fflush(stdout);}
      free(mdata); imgEmpty(&img);
      return(STATUS_NOMATRIX);
    }
    /* Copy short ints to IMG */
    mptr=mdata;
    for(yi=0; yi<ydim; yi++)
      for(xi=0; xi<xdim; xi++) {
        si=(short int*)mptr;
        img.m[zi][yi][xi][0]=(float)*si*scale_factor;
        mptr+=2;
      }
    if(verbose>3) printf("   plane %d\n", zi+1);
    else if(verbose==0) {fprintf(stdout, "."); fflush(stdout);}
  }
  free(mdata);
  if(verbose==0) {fprintf(stdout, "\n"); fflush(stdout);}
  /* Save ECAT 7 image volume */
  ret=imgWrite(ecatfile, &img);
  if(ret!=0) {imgEmpty(&img); return(STATUS_CANNOTWRITE);}
 
  imgEmpty(&img);
  return STATUS_OK;
}

Referenced by imgMicropetToEcat7().

◆ imgMicropetPETToEcat7()

int imgMicropetPETToEcat7	(	FILE *	fph,
		FILE *	fpi,
		char *	ecatfile,
		int	verbose )

extern

Read MicroPET static or dynamic PET image and write ECAT 7 image volume frame-by-frame.

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fph	MicroPET header file pointer.
fpi	MicroPET image datafile pointer.
ecatfile	ECAT image file name.
verbose	Verbose level.

Definition at line 85 of file img_upet.c.

  {
  int n, zi, xi, yi, ti, ret;
 
 
  if(verbose>1) printf("%s(*fph, *fpi, %s, %d)\n", __func__, ecatfile, verbose);
  /* Check input */
  if(fph==NULL || fpi==NULL || ecatfile==NULL) return STATUS_FAULT;
 
  /* Remove existing ECAT file */
  if(access(ecatfile, 0)!=-1 && remove(ecatfile)!=0) {
    return(STATUS_CANNOTERASE);
  }
 
  /*
   *  Read image dimensions from header
   */
  int zdim, xdim, ydim, tdim;
  ret=upetGetImageDimensions(fph, &zdim, &xdim, &ydim, &tdim);
  if(ret) {return(STATUS_INVALIDHEADER);}
  if(verbose>1) {
    printf("z_dim := %d\n", zdim);
    printf("x_dim := %d\n", xdim);
    printf("y_dim := %d\n", ydim);
    printf("t_dim := %d\n", tdim);
  }
 
  /*
   *  Read and write image frame-by-frame
   */
  IMG img; imgInit(&img);
  /* Allocate memory for one frame */
  ret=imgAllocate(&img, zdim, ydim, xdim, 1);
  if(ret) {return(STATUS_NOMEMORY);}
  /* Fill header with what we now can */
  float calibration_factor;
  ret=imgGetMicropetMainHeader(fph, &img, &calibration_factor, verbose-2);
  if(ret) {
    if(verbose>2) printf("ret := %d\n", ret);
    imgEmpty(&img); return(STATUS_INVALIDHEADER);
  }
  if(verbose>1) printf("calibration_factor := %g\n", calibration_factor);
  img._fileFormat=IMG_E7;
  img.type=IMG_TYPE_IMAGE;
  studynr_from_fname(ecatfile, img.studyNr);
  upetScanStart(fph, &img.scanStart);
  /* Allocate memory for the binary data */
  long long int pxlnr=xdim*ydim*zdim;
  char *mdata, *mptr;
  mdata=(char*)malloc(pxlnr*sizeof(float)); if(mdata==NULL) {
    imgEmpty(&img); return(STATUS_NOMEMORY);
  }
  /* Frame-by-frame */
  float *fptr;
  for(ti=0; ti<tdim; ti++) {
    if(verbose>3) {printf("ti=%d\n", ti); fflush(stdout);}
    /* Read frame information from MicroPET header into IMG */
    ret=imgGetMicropetFrameHeader(fph, &img, ti, verbose-2);
    if(ret) {
      if(verbose==0) {fprintf(stdout, "\n"); fflush(stdout);}
      free(mdata); imgEmpty(&img);
      return(STATUS_INVALIDHEADER);
    }
    /* Read floats */
    mptr=mdata;
    if((n=fread(mptr, 4, pxlnr, fpi)) < pxlnr) {
      if(verbose==0) {fprintf(stdout, "\n"); fflush(stdout);}
      free(mdata); imgEmpty(&img);
      return(STATUS_NOMATRIX);
    }
    /* Copy floats to IMG */
    mptr=mdata;
    for(zi=0; zi<zdim; zi++)
      for(yi=0; yi<ydim; yi++)
        for(xi=0; xi<xdim; xi++) {
          fptr=(float*)mptr;
          img.m[zi][yi][xi][0]=(*fptr)*img.weight[0]*calibration_factor;
          mptr+=4;
        }
    /* Write frame */
    ret=imgWriteFrame(ecatfile, ti+1, &img, 0); //printf("ret := %d\n", ret);
    if(ret!=STATUS_OK) break;
    if(verbose>1) {printf("    frame written.\n"); fflush(stdout);}
    else if(verbose==0) {fprintf(stdout, "."); fflush(stdout);}
  };
  free(mdata); imgEmpty(&img);
  if(verbose==0) {fprintf(stdout, "\n"); fflush(stdout);}
  if(verbose==0 && ret==STATUS_NOMATRIX) {
    fprintf(stdout, "  %d frame(s) processed.\n", ti);
  }
  if(ret!=STATUS_OK && ret!=STATUS_NOMATRIX) {
    remove(ecatfile); return ret;
  }
 
  return STATUS_OK;
}

Referenced by imgMicropetToEcat7().

◆ imgMicropetToEcat7()

int imgMicropetToEcat7	(	char *	upetname,
		char *	ecatfile,
		int	verbose )

extern

Read MicroPET image and write ECAT 7 image volume frame-by-frame.

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

upetname	MicroPET image filename.
ecatfile	ECAT image filename.
verbose	Verbose level

Definition at line 15 of file img_upet.c.

  {
  char upetheader[FILENAME_MAX], upetimage[FILENAME_MAX];
  int n, ret;
  int acquisition_mode, data_type;
  char tmp[MAX_MICROPET_LINE_LEN];
 
 
  if(verbose>1) printf("\n%s(%s, %s, %d)\n", __func__, upetname, ecatfile, verbose);
  /* Check the arguments */
  if(upetname==NULL || ecatfile==NULL) return STATUS_FAULT;
  ret=upetExists(upetname, upetheader, upetimage, verbose-1);
  if(ret!=2) return STATUS_NOFILE;
 
  /*
   *  Open Micropet Header and binary data files
   */
  FILE *fph, *fpi;
  if((fph=fopen(upetheader, "r"))==NULL) return(STATUS_NOHEADERFILE);
  if((fpi=fopen(upetimage, "rb"))==NULL) {fclose(fph); return(STATUS_NOIMGDATA);}
 
 
  /*
   *  Check that image format is (currently) supported
   */
  rewind(fph);
  if(verbose>1) printf("checking that image format is supported\n");
  n=-1; if(upetHeaderReadParameter(fph, "file_type", tmp)==0)
    (void)sscanf(tmp, "%d", &n);
  if(verbose>2) printf("file_type := %d\n", n);
  if(n!=5) {fclose(fph); fclose(fpi); return(STATUS_UNSUPPORTED);}
  acquisition_mode=-1;
  if(upetHeaderReadParameter(fph, "acquisition_mode", tmp)==0)
    (void)sscanf(tmp, "%d", &acquisition_mode);
  if(verbose>2) printf("acquisition_mode := %d\n", acquisition_mode);
  if(acquisition_mode!=2 && acquisition_mode!=3 && acquisition_mode!=9) {
    fclose(fph); fclose(fpi); return(STATUS_UNSUPPORTED);}
  data_type=-1;
  if(upetHeaderReadParameter(fph, "data_type", tmp)==0)
    (void)sscanf(tmp, "%d", &data_type);
  if(verbose>2) printf("data_type := %d\n", data_type);
  if(data_type!=4 && data_type!=2) {
    fclose(fph); fclose(fpi); return(STATUS_UNSUPPORTED);}
 
  /*
   *  Convert PET or CT image
   */
  if(acquisition_mode==2 || acquisition_mode==3) {
    ret=imgMicropetPETToEcat7(fph, fpi, ecatfile, verbose);
  } else if(acquisition_mode==9) {
    ret=imgMicropetCTToEcat7(fph, fpi, ecatfile, verbose);
  } else {
    ret=STATUS_UNSUPPORTED;
  }
  fclose(fph); fclose(fpi);
  return ret;
}

◆ imgMinMax()

int imgMinMax	(	IMG *	img,
		float *	minvalue,
		float *	maxvalue )

extern

Searches the min and max pixel value in the IMG data.

See also: imgFrameMinMax, imgRangeMinMax, imgReadMinMax

Returns: Returns 0 when successful.

Parameters

img	Pointer to IMG struct from where min and pixels are searched.
minvalue	Pointer to min pixel value; Enter NULL if not needed.
maxvalue	Pointer to max pixel value; Enter NULL if not needed.

Definition at line 154 of file imgminmax.c.

  {
  return (imgRangeMinMax(img, NULL, NULL, maxvalue, NULL, minvalue));
}

Referenced by imgPVCRRL(), imgPVCRVC(), imgReadMinMax(), imgSetAnalyzeHeader(), imgWriteAnalyze(), and imgWriteNifti().

◆ imgNaNs()

unsigned long long imgNaNs	(	IMG *	img,
		int	fix )

extern

Searches the image data for missing pixel values, optionally setting those to zero.

See also: imgExistentTimes

Returns: the number of missing pixel values.

Parameters

img	Pointer to IMG structure.
fix	Set (1) or do not set (0) missing pixels to zero.

Definition at line 658 of file img.c.

  {
  if(img==NULL) return(0);
  unsigned long long n=0;
  for(int zi=0; zi<img->dimz; zi++) {
    for(int yi=0; yi<img->dimy; yi++) {
      for(int xi=0; xi<img->dimx; xi++) {
        for(int ti=0; ti<img->dimt; ti++) {
          if(!isfinite(img->m[zi][yi][xi][ti])) {
            n++;
            if(fix!=0) img->m[zi][yi][xi][ti]=0.0;
          }
        }
      }
    }
  }
  return(n);
}

◆ imgRangeMinMax()

int imgRangeMinMax	(	IMG *	img,
		IMG_RANGE *	r,
		IMG_PIXEL *	maxp,
		float *	maxv,
		IMG_PIXEL *	minp,
		float *	minv )

extern

Finds max and/or min voxel inside specified image range.

See also: imgFrameMinMax, imgMinMax, imgAvg

Returns: 0 if ok, 1 invalid volume status, 2 invalid range endings, 3 inconsistent range dimensions, 4 inconsistent dimensions

Parameters

img	Pointer to IMG structure.
r	Pointer to image range inside IMG; enter NULL if whole IMG is used.
maxp	Pixel where max pixel position is written; NULL if not needed.
maxv	Target for max value; NULL if not needed.
minp	Pixel where min pixel position is written; NULL if not needed.
minv	Target for min value; NULL if not needed.

Definition at line 71 of file imgminmax.c.

  {
  int zi, yi, xi, fi;
  float lmax, lmin;
 
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(1);
 
  if(r!=NULL) {
    if(r->z1<1 || r->y1<1 || r->x1<1 || r->f1<1) return(2);
    if(r->z2<r->z1 || r->y2<r->y1 || r->x2<r->x1 || r->f2<r->f1) return(3);
    if(r->z2>img->dimz || r->y2>img->dimy || r->x2>img->dimx || r->f2>img->dimt) return(4);
 
    zi=r->z1-1; yi=r->y1-1; xi=r->x1-1; fi=r->f1-1;
    lmax=lmin=nanf("");
    if(maxp!=NULL) {maxp->z=zi+1; maxp->y=yi+1; maxp->x=xi+1; maxp->f=fi+1;}
    if(minp!=NULL) {minp->z=zi+1; minp->y=yi+1; minp->x=xi+1; minp->f=fi+1;}
    for(zi=r->z1-1; zi<r->z2; zi++) {
      for(yi=r->y1-1; yi<r->y2; yi++) {
        for(xi=r->x1-1; xi<r->x2; xi++) {
          for(fi=r->f1-1; fi<r->f2; fi++) {
            if(!isfinite(lmax) || img->m[zi][yi][xi][fi]>lmax) {
              lmax=img->m[zi][yi][xi][fi];
              if(maxp!=NULL && isfinite(img->m[zi][yi][xi][fi])) {
                maxp->z=zi+1; maxp->y=yi+1; maxp->x=xi+1; maxp->f=fi+1;}
            }
            if(!isfinite(lmin) || img->m[zi][yi][xi][fi]<lmin) {
              lmin=img->m[zi][yi][xi][fi];
              if(minp!=NULL && isfinite(img->m[zi][yi][xi][fi])) {
                minp->z=zi+1; minp->y=yi+1; minp->x=xi+1; minp->f=fi+1;}
            }
          }
        }
      }
    }
  } else {
    zi=yi=xi=fi=0; lmax=lmin=nanf("");
    if(maxp!=NULL) {maxp->z=zi+1; maxp->y=yi+1; maxp->x=xi+1; maxp->f=fi+1;}
    if(minp!=NULL) {minp->z=zi+1; minp->y=yi+1; minp->x=xi+1; minp->f=fi+1;}
    for(zi=0; zi<img->dimz; zi++) {
      for(yi=0; yi<img->dimy; yi++) {
        for(xi=0; xi<img->dimx; xi++) {
          for(fi=0; fi<img->dimt; fi++) {
            if(!isfinite(lmax) || img->m[zi][yi][xi][fi]>lmax) {
              lmax=img->m[zi][yi][xi][fi];
              if(maxp!=NULL && isfinite(img->m[zi][yi][xi][fi])) {
                maxp->z=zi+1; maxp->y=yi+1; maxp->x=xi+1; maxp->f=fi+1;}
            }
            if(!isfinite(lmin) || img->m[zi][yi][xi][fi]<lmin) {
              lmin=img->m[zi][yi][xi][fi];
              if(minp!=NULL && isfinite(img->m[zi][yi][xi][fi])) {
                minp->z=zi+1; minp->y=yi+1; minp->x=xi+1; minp->f=fi+1;}
            }
          }
        }
      }
    }
  }
  if(maxv!=NULL) *maxv=lmax;
  if(minv!=NULL) *minv=lmin;
  if(!isfinite(lmax) && (maxp!=NULL || maxv!=NULL)) return(5); 
  if(!isfinite(lmin) && (minp!=NULL || minv!=NULL)) return(5); 
  return(0);
}

Referenced by imgMinMax().

◆ imgRead()

int imgRead	(	const char *	fname,
		IMG *	img )

extern

Read an image or sinogram file in ECAT 6.3 or ECAT 7.x format, or image in NIfTI-1, Analyze 7.5, or microPET format.

See also: imgReadFrame, imgWrite

Returns: 0 if ok, 1 invalid input, 2 image status is not 'initialized', 4 unrecognised format, 5 unsupported Ecat7 type, sets IMG->statmsg in case of error.

Parameters

fname	Input filename.
img	Pointer to initialized IMG structure.

See also: imgInit, imgEmpty

Definition at line 26 of file imgfile.c.

  {
  FILE *fp;
  int ret;
  ECAT7_mainheader ecat7_main_header;
  ECAT63_mainheader ecat63_main_header;
  char temp[FILENAME_MAX];
 
  if(IMG_TEST) {printf("imgRead(%s, *img)\n", fname); fflush(stdout);}
  /* Check the arguments */
  if(fname==NULL) {img->statmsg=imgStatus(STATUS_FAULT); return(1);}
  if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) {
    img->statmsg=imgStatus(STATUS_FAULT); return(2);}
 
  /* Check if we have NIfTI file, which may be in single file format,
     or dual file format which has similar names as microPET and Analyze */
  if(niftiExists(fname, NULL, NULL, NULL, NULL, IMG_TEST-3, NULL)>0) {
    /* Read NIfTI image */
    ret=imgReadNifti(fname, img, IMG_TEST);
    if(IMG_TEST) {printf("imgReadNifti() := %d\n", ret); fflush(stdout);}
    if(ret==STATUS_OK) {
      if(IMG_TEST) printf("%s identified as supported NIfTI.\n", fname);
      img->statmsg=imgStatus(STATUS_OK);
      return(STATUS_OK);
    }
    img->statmsg=imgStatus(ret); return(4);
  }
 
  /* Check if we have microPET or Analyze file, which consist of separate header
     and data files, and have similar names */
  if(upetExists(fname, NULL, NULL, IMG_TEST-3)==2) {
    /* Read microPET image */
    ret=imgReadMicropet(fname, img); if(ret!=STATUS_OK) return(3);
    if(IMG_TEST) printf("%s identified as microPET format.\n", fname);
    return(0);
  }
  if(anaExistsNew(fname, temp, NULL, NULL)!=0) {
    anaRemoveFNameExtension(temp);
    /* Read Analyze image */
    ret=imgReadAnalyze(temp, img);
    if(IMG_TEST) {printf("imgReadAnalyze() := %d\n", ret); fflush(stdout);}
    if(ret==STATUS_OK) {
      if(IMG_TEST) printf("%s identified as supported Analyze 7.5 format.\n", fname);
      img->statmsg=imgStatus(STATUS_OK);
      return(0);
    }
    if(ret==STATUS_NOSIFDATA || ret==STATUS_WRONGSIFDATA) {
      img->statmsg=imgStatus(ret); return(0);}
    img->statmsg=imgStatus(ret); return(4);
  }
 
  /* Check if we have an ECAT file */
  /* Open file for read */
  if((fp=fopen(fname, "rb")) == NULL) {
    img->statmsg=imgStatus(STATUS_NOFILE); return(4);
  }
  /* Try to read ECAT 7.x main header */
  ret=ecat7ReadMainheader(fp, &ecat7_main_header);
  if(ret) {fclose(fp); img->statmsg=imgStatus(STATUS_UNKNOWNFORMAT); return(4);}
  /* If header could be read, check for magic number */
  if(strncmp(ecat7_main_header.magic_number, ECAT7V_MAGICNR, 7)==0) {
    /* This is ECAT 7.x file */
    /* Check if file type is supported */
    if(imgEcat7Supported(&ecat7_main_header)==0) {
      fclose(fp); img->statmsg=imgStatus(STATUS_UNSUPPORTED); return(5);
    }
    fclose(fp);
    /* Read file */
    if(IMG_TEST) printf("%s identified as supported ECAT 7.x %s format\n",
      fname, ecat7filetype(ecat7_main_header.file_type));
    ret=imgReadEcat7(fname, img);
    if(ret) {if(IMG_TEST) printf("imgReadEcat7()=%d\n", ret); return(6);}
  } else {
    /* Check if file is in ECAT 6.3 format */
    ret=ecat63ReadMainheader(fp, &ecat63_main_header);
    fclose(fp);
    if(ret==0) {
      /* It seems to be ECAT 6.3, so read it */
      if(IMG_TEST) printf("%s identified as supported ECAT 6.3 %s format\n",
        fname, ecat7filetype(ecat63_main_header.file_type));
      ret=ecat63ReadAllToImg(fname, img);
      if(ret) {
        if(IMG_TEST) fprintf(stderr, "ecat63ReaddAllToImg: %s\n", ecat63errmsg);
        if(ret==6) img->statmsg=imgStatus(STATUS_MISSINGMATRIX);
        else img->statmsg=imgStatus(STATUS_UNSUPPORTED);
        return(6);
      }
    } else {img->statmsg=imgStatus(STATUS_UNKNOWNFORMAT); return(4);}
  }
  img->statmsg=imgStatus(STATUS_OK);
  return(0);
}

Referenced by imgReadModelingData().

◆ imgReadAnalyze()

int imgReadAnalyze	(	const char *	dbname,
		IMG *	img )

extern

Read Analyze 7.5 image.

Analyze database name must be given with path. Image and header files with .img and .hdr extensions must exist. Also SIF file with .sif extension is used, if it exists. anaFlipping() determines whether image is flipped in z-direction; image is always flipped in x,y-directions.

Parameters

dbname	Analyze database name with path, with or without extension
img	Pointer to initialized IMG structure

Returns: 0 if ok, and otherwise IMG status code; sets IMG->statmsg in case of error.

Definition at line 24 of file img_ana.c.

                                                 {
  FILE *fp;
  int ret;
  float *fdata=NULL, *fptr;
  ANALYZE_DSR dsr;
  char datfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  int dimNr, dimx, dimy, dimz=1, dimt=1;
  SIF sif;
 
 
  if(IMG_TEST) printf("imgReadAnalyze(%s, *img)\n", dbname);
 
  /* Check the arguments */
  imgSetStatus(img, STATUS_OK);
  if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
  if(dbname==NULL || !dbname[0]) {imgSetStatus(img, STATUS_FAULT); return(1);}
  
  /* Make the image and header filenames */
  ret=anaExistsNew(dbname, hdrfile, datfile, siffile);
  if(ret==0) {imgSetStatus(img, STATUS_NOHEADERFILE); return(3);}
  if(ret==1 && IMG_TEST>0) printf("no SIF found for %s\n", dbname); 
 
  /* Read Analyze header file */
  ret=anaReadHeader(hdrfile, &dsr);
  if(ret) {
    if(ret==1) imgSetStatus(img, STATUS_FAULT);
    else if(ret==2) imgSetStatus(img, STATUS_NOHEADERFILE);
    else imgSetStatus(img, STATUS_UNSUPPORTED);
    return(3);
  }
  if(IMG_TEST) anaPrintHeader(&dsr, stdout);
 
  /* Open image datafile */
  if(IMG_TEST) fprintf(stdout, "reading image data %s\n", datfile);
  if((fp=fopen(datfile, "rb")) == NULL) {
    imgSetStatus(img, STATUS_NOIMGDATA); return(5);}
 
  /* Prepare IMG for Analyze image */
  /* Get the image dimensions from header */
  dimNr=dsr.dime.dim[0];
  if(dimNr<2) {fclose(fp); imgSetStatus(img, STATUS_INVALIDHEADER); return(4);}
  dimx=dsr.dime.dim[1]; dimy=dsr.dime.dim[2];
  if(dimNr>2) {dimz=dsr.dime.dim[3]; if(dimNr>3) dimt=dsr.dime.dim[4];}
  long long pxlNr=dimx*dimy*dimz;
  if(pxlNr<1) {fclose(fp); imgSetStatus(img, STATUS_INVALIDHEADER); return(4);}
  /* Allocate memory for IMG */
  ret=imgAllocate(img, dimz, dimy, dimx, dimt);
  if(ret) {fclose(fp); imgSetStatus(img, STATUS_NOMEMORY); return(11);}
  /* Copy information from Analyze header */
  img->type=IMG_TYPE_IMAGE;
  strlcpy(img->studyNr, dsr.hist.patient_id, MAX_STUDYNR_LEN+1);
  if(strcmp(img->studyNr, ".")==0) strcpy(img->studyNr, "");
  strcpy(img->patientName, dsr.hist.patient_id);
  img->sizex=dsr.dime.pixdim[1];
  img->sizey=dsr.dime.pixdim[2];
  img->sizez=dsr.dime.pixdim[3];
  img->xform[0]=NIFTI_XFORM_UNKNOWN; // qform
  img->xform[1]=NIFTI_XFORM_SCANNER_ANAT; // sform
  /*if(dsr.dime.funused2>1.E-5) img->zoom=dsr.dime.funused2;*/
  if(dsr.dime.funused3>1.E-5) img->isotopeHalflife=dsr.dime.funused3;
  for(int pi=0; pi<dimz; pi++) img->planeNumber[pi]=pi+1;
  if(dsr.little) img->_fileFormat=IMG_ANA_L; else img->_fileFormat=IMG_ANA;
  /* Decay correction */
  if(strstr(dsr.hist.descrip, "Decay corrected.")!=NULL)
    img->decayCorrection=IMG_DC_CORRECTED;
  else if(strstr(dsr.hist.descrip, "No decay correction.")!=NULL)
    img->decayCorrection=IMG_DC_NONCORRECTED;
  else
    img->decayCorrection=IMG_DC_CORRECTED; // just assumed so
 
  /* Allocate memory for one image frame */
  fdata=malloc(pxlNr*sizeof(float));
  if(fdata==NULL) {fclose(fp); imgSetStatus(img, STATUS_NOMEMORY); return(12);}
 
  /* Read one image frame at a time */
  for(int fi=0; fi<dimt; fi++) {
    fptr=fdata;
    ret=anaReadImagedata(fp, &dsr, fi+1, fptr);
    if(ret) {
      free(fdata); fclose(fp); imgSetStatus(img, STATUS_NOIMGDATA); return(7);}
    /* Copy pixel values to IMG */
    fptr=fdata;
    if(anaFlipping()==0) { /* no flipping in z-direction */
      for(int pi=0; pi<img->dimz; pi++)
        for(int yi=dimy-1; yi>=0; yi--)
          for(int xi=dimx-1; xi>=0; xi--)
            img->m[pi][yi][xi][fi]=*fptr++;
    } else {
      for(int pi=dimz-1; pi>=0; pi--)
        for(int yi=dimy-1; yi>=0; yi--)
          for(int xi=dimx-1; xi>=0; xi--)
            img->m[pi][yi][xi][fi]=*fptr++;
    }
  } /* next frame */
  free(fdata);
  fclose(fp);
  
  /* Try to read frame time information from SIF file */
  /* Check if SIF file is found */
  if(siffile[0]) {
    if(IMG_TEST) printf("reading SIF file %s\n", siffile);
    if(access(siffile, 0) == -1) {
      if(IMG_TEST) printf(" No SIF file; therefore unknown frame times.\n");
      return(0);
    }
  }
  /* If found, then read it */
  sifInit(&sif); ret=sifRead(siffile, &sif);
  if(ret) {imgSetStatus(img, STATUS_NOSIFDATA); return(21);}
 
  /* Copy SIF contents */
  ret=sif2img(&sif, img, 1, 1, 1, IMG_TEST-2);
  sifEmpty(&sif);
  if(ret!=0) {imgSetStatus(img, STATUS_WRONGSIFDATA); return(22);}
  
  return(0);
}

Referenced by imgRead().

◆ imgReadAnalyzeFirstFrame()

int imgReadAnalyzeFirstFrame	(	const char *	fname,
		IMG *	img )

extern

Read the first frame from an Analyze 7.5 database into IMG data structure.

Parameters

fname	Name of Analyze database from which IMG contents will be read
img	pointer to the initiated but not preallocated IMG data

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 592 of file img_ana.c.

                                                          {
  int ret=0;
 
  if(IMG_TEST) printf("\nimgReadAnalyzeFirstFrame(%s, *img)\n", fname);
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(fname==NULL) return STATUS_FAULT;
 
  /* Read header information from file */
  ret=imgReadAnalyzeHeader(fname, img); if(ret) return(ret);
  if(IMG_TEST>3) imgInfo(img);
 
  /* Allocate memory for one frame */
  img->dimt=1;
  ret=imgAllocate(img, img->dimz, img->dimy, img->dimx, img->dimt);
  if(ret) return STATUS_NOMEMORY;
 
  /* Read the first frame */
  ret=imgReadAnalyzeFrame(fname, 1, img, 0); if(ret) return(ret); 
 
  /* All went well */
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgAnalyzeToEcat().

◆ imgReadAnalyzeFrame()

int imgReadAnalyzeFrame	(	const char *	fname,
		int	frame_to_read,
		IMG *	img,
		int	frame_index )

extern

Read a specified frame from an Analyze 7.5 database into preallocated IMG data structure.

Analyze database consists of two or three files in the same directory: fname.hdr, fname.img, and optionally fname.sif. IMG header is assumed to be filled correctly before calling this function, except for information concerning separate planes and this frame, which is filled here. If frame does not exist, then and only then STATUS_NOMATRIX is returned.

Parameters

fname	name of Analyze database from which IMG contents will be read
frame_to_read	frame which will be read [1..frameNr]
img	pointer to the IMG data. Place for the frame must be preallocated
frame_index	IMG frame index [0..dimt-1] where data will be placed

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 639 of file img_ana.c.

  {
  FILE *fp;
  int ret;
  float *fdata=NULL, *fptr;
  ANALYZE_DSR dsr;
  char datfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  SIF sif;
 
 
  if(IMG_TEST) printf("\nimgReadAnalyzeFrame(%s, %d, *img, %d)\n",
    fname, frame_to_read, frame_index);
    
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
  if(fname==NULL) return STATUS_FAULT;
  if(frame_index<0 || frame_index>img->dimt-1) return STATUS_FAULT;
  if(frame_to_read<1) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  
  /* Determine the names of hdr, data and sif files */
  ret=anaDatabaseExists(fname, hdrfile, datfile, siffile);
  if(ret==0) return STATUS_NOFILE;
 
  /* Read Analyze header file */
  ret=anaReadHeader(hdrfile, &dsr);
  if(ret!=0) {
    if(ret==1) return STATUS_FAULT;
    else if(ret==2) return STATUS_NOHEADERFILE;
    else return STATUS_UNSUPPORTED;
    return(STATUS_FAULT);
  }
 
  /* Open image datafile */
  if(IMG_TEST>2) fprintf(stdout, "reading image data %s\n", datfile);
  if((fp=fopen(datfile, "rb")) == NULL) return STATUS_NOIMGDATA;
 
  /* Allocate memory for one image frame */
  fdata=malloc((size_t)img->dimx*img->dimy*img->dimz*sizeof(float));
  if(fdata==NULL) {fclose(fp); return STATUS_NOMEMORY;}
 
  /* Read the required image frame */
  fptr=fdata;
  ret=anaReadImagedata(fp, &dsr, frame_to_read, fptr);
  fclose(fp);
  if(ret==3) {free(fdata); return STATUS_NOMATRIX;} /* no more frames */
  if(ret!=0) {free(fdata); return STATUS_UNSUPPORTED;}
 
  /* Copy pixel values to IMG */
  fptr=fdata;
  if(anaFlipping()==0) { /* no flipping in z-direction */
    for(int pi=0; pi<img->dimz; pi++)
      for(int yi=img->dimy-1; yi>=0; yi--)
        for(int xi=img->dimx-1; xi>=0; xi--)
          img->m[pi][yi][xi][frame_index]=*fptr++;
  } else {
    for(int pi=img->dimz-1; pi>=0; pi--)
      for(int yi=img->dimy-1; yi>=0; yi--)
        for(int xi=img->dimx-1; xi>=0; xi--)
          img->m[pi][yi][xi][frame_index]=*fptr++;
  }
  free(fdata);
 
  /* Set decay correction factor to zero */
  img->decayCorrFactor[frame_index]=0.0;
 
  imgSetStatus(img, STATUS_OK); /* If the rest is failed, no problem */
 
  /* 
   *  Try to read frame time information from SIF file
   */
  sifInit(&sif);
  if(sifRead(siffile, &sif)!=0) return STATUS_OK;
  /* Frame information */
  if(sif.frameNr>=frame_to_read) {
    img->start[frame_index]=sif.x1[frame_to_read-1];
    img->end[frame_index]=sif.x2[frame_to_read-1];
    img->mid[frame_index]=0.5*(img->start[frame_index]+img->end[frame_index]);
    img->prompts[frame_index]=sif.prompts[frame_to_read-1];
    img->randoms[frame_index]=sif.randoms[frame_to_read-1];
  }
  sifEmpty(&sif);
 
  return STATUS_OK;
}

Referenced by imgAnalyzeToEcat(), imgReadAnalyzeFirstFrame(), and imgReadFrame().

◆ imgReadAnalyzeHeader()

int imgReadAnalyzeHeader	(	const char *	dbname,
		IMG *	img )

extern

Fill IMG struct header information from Analyze 7.5 database files.

SIF file is read if available. Information concerning separate frames or planes is not filled though.

Parameters

dbname	name of Analyze database, may contain filename extension
img	pointer to the initiated IMG data

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 360 of file img_ana.c.

                                                       {
  char hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  ANALYZE_DSR ana_header;
  SIF sif;
  double f;
  int ret;
 
  if(IMG_TEST) printf("\nimgReadAnalyzeHeader(%s, *img)\n", dbname);
  
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(dbname==NULL) return STATUS_FAULT;
 
  /* Determine the names of hdr and sif files */
  ret=anaDatabaseExists(dbname, hdrfile, NULL, siffile);
  if(ret==0) return STATUS_NOFILE;
  
  /* Read Analyze header file */
  ret=anaReadHeader(hdrfile, &ana_header);
  if(ret!=0) {
    if(IMG_TEST>1) printf("anaReadHeader() return value := %d\n", ret);
    if(ret==1) return STATUS_FAULT;
    else if(ret==2) return STATUS_NOHEADERFILE;
    else return STATUS_UNSUPPORTED;
    return(STATUS_FAULT);
  }
  /* and set IMG contents */
  ret=imgGetAnalyzeHeader(img, &ana_header);
  if(ret!=0) {
    imgSetStatus(img, ret);
    return(ret);
  }
 
  /* If SIF does not exist, then that's it */
  if(!siffile[0]) {
    imgSetStatus(img, STATUS_OK);
    return STATUS_OK;
  }
 
  /* SIF is available, so read that too */
  sifInit(&sif); ret=0;
  if(sifRead(siffile, &sif)!=0) return STATUS_OK;
  /* Copy scan time */
  img->scanStart=sif.scantime;
  /* Study number, if not yet defined */
  if(!img->studyNr[0] && strlen(sif.studynr)>1 )
    strlcpy(img->studyNr, sif.studynr, MAX_STUDYNR_LEN+1);
  /* Isotope half-life, if not yet defined */
  f=hlFromIsotope(sif.isotope_name);
  if(img->isotopeHalflife<=0.0 && f>0.0) img->isotopeHalflife=60.0*f;
  sifEmpty(&sif);
 
  return STATUS_OK;
}

Referenced by imgFormatDetermine(), imgReadAnalyzeFirstFrame(), imgReadHeader(), and imgWriteAnalyzeFrame().

◆ imgReadEcat63FirstFrame()

int imgReadEcat63FirstFrame	(	const char *	fname,
		IMG *	img )

extern

Read the first frame from an ECAT 6.3 file into IMG data structure.

Parameters

fname	name of file from which IMG contents will be read
img	pointer to the initiated but not preallocated IMG data

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 1457 of file img_e63.c.

                                                         {
  int ret=0;
 
  if(IMG_TEST) printf("\nimgReadEcat63FirstFrame(%s, *img)\n", fname);
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(fname==NULL) return STATUS_FAULT;
 
  /* Read header information from file */
  ret=imgReadEcat63Header(fname, img); if(ret) return(ret);
  if(IMG_TEST>4) imgInfo(img);
 
  /* Allocate memory for one frame */
  img->dimt=1;
  ret=imgAllocate(img, img->dimz, img->dimy, img->dimx, img->dimt);
  if(ret) return STATUS_NOMEMORY;
 
  /* Read the first frame */
  ret=imgReadEcat63Frame(fname, 1, img, 0); if(ret) return(ret); 
 
  /* All went well */
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

◆ imgReadEcat63Frame()

int imgReadEcat63Frame	(	const char *	fname,
		int	frame_to_read,
		IMG *	img,
		int	frame_index )

extern

Read a specified frame from an ECAT 6.3 file into preallocated IMG data structure.

IMG header is assumed to be filled correctly before calling this function, except for information concerning separate planes and this frame, which is filled here.

Parameters

fname	name of file from which IMG contents will be read
frame_to_read	frame which will be read (1..frameNr)
img	pointer to the IMG data. Place for the frame must be preallocated
frame_index	IMG frame index (0..dimt-1) where data will be placed

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error. If frame does not exist, then and only then STATUS_NOMATRIX is returned.

Definition at line 1503 of file img_e63.c.

  {
  int                 ret=0, blkNr=0, frame, plane, seqplane=-1;
  int                 local_data_type=0;
  FILE               *fp;
  ECAT63_mainheader   main_header;
  MATRIXLIST          mlist;
  Matval              matval;
  ECAT63_imageheader  image_header;
  ECAT63_scanheader   scan_header;
  ECAT63_attnheader   attn_header;
  ECAT63_normheader   norm_header;
  float               scale=1.0;
  short int          *sptr;
  char               *mdata=NULL, *mptr;
  /*int                *iptr;*/
 
 
  if(IMG_TEST) printf("\nimgReadEcat63Frame(%s, %d, *img, %d)\n",
    fname, frame_to_read, frame_index);
    
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(fname==NULL) return STATUS_FAULT;
  if(frame_index<0 || frame_index>img->dimt-1) return STATUS_FAULT;
  if(frame_to_read<1) return STATUS_FAULT;
 
  /* Open the file */
  if((fp=fopen(fname, "rb")) == NULL) return STATUS_NOFILE;
  
  /* Read main header */
  if((ret=ecat63ReadMainheader(fp, &main_header))) {
    fclose(fp); return STATUS_NOMAINHEADER;}
 
  /* Read matrix list and nr and sort it */
  ecat63InitMatlist(&mlist);
  ret=ecat63ReadMatlist(fp, &mlist, IMG_TEST-1);
  if(ret) {fclose(fp); return STATUS_NOMATLIST;}
  if(mlist.matrixNr<=0) {
    fclose(fp); ecat63EmptyMatlist(&mlist); return STATUS_INVALIDMATLIST;}
  /* Make sure that plane and frame numbers are continuous */
  ecat63GatherMatlist(&mlist, 1, 1, 1, 1);
  ecat63SortMatlistByFrame(&mlist);
  
  /* Calculate and check the size of one data matrix */
  ret=ecat63GetMatrixBlockSize(&mlist, &blkNr);
  if(ret) {ecat63EmptyMatlist(&mlist); fclose(fp); return ret;}
  /* And allocate memory for the raw data blocks */
  if(IMG_TEST>6) printf("allocating memory for %d blocks\n", blkNr);
  mdata=(char*)malloc((size_t)blkNr*MatBLKSIZE);
  if(mdata==NULL) {
    fclose(fp); ecat63EmptyMatlist(&mlist); return STATUS_NOMEMORY;}
 
  /* Read all matrices that belong to the required frame */
  ret=0; seqplane=-1;
  for(int m=0; m<mlist.matrixNr; m++) if(mlist.matdir[m].matstat==1) {
    /* get frame and plane */
    mat_numdoc(mlist.matdir[m].matnum, &matval);
    plane=matval.plane;
    if(main_header.num_frames>=main_header.num_gates) frame=matval.frame;
    else frame=matval.gate; /* printf("frame=%d plane=%d\n", frame, plane); */
    if(frame!=frame_to_read) continue; /* do not process other frames */
    seqplane++; 
    if(img->planeNumber[seqplane]<1) {
      img->planeNumber[seqplane]=plane;
    } else if(img->planeNumber[seqplane]!=plane) {
      fclose(fp); ecat63EmptyMatlist(&mlist); free(mdata);
      return STATUS_MISSINGMATRIX;    
    }
    
    /* Read the subheader */
    if(IMG_TEST>4) printf("reading subheader for matrix %d,%d\n", frame, plane);
    if(main_header.file_type==IMAGE_DATA) {
      ret=ecat63ReadImageheader(fp, mlist.matdir[m].strtblk, &image_header, IMG_TEST-10, NULL);
      scale=image_header.quant_scale;
      if(image_header.ecat_calibration_fctr>0.0 && 
         fabs(main_header.calibration_factor/image_header.ecat_calibration_fctr - 1.0)>0.0001)
        scale*=image_header.ecat_calibration_fctr;
      local_data_type=image_header.data_type;
      img->start[frame_index]=image_header.frame_start_time/1000.;
      img->end[frame_index]=img->start[frame_index]+image_header.frame_duration/1000.;
      img->mid[frame_index]=0.5*(img->start[frame_index]+img->end[frame_index]);
      if(image_header.decay_corr_fctr>1.0) {
        img->decayCorrFactor[frame_index]=image_header.decay_corr_fctr;
        img->decayCorrection=IMG_DC_CORRECTED;
      } else {
        img->decayCorrFactor[frame_index]=0.0;
        img->decayCorrection=IMG_DC_UNKNOWN;
      }
      img->xform[0]=NIFTI_XFORM_UNKNOWN; // qform
      img->xform[1]=NIFTI_XFORM_SCANNER_ANAT; // sform
      img->quatern[6]=img->sizex; img->quatern[9]=img->sizex;
      img->quatern[11]=img->sizey; img->quatern[13]=img->sizey;
      img->quatern[16]=img->sizez; img->quatern[17]=img->sizez;
    } else if(main_header.file_type==RAW_DATA) {
      ret=ecat63ReadScanheader(fp, mlist.matdir[m].strtblk, &scan_header, IMG_TEST-10, NULL);
      scale=scan_header.scale_factor;
      if(scan_header.loss_correction_fctr>0.0) scale*=scan_header.loss_correction_fctr;
      local_data_type=scan_header.data_type;
      img->start[frame_index]=scan_header.frame_start_time/1000.;
      img->end[frame_index]=img->start[frame_index]+scan_header.frame_duration/1000.;
      img->mid[frame_index]=0.5*(img->start[frame_index]+img->end[frame_index]);
      img->sampleDistance=10.0*scan_header.sample_distance;
      img->prompts[frame_index]=(float)scan_header.prompts;
      img->randoms[frame_index]=(float)scan_header.delayed;
    } else if(main_header.file_type==ATTN_DATA) {
      ret=ecat63ReadAttnheader(fp, mlist.matdir[m].strtblk, &attn_header, IMG_TEST-10, NULL);
      img->sampleDistance=10.0*attn_header.sample_distance;
      scale=attn_header.scale_factor;
      local_data_type=attn_header.data_type;
    } else if(main_header.file_type==NORM_DATA) {
      ret=ecat63ReadNormheader(fp, mlist.matdir[m].strtblk, &norm_header, IMG_TEST-10, NULL);
      scale=norm_header.scale_factor;
      local_data_type=norm_header.data_type;
    } else
      img->_dataType=-1;
    if(ret) {
      ecat63EmptyMatlist(&mlist); free(mdata); fclose(fp);
      return STATUS_NOSUBHEADER;
    }
    if(main_header.calibration_factor>0.0) scale*=main_header.calibration_factor;
    if(IMG_TEST>6) printf("scale=%e datatype=%d\n", scale, img->_dataType);
    /* Read the pixel data */
    if(IMG_TEST>4) printf("reading matrix data\n");
    ret=ecat63ReadMatdata(fp, mlist.matdir[m].strtblk+1,
         mlist.matdir[m].endblk-mlist.matdir[m].strtblk,
         mdata, local_data_type);
    if(ret) {
      ecat63EmptyMatlist(&mlist); free(mdata); fclose(fp);
      return STATUS_MISSINGMATRIX;
    }
    if(IMG_TEST>4) printf("converting matrix data to floats\n");
    mptr=mdata;
    if(local_data_type==BYTE_TYPE) {
      for(int yi=0; yi<img->dimy; yi++)
        for(int xi=0; xi<img->dimx; xi++, mptr++) {
          img->m[seqplane][yi][xi][frame_index]=scale*(float)(*mptr);
        }
    } else if(local_data_type==VAX_I2 || local_data_type==SUN_I2) {
      for(int yi=0; yi<img->dimy; yi++)
        for(int xi=0; xi<img->dimx; xi++, mptr+=2) {
          sptr=(short int*)mptr;
          img->m[seqplane][yi][xi][frame_index]=scale*(float)(*sptr);
        }
    } else if(local_data_type==VAX_I4 || local_data_type==SUN_I4) {
      for(int yi=0; yi<img->dimy; yi++)
        for(int xi=0; xi<img->dimx; xi++, mptr+=4) {
          /*iptr=(int*)mptr;*/
          img->m[seqplane][yi][xi][frame_index]=1.0; /* scale*(float)(*iptr); */
        }
    } else if(local_data_type==VAX_R4 || local_data_type==IEEE_R4) {
      for(int yi=0; yi<img->dimy; yi++)
        for(int xi=0; xi<img->dimx; xi++, mptr+=4) {
          memcpy(&img->m[seqplane][yi][xi][frame_index], mptr, 4);
          img->m[seqplane][yi][xi][frame_index]*=scale;
        }
    }
  } /* next matrix */
  if(IMG_TEST>3) printf("end of matrices.\n");
  
  free(mdata);
  ecat63EmptyMatlist(&mlist); 
  fclose(fp);
 
  /* seqplane is <0 only if this frame did not exist at all; return -1 */
  if(IMG_TEST>4) printf("last_seqplane := %d.\n", seqplane);
  if(seqplane<0) {imgSetStatus(img, STATUS_NOMATRIX); return STATUS_NOMATRIX;}
 
  /* check that correct number of planes was read */
  if(seqplane+1 != img->dimz) {
    imgSetStatus(img, STATUS_MISSINGMATRIX);
    return STATUS_MISSINGMATRIX;
  }
 
  /* For saving IMG data, only 2-byte VAX data types are allowed,
     so change it now */
  if(img->_dataType==VAX_I4 || img->_dataType==VAX_R4) img->_dataType=VAX_I2;
 
  /* All went well */
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgReadEcat63FirstFrame(), and imgReadFrame().

◆ imgReadEcat63Header()

int imgReadEcat63Header	(	const char *	fname,
		IMG *	img )

extern

Fill IMG structure header information from an image or sinogram file in ECAT 6.3 format. Information concerning separate frames or planes is not filled.

Note: ECAT 6.3 files do not have a magic number, therefore, do not use this function to determine if your file is in this format, at least test all other possible formats before calling this.

Parameters

fname	image or sinogram filename
img	pointer to initialized IMG structure

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 1318 of file img_e63.c.

  {
  int                 m, blkNr=0, ret=0;
  int                 frameNr, planeNr;
  FILE               *fp;
  ECAT63_mainheader   main_header;
  MATRIXLIST          mlist;
  ECAT63_imageheader  image_header;
  ECAT63_scanheader   scan_header;
  ECAT63_attnheader   attn_header;
  ECAT63_normheader   norm_header;
 
 
  if(IMG_TEST>0) printf("\nimgReadEcat63Header(%s, *img)\n", fname);
  
  /* Check the arguments */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(fname==NULL) return STATUS_FAULT;
    
  /* Open the file */
  if((fp=fopen(fname, "rb")) == NULL) return STATUS_NOFILE;
  
  /* Read main header */
  if((ret=ecat63ReadMainheader(fp, &main_header))) {
    fclose(fp); return STATUS_NOMAINHEADER;}
  /* Check if file_type is supported */
  if(imgEcat63Supported(&main_header)==0) {
    fclose(fp); return STATUS_UNSUPPORTED;}
  /* Copy main header information into IMG; sets also img.type */
  imgGetEcat63MHeader(img, &main_header);
  if(IMG_TEST>7) printf("img.type := %d\n", img->type);
  img->_fileFormat=imgGetEcat63Fileformat(&main_header);
  if(IMG_TEST>7) printf("img._fileFormat := %d\n", img->_fileFormat);
  if(img->_fileFormat==IMG_UNKNOWN) {fclose(fp); return STATUS_UNSUPPORTED;}
 
  /* Read matrix list and nr and sort it */
  ecat63InitMatlist(&mlist);
  ret=ecat63ReadMatlist(fp, &mlist, IMG_TEST-1);
  if(ret) {fclose(fp); return STATUS_NOMATLIST;}
  if(mlist.matrixNr<=0) {
    ecat63EmptyMatlist(&mlist); fclose(fp); return STATUS_INVALIDMATLIST;}
  /* Make sure that plane and frame numbers are continuous */
  ecat63GatherMatlist(&mlist, 1, 1, 1, 1);
  ecat63SortMatlistByPlane(&mlist); // otherwise frameNr can't be computed below
  /* Trim extra frames */
  if(main_header.num_frames>0)
    /*del_nr=*/ecat63DeleteLateFrames(&mlist, main_header.num_frames);
  /* Get plane and frame numbers and check that volume is full */
  ret=ecat63GetPlaneAndFrameNr(&mlist, &main_header, &planeNr, &frameNr);
  if(ret) {ecat63EmptyMatlist(&mlist); fclose(fp); return ret;}
  img->dimz=planeNr;
  img->dimt=frameNr;
  /* Calculate and check the size of one data matrix */
  ret=ecat63GetMatrixBlockSize(&mlist, &blkNr);
  if(ret) {ecat63EmptyMatlist(&mlist); fclose(fp); return ret;}
 
  /* Read one subheader */
  if(IMG_TEST>5) printf("main_header.file_type := %d\n", main_header.file_type);
  m=0;
  switch(main_header.file_type) {
    case IMAGE_DATA:
      ret=ecat63ReadImageheader(fp, mlist.matdir[m].strtblk, &image_header, IMG_TEST-10, NULL);
      break;
    case RAW_DATA:
      ret=ecat63ReadScanheader(fp, mlist.matdir[m].strtblk, &scan_header, IMG_TEST-10, NULL);
      break;
    case ATTN_DATA:
      ret=ecat63ReadAttnheader(fp, mlist.matdir[m].strtblk, &attn_header, IMG_TEST-10, NULL);
      break;
    case NORM_DATA:
      ret=ecat63ReadNormheader(fp, mlist.matdir[m].strtblk, &norm_header, IMG_TEST-10, NULL);
      break;
    default: ret=-1;
  }
  /* Free locally allocated memory and close the file */
  ecat63EmptyMatlist(&mlist); fclose(fp);
  /* Check whether subheader was read */
  if(ret) return STATUS_NOSUBHEADER;
 
  /* Get the following information in the subheader:
     dimensions x, y and z; datatype;
     image decay correction on/off, zoom, and pixel size;
     sinogram sample distance.
   */
  switch(main_header.file_type) {
    case IMAGE_DATA:
      img->dimx=image_header.dimension_1; img->dimy=image_header.dimension_2;
      if(img->unit<1) imgUnitFromEcat(img, image_header.quant_units);
      img->_dataType=image_header.data_type;
      img->zoom=image_header.recon_scale;
      if(image_header.decay_corr_fctr>1.0) img->decayCorrection=IMG_DC_CORRECTED;
      else img->decayCorrection=IMG_DC_UNKNOWN;
      img->sizex=img->sizey=10.*image_header.pixel_size;
      if(img->sizez<10.*image_header.slice_width)
        img->sizez=10.*image_header.slice_width;
      break;
    case RAW_DATA:
      img->dimx=scan_header.dimension_1; img->dimy=scan_header.dimension_2;
      img->type=IMG_TYPE_RAW;
      img->_dataType=scan_header.data_type;
      img->decayCorrection=IMG_DC_NONCORRECTED;
      img->sampleDistance=10.0*scan_header.sample_distance;
      break;
    case ATTN_DATA:
      img->dimx=attn_header.dimension_1; img->dimy=attn_header.dimension_2;
      img->type=IMG_TYPE_ATTN;
      img->decayCorrection=IMG_DC_NONCORRECTED;
      img->_dataType=attn_header.data_type;
      break;
    case NORM_DATA:
      img->dimx=norm_header.dimension_1; img->dimy=norm_header.dimension_2;
      img->type=IMG_TYPE_RAW;
      img->decayCorrection=IMG_DC_NONCORRECTED;
      img->_dataType=norm_header.data_type;
      break;
  }
 
  /* For saving IMG data, only 2-byte VAX data types are allowed,
     so change it now */
  if(img->_dataType==VAX_I4 || img->_dataType==VAX_R4) img->_dataType=VAX_I2;
 
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgFormatDetermine(), imgReadEcat63FirstFrame(), imgReadHeader(), and imgWriteEcat63Frame().

◆ imgReadEcat7()

int imgReadEcat7	(	const char *	fname,
		IMG *	img )

extern

Read ECAT 7 image, volume or 2D sinogram.

Returns: 0 if ok, 1 invalid input, 2 image status is not 'initialized', 3 failed to open file field for reading, 4 recognize file, 5 file type not supported, 6 invalid matrix list, 7 invalid number of matrices/frames, 8 variable matrix size, 9 failed to read header, 11 failed to allocate memory for data, 13 failed to read data.

Parameters

fname	Name of the input ECAT 7 file.
img	Data structure in which the file is read; must be initialized before using this function.

Definition at line 19 of file img_e7.c.

  {
  ECAT7_mainheader main_header;
  ECAT7_imageheader image_header;
  ECAT7_2Dscanheader scan2d_header;
  ECAT7_scanheader scan_header;
  ECAT7_polmapheader polmap_header;
  ECAT7_MATRIXLIST mlist;
  ECAT7_Matval matval;
  float *fdata=NULL, *fptr;
  int blkNr=0;
 
 
  if(IMG_TEST) printf("imgReadEcat7(%s, *img)\n", fname);
  /* Check the arguments */
  if(fname==NULL) return(1);
  if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
 
  /* Open file for read */
  FILE *fp;
  if((fp=fopen(fname, "rb"))==NULL) {imgSetStatus(img,STATUS_NOFILE); return(3);}
  
  /* Read main header */
  int ret=ecat7ReadMainheader(fp, &main_header);
  if(ret) {fclose(fp); imgSetStatus(img, STATUS_UNKNOWNFORMAT); return(4);}
  /* Check for magic number */
  if(strncmp(main_header.magic_number, ECAT7V_MAGICNR, 7)!=0) {
    fclose(fp); imgSetStatus(img, STATUS_UNKNOWNFORMAT); return(4);
  }
  
  /* Check if file_type is supported */
  if(imgEcat7Supported(&main_header)==0) {
    fclose(fp); imgSetStatus(img, STATUS_UNSUPPORTED); return(5);
  }
 
  /* Read matrix list */
  ecat7InitMatlist(&mlist);
  ret=ecat7ReadMatlist(fp, &mlist, IMG_TEST-1);
  if(ret || mlist.matrixNr<1 || ecat7CheckMatlist(&mlist)) {
    if(IMG_TEST) printf("  ret=%d   mlist.matrixNr=%d\n", ret, mlist.matrixNr);
    fclose(fp); imgSetStatus(img, STATUS_INVALIDMATLIST); return(6);}
  ecat7SortMatlistByPlane(&mlist);
  if(IMG_TEST>2) ecat7PrintMatlist(&mlist);
 
  /* Calculate the number of planes, frames and gates */
  /* Check that all planes have equal nr of frames (gates) */
  /* and check that frames (gates) are consequentally numbered */
  int frame, plane, prev_frame, prev_plane, planeNr, frameNr;
  prev_plane=plane=-1; prev_frame=frame=-1; frameNr=planeNr=0; ret=0;
  for(int m=0; m<mlist.matrixNr; m++) {
    ecat7_id_to_val(mlist.matdir[m].id, &matval); plane=matval.plane;
    if(main_header.num_frames>=main_header.num_gates) frame=matval.frame;
    else frame=matval.gate;
    if(plane!=prev_plane) {frameNr=1; planeNr++;}
    else {frameNr++; if(prev_frame>0 && frame!=prev_frame+1) {ret=1; break;}}
    prev_plane=plane; prev_frame=frame;
    /* Calculate and check the size of one data matrix */
    if(m==0) {
      blkNr=mlist.matdir[m].endblk-mlist.matdir[m].strtblk;
    } else if(blkNr!=mlist.matdir[m].endblk-mlist.matdir[m].strtblk) {
      ret=2; break;
    }
  } /* next matrix */
  if(IMG_TEST>2) printf("frameNr=%d planeNr=%d\n", frameNr, planeNr);
  if(ret==1 || (frameNr*planeNr != mlist.matrixNr)) {
    fclose(fp); imgSetStatus(img, STATUS_MISSINGMATRIX);
    ecat7EmptyMatlist(&mlist); return(7);
  }
  if(ret==2) {
    fclose(fp); imgSetStatus(img, STATUS_VARMATSIZE);
    ecat7EmptyMatlist(&mlist); return(8);
  }
 
  /* Read the first subheader to get planeNr from volumes and to get x&y dim */
  int m=0, dimx, dimy, dimz=1;
  imgSetStatus(img, STATUS_NOSUBHEADER);
  switch(main_header.file_type) {
    case ECAT7_IMAGE8:
    case ECAT7_IMAGE16:
    case ECAT7_VOLUME8:
    case ECAT7_VOLUME16:
      img->type=IMG_TYPE_IMAGE;
      ret=ecat7ReadImageheader(fp, mlist.matdir[m].strtblk, &image_header);
      dimx=image_header.x_dimension; dimy=image_header.y_dimension;
      if(image_header.num_dimensions>2 && image_header.z_dimension>1)
        planeNr=dimz=image_header.z_dimension;
      break;
    case ECAT7_2DSCAN:
      img->type=IMG_TYPE_RAW;
      ret=ecat7Read2DScanheader(fp, mlist.matdir[m].strtblk, &scan2d_header);
      dimx=scan2d_header.num_r_elements; dimy=scan2d_header.num_angles;
      if(scan2d_header.num_dimensions>2 && scan2d_header.num_z_elements>1)
        planeNr=dimz=scan2d_header.num_z_elements;
      break;
    case ECAT7_3DSCAN:
    case ECAT7_3DSCAN8:
    case ECAT7_3DSCANFIT:
      img->type=IMG_TYPE_RAW;
      ret=ecat7ReadScanheader(fp, mlist.matdir[m].strtblk, &scan_header);
      dimx=scan_header.num_r_elements; dimy=scan_header.num_angles;
      dimz=0;
      for(int i=0; i<64; i++) dimz+=scan_header.num_z_elements[i];
      planeNr=dimz;
      /*if(scan_header.axial_compression!=0) {
        img->statmsg=imgmsg[STATUS_UNSUPPORTEDAXIALCOMP]; ret=-1;}*/
      break;
    case ECAT7_POLARMAP:
      img->type=IMG_TYPE_POLARMAP;
      ret=ecat7ReadPolmapheader(fp, mlist.matdir[m].strtblk, &polmap_header);
      planeNr=dimz=dimy=1; dimx=0;
      for(int i=0; i<polmap_header.num_rings; i++)
        dimx+=polmap_header.sectors_per_ring[i];
      break;
    default: dimx=dimy=dimz=planeNr=0; ret=-1;
  }
  long long pxlNr=dimx*dimy;
  if(ret || pxlNr<1 || planeNr<1) {
    fclose(fp);  ecat7EmptyMatlist(&mlist); return(9);}
  imgSetStatus(img, STATUS_OK);
 
  /* Allocate memory for IMG data */
  ret=imgAllocate(img, planeNr, dimy, dimx, frameNr);
  if(ret) {
    fclose(fp); imgSetStatus(img, STATUS_NOMEMORY);
    ecat7EmptyMatlist(&mlist); return(11);
  }
  /* Copy information from mainheader */
  imgGetEcat7MHeader(img, &main_header);
  /* Set fileFormat */
  switch(main_header.file_type) {
    case ECAT7_IMAGE8:
    case ECAT7_IMAGE16:
      img->_fileFormat=IMG_E7_2D; break;
    case ECAT7_VOLUME8:
    case ECAT7_VOLUME16:
      img->_fileFormat=IMG_E7; break;
    case ECAT7_2DSCAN:
      img->_fileFormat=IMG_E7_2D; break;
    case ECAT7_3DSCAN:
    case ECAT7_3DSCAN8:
    case ECAT7_3DSCANFIT:
      img->_fileFormat=IMG_E7; break;
    case ECAT7_POLARMAP:
      img->_fileFormat=IMG_POLARMAP; break;
    default:
      img->_fileFormat=IMG_UNKNOWN; break;
  }
 
  if(dimz>1) {
    /* Read ECAT volume matrices */
    int fi=0;
    for(int m=0; m<mlist.matrixNr; m++) {
      /* Get matrix values */
      ecat7_id_to_val(mlist.matdir[m].id, &matval);
      /* Read subheader and data */
      if(img->type==IMG_TYPE_IMAGE)
        ret=ecat7ReadImageMatrix(fp, mlist.matdir[m].strtblk,
              mlist.matdir[m].endblk, &image_header, &fdata);
      else
        ret=ecat7ReadScanMatrix(fp, mlist.matdir[m].strtblk,
              mlist.matdir[m].endblk, &scan_header, &fdata);
      if(ret || fdata==NULL) {
        if(IMG_TEST) printf("ecat7ReadXMatrix()=%d\n%s\n", ret, ecat7errmsg);
        fclose(fp); imgSetStatus(img, STATUS_NOMATRIX);
        ecat7EmptyMatlist(&mlist); return(13);
      }
      /* Copy subheader information */
      if(img->type==IMG_TYPE_POLARMAP) {
        img->_dataType=polmap_header.data_type;
        img->start[fi]=polmap_header.frame_start_time/1000.;
        img->end[fi]=img->start[fi]+polmap_header.frame_duration/1000.;
        img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
        img->sizex=0.001*polmap_header.pixel_size;
      } else if(img->type==IMG_TYPE_IMAGE) {
        img->_dataType=image_header.data_type;
        img->start[fi]=image_header.frame_start_time/1000.;
        img->end[fi]=img->start[fi]+image_header.frame_duration/1000.;
        img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
        if(image_header.decay_corr_fctr>1.0) {
          img->decayCorrFactor[fi]=image_header.decay_corr_fctr;
          img->decayCorrection=IMG_DC_CORRECTED;
        } else {
          img->decayCorrFactor[fi]=0.0;
          img->decayCorrection=IMG_DC_UNKNOWN;
        }
        img->zoom=image_header.recon_zoom;
        img->sizex=10.*image_header.x_pixel_size;
        img->sizey=10.*image_header.y_pixel_size;
        img->sizez=10.*image_header.z_pixel_size;
        img->resolutionx=10.*image_header.x_resolution;
        img->resolutiony=10.*image_header.y_resolution;
        img->resolutionz=10.*image_header.z_resolution;
        img->xform[0]=NIFTI_XFORM_UNKNOWN; // qform
        img->xform[1]=NIFTI_XFORM_SCANNER_ANAT; // sform
        img->quatern[6]=img->sizex; img->quatern[9]=img->sizex;
        img->quatern[11]=img->sizey; img->quatern[13]=img->sizey;
        img->quatern[16]=img->sizez; img->quatern[17]=img->sizez;
        img->mt[0]=image_header.mt_1_1;
        img->mt[1]=image_header.mt_1_2;
        img->mt[2]=image_header.mt_1_3;
        img->mt[3]=image_header.mt_1_4;
        img->mt[4]=image_header.mt_2_1;
        img->mt[5]=image_header.mt_2_2;
        img->mt[6]=image_header.mt_2_3;
        img->mt[7]=image_header.mt_2_4;
        img->mt[8]=image_header.mt_3_1;
        img->mt[9]=image_header.mt_3_2;
        img->mt[10]=image_header.mt_3_3;
        img->mt[11]=image_header.mt_3_4;
      } else {
        img->_dataType=scan_header.data_type;
        img->start[fi]=scan_header.frame_start_time/1000.;
        img->end[fi]=img->start[fi]+scan_header.frame_duration/1000.;
        img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
        if(scan_header.x_resolution>0.0)
          img->sampleDistance=10.0*scan_header.x_resolution;
        else
          img->sampleDistance=10.0*main_header.bin_size;
        /* also, correct for dead-time */
        if(scan_header.deadtime_correction_factor>0.0) {
          fptr=fdata;
          for(long long i=0; i<dimz*pxlNr; i++, fptr++)
            *fptr*=scan_header.deadtime_correction_factor;
        }
        img->prompts[fi]=(float)scan_header.prompts;
        img->randoms[fi]=scan_header.delayed;
      }
      /* Copy matrix data through volume planes */
      for(int pi=0; pi<dimz; pi++) {
        fptr=fdata+pi*pxlNr;
        for(int yi=0; yi<dimy; yi++)
          for(int xi=0; xi<dimx; xi++)
            img->m[pi][yi][xi][fi]= *fptr++;
      }
      free(fdata); fi++;
    } /* next matrix */
    /* Set plane numbers */
    for(int pi=0; pi<dimz; pi++) img->planeNumber[pi]=pi+1;
  } else {
    /* Read separate matrices */
    prev_plane=plane=-1; prev_frame=frame=-1;
    int pi=-1, fi=-1;
    for(int m=0; m<mlist.matrixNr; m++) {
      ecat7_id_to_val(mlist.matdir[m].id, &matval); plane=matval.plane;
      if(main_header.num_frames>=main_header.num_gates) frame=matval.frame;
      else frame=matval.gate;
      if(plane!=prev_plane) {fi=0; pi++;} else fi++;
      /* Read subheader and data */
      if(img->type==IMG_TYPE_POLARMAP)
        ret=ecat7ReadPolarmapMatrix(fp, mlist.matdir[m].strtblk,
              mlist.matdir[m].endblk, &polmap_header, &fdata);
      else if(img->type==IMG_TYPE_IMAGE)
        ret=ecat7ReadImageMatrix(fp, mlist.matdir[m].strtblk,
              mlist.matdir[m].endblk, &image_header, &fdata);
      else
        ret=ecat7Read2DScanMatrix(fp, mlist.matdir[m].strtblk,
              mlist.matdir[m].endblk, &scan2d_header, &fdata);
      if(ret || fdata==NULL) {
        fclose(fp); imgSetStatus(img, STATUS_NOMATRIX);
        ecat7EmptyMatlist(&mlist); return(13);
      }
      /* Copy subheader information */
      if(fi==0) img->planeNumber[pi]=plane;
      if(img->type==IMG_TYPE_POLARMAP) {
        img->_dataType=polmap_header.data_type;
        img->start[fi]=polmap_header.frame_start_time/1000.;
        img->end[fi]=img->start[fi]+polmap_header.frame_duration/1000.;
        img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
        img->sizex=0.001*polmap_header.pixel_size;
      } else if(img->type==IMG_TYPE_IMAGE) {
        img->_dataType=image_header.data_type;
        img->start[fi]=image_header.frame_start_time/1000.;
        img->end[fi]=img->start[fi]+image_header.frame_duration/1000.;
        img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
        if(image_header.decay_corr_fctr>1.0) {
          img->decayCorrFactor[fi]=image_header.decay_corr_fctr;
          img->decayCorrection=IMG_DC_CORRECTED;
        } else {
          img->decayCorrFactor[fi]=0.0;
          img->decayCorrection=IMG_DC_UNKNOWN;
        }
        img->zoom=image_header.recon_zoom;
        img->sizex=10.*image_header.x_pixel_size;
        img->sizey=10.*image_header.y_pixel_size;
        img->sizez=10.*image_header.z_pixel_size;
        img->resolutionx=10.*image_header.x_resolution;
        img->resolutiony=10.*image_header.y_resolution;
        img->resolutionz=10.*image_header.z_resolution;
        img->xform[0]=NIFTI_XFORM_UNKNOWN; // qform
        img->xform[1]=NIFTI_XFORM_SCANNER_ANAT; // sform
        img->quatern[6]=img->sizex; img->quatern[9]=img->sizex;
        img->quatern[11]=img->sizey; img->quatern[13]=img->sizey;
        img->quatern[16]=img->sizez; img->quatern[17]=img->sizez;
        img->mt[0]=image_header.mt_1_1;
        img->mt[1]=image_header.mt_1_2;
        img->mt[2]=image_header.mt_1_3;
        img->mt[3]=image_header.mt_1_4;
        img->mt[4]=image_header.mt_2_1;
        img->mt[5]=image_header.mt_2_2;
        img->mt[6]=image_header.mt_2_3;
        img->mt[7]=image_header.mt_2_4;
        img->mt[8]=image_header.mt_3_1;
        img->mt[9]=image_header.mt_3_2;
        img->mt[10]=image_header.mt_3_3;
        img->mt[11]=image_header.mt_3_4;
      } else {
        img->_dataType=scan2d_header.data_type;
        img->start[fi]=scan2d_header.frame_start_time/1000.;
        img->end[fi]=img->start[fi]+scan2d_header.frame_duration/1000.;
        img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
        if(scan_header.x_resolution>0.0)
          img->sampleDistance=10.0*scan_header.x_resolution;
        else
          img->sampleDistance=10.0*main_header.bin_size;
        /* also, correct for dead-time */
        if(scan2d_header.deadtime_correction_factor>0.0) {
          fptr=fdata;
          for(long long i=0; i<pxlNr; i++, fptr++)
            *fptr*=scan2d_header.deadtime_correction_factor;
        }
        img->prompts[fi]=(float)scan_header.prompts;
        img->randoms[fi]=scan_header.delayed;
      }
      /* Copy matrix data */
      fptr=fdata;
      for(int yi=0; yi<dimy; yi++) for(int xi=0; xi<dimx; xi++)
        img->m[pi][yi][xi][fi]= *fptr++;
      free(fdata);
      /* prepare for the next matrix */
      prev_plane=plane; prev_frame=frame;
    } /* next matrix */
  }
  fclose(fp); ecat7EmptyMatlist(&mlist);
 
  /* Calibrate */
  if(main_header.ecat_calibration_factor>0.0)
    for(int pi=0; pi<img->dimz; pi++)
      for(int yi=0; yi<img->dimy; yi++) for(int xi=0; xi<img->dimx; xi++)
        for(int fi=0; fi<img->dimt; fi++)
          img->m[pi][yi][xi][fi]*=main_header.ecat_calibration_factor;
 
  imgSetStatus(img, STATUS_OK);
  return(0);
}

Referenced by imgRead().

◆ imgReadEcat7FirstFrame()

int imgReadEcat7FirstFrame	(	const char *	fname,
		IMG *	img )

extern

Read the first frame from an ECAT 7 file into IMG data structure.

Parameters

fname	name of file from which IMG contents will be read
img	pointer to the initiated but not preallocated IMG data

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 1060 of file img_e7.c.

                                                        {
  int ret=0;
 
  if(IMG_TEST) printf("\nimgReadEcat7FirstFrame(%s, *img)\n", fname);
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(fname==NULL) return STATUS_FAULT;
 
  /* Read header information from file */
  ret=imgReadEcat7Header(fname, img); if(ret) return(ret);
  if(IMG_TEST>3) imgInfo(img);
 
  /* Allocate memory for one frame */
  img->dimt=1;
  ret=imgAllocate(img, img->dimz, img->dimy, img->dimx, img->dimt);
  if(ret) return STATUS_NOMEMORY;
 
  /* Read the first frame */
  ret=imgReadEcat7Frame(fname, 1, img, 0); if(ret) return(ret); 
 
  /* All went well */
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

◆ imgReadEcat7Frame()

int imgReadEcat7Frame	(	const char *	fname,
		int	frame_to_read,
		IMG *	img,
		int	frame_index )

extern

Read a specified frame from an ECAT 7 file into preallocated IMG data structure. IMG header is assumed to be filled correctly before calling this function, except for information concerning separate planes and this frame, which is filled here. If frame does not exist, then and only then STATUS_NOMATRIX is returned.

Parameters

fname	name of file from which IMG contents will be read
frame_to_read	frame which will be read [1..frameNr]
img	pointer to the IMG data. Place for the frame must be preallocated
frame_index	IMG frame index [0..dimt-1] where data will be placed

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 1103 of file img_e7.c.

  {
  FILE *fp;
  int ret, frame, plane, seqplane;
  /* int blkNr=0; */
  ECAT7_mainheader main_header;
  ECAT7_imageheader image_header;
  ECAT7_2Dscanheader scan2d_header;
  ECAT7_scanheader scan_header;
  ECAT7_polmapheader polmap_header;
  ECAT7_MATRIXLIST mlist;
  ECAT7_Matval matval;
  float *fdata=NULL, *fptr;
 
 
  if(IMG_TEST) printf("\nimgReadEcat7Frame(%s, %d, *img, %d)\n",
    fname, frame_to_read, frame_index);
    
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
  if(fname==NULL) return STATUS_FAULT;
  if(frame_index<0 || frame_index>img->dimt-1) return STATUS_FAULT;
  if(frame_to_read<1) return STATUS_FAULT;
 
  /* Open file for read */
  if((fp=fopen(fname, "rb")) == NULL) return STATUS_NOFILE;
 
  /* Read main header */
  ret=ecat7ReadMainheader(fp, &main_header);
  if(ret) {fclose(fp); return STATUS_NOMAINHEADER;}
  /* Check for magic number */
  if(strncmp(main_header.magic_number, ECAT7V_MAGICNR, 7)!=0) {
    fclose(fp); return STATUS_UNKNOWNFORMAT;}
  /* Check if file_type is supported */
  if(imgEcat7Supported(&main_header)==0) {
    fclose(fp); return STATUS_UNSUPPORTED;}
  /* Read matrix list and nr and sort it */
  ecat7InitMatlist(&mlist);
  ret=ecat7ReadMatlist(fp, &mlist, IMG_TEST-1);
  if(ret) {fclose(fp); return STATUS_NOMATLIST;}
  if(mlist.matrixNr<=0 || ecat7CheckMatlist(&mlist)) {
    fclose(fp); ecat7EmptyMatlist(&mlist); return STATUS_INVALIDMATLIST;}
  /* Make sure that plane and frame numbers are continuous */
  ecat7GatherMatlist(&mlist, 1, 1, 1, 1);
  ecat7SortMatlistByFrame(&mlist); /* printf("matlist sorted\n"); */
  /* Calculate and check the size of one data matrix */
  /*ret=ecat7GetMatrixBlockSize(&mlist, &blkNr);
    if(ret) {fclose(fp); return ret;}*/
 
  /* Read all matrices that belong to the required frame */
  /*blkNr=-1;*/
  ret=0; seqplane=-1; 
  long long pxlNr=img->dimx*img->dimy;
  for(int m=0; m<mlist.matrixNr; m++) {
    /* get frame and plane */
    ecat7_id_to_val(mlist.matdir[m].id, &matval); plane=matval.plane;
    if(main_header.num_frames>=main_header.num_gates) frame=matval.frame;
    else frame=matval.gate; /* printf("frame=%d plane=%d\n", frame, plane); */
    if(frame!=frame_to_read) continue; /* do not process other frames */
    /*if(img->dimz>1) seqplane++; else seqplane=plane-1; */
    if(img->_fileFormat==IMG_E7_2D) seqplane=plane-1; else seqplane++;
    
    /* Read subheader and data */
    if(IMG_TEST>4) printf("reading matrix %d,%d\n", frame, plane);
    if(img->type==IMG_TYPE_IMAGE) { /* 2D or 3D image */
      ret=ecat7ReadImageMatrix(fp, mlist.matdir[m].strtblk,
              mlist.matdir[m].endblk, &image_header, &fdata);
    } else if(img->type==IMG_TYPE_POLARMAP) {  /* polarmap */
      ret=ecat7ReadPolarmapMatrix(fp, mlist.matdir[m].strtblk,
              mlist.matdir[m].endblk, &polmap_header, &fdata);
    } else if(img->dimz>1) { /* 3D sinogram */
      ret=ecat7ReadScanMatrix(fp, mlist.matdir[m].strtblk,
            mlist.matdir[m].endblk, &scan_header, &fdata);
    } else { /* 2D sinogram */
      ret=ecat7Read2DScanMatrix(fp, mlist.matdir[m].strtblk,
            mlist.matdir[m].endblk, &scan2d_header, &fdata);
    }
    if(ret || fdata==NULL) {
      fclose(fp); ecat7EmptyMatlist(&mlist); return STATUS_NOMATRIX;}
 
    /* Copy information concerning this frame and make correction to data */
    if(img->type==IMG_TYPE_IMAGE) {
      img->start[frame_index]=image_header.frame_start_time/1000.;
      img->end[frame_index]=
        img->start[frame_index]+image_header.frame_duration/1000.;
      img->mid[frame_index]=0.5*(img->start[frame_index]+img->end[frame_index]);
      if(image_header.decay_corr_fctr>1.0) {
        img->decayCorrFactor[frame_index]=image_header.decay_corr_fctr;
        img->decayCorrection=IMG_DC_CORRECTED;
      } else {
        img->decayCorrFactor[frame_index]=0.0;
        img->decayCorrection=IMG_DC_UNKNOWN;
      }
    } else if(img->type==IMG_TYPE_POLARMAP) {  /* polarmap */
      img->start[frame_index]=polmap_header.frame_start_time/1000.;
      img->end[frame_index]=
        img->start[frame_index]+polmap_header.frame_duration/1000.;
      img->mid[frame_index]=0.5*(img->start[frame_index]+img->end[frame_index]);
    } else if(img->dimz>1) {
      img->start[frame_index]=scan_header.frame_start_time/1000.;
      img->end[frame_index]=
        img->start[frame_index]+scan_header.frame_duration/1000.;
      img->mid[frame_index]=0.5*(img->start[frame_index]+img->end[frame_index]);
      /* also, correct for dead-time */
      if(scan_header.deadtime_correction_factor>0.0) {
        fptr=fdata;
        for(long long i=0; i<img->dimz*pxlNr; i++, fptr++)
          *fptr*=scan_header.deadtime_correction_factor;
      }
      img->prompts[frame_index]=(float)scan_header.prompts;
      img->randoms[frame_index]=scan_header.delayed;
    } else {
      img->start[frame_index]=scan2d_header.frame_start_time/1000.;
      img->end[frame_index]=
        img->start[frame_index]+scan2d_header.frame_duration/1000.;
      img->mid[frame_index]=0.5*(img->start[frame_index]+img->end[frame_index]);
      /* also, correct for dead-time */
      if(scan2d_header.deadtime_correction_factor>0.0) {
        fptr=fdata;
        for(long long i=0; i<pxlNr; i++, fptr++)
          *fptr*=scan2d_header.deadtime_correction_factor;
      }
      img->prompts[frame_index]=(float)scan2d_header.prompts;
      img->randoms[frame_index]=scan2d_header.delayed;
    }
    /* Copy matrix data through volume planes */
    if(img->_fileFormat!=IMG_E7_2D) {
    /* if(img->dimz>1) { */
      for(int pi=0; pi<img->dimz; pi++) {
        if(IMG_TEST>5)
          printf("  putting data into m[%d][][][%d]\n", pi, frame_index);
        fptr=fdata+pi*pxlNr;
        for(int yi=0; yi<img->dimy; yi++)
          for(int xi=0; xi<img->dimx; xi++)
            img->m[pi][yi][xi][frame_index]= *fptr++;
      }
    } else {
        if(IMG_TEST>5)
          printf("  putting data into m[%d][][][%d]\n", seqplane, frame_index);
        fptr=fdata;
        for(int yi=0; yi<img->dimy; yi++)
          for(int xi=0; xi<img->dimx; xi++)
            img->m[seqplane][yi][xi][frame_index]= *fptr++;
        img->planeNumber[seqplane]=plane;
    }
    free(fdata);
    /* Calibrate */
    if(main_header.ecat_calibration_factor>0.0)
      for(int pi=0; pi<img->dimz; pi++)
        for(int yi=0; yi<img->dimy; yi++) for(int xi=0; xi<img->dimx; xi++)
          img->m[pi][yi][xi][frame_index]*=main_header.ecat_calibration_factor;
  } /* next matrix */
  if(IMG_TEST>3) printf("end of matrices.\n");
  ecat7EmptyMatlist(&mlist);
  fclose(fp);
 
  /* seqplane is <0 only if this frame did not exist at all; return -1 */
  if(IMG_TEST>4) printf("last_seqplane := %d.\n", seqplane);
  if(seqplane<0) return STATUS_NOMATRIX;
 
  /* check that correct number of planes was read */
  if(seqplane>0 && (seqplane+1 != img->dimz)) return STATUS_MISSINGMATRIX;
 
  /* All went well */
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgReadEcat7FirstFrame(), and imgReadFrame().

◆ imgReadEcat7Header()

int imgReadEcat7Header	(	const char *	fname,
		IMG *	img )

extern

Fill IMG struct header information from an image or sinogram file in ECAT 7 format. Information concerning separate frames or planes is not filled.

Parameters

fname	image or sinogram filename
img	pointer to initialized IMG structure

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 860 of file img_e7.c.

                                                    {
  FILE *fp;
  int ret, m;
  int planeNr, frameNr, blkNr=0;
  ECAT7_mainheader main_header;
  ECAT7_imageheader image_header;
  ECAT7_2Dscanheader scan2d_header;
  ECAT7_scanheader scan_header;
  ECAT7_polmapheader polmap_header;
  ECAT7_MATRIXLIST mlist;
 
 
  if(IMG_TEST) printf("\nimgReadEcat7Header(%s, *img)\n", fname);
  
  /* Check the arguments */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(fname==NULL) return STATUS_FAULT;
    
  /* Open the file */
  if((fp=fopen(fname, "rb")) == NULL) return STATUS_NOFILE;
 
  /* Read main header */
  ret=ecat7ReadMainheader(fp, &main_header);
  if(ret) {fclose(fp); return STATUS_NOMAINHEADER;}
  /* Check for magic number */
  if(strncmp(main_header.magic_number, ECAT7V_MAGICNR, 7)!=0) {
    fclose(fp); return STATUS_UNKNOWNFORMAT;}
  /* Check if file_type is supported */
  if(imgEcat7Supported(&main_header)==0) {fclose(fp); return STATUS_UNSUPPORTED;}
  /* Copy main header information into IMG; sets also img.type */
  imgGetEcat7MHeader(img, &main_header);
  if(IMG_TEST>7) printf("img.type := %d\n", img->type);
  img->_fileFormat=imgGetEcat7Fileformat(&main_header);
  if(IMG_TEST>7) printf("img._fileFormat := %d\n", img->_fileFormat);
  if(img->_fileFormat==IMG_UNKNOWN) {fclose(fp); return STATUS_UNSUPPORTED;}
 
  /* Read matrix list */
  ecat7InitMatlist(&mlist);
  ret=ecat7ReadMatlist(fp, &mlist, IMG_TEST-1);
  if(ret || mlist.matrixNr<1 || ecat7CheckMatlist(&mlist)) {
    fclose(fp); return STATUS_INVALIDMATLIST;}
  /* Make sure that plane and frame numbers are continuous */
  ecat7GatherMatlist(&mlist, 1, 1, 1, 1);
  /* Get plane and frame numbers and check that volume is full */
  ret=ecat7GetPlaneAndFrameNr(&mlist, &main_header, &planeNr, &frameNr);
  if(ret) {ecat7EmptyMatlist(&mlist); fclose(fp); return ret;}
  img->dimz=planeNr;
  img->dimt=frameNr;
  /* Get and check the size of data matrices */
  ret=ecat7GetMatrixBlockSize(&mlist, &blkNr);
  if(ret) {ecat7EmptyMatlist(&mlist); fclose(fp); return ret;}
 
  /* Read one subheader */
  if(IMG_TEST>5) printf("main_header.file_type := %d\n", main_header.file_type);
  m=0;
  switch(main_header.file_type) {
    case ECAT7_IMAGE8:
    case ECAT7_IMAGE16:
    case ECAT7_VOLUME8:
    case ECAT7_VOLUME16:
      ret=ecat7ReadImageheader(fp, mlist.matdir[m].strtblk, &image_header);
      break;
    case ECAT7_2DSCAN:
      ret=ecat7Read2DScanheader(fp, mlist.matdir[m].strtblk, &scan2d_header);
      break;
    case ECAT7_3DSCAN:
    case ECAT7_3DSCAN8:
    case ECAT7_3DSCANFIT:
      ret=ecat7ReadScanheader(fp, mlist.matdir[m].strtblk, &scan_header);
      break;
    case ECAT7_POLARMAP:
      ret=ecat7ReadPolmapheader(fp, mlist.matdir[m].strtblk, &polmap_header);
      break;
    default: ret=-1;
  }
  /* Free locally allocated memory and close the file */
  ecat7EmptyMatlist(&mlist); fclose(fp);
  /* Check whether subheader was read */
  if(ret) return STATUS_NOSUBHEADER;
 
  /* Get the following information in the subheader:
     dimensions x, y and z; datatype;
     image decay correction on/off, zoom, pixel size and resolution;
     sinogram sample distance; matrix transformation parameters.
   */
  switch(main_header.file_type) {
    case ECAT7_IMAGE8:
    case ECAT7_IMAGE16:
    case ECAT7_VOLUME8:
    case ECAT7_VOLUME16:
      img->dimx=image_header.x_dimension; img->dimy=image_header.y_dimension;
      if(image_header.num_dimensions>2 && image_header.z_dimension>1)
        /*planeNr=*/ img->dimz=image_header.z_dimension;
      img->_dataType=image_header.data_type;
      if(image_header.decay_corr_fctr>1.0) img->decayCorrection=IMG_DC_CORRECTED;
      img->zoom=image_header.recon_zoom;
      img->sizex=10.*image_header.x_pixel_size;
      img->sizey=10.*image_header.y_pixel_size;
      img->sizez=10.*image_header.z_pixel_size;
      img->resolutionx=10.*image_header.x_resolution;
      img->resolutiony=10.*image_header.y_resolution;
      img->resolutionz=10.*image_header.z_resolution;
      img->xform[0]=NIFTI_XFORM_UNKNOWN;
      img->xform[1]=NIFTI_XFORM_SCANNER_ANAT;
      img->quatern[6]=img->sizex; img->quatern[9]=img->sizex;
      img->quatern[11]=img->sizey; img->quatern[13]=img->sizey;
      img->quatern[16]=img->sizez; img->quatern[17]=img->sizez;
      img->mt[0]=image_header.mt_1_1;
      img->mt[1]=image_header.mt_1_2;
      img->mt[2]=image_header.mt_1_3;
      img->mt[3]=image_header.mt_1_4;
      img->mt[4]=image_header.mt_2_1;
      img->mt[5]=image_header.mt_2_2;
      img->mt[6]=image_header.mt_2_3;
      img->mt[7]=image_header.mt_2_4;
      img->mt[8]=image_header.mt_3_1;
      img->mt[9]=image_header.mt_3_2;
      img->mt[10]=image_header.mt_3_3;
      img->mt[11]=image_header.mt_3_4;
      break;
    case ECAT7_2DSCAN:
      img->dimx=scan2d_header.num_r_elements;
      img->dimy=scan2d_header.num_angles;
      if(scan2d_header.num_dimensions>2 && scan2d_header.num_z_elements>1)
        planeNr=img->dimz=scan2d_header.num_z_elements;
      img->_dataType=scan2d_header.data_type;
      if(scan2d_header.x_resolution>0.0)
        img->sampleDistance=10.0*scan2d_header.x_resolution;
      else
        img->sampleDistance=10.0*main_header.bin_size;
      break;
    case ECAT7_3DSCAN:
    case ECAT7_3DSCAN8:
    case ECAT7_3DSCANFIT:
      img->dimx=scan_header.num_r_elements; img->dimy=scan_header.num_angles;
      for(int i=img->dimz=0; i<64; i++) img->dimz+=scan_header.num_z_elements[i];
      /* planeNr=img->dimz; */
      img->_dataType=scan_header.data_type;
      if(scan_header.x_resolution>0.0)
        img->sampleDistance=10.0*scan_header.x_resolution;
      else
        img->sampleDistance=10.0*main_header.bin_size;
      break;
    case ECAT7_POLARMAP:
      img->dimy=img->dimz=1;
      img->polarmap_num_rings=polmap_header.num_rings;
      if(img->polarmap_num_rings>MAX_POLARMAP_NUM_RINGS)
        return STATUS_INVALIDPOLARMAP;
      for(int i=0; i<img->polarmap_num_rings; i++) {
        img->polarmap_sectors_per_ring[i]=polmap_header.sectors_per_ring[i];
        img->polarmap_ring_position[i]=polmap_header.ring_position[i];
        img->polarmap_ring_angle[i]=polmap_header.ring_angle[i];
      }
      img->polarmap_start_angle=polmap_header.start_angle;
      img->dimx=0;
      for(int i=0; i<img->polarmap_num_rings; i++)
        img->dimx+=img->polarmap_sectors_per_ring[i];
      /* pixel_size actually contains volume, in cubic cm */
      img->sizex=img->sizey=img->sizez=0.001*polmap_header.pixel_size;
      break;
  }
 
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgFormatDetermine(), imgReadEcat7FirstFrame(), imgReadHeader(), and imgWriteEcat7Frame().

◆ imgReadFrame()

int imgReadFrame	(	const char *	fname,
		int	frame_to_read,
		IMG *	img,
		int	frame_index )

extern

Read one time frame from a supported PET image or sinogram file into IMG data structure.

This functions can be called repeatedly to read all the frames one at a time to conserve memory.

See also: imgRead, imgReadHeader, imgWriteFrame

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error. Specifically, return value STATUS_NOMATRIX signals that frame does not exist, i.e. all frames have been read. IMG.statmsg can be set using ERROR_STATUS.

Parameters

fname	Name of file from which IMG contents will be read. Currently supported file formats are ECAT 6.3 images and sinograms, ECAT 7.x 2D and 3D images and sinograms, and NIfTI-1, Analyze 7.5, and microPET 3D and 4D images.
frame_to_read	Frame which will be read [1..frameNr].
img	Pointer to initiated or occupied IMG data. If occupied, then new frame is tested to match the previous file type, dimensions, and other fundamental information contained in the IMG. If not occupied, then memory is allocated here.
frame_index	IMG frame index (0..dimt-1) where data will be placed. If index is >0, then the memory for that frame must be allocated before calling this function.

Definition at line 269 of file imgfile.c.

  {
  IMG test_img;
  int ret=0;
 
  if(IMG_TEST) {
    printf("\nimgReadFrame(%s, %d, *img, %d)\n", fname, frame_to_read, frame_index);
    fflush(stdout);
  }
  /*
   *  Check the input 
   */
  if(fname==NULL) return STATUS_FAULT;
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED && img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
  if(frame_to_read<1) return STATUS_FAULT;
  if(frame_index<0) return STATUS_FAULT;
  /* if frame_index>0, then there must be sufficient memory allocated for it */
  if(frame_index>0) {
    if(img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
    if(frame_index>img->dimt-1) return STATUS_FAULT;
  }
 
  /*
   *  If IMG is preallocated, check that fundamental header information
   *  is compatible with old and new contents.
   *  If not allocated, then read the header contents, and allocate it
   */
  imgInit(&test_img);
  if(img->status==IMG_STATUS_OCCUPIED) {
    ret=imgReadHeader(fname, &test_img, img->_fileFormat); 
    imgSetStatus(&test_img, ret);
    if(IMG_TEST>1) printf("imgReadHeader() return message := %s\n", test_img.statmsg);
    if(ret) return(ret);
    if(IMG_TEST>3) imgInfo(&test_img);
    /* Test that file format and type are the same */
    ret=0;
    if(img->type!=test_img.type) ret++;
    if(img->_fileFormat!=test_img._fileFormat) ret++;
    /* Test that x, y, and z dimensions are the same */
    if(img->dimx!=test_img.dimx) ret++;
    if(img->dimy!=test_img.dimy) ret++;
    if(img->dimz!=test_img.dimz) ret++; 
    imgEmpty(&test_img); if(ret>0) return STATUS_INVALIDHEADER;
  } else {
    ret=imgReadHeader(fname, img, IMG_UNKNOWN);
    imgSetStatus(img, ret);
    if(IMG_TEST>1) printf("imgReadHeader() return message := %s\n", img->statmsg);
    if(ret) return(ret);
    if(IMG_TEST>3) imgInfo(img);
    /* Allocate memory for one frame */
    img->dimt=1;
    ret=imgAllocate(img, img->dimz, img->dimy, img->dimx, img->dimt);
    if(ret) return STATUS_NOMEMORY;
  }
 
  /*
   *  Read the frame data and corresponding information like frame time
   *  if available   
   */
  switch(img->_fileFormat) {
    case IMG_E7:
    case IMG_E7_2D:
    case IMG_POLARMAP:
      ret=imgReadEcat7Frame(fname, frame_to_read, img, frame_index);
      if(IMG_TEST>1) printf("imgReadEcat7Frame() return value := %d\n", ret);
      break;
    case IMG_E63:
      ret=imgReadEcat63Frame(fname, frame_to_read, img, frame_index);
      if(IMG_TEST>1) printf("imgReadEcat63Frame() return value := %d\n", ret);
      break;
    case IMG_ANA:
    case IMG_ANA_L:
      ret=imgReadAnalyzeFrame(fname, frame_to_read, img, frame_index);
      if(IMG_TEST>1) printf("imgReadAnalyzeFrame() return value := %d\n", ret);
      break;
    case IMG_NIFTI_1S:
    case IMG_NIFTI_1D:
      ret=imgReadNiftiFrame(fname, frame_to_read, img, frame_index, IMG_TEST-2);
      if(IMG_TEST>1) printf("imgReadNiftiFrame() return value := %d\n", ret);
      break;
    case IMG_MICROPET:
      ret=imgReadMicropetFrame(fname, frame_to_read, img, frame_index);
      if(IMG_TEST>1) printf("imgReadAnalyzeFrame() return value := %d\n", ret);
      break;
    default:
      ret=STATUS_UNSUPPORTED;
  }
  imgSetStatus(img, ret);
  return ret;
}

Referenced by imgReadMinMax().

◆ imgReadHeader()

int imgReadHeader	(	const char *	fname,
		IMG *	img,
		int	format )

extern

Fill IMG struct header information from an image or sinogram file in ECAT 6.3, ECAT 7.x or Analyze 7.5 format.

Information concerning separate frames or planes is not filled.

See also: imgInit, imgEmpty, imgReadFrame

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fname	Image or sinogram file name
img	Pointer to initialized but not allocated IMG structure.
format	Image file format, if known (IMG_E63, IMG_E7, ...); if not known, set to IMG_UNKNOWN or 0.

Definition at line 199 of file imgfile.c.

  {
  int ret;
 
  if(IMG_TEST) {
    printf("\nimgReadHeader(%s, *img, %d)\n", fname, format);
    fflush(stdout);
  }
 
  /* Check the arguments */
  if(fname==NULL) return STATUS_FAULT;
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
 
  /* If user did not know the file format, then try to decide it */
  if(format==IMG_UNKNOWN) {
    int scanner, imgtype, modality;
    ret=imgFormatDetermine(fname, NULL, NULL, NULL, NULL, 
           &format, &scanner, &imgtype, &modality, IMG_TEST-3);
    if(ret!=0) {
      imgSetStatus(img, ret);
      return(ret);
    }
    if(format==IMG_UNKNOWN) {
      imgSetStatus(img, STATUS_UNSUPPORTED);
      return(STATUS_UNSUPPORTED);
    }
  }
 
  /* Read the header for the file format */
  ret=STATUS_UNSUPPORTED;
  if(format==IMG_ANA || format==IMG_ANA_L) {
    /* Read Analyze header information */
    ret=imgReadAnalyzeHeader(fname, img);
  } else if(format==IMG_NIFTI_1S || format==IMG_NIFTI_1D) {
    /* Read NIfTI image header information */
    ret=imgReadNiftiHeader(fname, img, IMG_TEST-2);
  } else if(format==IMG_MICROPET) {
    /* Read microPET header information */
    ret=imgReadMicropetHeader(fname, img);
  } else if(format==IMG_E7 || format==IMG_E7_2D) {
    ret=imgReadEcat7Header(fname, img);
  } else if(format==IMG_E63 || format==IMG_POLARMAP) {
    ret=imgReadEcat63Header(fname, img);
  }  
  imgSetStatus(img, ret);
  return(ret);
}

Referenced by imgReadFrame().

◆ imgReadMicropet()

int imgReadMicropet	(	const char *	fname,
		IMG *	img )

extern

Read the whole dynamic microPET image into IMG data structure.

Note that microPET images are often too large for 32-bit systems.

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fname	Name of microPET image (hdr or img file, or without extension) from which IMG contents will be read.
img	Pointer to the initiated but not preallocated IMG data.

Definition at line 971 of file img_upet.c.

  {
  int fi=0, ret=0;
 
  if(IMG_TEST) printf("\n%s(%s, *img)\n", __func__, fname);
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(fname==NULL) return STATUS_FAULT;
 
  /* Read the first frame into IMG struct */
  fi=0;
  if(IMG_TEST>2) printf("reading frame %d\n", fi+1);
  ret=imgReadMicropetFirstFrame(fname, img);
  if(ret!=STATUS_OK) {
    if(IMG_TEST>0) printf("imgReadMicropetFirstFrame() := %s\n", img->statmsg);
    imgEmpty(img); return ret;
  }
  /* Read rest of the frames */
  do {
    fi++;
    if(IMG_TEST>2) printf("reading frame %d\n", fi+1);
    ret=imgReadMicropetFrame(fname, fi+1, img, fi);
  } while(ret==0);
  if(ret!=STATUS_OK && ret!=STATUS_NOMATRIX) {
    if(IMG_TEST>0) printf("imgReadMicropetFrame() := %s\n", img->statmsg);
    imgEmpty(img); return ret;
  }
  if(IMG_TEST>1) printf("%d frame(s) were read.\n", fi);
 
  /* All went well */
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgRead().

◆ imgReadMicropetFirstFrame()

int imgReadMicropetFirstFrame	(	const char *	fname,
		IMG *	img )

extern

Read the first frame from a microPET image into IMG data structure.

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fname	Name of microPET image (hdr or img file, or without extension) from which IMG contents will be read.
img	Pointer to the initiated but not preallocated IMG data.

Definition at line 925 of file img_upet.c.

  {
  int ret=0;
 
  if(IMG_TEST) printf("\n%s(%s, *img)\n", __func__, fname);
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(fname==NULL) return STATUS_FAULT;
 
  /* Read header information from file */
  ret=imgReadMicropetHeader(fname, img);
  if(IMG_TEST>1) printf("imgReadMicropetHeader() := %s\n", img->statmsg);
  if(ret) return(ret);
  if(IMG_TEST>3) imgInfo(img);
 
  /* Allocate memory for one frame */
  img->dimt=1;
  ret=imgAllocate(img, img->dimz, img->dimy, img->dimx, img->dimt);
  if(ret) return STATUS_NOMEMORY;
 
  /* Read the first frame */
  ret=imgReadMicropetFrame(fname, 1, img, 0);
  if(IMG_TEST>1) printf("imgReadMicropetFrame() := %s\n", img->statmsg);
  if(ret) return(ret); 
 
  /* All went well */
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgReadMicropet().

◆ imgReadMicropetFrame()

int imgReadMicropetFrame	(	const char *	fname,
		int	frame_to_read,
		IMG *	img,
		int	frame_index )

extern

Read a specified frame from microPET image into preallocated IMG data structure.

MicroPET image consists of two files in the same directory: fname.hdr and fname.img. IMG header is assumed to be filled correctly before calling this function, except for information concerning separate planes and this frame, which is filled here. If frame does not exist, then and only then STATUS_NOMATRIX is returned.

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fname	Name of microPET image (hdr or img file, or without extension) from which IMG contents will be read.
frame_to_read	Frame which will be read [1..frameNr].
img	Pointer to the IMG data. Place for the frame must be preallocated.
frame_index	IMG frame index [0..dimt-1] where data will be placed.

Definition at line 819 of file img_upet.c.

  {
  FILE *fp;
  int i, fi, ret, zi, xi, yi;
  float *fdata=NULL, *fptr, f;
  char datfile[FILENAME_MAX], hdrfile[FILENAME_MAX];
  char key[MAX_MICROPET_LINE_LEN], value[MAX_MICROPET_LINE_LEN];
 
 
  if(IMG_TEST) printf("\n%s(%s, %d, *img, %d)\n", __func__, fname, frame_to_read, frame_index);
    
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
  if(fname==NULL) return STATUS_FAULT;
  if(frame_index<0 || frame_index>img->dimt-1) return STATUS_FAULT;
  if(frame_to_read<1) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  
  /* Determine the names of hdr and data files */
  ret=upetExists(fname, hdrfile, datfile, IMG_TEST-1);
  if(ret<2) {imgSetStatus(img, STATUS_NOFILE); return STATUS_NOFILE;}
 
  /* Read microPET header file into IFT, if not available already */
  imgSetStatus(img, STATUS_INVALIDHEADER);
  if(img->ift.keyNr<10) {
    iftEmpty(&img->ift);
    ret=defRead(&img->ift, hdrfile, 0);
    if(ret!=0) {
      if(IMG_TEST>1) printf("defRead() return value := %d\n", ret);
      return(STATUS_INVALIDHEADER);
    }
    if(IMG_TEST>3) printf("ift.keyNr := %d\n", img->ift.keyNr);
  }
 
  /* Read frame header information */
  strcpy(key, "frame"); sprintf(value, "%d", frame_to_read-1);
  fi=iftGetFullmatchFrom(&img->ift, 0, key, value, 0);
  if(fi<0) {imgSetStatus(img, STATUS_NOMATRIX); return STATUS_NOMATRIX;}
  i=iftGetFloatValue(&img->ift, fi+1, "frame_start", &f, 0);
  if(i<0 || isnan(f)) {return STATUS_INVALIDHEADER;}
  img->start[frame_index]=f;
  i=iftGetFloatValue(&img->ift, fi+1, "frame_duration", &f, 0);
  if(i<0 || isnan(f) || f<0.0) {return STATUS_INVALIDHEADER;}
  img->end[frame_index]=img->start[frame_index]+f;
  img->mid[frame_index]=0.5*(img->end[frame_index]+img->start[frame_index]);
  /* decay correction */
  i=iftGetFloatValue(&img->ift, fi+1, "decay_correction", &f, 0);
  if(i<0 || isnan(f) || f<0.0) {return STATUS_INVALIDHEADER;}
  img->decayCorrFactor[frame_index]=f;
  //printf("   decayCorrFactor=%g\n", img->decayCorrFactor[0]);
  /* set plane numbers */
  for(zi=0; zi<img->dimz; zi++) img->planeNumber[zi]=zi+1;
  /* prompts and randoms (delays), without checking the result */
  i=iftGetFloatValue(&img->ift, fi+1, "prompts_rate", &img->prompts[frame_index], 0);
  i=iftGetFloatValue(&img->ift, fi+1, "delays_rate", &img->randoms[frame_index], 0);
 
  /* Open image datafile */
  if(IMG_TEST>2) fprintf(stdout, "reading image data %s\n", datfile);
  if((fp=fopen(datfile, "rb"))==NULL) {
    imgSetStatus(img, STATUS_NOIMGDATA); return STATUS_NOIMGDATA;}
 
  /* Allocate memory for one image frame */
  fdata=malloc((size_t)img->dimx*img->dimy*img->dimz*sizeof(float));
  if(fdata==NULL) {
    fclose(fp); imgSetStatus(img, STATUS_NOMEMORY);
    return STATUS_NOMEMORY;
  }
 
  /* Read the required image frame */
  fptr=fdata;
  ret=upetReadImagedata(fp, &img->ift, frame_to_read, fptr);
  if(ret!=0 && IMG_TEST) fprintf(stdout, "upetReadImagedata() := %d\n", ret);
  fclose(fp);
  if(ret==3) { /* no more frames */
    free(fdata); imgSetStatus(img, STATUS_NOMATRIX); return STATUS_NOMATRIX;}
  if(ret!=0) {
    free(fdata); imgSetStatus(img, STATUS_UNSUPPORTED); return STATUS_UNSUPPORTED;}
 
  /* Copy pixel values to IMG */
  fptr=fdata;
  for(zi=0; zi<img->dimz; zi++)
    for(yi=0; yi<img->dimy; yi++)
      for(xi=0; xi<img->dimx; xi++)
        img->m[zi][yi][xi][frame_index]=*fptr++;
  free(fdata);
 
  imgSetStatus(img, STATUS_OK); /* If the rest is failed, no problem */
  return STATUS_OK;
}

Referenced by imgReadFrame(), imgReadMicropet(), and imgReadMicropetFirstFrame().

◆ imgReadMicropetHeader()

int imgReadMicropetHeader	(	const char *	dbname,
		IMG *	img )

extern

Fill IMG struct header information from microPET database files.

Information concerning separate frames or planes is not filled though.

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

dbname	Name of microPET database, may contain filename extension
img	Pointer to the initiated IMG data

Definition at line 767 of file img_upet.c.

  {
  char hdrfile[FILENAME_MAX];
  int ret;
 
  if(IMG_TEST) printf("\n%s(%s, *img)\n", __func__, dbname);
  
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED) return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(dbname==NULL) return STATUS_FAULT;
 
  /* Determine the names of hdr and sif files */
  ret=upetExists(dbname, hdrfile, NULL, IMG_TEST-1);
  if(ret==0) return STATUS_NOFILE;
  
  /* Read microPET header file into IFT */
  iftEmpty(&img->ift);
  ret=defRead(&img->ift, hdrfile, 0);
  if(ret!=0) {
    if(IMG_TEST>1) printf("defRead() return value := %d\n", ret);
    return(STATUS_FAULT);
  }
  /* and set IMG contents */
  ret=imgGetMicropetHeader(img);
  if(ret!=0) {
    imgSetStatus(img, ret);
    return(ret);
  }
 
  return STATUS_OK;
}

Referenced by imgFormatDetermine(), imgReadHeader(), and imgReadMicropetFirstFrame().

◆ imgReadMinMax()

int imgReadMinMax	(	const char *	fname,
		float *	fmin,
		float *	fmax )

extern

Read the calibrated maximum and minimum pixel values in the specified file in ECAT 7, ECAT 6.3, or Analyze 7.5 format.

File is read frame-by-frame with normal IMG functions.

See also: imgFrameMinMax, imgRangeMinMax, imgMinMax

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fname	ECAT 7 or ECAT 6.3 filename, or Analyze 7.5 database.
fmin	Pointer to minimum pixel value that will be set by this function.
fmax	Pointer to maximum pixel value that will be set by this function.

Definition at line 211 of file imgminmax.c.

  {
  int fi=0, ret;
  IMG img;
  float frmin, frmax;
 
  if(IMG_TEST) printf("imgReadMinMax(%s, *fmin, *fmax)\n", fname);
  imgInit(&img);
  while((ret=imgReadFrame(fname, fi+1, &img, 0)) == 0) {
    if(imgMinMax(&img, &frmin, &frmax)!=0) {imgEmpty(&img); return STATUS_FAULT;}
    if(fi==0) {
      if(fmin!=NULL) *fmin=frmin;
      if(fmin!=NULL) *fmax=frmax;
    } else {
      if(fmin!=NULL && !(*fmin<=frmin)) *fmin=frmin;
      if(fmax!=NULL && !(*fmax>=frmax)) *fmax=frmax;
    }
    fi++;
  } /* next frame */
  imgEmpty(&img);
  if(ret==STATUS_NOMATRIX && fi>0) return STATUS_OK;
  else return ret;
}

◆ imgReadNifti()

int imgReadNifti	(	const char *	filename,
		IMG *	img,
		int	verbose )

extern

Read Nifti-1 image.

Nifti database name must be given with path. Either one file with extension .nii, or image and header files with extensions .img and .hdr must exist. Also SIF file with .sif extension is used, if it exists.

Returns: 0 if ok, and otherwise IMG status code (<>0); sets IMG->statmsg in case of an error.

See also: imgInit, imgReadNiftiFirstFrame, imgReadNiftiHeader, imgWriteNifti

Parameters

filename	Nifti database name with path, with or without extension
img	Pointer to initialized IMG structure
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 23 of file img_nii.c.

  {
  if(verbose>0) {printf("imgReadNifti(%s, ...)\n", filename); fflush(stdout);}
 
  /* Check the arguments */
  if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) {
    if(img!=NULL) imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid IMG argument\n");
    return(STATUS_FAULT);
  }
  if(filename==NULL || !filename[0]) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid filename\n");
    return(STATUS_FAULT);
  }
  imgSetStatus(img, STATUS_OK);
 
  /* Read header information from file */
  int ret=imgReadNiftiHeader(filename, img, verbose-1); if(ret) {return(ret);}
  if(verbose>10) imgInfo(img);
 
  /* Allocate memory for all frames */
  ret=imgAllocate(img, img->dimz, img->dimy, img->dimx, img->dimt);
  if(ret) {
    imgSetStatus(img, STATUS_OK);
    return STATUS_NOMEMORY;
  }
 
  /* Read one frame at a time */
  for(int fi=0; fi<img->dimt; fi++) {
    ret=imgReadNiftiFrame(filename, 1+fi, img, fi, verbose-1);
    if(ret) return(ret);
  }
 
  /* All went well */
  imgSetStatus(img, STATUS_OK);
  return(STATUS_OK);
}

Referenced by imgRead().

◆ imgReadNiftiFirstFrame()

int imgReadNiftiFirstFrame	(	const char *	filename,
		IMG *	img,
		int	verbose )

extern

Read the first frame of Nifti-1 image into IMG data structure.

Nifti database name must be given with path. Either one file with extension .nii, or image and header files with extensions .img and .hdr must exist. Also SIF file with .sif extension is used, if it exists.

Returns: 0 if ok, and otherwise IMG status code (<>0); sets IMG->statmsg in case of an error.

Parameters

filename	Nifti database name with path, with or without extension
img	Pointer to initialized IMG structure
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 78 of file img_nii.c.

  {
  if(verbose>0) {printf("imgReadNiftiFirstFrame(%s, ...)\n", filename); fflush(stdout);}
 
  /* Check the arguments */
  if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) {
    if(img!=NULL) imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid IMG argument\n");
    return(STATUS_FAULT);
  }
  if(filename==NULL || !filename[0]) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid filename\n");
    return(STATUS_FAULT);
  }
  imgSetStatus(img, STATUS_OK);
 
  /* Read header information from file */
  int ret=imgReadNiftiHeader(filename, img, verbose-1); if(ret) {return(ret);}
  if(verbose>10) imgInfo(img);
 
  /* Allocate memory for one frame */
  img->dimt=1;
  ret=imgAllocate(img, img->dimz, img->dimy, img->dimx, img->dimt);
  if(ret) {
    imgSetStatus(img, STATUS_OK);
    return STATUS_NOMEMORY;
  }
 
  /* Read the first frame */
  ret=imgReadNiftiFrame(filename, 1, img, 0, verbose-1); if(ret) return(ret); 
 
  /* All went well */
  imgSetStatus(img, STATUS_OK);
  return(STATUS_OK);
}

Referenced by imgNiftiToEcat().

◆ imgReadNiftiFrame()

int imgReadNiftiFrame	(	const char *	filename,
		int	frame_to_read,
		IMG *	img,
		int	frame_index,
		int	verbose )

extern

Read a specified frame from a Nifti database files into preallocated IMG data structure.

IMG header is assumed to be filled correctly before calling this function, except for information concerning separate planes and this frame, which is filled here.

Returns: 0 if ok, and otherwise IMG status code (<>0); sets IMG->statmsg in case of an error. If frame does not exist, then and only then STATUS_NOMATRIX is returned.

See also: imgReadNifti, imgNaNs

Parameters

filename	Pointer to string that contains the name of NIfTI database with path, with or without filename extension. Either one file with extension .nii, or image and header files with extensions .img and .hdr must exist. Also SIF file with .sif extension is used, if it exists; however, information concerning separate frames or planes is not filled.
frame_to_read	Frame which will be read from database [1..frameNr]
img	Pointer to the IMG data. Place for the frame must be preallocated
frame_index	IMG frame index [0..dimt-1] where data will be placed
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 311 of file img_nii.c.

  {
  char basefile[FILENAME_MAX], tmp[256];
  char datfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  NIFTI_DSR dsr;
  int ret;
  SIF sif;
  FILE *fp;
  float *fdata=NULL, *fptr;
 
 
  if(verbose>0) {
    printf("\nimgReadNiftiFrame(%s, %d, *img, %d, %d)\n",
           filename, frame_to_read, frame_index, verbose);
    fflush(stdout);
  }
 
  /* Check the input */
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    if(img!=NULL) imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid IMG argument\n");
    return(STATUS_FAULT);
  }
  if(filename==NULL || !filename[0]) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid filename\n");
    return(STATUS_FAULT);
  }
  if(frame_index<0 || frame_index>img->dimt-1 || frame_to_read<1) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid frame settings\n");
    return STATUS_FAULT;
  }
 
  /* Extract the base file name without extensions */
  strcpy(basefile, filename); niftiRemoveFNameExtension(basefile);
  if(strlen(basefile)<1) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid filename\n");
    return(STATUS_FAULT);
  }
 
  /* Make the image and header filenames, and read Nifti header */
  ret=niftiExists(basefile, hdrfile, datfile, siffile, &dsr, verbose-2, tmp);
  if(ret==0) {
    imgSetStatus(img, STATUS_NOFILE);
    if(verbose>0) fprintf(stderr, "Error: %s\n", tmp);
    return(STATUS_NOFILE);
  }
  if(ret==1 && verbose>1) {
    printf("no SIF found for %s\n", basefile); fflush(stdout);}
 
  /* Open image datafile */
  if(verbose>2) {fprintf(stdout, "reading image data %s\n", datfile); fflush(stdout);}
  if((fp=fopen(datfile, "rb")) == NULL) {
    imgSetStatus(img, STATUS_NOIMGDATAFILE);
    return STATUS_NOIMGDATAFILE;
  }
 
  /* Allocate memory for one image frame */
  imgSetStatus(img, STATUS_NOMEMORY);
  fdata=calloc((size_t)img->dimx*img->dimy*img->dimz, sizeof(float));
  if(fdata==NULL) {fclose(fp); return STATUS_NOMEMORY;}
 
  /* Read the required image frame */
  fptr=fdata;
  ret=niftiReadImagedata(fp, &dsr, frame_to_read, fptr, verbose-1, tmp);
  if(verbose>1) printf("niftiReadImagedata() -> %s\n", tmp);
  fclose(fp);
  if(ret==-1) { /* no more frames */
    free(fdata); imgSetStatus(img, STATUS_NOMATRIX);
    return STATUS_NOMATRIX;
  }
  if(ret!=0) {
    free(fdata); imgSetStatus(img, STATUS_UNSUPPORTED);
    return STATUS_UNSUPPORTED;
  }
 
  if(0) { // Call imgNaNs(IMG, 1) instead
    /* Check for invalid pixel values and set to zero.
       SPM can write lots of NaNs on image borders.
       Remove this later, if/when all image processing functions support NaN and Inf. */
    long long int goodNr=0;
    fptr=fdata;
    for(int zi=0; zi<img->dimz; zi++)
      for(int yi=0; yi<img->dimy; yi++)
        for(int xi=0; xi<img->dimx; xi++) {
          if(isfinite(*fptr)) goodNr++; else *fptr=0.0;
          fptr++;
        }
    if(goodNr==0) {
      free(fdata);
      imgSetStatus(img, STATUS_NOIMGDATA);
      return STATUS_NOIMGDATA;
    }
  }
 
  /* Copy pixel values to IMG */
  fptr=fdata;
  for(int zi=0; zi<img->dimz; zi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++)
        img->m[zi][yi][xi][frame_index]=*fptr++;
  free(fdata);
 
  /* Set decay correction factor to zero */
  img->decayCorrFactor[frame_index]=0.0;
 
  /* Set plane numbers */
  for(int fi=0; fi<img->dimz; fi++) img->planeNumber[fi]=fi+1;
 
  /* 
   *  Try to read frame time information from SIF file
   */
  imgSetStatus(img, STATUS_OK); /* If the rest is failed, no problem */
  sifInit(&sif);
  if(sifRead(siffile, &sif)!=0) {
    if(verbose>1) {fprintf(stdout, "  cannot read SIF (%s)\n", siffile); fflush(stdout);}
    return STATUS_OK;
  }
  /* Frame information */
  if(verbose>3) {fprintf(stdout, "  setting frame times\n"); fflush(stdout);}
  if(sif.frameNr>=frame_to_read) {
    img->start[frame_index]=sif.x1[frame_to_read-1];
    img->end[frame_index]=sif.x2[frame_to_read-1];
    img->mid[frame_index]=0.5*(img->start[frame_index]+img->end[frame_index]);
    img->prompts[frame_index]=sif.prompts[frame_to_read-1];
    img->randoms[frame_index]=sif.randoms[frame_to_read-1];
  }
  sifEmpty(&sif);
 
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgNiftiToEcat(), imgReadFrame(), imgReadNifti(), and imgReadNiftiFirstFrame().

◆ imgReadNiftiHeader()

int imgReadNiftiHeader	(	const char *	filename,
		IMG *	img,
		int	verbose )

extern

Fill IMG struct header information from Nifti database files.

Nifti database name must be given with path. Either one file with extension .nii, or image and header files with extensions .img and .hdr must exist. Also SIF file with .sif extension is used, if it exists; however, information concerning separate frames or planes is not filled.

Returns: 0 if ok, and otherwise IMG status code (<>0); sets IMG->statmsg in case of an error.

See also: imgGetNiftiHeader

Parameters

filename	Nifti database name with path, with or without extension
img	Pointer to initialized IMG structure
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 134 of file img_nii.c.

  {
  char basefile[FILENAME_MAX], tmp[256];
  char datfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  NIFTI_DSR dsr;
  int ret;
  SIF sif;
  double f;
 
  if(verbose>0) {printf("imgReadNiftiHeader(%s, ...)\n", filename); fflush(stdout);}
 
  /* Check the arguments */
  if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) {
    if(img!=NULL) imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid IMG argument\n");
    return(STATUS_FAULT);
  }
  if(filename==NULL || !filename[0]) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid filename\n");
    return(STATUS_FAULT);
  }
  imgSetStatus(img, STATUS_OK);
 
  /* Extract the base file name without extensions */
  strcpy(basefile, filename); niftiRemoveFNameExtension(basefile);
  if(strlen(basefile)<1) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid filename\n");
    return(STATUS_FAULT);
  }
 
  /* Make the image and header filenames, and read Nifti header */
  ret=niftiExists(basefile, hdrfile, datfile, siffile, &dsr, verbose-2, tmp);
  if(ret==0) {
    imgSetStatus(img, STATUS_NOFILE);
    if(verbose>0) fprintf(stderr, "Error: %s\n", tmp);
    return(STATUS_NOFILE);
  }
  if(ret==1 && verbose>1) printf("no SIF found for %s\n", basefile); 
 
  /* and set IMG contents */
  ret=imgGetNiftiHeader(img, &dsr, verbose-2);
  if(ret!=0) {
    imgSetStatus(img, ret);
    return(ret);
  }
 
  /* If SIF does not exist, then that's it */
  if(!siffile[0]) {
    imgSetStatus(img, STATUS_OK);
    return STATUS_OK;
  }
 
  /* SIF is available, so read that too */
  if(verbose>1) {printf("reading SIF %s\n", siffile); fflush(stdout);}
  sifInit(&sif); ret=0;
  if(sifRead(siffile, &sif)!=0) return STATUS_OK;
  /* Copy scan time */
  img->scanStart=sif.scantime;
  /* Study number, if not yet defined */
  if(!img->studyNr[0] && strlen(sif.studynr)>1 )
    strlcpy(img->studyNr, sif.studynr, MAX_STUDYNR_LEN+1);
  /* Isotope half-life, if not yet defined */
  f=hlFromIsotope(sif.isotope_name);
  if(img->isotopeHalflife<=0.0 && f>0.0) img->isotopeHalflife=60.0*f;
  sifEmpty(&sif);
 
  return(STATUS_OK);
}

Referenced by imgReadHeader(), imgReadNifti(), and imgReadNiftiFirstFrame().

◆ imgSetAnalyzeHeader()

int imgSetAnalyzeHeader	(	IMG *	img,
		const char *	dbname,
		ANALYZE_DSR *	dsr,
		float	fmin,
		float	fmax )

extern

Copy header information in IMG struct into Analyze 7.5 header struct.

Min, max, and scale factor are set here and they apply to all frames.

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

img	pointer to IMG struct from which header information is read
dbname	Analyze 7.5 database name
dsr	pointer to Analyze header struct to be filled
fmin	minimum pixel value in all frames that will be written
fmax	maximum pixel value in all frames that will be written

Definition at line 486 of file img_ana.c.

  {
  struct tm tm; //*st;
  char *cptr;
  float g;
 
  if(IMG_TEST) printf("\nimgSetAnalyzeHeader(*img, %s, *dsr, %g, %g)\n",
                      dbname, fmin, fmax);
  
  /* Check the input */
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_INITIALIZED && img->status!=IMG_STATUS_OCCUPIED)
    return STATUS_FAULT;
  imgSetStatus(img, STATUS_FAULT);
  if(dsr==NULL) return STATUS_FAULT;
 
  /* Byte order */
  if(img->_fileFormat==IMG_ANA_L) dsr->little=1; else dsr->little=0;
  /* Header key */
  memset(&dsr->hk, 0, sizeof(ANALYZE_HEADER_KEY));
  memset(&dsr->dime, 0, sizeof(ANALYZE_HEADER_IMGDIM));
  memset(&dsr->hist, 0, sizeof(ANALYZE_HEADER_HISTORY));
  dsr->hk.sizeof_hdr=348;
  strcpy(dsr->hk.data_type, "");
  cptr=strrchr(dbname, '/'); if(cptr==NULL) cptr=strrchr(dbname, '\\');
  if(cptr!=NULL) cptr++;
  if(cptr==NULL) cptr=(char*)dbname;
  strncpy(dsr->hk.db_name, cptr, 17);
  dsr->hk.extents=16384;
  dsr->hk.regular='r';
  /* Image dimension */
  dsr->dime.dim[0]=4;
  dsr->dime.dim[1]=img->dimx;
  dsr->dime.dim[2]=img->dimy;
  dsr->dime.dim[3]=img->dimz;
  dsr->dime.dim[4]=img->dimt;
  dsr->dime.datatype=ANALYZE_DT_SIGNED_SHORT;
  dsr->dime.bitpix=16;
  dsr->dime.pixdim[0]=0.0;
  dsr->dime.pixdim[1]=img->sizex;
  dsr->dime.pixdim[2]=img->sizey;
  dsr->dime.pixdim[3]=img->sizez;
  dsr->dime.pixdim[4]=0.0;
  dsr->dime.funused1=0.0; /* Scale factor is set later */
  /* dsr.dime.funused2=img->zoom; */ /* Reconstruction zoom */
  dsr->dime.funused3=img->isotopeHalflife;
  /* Data history */
  if(img->decayCorrection==IMG_DC_CORRECTED)
    strcpy(dsr->hist.descrip, "Decay corrected.");
  else if(img->decayCorrection==IMG_DC_NONCORRECTED)
    strcpy(dsr->hist.descrip, "No decay correction.");
  else
    strcpy(dsr->hist.descrip, "");
  if(strlen(img->studyNr)>0 && strcmp(img->studyNr, ".")!=0)
    memcpy(dsr->hist.scannum, img->studyNr, 10);
  else
    strcpy(img->studyNr, "");
  gmtime_r((time_t*)&img->scanStart, &tm);
  if(!strftime(dsr->hist.exp_date, 10, "%Y%m%d", &tm))
    strcpy(dsr->hist.exp_date, "19000101");
  if(!strftime(dsr->hist.exp_time, 10, "%H:%M:%S", &tm))
    strncpy(dsr->hist.exp_time, "00:00:00", 10);
 
  /* Determine and set scale factor and cal_min & cal_max */
  if(fmin<fmax) {
    dsr->dime.cal_min=fmin; dsr->dime.cal_max=fmax;
  } else { /* not given in function call, try to find those here */
    if(img->status==IMG_STATUS_OCCUPIED &&
       imgMinMax(img, &dsr->dime.cal_min, &dsr->dime.cal_max)==0) {}
    else return STATUS_FAULT;
  }
  if(fabs(dsr->dime.cal_min) > fabs(dsr->dime.cal_max)) g=fabs(dsr->dime.cal_min);
  else g = fabs(dsr->dime.cal_max);
  /* if(fabs(dsr->dime.cal_min)>fabs(dsr->dime.cal_max))
     g=fabs(dsr->dime.cal_min); */
  /* else g=fabs(dsr->dime.cal_max); */
  if(g<1E-20) g=1.0; else g=32767./g; dsr->dime.funused1=1.0/g;
  /* Set header glmin & glmax */
  dsr->dime.glmin=temp_roundf(fmin*g); dsr->dime.glmax=temp_roundf(fmax*g);
  /* printf("glmin=%d\n", dsr->dime.glmin); */
  /* printf("glmax=%d\n", dsr->dime.glmax); */
 
  imgSetStatus(img, STATUS_OK);
  return STATUS_OK;
}

Referenced by imgWriteAnalyzeFrame().

◆ imgSetDecayCorrFactors()

int imgSetDecayCorrFactors	(	IMG *	image,
		int	mode )

extern

Sets (mode=1) or removes (mode=0) decay correction factors in IMG. IMG pixel data is not changed.

Returns: 0 if ok, 1 image status is not 'occupied', 2 invalid exponent value, 3 image frame times are missing.

See also: imgDecayCorrection, imgBranchingCorrection, imgIsotope

Parameters

image	Pointer to IMG data.
mode	Factors are calculated for decay correction (1) or for removing decay correction (0).

Definition at line 87 of file imgdecayc.c.

  {
  float lambda, cf, dur;
 
  /* Check for arguments */
  if(image->status!=IMG_STATUS_OCCUPIED) return(1);
  if(image->isotopeHalflife<=0.0) return(1);
 
  /* Check that image contains frame times */
  if(mode!=0 && image->end[image->dimt-1]<=0.0) return(3);
 
  /* All time frames */
  for(int fi=0; fi<image->dimt; fi++) {
    if(mode==0) {
      image->decayCorrFactor[fi]=1.0;
    } else {
      dur=image->end[fi]-image->start[fi];
      if(image->end[fi]>0.0) {
        lambda=hl2lambda(image->isotopeHalflife); if(lambda<0.0) return(2);
        cf=hlLambda2factor_float(lambda, image->start[fi], dur);
        image->decayCorrFactor[fi]=cf;
      }
    }
  } /* next frame */
  if(mode==0) image->decayCorrection=IMG_DC_NONCORRECTED;
  else image->decayCorrection=IMG_DC_CORRECTED;
  return(0);
}

◆ imgSetEcat63MHeader()

void imgSetEcat63MHeader	(	IMG *	img,
		ECAT63_mainheader *	h )

extern

Copy information from IMG struct into ECAT 6.3 main header

Parameters

img	source image structure
h	target Ecat 6.3 main header

Definition at line 1223 of file img_e63.c.

{
  struct tm tm;
  memset(&tm, 0, sizeof(struct tm));
 
  if(IMG_TEST>0) printf("imgSetEcat63MHeader()\n");
  if(IMG_TEST>2) {
    char buf[32];
    if(!ctime_r_int(&img->scanStart, buf)) strcpy(buf, "1900-01-01 00:00:00");
    fprintf(stdout, "  scan_start_time := %s\n", buf);
  }
  h->sw_version=2;
  h->num_planes=img->dimz;  
  h->num_frames=img->dimt;  
  h->num_gates=1;
  h->num_bed_pos=1;
  if(img->type==IMG_TYPE_IMAGE) h->file_type=IMAGE_DATA;
  else h->file_type=RAW_DATA;
  h->data_type=VAX_I2;
  if(img->scanner>0) h->system_type=img->scanner;
  else h->system_type=ECAT63_SYSTEM_TYPE_DEFAULT;
  h->calibration_factor=1.0;
  h->axial_fov=img->axialFOV/10.0;
  h->transaxial_fov=img->transaxialFOV/10.0;
  h->plane_separation=img->sizez/10.0;
  h->calibration_units=imgUnitToEcat6(img);
  strncpy(h->radiopharmaceutical, img->radiopharmaceutical, 32);
  if(gmtime_r(&img->scanStart, &tm)!=NULL) {
    h->scan_start_year=tm.tm_year+1900;
    h->scan_start_month=tm.tm_mon+1;
    h->scan_start_day=tm.tm_mday;
    h->scan_start_hour=tm.tm_hour;
    h->scan_start_minute=tm.tm_min;
    h->scan_start_second=tm.tm_sec;
    if(IMG_TEST>2) {
      printf("  img->scanStart := %ld\n", (long int)img->scanStart);
      printf("  -> tm_year := %d\n", tm.tm_year);
      printf("  -> tm_hour := %d\n", tm.tm_hour);
    } 
  } else {
    h->scan_start_year=1900;
    h->scan_start_month=1;
    h->scan_start_day=1;
    h->scan_start_hour=0;
    h->scan_start_minute=0;
    h->scan_start_second=0;
    if(IMG_TEST>0) printf("invalid scan_start_time in IMG\n");
  }
  h->isotope_halflife=img->isotopeHalflife;
  strcpy(h->isotope_code, imgIsotope(img));
  strlcpy(h->study_name, img->studyNr, 12);
  strcpy(h->patient_name, img->patientName);
  strcpy(h->patient_id, img->patientID);
  strlcpy(h->user_process_code, img->userProcessCode, 10);
  strlcpy(h->study_description, img->studyDescription, 32);
}

Referenced by imgWriteEcat63Frame().

◆ imgSetEcat63SHeader()

void imgSetEcat63SHeader	(	IMG *	img,
		void *	h )

extern

Copies Ecat6.3 image or scan sub header information from IMG struct.

Parameters

img	source image structure
h	target sub header structure

Definition at line 1872 of file img_e63.c.

                                            {
  ECAT63_imageheader *image_header;
  ECAT63_scanheader *scan_header;
 
  if(img->type==IMG_TYPE_RAW) {
    scan_header=(ECAT63_scanheader*)h;
    scan_header->data_type=VAX_I2;
    scan_header->dimension_1=img->dimx;
    scan_header->dimension_2=img->dimy;
    scan_header->frame_duration_sec=1;
    scan_header->scale_factor=1.0;
    scan_header->frame_start_time=0;
    scan_header->frame_duration=1000;
    scan_header->loss_correction_fctr=1.0;
    scan_header->sample_distance=img->sampleDistance/10.0;
  } else {
    image_header=(ECAT63_imageheader*)h;
    image_header->data_type=VAX_I2;
    image_header->num_dimensions=2;
    image_header->dimension_1=img->dimx;
    image_header->dimension_2=img->dimy;
    image_header->recon_scale=img->zoom;
    image_header->quant_scale=1.0;
    image_header->slice_width=img->sizez/10.;
    image_header->pixel_size=img->sizex/10.;
    image_header->frame_start_time=0;
    image_header->frame_duration=1000;
    image_header->plane_eff_corr_fctr=1.0; // now we don't know which plane
    image_header->decay_corr_fctr=1.0;
    image_header->loss_corr_fctr=1.0;
    image_header->ecat_calibration_fctr=1.0;
    image_header->well_counter_cal_fctr=1.0;
    image_header->quant_units=imgUnitToEcat6(img);
  }
}

Referenced by imgWriteEcat63Frame().

◆ imgSetEcat7MHeader()

void imgSetEcat7MHeader	(	IMG *	img,
		ECAT7_mainheader *	h )

extern

Copy information from IMG to ECAT 7 main header

Parameters

img	source structure
h	target structure

Definition at line 781 of file img_e7.c.

{
  h->sw_version=72;
  if(img->type==IMG_TYPE_POLARMAP) {
    strcpy(h->magic_number, ECAT7V_MAGICNR);
    h->file_type=ECAT7_POLARMAP;
  } else if(img->type==IMG_TYPE_RAW) {
    strcpy(h->magic_number, ECAT7S_MAGICNR);
    if(img->_fileFormat==IMG_E7_2D) h->file_type=ECAT7_2DSCAN;
    else h->file_type=ECAT7_3DSCAN;
  } else {
    strcpy(h->magic_number, ECAT7V_MAGICNR);
    if(img->_fileFormat==IMG_E7_2D) h->file_type=ECAT7_IMAGE16;
    else h->file_type=ECAT7_VOLUME16;
  }
  h->system_type=img->scanner;
  h->scan_start_time=img->scanStart;
  h->isotope_halflife=img->isotopeHalflife;
  imgUnitToEcat7(img, h);
  h->ecat_calibration_factor=1.0;
  h->transaxial_fov=img->transaxialFOV/10.0;
  h->num_planes=img->dimz; /* h->num_planes=1; */
  h->num_frames=img->dimt;  
  h->num_gates=1;
  h->num_bed_pos=0;
  h->distance_scanned=img->axialFOV/10.0;
  h->plane_separation=img->sizez/10.0;
  strncpy(h->radiopharmaceutical, img->radiopharmaceutical, 32);
  strcpy(h->isotope_name, imgIsotope(img));
  strlcpy(h->study_type, img->studyNr, 12);
  strcpy(h->patient_name, img->patientName);
  strcpy(h->patient_id, img->patientID);
  h->patient_orientation=img->orientation;
  strcpy(h->study_description, img->studyDescription);
  strlcpy(h->user_process_code, img->userProcessCode, 10);
  h->branching_fraction=img->branchingFraction;
}

Referenced by imgWrite2DEcat7(), imgWriteEcat7(), imgWriteEcat7Frame(), and imgWritePolarmap().

◆ imgSetEcat7SHeader()

void imgSetEcat7SHeader	(	IMG *	img,
		void *	h )

extern

Set ECAT7 subheader based on IMG contents

Parameters

img	image structure
h	Ecat7 image, scan, 2D scan or polar map header

Definition at line 1482 of file img_e7.c.

                                           {
  ECAT7_imageheader *image_header;
  ECAT7_scanheader *scan_header;
  ECAT7_2Dscanheader *scan2d_header;
  ECAT7_polmapheader *polmap_header;
 
  if(img->type==IMG_TYPE_POLARMAP) {
    polmap_header=(ECAT7_polmapheader*)h;
    polmap_header->data_type=ECAT7_SUNI2;
    polmap_header->num_rings=img->polarmap_num_rings;
    if(polmap_header->num_rings>32) polmap_header->num_rings=32;
    for(int i=0; i<polmap_header->num_rings; i++) {
      polmap_header->sectors_per_ring[i]=img->polarmap_sectors_per_ring[i];
      polmap_header->ring_position[i]=img->polarmap_ring_position[i];
      polmap_header->ring_angle[i]=img->polarmap_ring_angle[i];
    }
    polmap_header->start_angle=258;
    polmap_header->pixel_size=1000.0*img->sizex;  
    polmap_header->quant_units=0; /* default, see main header */
  } else if(img->type==IMG_TYPE_RAW) {
    if(img->_fileFormat==IMG_E7_2D) {
      scan2d_header=(ECAT7_2Dscanheader*)h;
      scan2d_header->num_dimensions=2;
      scan2d_header->num_z_elements=1;
      scan2d_header->data_type=ECAT7_SUNI2;
      scan2d_header->num_r_elements=img->dimx;
      scan2d_header->num_angles=img->dimy;
    } else {
      scan_header=(ECAT7_scanheader*)h;
      scan_header->x_resolution=img->sampleDistance/10.0;
      scan_header->num_dimensions=4;
      if(img->dimz==239) {
        scan_header->num_z_elements[0]=63;
        scan_header->num_z_elements[1]=106;
        scan_header->num_z_elements[2]=70;
      } else {
        scan_header->num_z_elements[0]=img->dimz;
      }
      scan_header->storage_order=1;
      scan_header->data_type=ECAT7_SUNI2;
      scan_header->num_r_elements=img->dimx;
      scan_header->num_angles=img->dimy;
    }
  } else {
    image_header=(ECAT7_imageheader*)h;
    image_header->data_type=ECAT7_SUNI2;
    image_header->x_dimension=img->dimx;
    image_header->y_dimension=img->dimy;
    image_header->recon_zoom=img->zoom;
    image_header->x_pixel_size=0.1*img->sizex;
    image_header->y_pixel_size=0.1*img->sizey;
    image_header->z_pixel_size=0.1*img->sizez;
    image_header->x_resolution=0.1*img->resolutionx;
    image_header->y_resolution=0.1*img->resolutiony;
    image_header->z_resolution=0.1*img->resolutionz;
    image_header->mt_1_1=img->mt[0];
    image_header->mt_1_2=img->mt[1];
    image_header->mt_1_3=img->mt[2];
    image_header->mt_1_4=img->mt[3];
    image_header->mt_2_1=img->mt[4];
    image_header->mt_2_2=img->mt[5];
    image_header->mt_2_3=img->mt[6];
    image_header->mt_2_4=img->mt[7];
    image_header->mt_3_1=img->mt[8];
    image_header->mt_3_2=img->mt[9];
    image_header->mt_3_3=img->mt[10];
    image_header->mt_3_4=img->mt[11];
    if(img->_fileFormat==IMG_E7_2D) {
      image_header->num_dimensions=2;
      image_header->z_dimension=1;
    } else {
      image_header->num_dimensions=3;
      image_header->z_dimension=img->dimz;
    }
    for(int i=0; i<49; i++) image_header->fill_user[i]=0;
  }
}

Referenced by imgWriteEcat7Frame(), and imgWritePolarmap().

◆ imgSetNiftiHeader()

int imgSetNiftiHeader	(	IMG *	img,
		const char *	dbname,
		NIFTI_DSR *	dsr,
		float	fmin,
		float	fmax,
		int	verbose )

extern

Copy header information in IMG structure into NIfTI header structure.

Min, max, and scale factor are set here and they apply to all frames.

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

See also: imgGetNiftiHeader, imgReadNiftiHeader

Parameters

img	pointer to IMG structure from which header information is read
dbname	NIfTI database name
dsr	pointer to NIfTI header struct to be filled
fmin	minimum pixel value in all frames that will be written
fmax	maximum pixel value in all frames that will be written
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 471 of file img_nii.c.

  {
  if(verbose>0) {
    printf("\nimgSetNiftiHeader(*img, %s, *dsr, %g, %g, ...)\n", dbname, fmin, fmax);
    fflush(stdout);
  }
  /* Check the input */
  if(dbname==NULL || !dbname[0]) {
    if(verbose>0) fprintf(stderr, "Error: invalid filename\n");
    return(STATUS_FAULT);
  }
  if(img==NULL || (img->status!=IMG_STATUS_INITIALIZED && img->status!=IMG_STATUS_OCCUPIED)) {
    if(verbose>0) fprintf(stderr, "Error: invalid IMG argument\n");
    return(STATUS_FAULT);
  }
  if(dsr==NULL) {
    if(verbose>0) fprintf(stderr, "Error: invalid header struct\n");
    return STATUS_FAULT;
  }
 
  /* Set NIfTI byte order to current machines byte order */
  dsr->byte_order=little_endian();
 
  /* Initiate header struct with zeroes */
  memset(&dsr->h, 0, sizeof(NIFTI_1_HEADER));
  memset(&dsr->e, 0, sizeof(NIFTI_EXTENDER));
 
  /* Set header */
  dsr->h.sizeof_hdr=NIFTI_HEADER_SIZE;
  strcpy(dsr->h.data_type, "");
  char *cptr=strrchr(dbname, '/'); if(cptr==NULL) cptr=strrchr(dbname, '\\');
  if(cptr!=NULL) cptr++;
  if(cptr==NULL) cptr=(char*)dbname;
  strncpy(dsr->h.db_name, cptr, 17);
  dsr->h.extents=16384; // not used in NIfTI, but required for Analyze compatibility
  dsr->h.regular='r'; // not used in NIfTI, but required for Analyze compatibility
  dsr->h.dim_info='\0'; // MRI slice ordering
 
  /* Image dimension */
  for(int i=0; i<8; i++) dsr->h.dim[i]=1;
  dsr->h.dim[0]=4;
  dsr->h.dim[1]=img->dimx;
  dsr->h.dim[2]=img->dimy;
  dsr->h.dim[3]=img->dimz;
  dsr->h.dim[4]=img->dimt;
  dsr->h.intent_p1=0.0;
  dsr->h.intent_p2=0.0;
  dsr->h.intent_p3=0.0;
  dsr->h.intent_code=NIFTI_INTENT_NONE;
  dsr->h.datatype=NIFTI_DT_FLOAT; // data as floats, so no need to scale
  dsr->h.bitpix=32;
  dsr->h.slice_start=0;
  for(int i=0; i<8; i++) dsr->h.pixdim[i]=0.0;
  // https://nifti.nimh.nih.gov/nifti-1/documentation/nifti1fields/nifti1fields_pages/qsform.html
  dsr->h.pixdim[0]=1.0; // Set to either 1.0 or -1.0
  dsr->h.pixdim[1]=img->sizex;
  dsr->h.pixdim[2]=img->sizey;
  dsr->h.pixdim[3]=img->sizez;
  if(img->_fileFormat==IMG_NIFTI_1D)
    dsr->h.vox_offset=0;
  else
    dsr->h.vox_offset=352;
  dsr->h.scl_slope=1.0; // data as floats, so no need to scale
  dsr->h.scl_inter=0.0; // data as floats, so no need to scale
  dsr->h.slice_end=0;
  dsr->h.slice_code=0;
  dsr->h.xyzt_units=NIFTI_UNITS_MM+NIFTI_UNITS_SEC;
  dsr->h.cal_max=fmax;
  dsr->h.cal_min=0.0; // scale display colours to have black at zero
  dsr->h.slice_duration=0.0;
  dsr->h.toffset=0.0;
  dsr->h.glmax=fmax; // unused in NIfTI
  dsr->h.glmin=fmin; // unused in NIfTI
 
  strlcpy(dsr->h.descrip, img->studyNr, 80);
  strcpy(dsr->h.aux_file, "");
 
  dsr->h.qform_code=img->xform[0];
  dsr->h.sform_code=img->xform[1];
  dsr->h.quatern_b=img->quatern[0];
  dsr->h.quatern_c=img->quatern[1];
  dsr->h.quatern_d=img->quatern[2];
  dsr->h.qoffset_x=img->quatern[3];
  dsr->h.qoffset_y=img->quatern[4];
  dsr->h.qoffset_z=img->quatern[5];
  for(int i=0; i<4; i++) dsr->h.srow_x[i]=img->quatern[6+i];
  for(int i=0; i<4; i++) dsr->h.srow_y[i]=img->quatern[10+i];
  for(int i=0; i<4; i++) dsr->h.srow_z[i]=img->quatern[14+i];
  strcpy(dsr->h.intent_name, "");
 
  if(img->_fileFormat==IMG_NIFTI_1D) strcpy(dsr->h.magic, "ni1");
  else strcpy(dsr->h.magic, "n+1");
 
  /* Extension is left as 0 0 0 0 */
 
  return STATUS_OK;
}

Referenced by imgWriteNiftiFrame().

◆ imgSetStatus()

void imgSetStatus	(	IMG *	img,
		int	status_index )

extern

Set the IMG image error status message pointer (statmsg) and index

Parameters

img	Pointer to IMG struct where statmsg will be set
status_index	Index of img_status_string

Definition at line 345 of file img.c.

{
  int n=0;
  if(img==NULL) return;
  while(imgmsg[n]!=0) n++;
  if(status_index<0 || status_index>n-1) img->errstatus=STATUS_FAULT;
  else img->errstatus=status_index;
  img->statmsg=imgmsg[img->errstatus];
}

Referenced by ecat63ReadAllToImg(), imgAllocate(), imgEmpty(), imgExtractRange(), imgGetAnalyzeHeader(), imgGetMicropetHeader(), imgGetNiftiHeader(), imgInit(), imgReadAnalyze(), imgReadAnalyzeFirstFrame(), imgReadAnalyzeFrame(), imgReadAnalyzeHeader(), imgReadEcat63FirstFrame(), imgReadEcat63Frame(), imgReadEcat63Header(), imgReadEcat7(), imgReadEcat7FirstFrame(), imgReadEcat7Frame(), imgReadEcat7Header(), imgReadFrame(), imgReadHeader(), imgReadMicropet(), imgReadMicropetFirstFrame(), imgReadMicropetFrame(), imgReadMicropetHeader(), imgReadNifti(), imgReadNiftiFirstFrame(), imgReadNiftiFrame(), imgReadNiftiHeader(), imgSetAnalyzeHeader(), imgTimeIntegral(), imgWrite(), imgWrite2DEcat7(), imgWriteAnalyze(), imgWriteEcat7(), imgWriteFrame(), imgWriteNifti(), imgWriteNiftiFrame(), and imgWritePolarmap().

◆ imgSetUnit()

int imgSetUnit	(	IMG *	img,
		char *	unit )

extern

Sets the unit in IMG based on specified unit string.

See also: imgUnitId, imgUnitFromEcat, imgUnitFromEcat7

Returns: Returns 0 if successful.

Definition at line 328 of file imgunits.c.

{
  int new_unit;
 
  if(img==NULL || unit==NULL) return(1);
  new_unit=imgUnitId(unit); if(new_unit<0) return(1-new_unit);
  img->unit=new_unit;
  return(0);
}

◆ imgSmoothMax()

int imgSmoothMax	(	IMG *	img,
		float *	maxvalue,
		IMG_PIXEL *	p )

extern

Searches the spatially (3x3) smoothed max pixel value in the IMG data.

See also: imgFrameMinMax, imgMinMax, imgMax, imgAbsMax, imgGetPeak

Returns: 0 if ok, 1 invalid image status, 2 invalid output pointer, 3 invalid image dimensions.

Parameters

img	Pointer to IMG struct
maxvalue	Pointer to float in which max pixel value will be written; enter NULL if not needed
p	Pointer to struct in which the position of max pixel will be written (1-based positions); enter NULL if not needed

Definition at line 248 of file imgminmax.c.

  {
  int pi, yi, xi, fi;
  float f, v;
 
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(maxvalue==NULL && p==NULL) return(2);
  if(img->dimt<1 || img->dimz<1 || img->dimy<3 || img->dimx<3) return(3);
  if(maxvalue!=NULL) *maxvalue=0.0;
  if(p!=NULL) p->x=p->y=p->z=p->f=1;
  f=-1.0E20;
  for(pi=0; pi<img->dimz; pi++)
    for(yi=1; yi<img->dimy-1; yi++)
      for(xi=1; xi<img->dimx-1; xi++)
        for(fi=0; fi<img->dimt; fi++) {
          v=img->m[pi][yi-1][xi-1][fi]+
            img->m[pi][yi-1][xi  ][fi]+
            img->m[pi][yi-1][xi+1][fi]+
            img->m[pi][yi  ][xi-1][fi]+
            img->m[pi][yi  ][xi  ][fi]*2.0+
            img->m[pi][yi  ][xi+1][fi]+
            img->m[pi][yi+1][xi-1][fi]+
            img->m[pi][yi+1][xi  ][fi]+
            img->m[pi][yi+1][xi+1][fi];
          v*=0.1;
          if(v>f) {
            f=v; if(p!=NULL) {p->x=xi+1; p->y=yi+1; p->z=pi+1; p->f=fi+1;}}
        }
  if(maxvalue!=NULL) *maxvalue=f;
  return(0);
}

◆ imgSS()

int imgSS	(	IMG *	img1,
		IMG *	img2,
		double *	ss )

extern

Calculates the sum-of-squares between pixels values of two images.

Precondition: Make sure that image pixel values are in the same units.

Returns: Returns <>0 in case of an error.

See also: imgMatchMatrix, imgMatchHeader, imgMaxDifference, imgConvertUnit

Parameters

img1	Pointer to the first IMG data.
img2	Pointer to the second IMG data.
ss	Pointer to the double variable to write the SS into.

Definition at line 412 of file imgcomp.c.

  {
  if(ss!=NULL) *ss=0.0;
  if(img1==NULL || img2==NULL) return(1);
  if(img1->dimz!=img2->dimz) return(2);
  if(img1->dimy!=img2->dimy) return(3);
  if(img1->dimx!=img2->dimx) return(4);
  if(img1->dimt!=img2->dimt) return(5);
 
  double sumsqr=0.0;
  for(int z=0; z<img1->dimz; z++)
    for(int y=0; y<img1->dimy; y++)
      for(int x=0; x<img1->dimx; x++)
        for(int i=0; i<img1->dimt; i++) {
          double d=img1->m[z][y][x][i]-img2->m[z][y][x][i];
          sumsqr+=d*d;
        }
  if(ss!=NULL) *ss=sumsqr;
 
  return(0);
}

◆ imgStatus()

char * imgStatus ( int status_index )

extern

Return pointer to string describing the image error status message

Parameters

status_index index of img_status_string

Returns: pointer to string

Definition at line 330 of file img.c.

                                  {
  int n=0;
  while(imgmsg[n]!=0) n++;
  if(status_index<0 || status_index>n-1) return((char*)imgmsg[STATUS_FAULT]);
  else return((char*)imgmsg[status_index]);
}

Referenced by ecatFixMatrixlist(), imgRead(), and imgWriteNifti().

◆ imgUnit()

char * imgUnit ( int dunit )

extern

Return pointer to string describing the calibrated image data unit

Returns: Pointer to string

Parameters

dunit Unit id number.

Definition at line 315 of file imgunits.c.

  {
  return(petCunit(dunit));
}

Referenced by clusterTACs(), cunit_check_dft_vs_img(), dftAllocateWithIMG(), imgInfo(), and sif2dft().

◆ imgUnitFromEcat()

void imgUnitFromEcat	(	IMG *	img,
		int	ecat_unit )

extern

Set IMG calibration unit based on ECAT 6.3 unit.

See also: imgUnitFromEcat7, imgUnitId, imgUnitToEcat6, imgSetUnit

Parameters

img	Pointer to target IMG structure.
ecat_unit	Calibration unit code id.

Definition at line 95 of file imgunits.c.

  {
  switch(ecat_unit) {
    case  0: /* Unknown               */
      img->unit=CUNIT_UNKNOWN; break;
    case  1: /* MBq/mL                */
      img->unit=CUNIT_MBQ_PER_ML; break;
    case  2: /* ECAT counts           */
      img->unit=CUNIT_COUNTS; break;
    case  3: /* uCi/ml                */
      img->unit=CUNIT_UCI_PER_ML; break;
    case  4: /* LMRGlu                */
      img->unit=CUNIT_UNKNOWN; break;
    case  5: /* LMRUGlu umol/min/100g */
      img->unit=CUNIT_UMOL_PER_MIN_PER_100G; break;
    case  6: /* LMRUGlu mg/min/100g   */
      img->unit=CUNIT_MG_PER_MIN_PER_100G; break;
    case  7: /* nCi/mL                */
      img->unit=CUNIT_NCI_PER_ML; break;
    case  8: /* Well counts           */
      img->unit=CUNIT_CPS; break;
    case  9: /* Bq/mL                 */
      img->unit=CUNIT_BQ_PER_ML; break;
    case 10: /* kBq/mL                */
      img->unit=CUNIT_KBQ_PER_ML; break;
    case 11: /* 1/min                 */
      img->unit=CUNIT_PER_MIN; break;
    case 12: /* mL/min/100g           */
      img->unit=CUNIT_ML_PER_DL_PER_MIN; break;
    case 13: /* sec*kBq/mL            */
      img->unit=CUNIT_SEC_KBQ_PER_ML; break;
    case 14: /* sec*nCi/mL            */
      img->unit=CUNIT_UNKNOWN; break;
    case 15: /* 1/sec                 */
      img->unit=CUNIT_PER_SEC; break;
    case 16: /* Unitless              */
      img->unit=CUNIT_UNITLESS; break;
    case 17: /* Hounsfield Unit       */
      img->unit=CUNIT_HU; break;
    case 18: /* Unknown               */
    default:
      img->unit=CUNIT_UNKNOWN; break;
  }
}

Referenced by ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), imgGetEcat63MHeader(), and imgReadEcat63Header().

◆ imgUnitFromEcat7()

void imgUnitFromEcat7	(	IMG *	img,
		ECAT7_mainheader *	h )

extern

Set IMG calibration unit based on ECAT7 main header.

See also: imgUnitFromEcat, imgUnitId, imgUnitToEcat7, imgSetUnit

Parameters

img	Pointer to target IMG structure.
h	Pointer to source ECAT 7 main header structure.

Definition at line 149 of file imgunits.c.

  {
  if(h->calibration_units==0) { /* Not calibrated */
    img->unit=1;
  } else if(h->calibration_units==1) {
    if(h->calibration_units_label==0)
      img->unit=CUNIT_BQ_PER_ML;
    else
      img->unit=imgUnitId(h->data_units);
  } else if(h->calibration_units==2) {
    img->unit=imgUnitId(h->data_units);
  } else {
    img->unit=CUNIT_UNKNOWN;
  }
}

Referenced by imgGetEcat7MHeader().

◆ imgUnitId()

int imgUnitId ( char * unit )

extern

Identify the specified unit string as IMG unit.

See also: imgSetUnit, imgUnitId, petCunitId

Returns: unit id number, -1 invalid input, -3 no match found

Parameters

unit	Pointer to string containing the unit to be identified.

Definition at line 14 of file imgunits.c.

  {
  if(unit==NULL) return(-1);
  if(strlen(unit)==0)                             return CUNIT_UNKNOWN;
  else if(strcasecmp(unit, "unknown")==0)         return CUNIT_UNKNOWN;
  else if(strcasecmp(unit, "cnts/sec")==0)        return CUNIT_CPS;
  else if(strcasecmp(unit, "counts/sec")==0)      return CUNIT_CPS;
  else if(strcasecmp(unit, "ECAT counts/sec")==0) return CUNIT_CPS;
  else if(strcasecmp(unit, "cps")==0)             return CUNIT_CPS;
  else if(strcasecmp(unit, "counts")==0)          return CUNIT_COUNTS;
  else if(strcasecmp(unit, "cnts")==0)            return CUNIT_COUNTS;
  else if(strcasecmp(unit, "kBq/cc")==0)          return CUNIT_KBQ_PER_ML;
  else if(strcasecmp(unit, "kBqcc")==0)           return CUNIT_KBQ_PER_ML;
  else if(strcasecmp(unit, "kBq/mL")==0)          return CUNIT_KBQ_PER_ML;
  else if(strcasecmp(unit, "kBqmL")==0)           return CUNIT_KBQ_PER_ML;
  else if(strcasecmp(unit, "sec*kBq/cc")==0)      return CUNIT_SEC_KBQ_PER_ML;
  else if(strcasecmp(unit, "sec*kBq/mL")==0)      return CUNIT_SEC_KBQ_PER_ML;
  else if(strcasecmp(unit, "integral")==0)        return CUNIT_SEC_KBQ_PER_ML;
  else if(strcasecmp(unit, "1/sec")==0)           return CUNIT_PER_SEC;
  else if(strcasecmp(unit, "1/s")==0)             return CUNIT_PER_SEC;
  else if(strcasecmp(unit, "s-1")==0)             return CUNIT_PER_SEC;
  else if(strcasecmp(unit, "1/min")==0)           return CUNIT_PER_MIN;
  else if(strcasecmp(unit, "min-1")==0)           return CUNIT_PER_MIN;
  else if(strcasecmp(unit, "mL/mL")==0)           return CUNIT_ML_PER_ML;
  else if(strcasecmp(unit, "mL/cc")==0)           return CUNIT_ML_PER_ML;
  else if(strcasecmp(unit, "mL/dL")==0)           return CUNIT_ML_PER_DL;
  else if(strcasecmp(unit, "mL/100mL")==0)        return CUNIT_ML_PER_DL;
  else if(strcasecmp(unit, "mL/(mL*min)")==0)     return CUNIT_ML_PER_ML_PER_MIN;
  else if(strcasecmp(unit, "mL/(min*mL)")==0)     return CUNIT_ML_PER_ML_PER_MIN;
  else if(strcasecmp(unit, "mL/(cc*min)")==0)     return CUNIT_ML_PER_ML_PER_MIN;
  else if(strcasecmp(unit, "mL/(min*cc)")==0)     return CUNIT_ML_PER_ML_PER_MIN;
  else if(strcasecmp(unit, "mL/mL/min")==0)       return CUNIT_ML_PER_ML_PER_MIN;
  else if(strcasecmp(unit, "mL/min/mL")==0)       return CUNIT_ML_PER_ML_PER_MIN;
  else if(strcasecmp(unit, "mL/cc/min")==0)       return CUNIT_ML_PER_ML_PER_MIN;
  else if(strcasecmp(unit, "mL/min/cc")==0)       return CUNIT_ML_PER_ML_PER_MIN;
  else if(strcasecmp(unit, "mL/(dL*min)")==0)     return CUNIT_ML_PER_DL_PER_MIN;
  else if(strcasecmp(unit, "mL/(min*dL)")==0)     return CUNIT_ML_PER_DL_PER_MIN;
  else if(strcasecmp(unit, "mL/(100mL*min)")==0)  return CUNIT_ML_PER_DL_PER_MIN;
  else if(strcasecmp(unit, "mL/(min*100mL)")==0)  return CUNIT_ML_PER_DL_PER_MIN;
  else if(strcasecmp(unit, "mL/dL/min")==0)       return CUNIT_ML_PER_DL_PER_MIN;
  else if(strcasecmp(unit, "mL/min/dL")==0)       return CUNIT_ML_PER_DL_PER_MIN;
  else if(strcasecmp(unit, "mL/100mL/min")==0)    return CUNIT_ML_PER_DL_PER_MIN;
  else if(strcasecmp(unit, "mL/min/100mL")==0)    return CUNIT_ML_PER_DL_PER_MIN;
  else if(strcasecmp(unit, "unitless")==0)        return CUNIT_UNITLESS;
  else if(strcasecmp(unit, "Hounsfield Unit")==0) return CUNIT_HU;
  else if(strcasecmp(unit, "HU")==0)              return CUNIT_HU;
  else if(strcasecmp(unit, "nCi/cc")==0)          return CUNIT_NCI_PER_ML;
  else if(strcasecmp(unit, "nCicc")==0)           return CUNIT_NCI_PER_ML;
  else if(strcasecmp(unit, "nCi/mL")==0)          return CUNIT_NCI_PER_ML;
  else if(strcasecmp(unit, "nCimL")==0)           return CUNIT_NCI_PER_ML;
  else if(strcasecmp(unit, "MBq/cc")==0)          return CUNIT_MBQ_PER_ML;
  else if(strcasecmp(unit, "MBqcc")==0)           return CUNIT_MBQ_PER_ML;
  else if(strcasecmp(unit, "MBq/mL")==0)          return CUNIT_MBQ_PER_ML;
  else if(strcasecmp(unit, "MBqmL")==0)           return CUNIT_MBQ_PER_ML;
  else if(strcasecmp(unit, "Bq/cc")==0)           return CUNIT_BQ_PER_ML;
  else if(strcasecmp(unit, "Bqcc")==0)            return CUNIT_BQ_PER_ML;
  else if(strcasecmp(unit, "Bq/mL")==0)           return CUNIT_BQ_PER_ML;
  else if(strcasecmp(unit, "BqmL")==0)            return CUNIT_BQ_PER_ML;
  else if(strcasecmp(unit, "uCi/cc")==0)          return CUNIT_UCI_PER_ML;
  else if(strcasecmp(unit, "uCicc")==0)           return CUNIT_UCI_PER_ML;
  else if(strcasecmp(unit, "uCi/mL")==0)          return CUNIT_UCI_PER_ML;
  else if(strcasecmp(unit, "uCimL")==0)           return CUNIT_UCI_PER_ML;
  else if(strcasecmp(unit, "umol/(100g*min)")==0) return CUNIT_UMOL_PER_MIN_PER_100G;
  else if(strcasecmp(unit, "umol/(min*100g)")==0) return CUNIT_UMOL_PER_MIN_PER_100G;
  else if(strcasecmp(unit, "umol/100g/min")==0)   return CUNIT_UMOL_PER_MIN_PER_100G;
  else if(strcasecmp(unit, "umol/min/100g")==0)   return CUNIT_UMOL_PER_MIN_PER_100G;
  else if(strcasecmp(unit, "mg/(100g*min)")==0)   return CUNIT_MG_PER_MIN_PER_100G;
  else if(strcasecmp(unit, "mg/(min*100g)")==0)   return CUNIT_MG_PER_MIN_PER_100G;
  else if(strcasecmp(unit, "mg/100g/min")==0)     return CUNIT_MG_PER_MIN_PER_100G;
  else if(strcasecmp(unit, "mg/min/100g")==0)     return CUNIT_MG_PER_MIN_PER_100G;
 
  return(-3);
}

Referenced by imgConvertUnit(), imgSetUnit(), and imgUnitFromEcat7().

◆ imgUnitToEcat6()

int imgUnitToEcat6 ( IMG * img )

extern

Return ECAT 6.3 calibration unit based on IMG unit

See also: imgUnitFromEcat, imgUnitId, imgUnitToEcat7, imgSetUnit

Returns: calibration unit code number.

Parameters

img	Pointer to IMG structure.

Definition at line 175 of file imgunits.c.

  {
  int ecat_unit;
  switch(img->unit) {
    case CUNIT_CPS: ecat_unit=9; break;
    case CUNIT_COUNTS: ecat_unit=2; break;
    case CUNIT_KBQ_PER_ML: ecat_unit=10; break;
    case CUNIT_SEC_KBQ_PER_ML: ecat_unit=13; break;
    case CUNIT_PER_SEC: ecat_unit=15; break;
    case CUNIT_PER_MIN: ecat_unit=11; break;
    case CUNIT_ML_PER_ML: ecat_unit=16; break;
    case CUNIT_ML_PER_DL: ecat_unit=16; break;
    case CUNIT_ML_PER_ML_PER_MIN: ecat_unit=11; break;
    case CUNIT_ML_PER_DL_PER_MIN: ecat_unit=12; break;
    case CUNIT_UNITLESS: ecat_unit=16; break;
    case CUNIT_HU: ecat_unit=17; break;
    case CUNIT_NCI_PER_ML: ecat_unit=7; break;
    case CUNIT_MBQ_PER_ML: ecat_unit=1; break;
    case CUNIT_BQ_PER_ML: ecat_unit=9; break;
    case CUNIT_UCI_PER_ML: ecat_unit=3; break;
    case CUNIT_UMOL_PER_MIN_PER_100G: ecat_unit=5; break;
    case CUNIT_MG_PER_MIN_PER_100G: ecat_unit=6; break;
    default: ecat_unit=0; break;
  }
  return(ecat_unit);
}

Referenced by ecat63AddImg(), ecat63WriteAllImg(), imgSetEcat63MHeader(), and imgSetEcat63SHeader().

◆ imgUnitToEcat7()

void imgUnitToEcat7	(	IMG *	img,
		ECAT7_mainheader *	h )

extern

Set ECAT 7 main header calibration units based on IMG unit.

See also: imgUnitFromEcat7, imgUnitId, imgUnitToEcat6, imgSetUnit

Parameters

img	Pointer to source IMG structure.
h	Pointer to target ECAT 7 main header structure.

Definition at line 209 of file imgunits.c.

  {
  switch(img->unit) {
    case CUNIT_CPS:
    case CUNIT_COUNTS:
      h->calibration_units=0;
      h->calibration_units_label=1;
      strcpy(h->data_units, "ECAT counts/sec");
      break;
    case CUNIT_KBQ_PER_ML:
      h->calibration_units=1;
      h->calibration_units_label=1;
      strcpy(h->data_units, "kBq/cc");
      break;
    case CUNIT_SEC_KBQ_PER_ML:
      h->calibration_units=2;
      h->calibration_units_label=1;
      strcpy(h->data_units, "sec*kBq/mL");
      break;
    case CUNIT_PER_SEC:
      h->calibration_units=2;
      h->calibration_units_label=1;
      strcpy(h->data_units, "1/sec");
      break;
    case CUNIT_PER_MIN:
      h->calibration_units=2;
      h->calibration_units_label=1;
      strcpy(h->data_units, "1/min");
      break;
    case CUNIT_ML_PER_ML:
      h->calibration_units=2;
      h->calibration_units_label=1;
      strcpy(h->data_units, "mL/mL");
      break;
    case CUNIT_ML_PER_DL:
      h->calibration_units=2;
      h->calibration_units_label=1;
      strcpy(h->data_units, "mL/dL");
      break;
    case CUNIT_ML_PER_ML_PER_MIN:
      h->calibration_units=2;
      h->calibration_units_label=1;
      strcpy(h->data_units, "mL/(mL*min)");
      break;
    case CUNIT_ML_PER_DL_PER_MIN:
      h->calibration_units=2;
      h->calibration_units_label=1;
      strcpy(h->data_units, "mL/(dL*min)");
      break;
    case CUNIT_UNITLESS:
      h->calibration_units=1;
      h->calibration_units_label=1;
      strcpy(h->data_units, "unitless");
      break;
    case CUNIT_NCI_PER_ML:
      h->calibration_units=1;
      h->calibration_units_label=1;
      strcpy(h->data_units, "nCi/cc");
      break;
    case CUNIT_MBQ_PER_ML:
      h->calibration_units=1;
      h->calibration_units_label=1;
      strcpy(h->data_units, "MBq/cc");
      break;
    case CUNIT_BQ_PER_ML:
      h->calibration_units=1;
      h->calibration_units_label=1;
      strcpy(h->data_units, "Bq/cc");
      break;
    case CUNIT_UCI_PER_ML:
      h->calibration_units=1;
      h->calibration_units_label=1;
      strcpy(h->data_units, "uCi/cc");
      break;
    case CUNIT_UMOL_PER_MIN_PER_100G:
      h->calibration_units=1;
      h->calibration_units_label=1;
      strcpy(h->data_units, "umol/min/100g");
      break;
    case CUNIT_MG_PER_MIN_PER_100G:
      h->calibration_units=1;
      h->calibration_units_label=1;
      strcpy(h->data_units, "mg/min/100g");
      break;
    case CUNIT_HU:
      h->calibration_units=1;
      h->calibration_units_label=1;
      strcpy(h->data_units, "HU");
      break;
    default:
      h->calibration_units=2;
      h->calibration_units_label=0;
      strcpy(h->data_units, "");
      break;
  }
}

Referenced by imgSetEcat7MHeader().

◆ imgWrite()

int imgWrite	(	const char *	fname,
		IMG *	img )

extern

Write an image or sinogram file.

Format depends on _fileFormat or file name extension.

See also: imgInit, imgEmpty, imgRead

Returns: 0 if ok, 1 invalid input, 2 invalid image type or status, 5 failed to write file, sets IMG->statmsg in case of error

Parameters

fname	File name for output image.
img	Pointer to IMG data.

Definition at line 136 of file imgfile.c.

  {
  int ret;
 
  if(IMG_TEST) printf("imgWrite(%s, *img)\n", fname);
  /* Check the arguments */
  if(fname==NULL) return(1);
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
  if(img->type!=IMG_TYPE_RAW &&
     img->type!=IMG_TYPE_IMAGE &&
     img->type!=IMG_TYPE_POLARMAP) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
 
  /* If _fileFormat is not defined, then determine it from the file name */
  if(img->_fileFormat==IMG_UNKNOWN) {
    if(IMG_TEST>1) printf("  file format determined based on file name\n");
    imgFormatFromFName(img, fname);
    if(IMG_TEST>1) printf("  _fileFormat := %d\n", img->_fileFormat);
  }
 
  /* Write */
  if(img->_fileFormat==IMG_E63) {
    ret=ecat63WriteAllImg(fname, img);
    switch(ret) {
      case 0: break;
      case 4: imgSetStatus(img, STATUS_NOMEMORY); break;
      case 3: imgSetStatus(img, STATUS_NOWRITEPERM); break;
      case 9: imgSetStatus(img, STATUS_DISKFULL); break;
      default: imgSetStatus(img, STATUS_FAULT);
    }
    if(ret) return(7);
  } else if(img->_fileFormat==IMG_ANA || img->_fileFormat==IMG_ANA_L) {
    ret=imgWriteAnalyze(fname, img); if(ret) return(5);
  } else if(img->_fileFormat==IMG_NIFTI_1S || img->_fileFormat==IMG_NIFTI_1D) {
    ret=imgWriteNifti(fname, img, 1, IMG_TEST-1); if(ret) return(5);
  } else if(img->_fileFormat==IMG_E7_2D) {
    ret=imgWrite2DEcat7(fname, img); if(ret) return(5);
  } else if(img->_fileFormat==IMG_POLARMAP) {
    ret=imgWritePolarmap(fname, img); if(ret) return(5);
  } else {
    ret=imgWriteEcat7(fname, img); if(ret) return(5);
  }
  imgSetStatus(img, STATUS_OK);
  return(0);
}

Referenced by imgMicropetCTToEcat7().

◆ imgWrite2DEcat7()

int imgWrite2DEcat7	(	const char *	fname,
		IMG *	img )

extern

Write ECAT 7 2D image or 2D sinogram.

Parameters

fname	output filename
img	pointer to image structure

Returns: 0 if ok, 1 invalid input, 2 image status is not 'occupied', 3 failed to allocate memory for data, 6 faield to create file, 7 failed to write data, 8 image type not supported, sets IMG->statmsg in case of error

Definition at line 526 of file img_e7.c.

                                                 {
  ECAT7_mainheader main_header;
  ECAT7_imageheader image_header;
  ECAT7_2Dscanheader scan2d_header;
  FILE *fp;
  int matrixId, ret;
  float *fdata, *fptr;
 
 
  if(IMG_TEST) printf("imgWrite2DEcat7(%s, *img)\n", fname);
  if(IMG_TEST>1 && ECAT7_TEST==0) ECAT7_TEST=1;
  /* Check the arguments */
  if(fname==NULL) {return(1);}
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
 
  /* Check image size */
  if(img->dimt>511 || img->dimz>255 || img->dimx>1024 || img->dimy>1024) {
    imgSetStatus(img, STATUS_INVALIDHEADER); return(2);}
 
  /* Initiate headers */
  memset(&main_header, 0, sizeof(ECAT7_mainheader));
  memset(&image_header,0, sizeof(ECAT7_imageheader));
  memset(&scan2d_header, 0, sizeof(ECAT7_2Dscanheader));
 
  /* Set main header */
  imgSetEcat7MHeader(img, &main_header);
  main_header.bin_size=img->sampleDistance/10.0;
  if(img->type==IMG_TYPE_RAW) main_header.file_type=ECAT7_2DSCAN;
  else main_header.file_type=ECAT7_IMAGE16;
  main_header.num_planes=img->dimz;
 
  /* Allocate memory for matrix float data */
  long long pxlNr=img->dimx*img->dimy;
  fdata=(float*)malloc(pxlNr*sizeof(float));
  if(fdata==NULL) {imgSetStatus(img, STATUS_NOMEMORY); return(3);}
 
  /* Open file, write main header and initiate matrix list */
  fp=ecat7Create(fname, &main_header);
  if(fp==NULL) {free(fdata); imgSetStatus(img, STATUS_NOWRITEPERM); return(6);}
 
  /* Set (most of) subheader contents */
  if(img->type==IMG_TYPE_RAW) {
    scan2d_header.num_dimensions=2;
    scan2d_header.num_z_elements=1;
    scan2d_header.data_type=ECAT7_SUNI2;
    scan2d_header.num_r_elements=img->dimx;
    scan2d_header.num_angles=img->dimy;
  } else if(img->type==IMG_TYPE_IMAGE) {
    image_header.num_dimensions=2;
    image_header.z_dimension=1;
    image_header.data_type=ECAT7_SUNI2;
    image_header.x_dimension=img->dimx;
    image_header.y_dimension=img->dimy;
    image_header.recon_zoom=img->zoom;
    image_header.x_pixel_size=0.1*img->sizex;
    image_header.y_pixel_size=0.1*img->sizey;
    image_header.z_pixel_size=0.1*img->sizez;
    image_header.x_resolution=0.1*img->resolutionx;
    image_header.y_resolution=0.1*img->resolutiony;
    image_header.z_resolution=0.1*img->resolutionz;
    img->quatern[6]=img->sizex; img->quatern[9]=img->sizex;
    img->quatern[11]=img->sizey; img->quatern[13]=img->sizey;
    img->quatern[16]=img->sizez; img->quatern[17]=img->sizez;
    image_header.mt_1_1=img->mt[0];
    image_header.mt_1_2=img->mt[1];
    image_header.mt_1_3=img->mt[2];
    image_header.mt_1_4=img->mt[3];
    image_header.mt_2_1=img->mt[4];
    image_header.mt_2_2=img->mt[5];
    image_header.mt_2_3=img->mt[6];
    image_header.mt_2_4=img->mt[7];
    image_header.mt_3_1=img->mt[8];
    image_header.mt_3_2=img->mt[9];
    image_header.mt_3_3=img->mt[10];
    image_header.mt_3_4=img->mt[11];
  }
 
  /* Write each matrix */
  for(int fi=0; fi<img->dimt; fi++) for(int pi=0; pi<img->dimz; pi++) {
 
    /* Create new matrix id (i.e. matnum) */
    matrixId=ecat7_val_to_id(fi+1, img->planeNumber[pi], 1, 0, 0);
 
    /* Copy matrix pixel values to fdata */
    fptr=fdata;
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++)
        if(isfinite(img->m[pi][yi][xi][fi])) *fptr++=img->m[pi][yi][xi][fi]; else *fptr++=0.0;
 
    /* Write subheader and data */
    fptr=fdata;
    if(img->type==IMG_TYPE_RAW) {
      scan2d_header.frame_start_time=(int)temp_roundf(1000.*img->start[fi]);
      scan2d_header.frame_duration=
       (int)temp_roundf(1000.*(img->end[fi]-img->start[fi]));
      scan2d_header.prompts=temp_roundf(img->prompts[fi]);
      scan2d_header.delayed=temp_roundf(img->randoms[fi]);
      ret=ecat7Write2DScanMatrix(fp, matrixId, &scan2d_header, fptr);
    } else if(img->type==IMG_TYPE_IMAGE) {
      image_header.frame_start_time=(int)temp_roundf(1000.*img->start[fi]);
      image_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[fi]-img->start[fi]));
      if(img->decayCorrection==IMG_DC_CORRECTED)
        image_header.decay_corr_fctr=img->decayCorrFactor[fi];
      else
        image_header.decay_corr_fctr=0.0;
      ret=ecat7WriteImageMatrix(fp, matrixId, &image_header, fptr);
    } else {
      free(fdata); fclose(fp); imgSetStatus(img, STATUS_UNSUPPORTED); return(8);
    }
    if(ret) {
      if(IMG_TEST) {printf("matrixId=%d ret=%d\n", matrixId, ret);}
      free(fdata); fclose(fp); imgSetStatus(img, STATUS_DISKFULL); return(7);
    }
 
  } /* next matrix */
  free(fdata); fclose(fp);
 
  imgSetStatus(img, STATUS_OK);
  return(0);
}

Referenced by imgWrite().

◆ imgWriteAnalyze()

int imgWriteAnalyze	(	const char *	dbname,
		IMG *	img )

extern

Write Analyze 7.5 image.

Analyze database name must be given with path. Path must exist. Image and header files with .img and .hdr extensions are created. Existing files are overwritten. anaFlipping() determines whether image is flipped in z-direction; image is always flipped in x,y-directions. Byte order is determined based on _fileFormat field.

Parameters

dbname	analyze database name with path, without extension
img	pointer to IMG data

Returns: 0 if ok, 1 invalid input, 2 invalid image status (image not occupied), 3 failed to resolve extreme values (min and max), 12 failed to allocate temp memory, 14 failed to open file for writing, 15 failed to write data, 21 failed to write header, and sets IMG->statmsg in case of error

Definition at line 162 of file img_ana.c.

                                                  {
  FILE *fp;
  int ret, little;
  float g;
  ANALYZE_DSR dsr;
  char datfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  const char *cptr;
  struct tm tm; //*st;
  short int *sdata, *sptr, smin, smax;
  SIF sif;
 
 
  if(IMG_TEST) printf("imgWriteAnalyze(%s, *img)\n", dbname);
 
  /* Check the arguments */
  imgSetStatus(img, STATUS_OK);
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
  if(dbname==NULL || !dbname[0]) {imgSetStatus(img, STATUS_FAULT); return(1);}
  
  /* Make the image and header filenames */  
  strcpy(datfile, dbname); strcat(datfile, ".img");
  strcpy(hdrfile, dbname); strcat(hdrfile, ".hdr");
  strcpy(siffile, dbname); strcat(siffile, ".sif");
 
 
  /*
   *  Fill Analyze header
   */
  if(img->_fileFormat==IMG_ANA_L) dsr.little=1; else dsr.little=0;
  /* Header key */
  memset(&dsr.hk, 0, sizeof(ANALYZE_HEADER_KEY));
  memset(&dsr.dime, 0, sizeof(ANALYZE_HEADER_IMGDIM));
  memset(&dsr.hist, 0, sizeof(ANALYZE_HEADER_HISTORY));
  dsr.hk.sizeof_hdr=348;
  strcpy(dsr.hk.data_type, "");
  cptr=strrchr(dbname, '/'); if(cptr==NULL) cptr=strrchr(dbname, '\\');
  if(cptr!=NULL) cptr++;
  if(cptr==NULL) cptr=dbname;
  strncpy(dsr.hk.db_name, cptr, 17);
  dsr.hk.extents=16384;
  dsr.hk.regular='r';
  /* Image dimension */
  dsr.dime.dim[0]=4;
  dsr.dime.dim[1]=img->dimx;
  dsr.dime.dim[2]=img->dimy;
  dsr.dime.dim[3]=img->dimz;
  dsr.dime.dim[4]=img->dimt;
  dsr.dime.datatype=ANALYZE_DT_SIGNED_SHORT;
  dsr.dime.bitpix=16;
  dsr.dime.pixdim[0]=0.0;
  dsr.dime.pixdim[1]=img->sizex;
  dsr.dime.pixdim[2]=img->sizey;
  dsr.dime.pixdim[3]=img->sizez;
  dsr.dime.pixdim[4]=0.0;
  dsr.dime.funused1=0.0; /* Scale factor is set later */
  /* dsr.dime.funused2=img->zoom; */ /* Reconstruction zoom */
  dsr.dime.funused3=img->isotopeHalflife;
  /* Data history */
  if(img->decayCorrection==IMG_DC_CORRECTED)
    strcpy(dsr.hist.descrip, "Decay corrected.");
  else if(img->decayCorrection==IMG_DC_NONCORRECTED) 
    strcpy(dsr.hist.descrip, "No decay correction.");
  else
    strcpy(dsr.hist.descrip, "");
  if(strlen(img->studyNr)>0 && strcmp(img->studyNr, ".")!=0)
    memcpy(dsr.hist.scannum, img->studyNr, 10);
  else
    strcpy(dsr.hist.scannum, "");
  gmtime_r((time_t*)&img->scanStart, &tm);
  if(!strftime(dsr.hist.exp_date, 10, "%Y-%m-%d", &tm))
    memcpy(dsr.hist.exp_date, "1900-01-01", 10);
  if(!strftime(dsr.hist.exp_time, 10, "%H:%M:%S", &tm))
    strlcpy(dsr.hist.exp_time, "00:00:00", 10);
 
  /*
   *  Scale data to short int range
   *  Determine and set scale factor and cal_min & cal_max
   */
  if(IMG_TEST) printf("scaling data to short ints\n");
  ret=imgMinMax(img, &dsr.dime.cal_min, &dsr.dime.cal_max);
  if(ret) {imgSetStatus(img, STATUS_FAULT); return(3);}
  if(IMG_TEST) printf("min=%g max=%g\n", dsr.dime.cal_min, dsr.dime.cal_max);
  if(fabs(dsr.dime.cal_min)>fabs(dsr.dime.cal_max)) g=fabs(dsr.dime.cal_min);
  else g=fabs(dsr.dime.cal_max);
  if(isnan(g)) {imgSetStatus(img, STATUS_FAULT); return 3;}
  if(g<1E-20) g=1.0; else g=32767./g; dsr.dime.funused1=1.0/g;
  if(IMG_TEST) printf("scale_factor=%g\n", dsr.dime.funused1);
 
  /* Allocate memory for short int array */
  size_t pxlNr=(img->dimx)*(img->dimy)*(img->dimz);
  sdata=malloc(pxlNr*sizeof(short int));
  if(sdata==NULL) {imgSetStatus(img, STATUS_NOMEMORY); return 12;}
 
  /* Open image data file for write */
  if((fp=fopen(datfile, "wb")) == NULL) {
    imgSetStatus(img, STATUS_CANTWRITEIMGFILE);
    free(sdata);
    return 14;
  }
 
  /* Copy and write image matrix data to short int array */
  /* Data is written one frame at a time */
  smin=smax=temp_roundf(g*img->m[0][0][0][0]);
  for(int fi=0; fi<img->dimt; fi++) {
    sptr=sdata;
    if(anaFlipping()==0) {
      for(int pi=0; pi<img->dimz; pi++)
        for(int yi=img->dimy-1; yi>=0; yi--)
          for(int xi=img->dimx-1; xi>=0; xi--) {
            *sptr=temp_roundf(g*img->m[pi][yi][xi][fi]);
            if(*sptr>smax) smax=*sptr; else if(*sptr<smin) smin=*sptr;
            sptr++;
          }
    } else {
      for(int pi=img->dimz-1; pi>=0; pi--)
        for(int yi=img->dimy-1; yi>=0; yi--)
          for(int xi=img->dimx-1; xi>=0; xi--) {
            *sptr=temp_roundf(g*img->m[pi][yi][xi][fi]);
            if(*sptr>smax) smax=*sptr; else if(*sptr<smin) smin=*sptr;
            sptr++;
          }
    }
    /* Change byte order if necessary */
    little=little_endian();
    if(little!=dsr.little)
      swabip(sdata, pxlNr*sizeof(short int));
    /* Write image data */
    if(fwrite(sdata, 2, pxlNr, fp) != pxlNr) {
      imgSetStatus(img, STATUS_CANTWRITEIMGFILE);
      free(sdata); fclose(fp);
      return 15;
    }
  }
  /* Done writing */
  fclose(fp);
  free(sdata);
 
  if(IMG_TEST) printf("smin=%d smax=%d\n", smin, smax);
 
  /* Set header glmin & glmax */
  dsr.dime.glmin=smin; dsr.dime.glmax=smax;
  
  /* Write Analyze header */
  ret=anaWriteHeader(hdrfile, &dsr);
  if(ret) {
    imgSetStatus(img, STATUS_CANTWRITEHEADERFILE);
    return 21;
  }
  imgSetStatus(img, STATUS_OK);
 
  /* Otherwise ready, but check if SIF should/can be written */
  sifInit(&sif);
  /* Try to read existing SIF */
  ret=sifRead(siffile, &sif);
  if(ret==0) { // SIF could be read
    if(sif.frameNr==img->dimt) {
      /* If size matches, then update the contents, but keep counts, in case
         previous SIF comes with actual count info from scanner */
      ret=img2sif(img, &sif, 1, 1, 0, IMG_TEST-2);
    } else {
      /* otherwise create SIF contents */
      ret=img2sif(img, &sif, 1, 1, 2, IMG_TEST-2);
    }
  } else {
    /* otherwise create SIF contents */
    ret=img2sif(img, &sif, 1, 1, 2, IMG_TEST-2);
  }
  if(ret!=0) {
    /* SIF data could not be made: do not give error, just do not write it */
    if(IMG_TEST>0) printf("SIF contents could not be filled.\n");
    return 0;
  }
  /* Write SIF */
  ret=sifWrite(&sif, siffile);  
  if(ret!=0) {
    /* SIF could not be written: do not give error, just do not write it */
    if(IMG_TEST>0)
      fprintf(stderr, "Error: SIF could not be written (%d).\n", ret);
  }
 
  imgSetStatus(img, STATUS_OK);
  return 0;
}

Referenced by imgWrite().

◆ imgWriteAnalyzeFrame()

int imgWriteAnalyzeFrame	(	const char *	dbname,
		int	frame_to_write,
		IMG *	img,
		int	frame_index,
		float	fmin,
		float	fmax )

extern

Write one PET frame from IMG data struct into Analyze 7.5 database file. This function can be called repeatedly to write all frames one at a time to conserve memory. This function does not write SIF.

Parameters

dbname	name of file where IMG contents will be written. If file does not exist, it is created. Make sure to delete existing file, unless you want to add data
frame_to_write	PET frame number (1..frameNr) which will be written: If set to 0, frame data will be written to an existing or new PET file as a new frame, never overwriting existing data. If >0, then frame data is written as specified frame number, overwriting any data existing with the same frame number.
img	pointer to the IMG data struct
frame_index	IMG frame index (0..dimt-1) which will be written
fmin	minimum pixel value in all frames that will be written; used only when writing the first frame
fmax	maximum pixel value in all frames that will be written; used only when writing the first frame

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 751 of file img_ana.c.

  {
  IMG test_img;
  int ret=0, little;
  FILE *fp;
  short int *sdata=NULL, *sptr;
  char datfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  ANALYZE_DSR dsr;
  float scale_factor=1.0;
 
 
  if(IMG_TEST) printf("\nimgWriteAnalyzeFrame(%s, %d, *img, %d, %g, %g)\n",
    dbname, frame_to_write, frame_index, fmin, fmax);
 
  /*
   *  Check the input 
   */
  if(dbname==NULL) return STATUS_FAULT;
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
  if(frame_to_write<0) return STATUS_FAULT;
  if(frame_index<0 || frame_index>=img->dimt) return STATUS_FAULT;
  if(img->_fileFormat!=IMG_ANA_L && img->_fileFormat!=IMG_ANA)
    return STATUS_FAULT;
 
  /*
   *  If database does not exist, then create it with new header,
   *  and if it does exist, then read and check header information.
   *  Create or edit header to contain correct frame nr.
   *  Determine the global scaling factor.   
   */
  imgInit(&test_img);
  if(anaDatabaseExists(dbname, hdrfile, datfile, siffile)==0) { // not existing
 
    /* Create database filenames */
    sprintf(hdrfile, "%s.hdr", dbname);
    sprintf(datfile, "%s.img", dbname);
    sprintf(siffile, "%s.sif", dbname);
 
    /* Set main header */
    imgSetAnalyzeHeader(img, dbname, &dsr, fmin, fmax);
    if(frame_to_write==0) frame_to_write=1;
    dsr.dime.dim[4]=frame_to_write;
    scale_factor=dsr.dime.funused1;
    if(fabs(scale_factor)>1.0E-20) scale_factor=1.0/scale_factor;
 
    /* Write Analyze header */
    ret=anaWriteHeader(hdrfile, &dsr);
    if(ret && IMG_TEST) printf("anaWriteHeader() := %d\n", ret);
    if(ret) return STATUS_CANTWRITEHEADERFILE;
 
    /* Remove datafile if necessary */
    if(access(datfile, 0) != -1) remove(datfile);
 
  } else { /* database does exist */
  
    /* Read header information for checking */
    ret=imgReadAnalyzeHeader(dbname, &test_img);
    if(ret!=0) {imgEmpty(&test_img); return ret;}
    /* Check that file format is the same */
    if(img->_fileFormat!=test_img._fileFormat || img->type!=test_img.type) {
      imgEmpty(&test_img); return STATUS_WRONGFILETYPE;}
    /* Check that matrix sizes are the same */
    if(img->dimz!=test_img.dimz || img->dimx!=test_img.dimx ||
       img->dimy!=test_img.dimy) {
      imgEmpty(&test_img); return STATUS_VARMATSIZE;}
    imgEmpty(&test_img);
 
    /* Read the header, set new frame number, and write it back */
    /* Get also the scale factor */
    if((ret=anaReadHeader(hdrfile, &dsr))!=0) return STATUS_NOMAINHEADER;
    scale_factor=1.0/dsr.dime.funused1;
    if(frame_to_write==0) frame_to_write=dsr.dime.dim[4]+1;
    if(dsr.dime.dim[4]<frame_to_write) {
      if(dsr.dime.dim[4]+1<frame_to_write) return STATUS_MISSINGMATRIX;
      dsr.dime.dim[4]=frame_to_write;
    }
    if((ret=anaWriteHeader(hdrfile, &dsr))!=0) return STATUS_NOWRITEPERM;
  }
  if(IMG_TEST>2) {
    printf("frame_to_write := %d\n", frame_to_write);
    printf("hdrfile := %s\n", hdrfile);
    printf("datfile := %s\n", datfile);
    printf("siffile := %s\n", siffile);
  }
 
  /* Allocate memory for matrix short int data (one plane) */
  size_t pxlNr=img->dimx*img->dimy;
  sdata=(short int*)malloc(pxlNr*sizeof(short int));
  if(sdata==NULL) return STATUS_NOMEMORY;
 
  /* Open datafile, not removing possible old contents */
  if(frame_to_write==1) fp=fopen(datfile, "wb"); else fp=fopen(datfile, "r+b");
  if(fp==NULL) {free(sdata); return STATUS_CANTWRITEIMGFILE;}
  /* Move file pointer to the place of current frame */
  if(fseeko(fp, (frame_to_write-1)*pxlNr*img->dimz*sizeof(short int),
           SEEK_SET)!=0) {
    free(sdata); fclose(fp); return STATUS_MISSINGMATRIX;}
  little=little_endian();
  /* Copy, scale and write data plane-by-plane */
  if(anaFlipping()==0) {
    for(int zi=0; zi<img->dimz; zi++) {
      sptr=sdata;
     /*printf("plane := %d\n  scale_factor := %g\n", zi+1, scale_factor);*/
      for(int yi=img->dimy-1; yi>=0; yi--)
        for(int xi=img->dimx-1; xi>=0; xi--) {
          *sptr=temp_roundf(scale_factor*img->m[zi][yi][xi][frame_index]);
          sptr++;
        }
      /* Change byte order if necessary */
      sptr=sdata; if(little!=dsr.little) swabip(sptr, pxlNr*sizeof(short int));
      /* Write image data */
      sptr=sdata;
      if(fwrite(sptr, sizeof(short int), pxlNr, fp) != pxlNr) {
        free(sdata); fclose(fp); return STATUS_CANTWRITEIMGFILE;
      }
    }
  } else {
    for(int zi=img->dimz-1; zi>=0; zi--) {
      sptr=sdata;
      for(int yi=img->dimy-1; yi>=0; yi--)
        for(int xi=img->dimx-1; xi>=0; xi--) {
          *sptr=temp_roundf(scale_factor*img->m[zi][yi][xi][frame_index]);
          sptr++;
        }
      /* Change byte order if necessary */
      sptr=sdata; if(little!=dsr.little) swabip(sptr, pxlNr*sizeof(short int));
      /* Write image data */
      sptr=sdata;
      if(fwrite(sptr, sizeof(short int), pxlNr, fp) != pxlNr) {
        free(sdata); fclose(fp); return STATUS_CANTWRITEIMGFILE;
      }
    }
  }
  free(sdata);
  fclose(fp);
 
  return STATUS_OK;
}

◆ imgWriteEcat63Frame()

int imgWriteEcat63Frame	(	const char *	fname,
		int	frame_to_write,
		IMG *	img,
		int	frame_index )

extern

Write one PET frame from IMG data struct into ECAT 6.3 image or sinogram file; format is specified in IMG struct. This function can be called repeatedly to write all frames one at a time to conserve memory. However, file with just mainheader and matrix list without any previous frame is not accepted.

Parameters

fname	name of file where IMG contents will be written. If file does not exist, it is created. Make sure to delete existing file, unless you want to add data
frame_to_write	PET frame number (1..frameNr) which will be written: If set to 0, frame data will be written to an existing or new PET file as a new frame, never overwriting existing data. If >0, then frame data is written as specified frame number, overwriting any data existing with the same frame number
img	pointer to the IMG data struct
frame_index	IMG frame index (0..dimt-1) which will be written

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 1711 of file img_e63.c.

  {
  IMG test_img;
  int ret=0, matrixId;
  ECAT63_mainheader   main_header;
  ECAT63_imageheader  image_header;
  ECAT63_scanheader   scan_header;
  void *sub_header=NULL;
  FILE *fp;
  float *fdata=NULL, *fptr;
 
 
  if(IMG_TEST>0) printf("\nimgWriteEcat63Frame(%s, %d, *img, %d)\n",
    fname, frame_to_write, frame_index);
  if(IMG_TEST>1) ECAT63_TEST=IMG_TEST-1;
  if(IMG_TEST>4) {
    char buf[32];
    if(!ctime_r_int(&img->scanStart, buf)) strcpy(buf, "1900-01-01 00:00:00");
    fprintf(stdout, "  scan_start_time := %s\n", buf);
  }
 
  /*
   *  Check the input 
   */
  if(fname==NULL) return STATUS_FAULT;
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
  if(frame_to_write<0) return STATUS_FAULT;
  if(frame_index<0 || frame_index>=img->dimt) return STATUS_FAULT;
  if(img->_fileFormat!=IMG_E63) return STATUS_FAULT;
 
  /* Check image size */
  if(img->dimt>511 || img->dimz>255 || img->dimx>1024 || img->dimy>1024) {
    strcpy(ecat63errmsg, "too large matrix size"); return(1);}
 
  /* Initiate headers */
  memset(&main_header, 0, sizeof(ECAT63_mainheader));
  memset(&image_header,0, sizeof(ECAT63_imageheader));
  memset(&scan_header, 0, sizeof(ECAT63_scanheader));
  imgInit(&test_img);
 
 
  /*
   *  If file does not exist, then create it with new mainheader,
   *  and if it does exist, then read and check header information.
   *  Create or edit mainheader to contain correct frame nr.   
   *  In any case, leave file pointer open for write.   
   */
  if(access(fname, 0) == -1) { /* file does not exist*/
 
    if(IMG_TEST>1) printf("  new file\n");
    /* Set main header */
    imgSetEcat63MHeader(img, &main_header);
    if(IMG_TEST>6) {
      ecat63PrintMainheader(&main_header, stdout);
    }
    if(frame_to_write==0) frame_to_write=1;
    main_header.num_frames=frame_to_write;
 
    /* Open file, write main header and initiate matrix list */
    fp=ecat63Create(fname, &main_header); if(fp==NULL) return STATUS_NOWRITEPERM;
 
  } else { /* file exists*/
  
    if(IMG_TEST>1) printf("  existing file\n");
    /* Read header information for checking */
    ret=imgReadEcat63Header(fname, &test_img); if(ret!=0) return ret;
    if(IMG_TEST>1) {
      char buf[32];
      if(!ctime_r_int(&test_img.scanStart, buf)) 
        strcpy(buf, "1900-01-01 00:00:00");
      fprintf(stdout, "scan_start_time := %s\n", buf);
    }
    /* Check that file format is the same */
    if(img->_fileFormat!=test_img._fileFormat || img->type!=test_img.type)
      return STATUS_WRONGFILETYPE;
    /* Check that matrix sizes are the same */
    if(img->dimz!=test_img.dimz || img->dimx!=test_img.dimx ||
       img->dimy!=test_img.dimy)
      return STATUS_VARMATSIZE;
    imgEmpty(&test_img);
 
    /* Open the file for read and write */
    if((fp=fopen(fname, "r+b"))==NULL) return STATUS_NOWRITEPERM;
 
    /* Read the mainheader, set new frame number, and write it back */
    if((ret=ecat63ReadMainheader(fp, &main_header))!=0)
      return STATUS_NOMAINHEADER;
    if(frame_to_write==0) frame_to_write=main_header.num_frames+1;
    if(main_header.num_frames<frame_to_write)
      main_header.num_frames=frame_to_write;
    if((ret=ecat63WriteMainheader(fp, &main_header))!=0)
      return STATUS_NOWRITEPERM;
    if(IMG_TEST>0) {
      char tmp[32];
      printf("  scan_start_time := %s\n", ecat63ScanstarttimeInt(&main_header, tmp));
    }
    
  }
  if(IMG_TEST>2) {
    printf("frame_to_write := %d\n", frame_to_write);
  }
 
  /* Allocate memory for matrix float data */
  size_t pxlNr=img->dimx*img->dimy*img->dimz;
  fdata=(float*)malloc(pxlNr*sizeof(float));
  if(fdata==NULL) {fclose(fp); return STATUS_NOMEMORY;}
  
  /* Set matrix subheader */
  if(img->type==IMG_TYPE_RAW) sub_header=(void*)&scan_header;
  else if(img->type==IMG_TYPE_IMAGE) sub_header=&image_header;
  else {fclose(fp); return STATUS_FAULT;}
  imgSetEcat63SHeader(img, sub_header);
 
  /* Copy matrix pixel values to fdata */
  fptr=fdata;
  for(int zi=0; zi<img->dimz; zi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++)
        *fptr++=img->m[zi][yi][xi][frame_index];
 
  /* Write subheader and data, and set the rest of subheader contents */
  fptr=fdata; ret=-1;
  for(int zi=0; zi<img->dimz; zi++, fptr+=img->dimx*img->dimy) {
    /* Create new matrix id (i.e. matnum) */
    matrixId=mat_numcod(frame_to_write, img->planeNumber[zi], 1, 0, 0);
    if(img->type==IMG_TYPE_RAW) {
      scan_header.frame_start_time=
        (int)temp_roundf(1000.*img->start[frame_index]);
      scan_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[frame_index]-img->start[frame_index]));
      scan_header.prompts=temp_roundf(img->prompts[frame_index]);
      scan_header.delayed=temp_roundf(img->randoms[frame_index]);
      ret=ecat63WriteScanMatrix(fp, matrixId, &scan_header, fptr);
    } else {
      image_header.frame_start_time=
        (int)temp_roundf(1000.*img->start[frame_index]);
      image_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[frame_index]-img->start[frame_index]));
      if(img->decayCorrection==IMG_DC_CORRECTED)
        image_header.decay_corr_fctr=img->decayCorrFactor[frame_index];
      else
        image_header.decay_corr_fctr=0.0;
      ret=ecat63WriteImageMatrix(fp, matrixId, &image_header, fptr);
    }
    if(ret!=0) break;
  } /* next plane*/
  free(fdata); fclose(fp);
  if(ret) return STATUS_DISKFULL;
 
  return STATUS_OK;
}

Referenced by imgWriteFrame().

◆ imgWriteEcat7()

int imgWriteEcat7	(	const char *	fname,
		IMG *	img )

extern

Write ECAT 7 3D image volume or 3D sinogram.

Parameters

fname	output filename
img	pointer to IMG data

Returns: 0 if ok, 1 invalid input, 2 image status is not 'occupied', 3 failed to allocate memory for data, 6 failed to create file, 7 failed to write data, 8 unsupported image type sets IMG->statmsg in case of error

Definition at line 382 of file img_e7.c.

                                               {
  ECAT7_mainheader main_header;
  ECAT7_imageheader image_header;
  ECAT7_scanheader scan_header;
  FILE *fp;
  int matrixId, ret;
  float *fdata, *fptr;
 
 
  if(IMG_TEST) printf("imgWriteEcat7(%s, *img)\n", fname);
  if(IMG_TEST>1 && ECAT7_TEST==0) ECAT7_TEST=1;
  /* Check the arguments */
  if(fname==NULL) return(1);
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
  if(img->type!=IMG_TYPE_RAW && img->type!=IMG_TYPE_IMAGE) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
 
  /* Check image size */
  if(img->dimt>511 || img->dimz>255 || img->dimx>1024 || img->dimy>1024) {
    imgSetStatus(img, STATUS_INVALIDHEADER); return(2);}
 
  /* Initiate headers */
  memset(&main_header, 0, sizeof(ECAT7_mainheader));
  memset(&image_header,0, sizeof(ECAT7_imageheader));
  memset(&scan_header, 0, sizeof(ECAT7_scanheader));
 
  /* Set main header */
  imgSetEcat7MHeader(img, &main_header);
  main_header.bin_size=img->sampleDistance/10.0;
 
  /* Allocate memory for matrix float data */
  long long pxlNr=img->dimx*img->dimy*img->dimz;
  fdata=(float*)malloc(pxlNr*sizeof(float));
  if(fdata==NULL) {imgSetStatus(img, STATUS_NOMEMORY); return(3);}
 
  /* Open file, write main header and initiate matrix list */
  fp=ecat7Create(fname, &main_header);
  if(fp==NULL) {free(fdata); imgSetStatus(img, STATUS_NOWRITEPERM); return(6);}
 
  /* Set (most of) subheader contents */
  if(img->type==IMG_TYPE_RAW) {
    scan_header.x_resolution=img->sampleDistance/10.0;
    scan_header.num_dimensions=4;
    if(img->dimz==239) {
      scan_header.num_z_elements[0]=63;
      scan_header.num_z_elements[1]=106;
      scan_header.num_z_elements[2]=70;
    } else {
      scan_header.num_z_elements[0]=img->dimz;
    }
    scan_header.storage_order=1;
    scan_header.data_type=ECAT7_SUNI2;
    scan_header.num_r_elements=img->dimx;
    scan_header.num_angles=img->dimy;
  } else if(img->type==IMG_TYPE_IMAGE) {
    image_header.num_dimensions=3;
    image_header.z_dimension=img->dimz;
    image_header.data_type=ECAT7_SUNI2;
    image_header.x_dimension=img->dimx;
    image_header.y_dimension=img->dimy;
    image_header.recon_zoom=img->zoom;
    image_header.x_pixel_size=0.1*img->sizex;
    image_header.y_pixel_size=0.1*img->sizey;
    image_header.z_pixel_size=0.1*img->sizez;
    image_header.x_resolution=0.1*img->resolutionx;
    image_header.y_resolution=0.1*img->resolutiony;
    image_header.z_resolution=0.1*img->resolutionz;
    img->quatern[6]=img->sizex; img->quatern[9]=img->sizex;
    img->quatern[11]=img->sizey; img->quatern[13]=img->sizey;
    img->quatern[16]=img->sizez; img->quatern[17]=img->sizez;
    image_header.mt_1_1=img->mt[0];
    image_header.mt_1_2=img->mt[1];
    image_header.mt_1_3=img->mt[2];
    image_header.mt_1_4=img->mt[3];
    image_header.mt_2_1=img->mt[4];
    image_header.mt_2_2=img->mt[5];
    image_header.mt_2_3=img->mt[6];
    image_header.mt_2_4=img->mt[7];
    image_header.mt_3_1=img->mt[8];
    image_header.mt_3_2=img->mt[9];
    image_header.mt_3_3=img->mt[10];
    image_header.mt_3_4=img->mt[11];
  }
 
  /* Write each matrix */
  for(int fi=0; fi<img->dimt; fi++) {
 
    /* Create new matrix id (i.e. matnum) */
    matrixId=ecat7_val_to_id(fi+1, 1, 1, 0, 0);
 
    /* Copy matrix pixel values to fdata */
    fptr=fdata;
    for(int pi=0; pi<img->dimz; pi++)
      for(int yi=0; yi<img->dimy; yi++)
        for(int xi=0; xi<img->dimx; xi++)
          if(isfinite(img->m[pi][yi][xi][fi])) *fptr++=img->m[pi][yi][xi][fi]; else *fptr++=0.0;
 
    /* Write subheader and data */
    fptr=fdata;
    if(img->type==IMG_TYPE_RAW) {
      scan_header.frame_start_time=(int)temp_roundf(1000.*img->start[fi]);
      scan_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[fi]-img->start[fi]));
      scan_header.prompts=temp_roundf(img->prompts[fi]);
      scan_header.delayed=temp_roundf(img->randoms[fi]);
      /*ecat7PrintScanheader(&scan_header, stdout);*/
      ret=ecat7WriteScanMatrix(fp, matrixId, &scan_header, fptr);
    } else if(img->type==IMG_TYPE_IMAGE) {
      image_header.frame_start_time=(int)temp_roundf(1000.*img->start[fi]);
      image_header.frame_duration=(int)temp_roundf(1000.*(img->end[fi]-img->start[fi]));
      if(img->decayCorrection==IMG_DC_CORRECTED)
        image_header.decay_corr_fctr=img->decayCorrFactor[fi];
      else
        image_header.decay_corr_fctr=0.0;
      /*ecat7PrintImageheader(&image_header, stdout);*/
      ret=ecat7WriteImageMatrix(fp, matrixId, &image_header, fptr);
    } else {
      free(fdata); fclose(fp); imgSetStatus(img, STATUS_UNSUPPORTED); return(8);
    }
    if(ret) {
      if(IMG_TEST) {printf("matrixId=%d ret=%d\n", matrixId, ret);}
      free(fdata); fclose(fp); imgSetStatus(img, STATUS_DISKFULL); return(7);
    }
 
  } /* next matrix */
  free(fdata); fclose(fp);
 
  imgSetStatus(img, STATUS_OK);
  return(0);
}

Referenced by imgWrite().

◆ imgWriteEcat7Frame()

int imgWriteEcat7Frame	(	const char *	fname,
		int	frame_to_write,
		IMG *	img,
		int	frame_index )

extern

Write one PET frame from IMG data struct into ECAT 7 image or sinogram file; format is specified in IMG struct. This function can be called repeatedly to write all frames one at a time to conserve memory. However, file with just mainheader and matrix list without any previous frame is not accepted.

Parameters

fname	name of file where IMG contents will be written. If file does not exist, it is created. Make sure to delete existing file, unless you want to add data
frame_to_write	PET frame number (1..frameNr) which will be written: If set to 0, frame data will be written to an existing or new PET file as a new frame, never overwriting existing data. If >0, then frame data is written as specified frame number, overwriting any data existing with the same frame number
img	pointer to the IMG data struct
frame_index	IMG frame index (0..dimt-1) which will be written

Returns: errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Definition at line 1295 of file img_e7.c.

  {
  IMG test_img;
  int ret=0, matrixId;
  ECAT7_mainheader main_header;
  ECAT7_imageheader image_header;
  ECAT7_scanheader scan_header;
  ECAT7_2Dscanheader scan2d_header;
  ECAT7_polmapheader polmap_header;
  void *sub_header=NULL;
  FILE *fp;
  float *fdata=NULL, *fptr;
 
 
  if(IMG_TEST) printf("\nimgWriteEcat7Frame(%s, %d, *img, %d)\n",
    fname, frame_to_write, frame_index);
    
  /*
   *  Check the input 
   */
  if(fname==NULL) return STATUS_FAULT;
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
  if(frame_to_write<0) return STATUS_FAULT;
  if(frame_index<0 || frame_index>=img->dimt) return STATUS_FAULT;
  if(img->_fileFormat!=IMG_E7 &&
     img->_fileFormat!=IMG_POLARMAP &&
     img->_fileFormat!=IMG_E7_2D) return STATUS_FAULT;
 
  /* Check image size */
  if(img->dimt>511 || img->dimz>255 || img->dimx>1024 || img->dimy>1024)
    return STATUS_INVALIDHEADER;
 
  /* Initiate headers */
  memset(&main_header, 0, sizeof(ECAT7_mainheader));
  memset(&image_header,0, sizeof(ECAT7_imageheader));
  memset(&scan_header, 0, sizeof(ECAT7_scanheader));
  memset(&scan2d_header, 0, sizeof(ECAT7_2Dscanheader));
  memset(&polmap_header,0, sizeof(ECAT7_polmapheader));
  imgInit(&test_img);
 
 
  /*
   *  If file does not exist, then create it with new mainheader,
   *  and if it does exist, then read and check header information.
   *  Create or edit mainheader to contain correct frame nr.   
   *  In any case, leave file pointer open for write.   
   */
  if(access(fname, 0) == -1) { /* file does not exist */
 
    /* Set main header */
    imgSetEcat7MHeader(img, &main_header);
    main_header.bin_size=img->sampleDistance/10.0;
    if(frame_to_write==0) frame_to_write=1;
    main_header.num_frames=frame_to_write;
 
    /* Open file, write main header and initiate matrix list */
    fp=ecat7Create(fname, &main_header); if(fp==NULL) return STATUS_NOWRITEPERM;
 
  } else { /* file exists */
  
    /* Read header information for checking */
    ret=imgReadEcat7Header(fname, &test_img); if(ret!=0) return ret;
    /* Check that file format is the same */
    if(img->_fileFormat!=test_img._fileFormat || img->type!=test_img.type)
      return STATUS_WRONGFILETYPE;
    /* Check that matrix sizes are the same */
    if(img->dimz!=test_img.dimz || img->dimx!=test_img.dimx ||
       img->dimy!=test_img.dimy)
      return STATUS_VARMATSIZE;
    imgEmpty(&test_img);
 
    /* Open the file for read and write */
    if((fp=fopen(fname, "r+b"))==NULL) return STATUS_NOWRITEPERM;
 
    /* Read the mainheader, set new frame number, and write it back */
    if((ret=ecat7ReadMainheader(fp, &main_header))!=0)
      return STATUS_NOMAINHEADER;
    if(frame_to_write==0) frame_to_write=main_header.num_frames+1;
    if(main_header.num_frames<frame_to_write)
      main_header.num_frames=frame_to_write;
    if((ret=ecat7WriteMainheader(fp, &main_header))!=0)
      return STATUS_NOWRITEPERM;
    
  }
  if(IMG_TEST>2) {
    printf("frame_to_write := %d\n", frame_to_write);
  }
 
  /* Allocate memory for matrix float data */
  long long pxlNr=img->dimx*img->dimy*img->dimz; /* for 2D too! */
  fdata=(float*)malloc(pxlNr*sizeof(float));
  if(fdata==NULL) {fclose(fp); return STATUS_NOMEMORY;}
  
  /* Set matrix subheader */
  if(img->_fileFormat==IMG_E7) {
    if(img->type==IMG_TYPE_RAW) sub_header=(void*)&scan_header;
    else sub_header=&image_header;
  } else if(img->_fileFormat==IMG_E7_2D) {
    if(img->type==IMG_TYPE_RAW) sub_header=(void*)&scan_header;
    else sub_header=(void*)&image_header;
  } else if(img->_fileFormat==IMG_POLARMAP) {
    sub_header=(void*)&polmap_header;
  } else {fclose(fp); return STATUS_FAULT;}
  imgSetEcat7SHeader(img, sub_header);
 
  /* Copy matrix pixel values to fdata */
  fptr=fdata;
  for(int zi=0; zi<img->dimz; zi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++)
        if(isfinite(img->m[zi][yi][xi][frame_index])) *fptr++=img->m[zi][yi][xi][frame_index]; else *fptr++=0.0;
 
  /* Write subheader and data, and set the rest of subheader contents */
  fptr=fdata; ret=-1;
  if(img->_fileFormat==IMG_E7) {
    /* Create new matrix id (i.e. matnum) */
    matrixId=ecat7_val_to_id(frame_to_write, 1, 1, 0, 0);
    if(img->type==IMG_TYPE_RAW) {
      scan_header.frame_start_time=
       (int)temp_roundf(1000.*img->start[frame_index]);
      scan_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[frame_index]-img->start[frame_index]));
      scan_header.prompts=temp_roundf(img->prompts[frame_index]);
      scan_header.delayed=temp_roundf(img->randoms[frame_index]);
      ret=ecat7WriteScanMatrix(fp, matrixId, &scan_header, fptr);
    } else {
      image_header.frame_start_time=
       (int)temp_roundf(1000.*img->start[frame_index]);
      image_header.frame_duration=
        (int)temp_roundf(1000.*(img->end[frame_index]-img->start[frame_index]));
      if(img->decayCorrection==IMG_DC_CORRECTED)
        image_header.decay_corr_fctr=img->decayCorrFactor[frame_index];
      else
        image_header.decay_corr_fctr=0.0;
      /*ecat7PrintImageheader(&image_header, stdout);*/
      ret=ecat7WriteImageMatrix(fp, matrixId, &image_header, fptr);
    }
  } else if(img->_fileFormat==IMG_E7_2D) {
    for(int zi=0; zi<img->dimz; zi++, fptr+=img->dimx*img->dimy) {
      /* Create new matrix id (i.e. matnum) */
      matrixId=ecat7_val_to_id(frame_to_write, img->planeNumber[zi], 1, 0, 0);
      if(img->type==IMG_TYPE_RAW) {
        scan2d_header.frame_start_time=
          (int)temp_roundf(1000.*img->start[frame_index]);
        scan2d_header.frame_duration=
          (int)temp_roundf(1000.*(img->end[frame_index]-img->start[frame_index]));
        scan2d_header.prompts=temp_roundf(img->prompts[frame_index]);
        scan2d_header.delayed=temp_roundf(img->randoms[frame_index]);
        ret=ecat7Write2DScanMatrix(fp, matrixId, &scan2d_header, fptr);
      } else {
        image_header.frame_start_time=
          (int)temp_roundf(1000.*img->start[frame_index]);
        image_header.frame_duration=
          (int)temp_roundf(1000.*(img->end[frame_index]-img->start[frame_index]));
        if(img->decayCorrection==IMG_DC_CORRECTED)
          image_header.decay_corr_fctr=img->decayCorrFactor[frame_index];
        else
          image_header.decay_corr_fctr=0.0;
        ret=ecat7WriteImageMatrix(fp, matrixId, &image_header, fptr);
      }
      if(ret!=0) break;
    } /* next plane */
  } else if(img->_fileFormat==IMG_POLARMAP) {
    /* Create new matrix id (i.e. matnum) */
    matrixId=ecat7_val_to_id(frame_to_write, 1, 1, 0, 0);
    polmap_header.frame_start_time=
     (int)temp_roundf(1000.*img->start[frame_index]);
    polmap_header.frame_duration=
     (int)temp_roundf(1000.*(img->end[frame_index]-img->start[frame_index]));
    ret=ecat7WritePolarmapMatrix(fp, matrixId, &polmap_header, fptr);
  }
  free(fdata); fclose(fp);
  if(ret) return STATUS_DISKFULL;
 
  return STATUS_OK;
}

Referenced by imgWriteFrame().

◆ imgWriteFrame()

int imgWriteFrame	(	const char *	fname,
		int	frame_to_write,
		IMG *	img,
		int	frame_index )

extern

Write one PET frame from IMG data struct into a supported PET image or sinogram file.

This function can be called repeatedly to write all frames one at a time to conserve memory.

Currently supported file formats are ECAT 6.3 images and sinograms, and ECAT 7.x 2D and 3D images and sinograms, and NIfTI-1 images. Analyze 7.5 images are NOT supported (because global min and max would be needed). SIF for NIfTI-1 files is not written by this function.

See also: imgReadFrame, imgReadHeader, imgWrite

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

Parameters

fname	Name of file where IMG contents will be written. If file exists, data is either overwritten or catenated as a new frame, depending on the following arguments. If file does not exist, it is created.
frame_to_write	PET frame number (1..frameNr) which will be written: If set to 0, frame data will be written to an existing or new PET file as a new frame, never overwriting existing data. If >0, then frame data is written as specified frame number, overwriting any data existing with the same frame number
img	Pointer to the IMG data structure.
frame_index	IMG frame index (0..dimt-1) which will be written.

Definition at line 392 of file imgfile.c.

  {
  int ret=0;
 
  if(IMG_TEST>0) {
    printf("\nimgWriteFrame(%s, %d, *img, %d)\n", fname, frame_to_write, frame_index);
    fflush(stdout);
  }
  if(IMG_TEST>3) {
    char buf[32];
    if(!ctime_r_int(&img->scanStart, buf)) strcpy(buf, "1900-01-01 00:00:00");
    fprintf(stdout, "  scan_start_time := %s\n", buf);
  }
    
  /*
   *  Check the input 
   */
  if(fname==NULL) return STATUS_FAULT;
  if(img==NULL) return STATUS_FAULT;
  if(img->status!=IMG_STATUS_OCCUPIED) return STATUS_FAULT;
  if(frame_to_write<0) return STATUS_FAULT;
  if(frame_index<0 || frame_index>=img->dimt) return STATUS_FAULT;
 
 
  /*
   *  Call separate function for each supported file format
   */
  imgFormatFromFName(img, fname);
  switch(img->_fileFormat) {
    case IMG_E7:
    case IMG_E7_2D:
    case IMG_POLARMAP:
      ret=imgWriteEcat7Frame(fname, frame_to_write, img, frame_index);
      break;
    case IMG_E63:
      ret=imgWriteEcat63Frame(fname, frame_to_write, img, frame_index);
      break;
    case IMG_ANA:
    case IMG_ANA_L:
      ret=STATUS_UNSUPPORTED;
      /* Not supported because would require global min&max values
       * if saved in short ints which is now the only possibility
       * ret=imgWriteAnaFrame(fname, frame_to_write, img, frame_index);
       */
      break;
    case IMG_NIFTI_1D:
    case IMG_NIFTI_1S:
#if(0)
      /* Not supported because would require global min&max values
       * if saved in short ints which is now the only possibility
       */
      ret=STATUS_UNSUPPORTED;
#endif
      /* Nifti is currently always written as floats, therefore
         global min and max pixel values are not yet needed */
      ret=imgWriteNiftiFrame(fname, frame_to_write, img, frame_index, 0, 0, IMG_TEST-2);
      break;
    default:
      ret=STATUS_UNSUPPORTED;
  }
  imgSetStatus(img, ret);
  return ret;
}

Referenced by imgAnalyzeToEcat(), imgMicropetPETToEcat7(), and imgNiftiToEcat().

◆ imgWriteNifti()

int imgWriteNifti	(	const char *	dbname,
		IMG *	img,
		int	save_sif,
		int	verbose )

extern

Write NIfTI-1 image.

Nifti database name can be given with path, however, path is not created in here. IMG field _fileFormat determines whether NIfTI is written in single file format (*.nii) or dual file format (*.hdr and *.img). Optionally SIF file with .sif extension is saved to store frame times.

Returns: 0 if ok, and otherwise IMG status code (<>0); sets IMG->statmsg in case of an error.

See also: imgInit, imgReadNiftiFirstFrame, imgReadNiftiHeader, imgReadNifti

Parameters

dbname	Nifti database name with path, with or without extension
img	Pointer to IMG structure containing the image data to be written
save_sif	Save (1) or do not save (0) SIF
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 811 of file img_nii.c.

  {
  int ret;
  char imgfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  float fmin, fmax;
  SIF sif;
 
  if(verbose>0) {
    printf("imgWriteNifti(%s, *img, %d, ...)\n", dbname, save_sif);
    fflush(stdout);
  }
 
  /*
   *  Check the input 
   */
  if(dbname==NULL || !dbname[0]) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid filename\n");
    return(STATUS_FAULT);
  }
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    if(img!=NULL) imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid IMG argument\n");
    return(STATUS_FAULT);
  }
  if(img->_fileFormat!=IMG_NIFTI_1D && img->_fileFormat!=IMG_NIFTI_1S) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid file format setting\n");
    return STATUS_FAULT;
  }
 
  /* Create the NIfTI filename(s) */
  ret=niftiCreateFNames(dbname, hdrfile, imgfile, siffile, img->_fileFormat);
  if(ret!=0) {
    if(verbose>0) fprintf(stderr, "  Error: invalid NIfTI name %s\n", dbname);
    imgSetStatus(img, STATUS_FAULT);
    return STATUS_FAULT;
  }
  /* Delete previous NIfTI */
  ret=niftiRemove(dbname, 0, verbose-1);
  if(ret!=0) {
    if(verbose>0) fprintf(stderr, "  Error: cannot delete previous NIfTI.\n");
    imgSetStatus(img, STATUS_CANNOTERASE);
    return STATUS_CANNOTERASE;
  }
 
  /*
   *  Get the global min and max pixel values;
   *  those are currently only saved in header, but may be later
   *  needed for scaling pixels to short ints
   */
  if(verbose>1) {fprintf(stdout, "  searching min and max\n"); fflush(stdout);}
  ret=imgMinMax(img, &fmin, &fmax);
  if(ret) {
    if(verbose>0) fprintf(stderr, "  Error: %s\n", imgStatus(ret));
    imgSetStatus(img, STATUS_NOIMGDATA);
    return STATUS_NOIMGDATA;
  }
  if(verbose>1) {
    printf("    global_min := %g\n    global_max := %g\n", fmin, fmax);
    fflush(stdout);
  }
  /*
   *  Write the image frames
   */
  for(int fi=0, ret=0; fi<img->dimt; fi++) {
    ret=imgWriteNiftiFrame(dbname, fi+1, img, fi, fmin, fmax, verbose-2);
    if(ret!=STATUS_OK) break;
    if(verbose>4) {printf("    frame written.\n"); fflush(stdout);}
  } // next frame
  //printf("ret := %d\n", ret);
  if(ret!=STATUS_OK) {
    niftiRemove(dbname, img->_fileFormat, verbose-3);
    if(verbose>0) fprintf(stderr, "Error: %s.\n", imgStatus(ret));
    return ret;
  }
 
  /* If SIF is not needed, then that's it */
  if(save_sif==0) {
    imgSetStatus(img, STATUS_OK);
    return 0;
  }
 
  /* Copy contents from IMG to SIF and save SIF */
  sifInit(&sif);
  /* Try to read existing SIF */
  ret=sifRead(siffile, &sif);
  if(ret==0) { // SIF could be read
    if(sif.frameNr==img->dimt) {
      /* If size matches, then update the contents, but keep counts, in case
         previous SIF comes with actual count info from scanner */
      ret=img2sif(img, &sif, 1, 1, 0, verbose-3);
    } else {
      /* otherwise create SIF contents */
      ret=img2sif(img, &sif, 1, 1, 2, verbose-3);
    }
  } else {
    /* otherwise create SIF contents */
    ret=img2sif(img, &sif, 1, 1, 2, verbose-3);
  }
  if(ret!=0) {
    if(verbose>0) fprintf(stderr, "  Error: cannot create SIF contents.\n");
    imgSetStatus(img, STATUS_CANNOTWRITE);
    sifEmpty(&sif);
    return STATUS_CANNOTWRITE;
  }
  /* Write SIF */
  ret=sifWrite(&sif, siffile);  
  if(ret!=0) {
    if(verbose>0) fprintf(stderr, "  Error: cannot write %s\n", siffile);
    imgSetStatus(img, STATUS_CANNOTWRITE);
    sifEmpty(&sif);
    return STATUS_CANNOTWRITE;
  }
  sifEmpty(&sif);
 
  imgSetStatus(img, STATUS_OK);
  return 0;
}

Referenced by imgWrite().

◆ imgWriteNiftiFrame()

int imgWriteNiftiFrame	(	const char *	dbname,
		int	frame_to_write,
		IMG *	img,
		int	frame_index,
		float	fmin,
		float	fmax,
		int	verbose )

extern

Write one PET frame from IMG data struct into NIfTI file.

This function can be called repeatedly to write all frames one at a time to conserve memory. This function does not write SIF. Single or dual file format is determined based on _fileFormat field in IMG struct. Byte order is the not changed.

Returns: Returns errstatus, which is STATUS_OK (0) when call was successful, and >0 in case of an error.

See also: imgReadNiftiFrame

Parameters

dbname	Name of NIfTI file where IMG contents will be written. If file does not exist, it is created. Make sure to delete existing file, unless you want to add data.
frame_to_write	PET frame number (1..frameNr) which will be written: If set to 0, frame data will be written to an existing or new PET file as a new additional frame, never overwriting existing data. If >0, then frame data is written as specified frame number, overwriting any data existing with the same frame number
img	pointer to the IMG data struct.
frame_index	IMG frame index (0..dimt-1) which will be written.
fmin	minimum pixel value in all frames that will be written; used only when writing the first frame.
fmax	maximum pixel value in all frames that will be written; used only when writing the first frame.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 594 of file img_nii.c.

  {
  IMG test_img;
  NIFTI_DSR dsr;
  int ret=0, fileis=0;
  char imgfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  char tmp[256];
  FILE *fp;
  float *fdata=NULL, *fptr;
 
 
  if(verbose>0) {
    printf("\nimgWriteNiftiFrame(%s, %d, *img, %d, %g, %g, ...)\n",
           dbname, frame_to_write, frame_index, fmin, fmax);
    fflush(stdout);
  }
  /*
   *  Check the input 
   */
  if(dbname==NULL || !dbname[0]) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid filename\n");
    return(STATUS_FAULT);
  }
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    if(img!=NULL) imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid IMG argument\n");
    return(STATUS_FAULT);
  }
  if(frame_index<0 || frame_index>img->dimt-1 || frame_to_write<0) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid frame settings\n");
    return STATUS_FAULT;
  }
  if(img->_fileFormat!=IMG_NIFTI_1D && img->_fileFormat!=IMG_NIFTI_1S) {
    imgSetStatus(img, STATUS_FAULT);
    if(verbose>0) fprintf(stderr, "Error: invalid file format setting\n");
    return STATUS_FAULT;
  }
 
  /*
   *  If NIfTI does not exist, then create it with new header,
   *  and if it does exist, then read and check header information.
   *  Create or edit header to contain correct frame nr.
   *  Determine the global scaling factors.   
   */
  imgInit(&test_img);
  fileis=niftiExists(dbname, hdrfile, imgfile, siffile, &dsr, verbose-2, NULL);
  if(fileis==0) { // not existing
    if(verbose>1) {
      printf("  writing 1st frame to a new file\n"); fflush(stdout);}
 
    /* Create database filenames */
    niftiCreateFNames(dbname, hdrfile, imgfile, siffile, img->_fileFormat);
 
    /* Set main header */
    ret=imgSetNiftiHeader(img, dbname, &dsr, fmin, fmax, verbose-1);
    if(ret!=0) {
      if(verbose>0) fprintf(stderr, "Error: cannot read NIfTI header\n");
      return STATUS_INVALIDHEADER;
    }
    if(frame_to_write==0) frame_to_write=1;
    dsr.h.dim[4]=1;
 
    /* Write NIfTI header */
    ret=niftiWriteHeader(hdrfile, &dsr, verbose-1, tmp);
    if(ret!=0) {
      if(verbose>0) fprintf(stderr, "Error in niftiWriteHeader(): %s\n", tmp);
      return STATUS_CANTWRITEHEADERFILE;
    }
 
    /* Remove dual format datafile if necessary */
    if(img->_fileFormat==IMG_NIFTI_1D)
      if(access(imgfile, 0) != -1) {
        if(verbose>0) printf("  removing %s\n", imgfile);
        remove(imgfile);
      }
 
  } else { /* NIfTI exists */
    if(verbose>1) printf("  adding frame to an existing file\n");
 
    /* Read header information for checking */
    ret=imgGetNiftiHeader(&test_img, &dsr, verbose-1);
    if(ret!=0) {
      if(verbose>0) fprintf(stderr, "Error: cannot read NIfTI header\n");
      imgEmpty(&test_img); return ret;
    }
    /* Check that file format is the same */
    if(img->_fileFormat!=test_img._fileFormat) {
      if(verbose>0) {
        fprintf(stderr, "Error: different file format\n");
        printf("  new._fileFormat:=%d\n", img->_fileFormat);
        printf("  prev._fileFormat:=%d\n", test_img._fileFormat);
      }
      imgEmpty(&test_img); return STATUS_WRONGFILETYPE;
    }
    /* Check also data type, if available */
    if(img->_dataType>0 && test_img._dataType>0 &&
       img->_dataType!=test_img._dataType)
    {
      if(verbose>0) {
        fprintf(stderr, "Error: different datatype\n");
        printf("  new._dataType:=%d\n", img->_dataType);
        printf("  prev._dataType:=%d\n", test_img._dataType);
      }
      imgEmpty(&test_img); return STATUS_WRONGFILETYPE;
    }
    /* Check that matrix sizes are the same */
    if(img->dimz!=test_img.dimz || img->dimx!=test_img.dimx ||
       img->dimy!=test_img.dimy) {
      if(verbose>0) fprintf(stderr, "Error: different matrix size\n");
      imgEmpty(&test_img); return STATUS_VARMATSIZE;}
    imgEmpty(&test_img);
 
    /* Set new frame number in NIfTI header */
    if(frame_to_write==0) frame_to_write=dsr.h.dim[4]+1;
    if(dsr.h.dim[4]<frame_to_write) {
      if(dsr.h.dim[4]+1<frame_to_write) {
        if(verbose>0) fprintf(stderr, "Error: missing matrix\n");
        return STATUS_MISSINGMATRIX;
      }
      dsr.h.dim[4]=frame_to_write;
    }
    /* and save the updated header */
    if((ret=niftiWriteHeader(hdrfile, &dsr, verbose-1, tmp))!=0) {
      if(verbose>0) fprintf(stderr, "Error: %s.\n", tmp);
      return STATUS_NOWRITEPERM;
    }
  }
  if(verbose>2) {
    printf("frame_to_write := %d\n", frame_to_write);
    printf("vox_offset := %d\n", (int)dsr.h.vox_offset);
    printf("hdrfile := %s\n", hdrfile);
    printf("imgfile := %s\n", imgfile);
    printf("siffile := %s\n", siffile);
    printf("magic := %s\n", dsr.h.magic);
  }
 
  /* Open voxel data file, not removing possible old contents like header */
  if(img->_fileFormat==IMG_NIFTI_1D && frame_to_write==1)
    fp=fopen(imgfile, "wb");
  else
    fp=fopen(imgfile, "r+b");
  if(fp==NULL) {
    if(verbose>0) fprintf(stderr, "Error: cannot open %s for write.\n",imgfile);
    return STATUS_CANTWRITEIMGFILE;
  }
 
  /* Move file pointer to the place of current frame */
  long long voxNr=img->dimz*img->dimy*img->dimx;
  if(fseeko(fp, (int)dsr.h.vox_offset+(frame_to_write-1)*voxNr*sizeof(float),
           SEEK_SET)!=0)
  {
    if(verbose>0) fprintf(stderr, "Error: invalid file write position.\n");
    fclose(fp); return STATUS_MISSINGMATRIX;
  }
 
  /* Allocate memory for matrix float data (one plane) */
  fdata=(float*)calloc(voxNr, sizeof(float));
  if(fdata==NULL) {
    if(verbose>0) fprintf(stderr, "Error: out of memory.\n");
    fclose(fp); return STATUS_NOMEMORY;
  }
 
  /* Write voxel values as floats */
  fptr=fdata;
  for(int zi=0; zi<img->dimz; zi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++, fptr++)
        *fptr=img->m[zi][yi][xi][frame_index];
  fptr=fdata;
  if(fwrite(fptr, sizeof(float), voxNr, fp) != (unsigned int)voxNr) {
    if(verbose>0) fprintf(stderr, "Error: disk full or no write permission.\n");
    free(fdata); fclose(fp); return STATUS_CANTWRITEIMGFILE;
  }
  free(fdata);
  fclose(fp);
 
  return STATUS_OK;
}

Referenced by imgWriteFrame(), and imgWriteNifti().

◆ imgWritePolarmap()

int imgWritePolarmap	(	const char *	fname,
		IMG *	img )

extern

Write ECAT 7 polar map.

Parameters

fname	output filename
img	pointer to image structure

Returns: 0 if ok, 1 invalid input, 2 image status is not 'occupied', 3 failed to allocate memory for data, 6 faield to create file, 7 failed to write data, 8 image type not supported, sets IMG->statmsg in case of error

Definition at line 661 of file img_e7.c.

                                                  {
  ECAT7_mainheader main_header;
  ECAT7_polmapheader polmap_header;
  FILE *fp;
  int matrixId, ret;
  float *fdata, *fptr;
 
 
  if(IMG_TEST) printf("imgWritePolarmap(%s, *img)\n", fname);
  if(IMG_TEST>1 && ECAT7_TEST==0) ECAT7_TEST=1;
  /* Check the arguments */
  if(fname==NULL) return(1);
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
  if(img->type!=IMG_TYPE_POLARMAP) {
    imgSetStatus(img, STATUS_FAULT); return(2);}
 
  /* Check image size */
  if(img->dimt>511 || img->dimz>255 || img->dimx>1024 || img->dimy>1024) {
    imgSetStatus(img, STATUS_INVALIDHEADER); return(2);}
 
  /* Initiate headers */
  memset(&main_header, 0, sizeof(ECAT7_mainheader));
  memset(&polmap_header,0, sizeof(ECAT7_polmapheader));
 
  /* Set main header */
  imgSetEcat7MHeader(img, &main_header);
  main_header.bin_size=img->sampleDistance/10.0;
 
  /* Allocate memory for matrix float data */
  long long pxlNr=img->dimx*img->dimy*img->dimz;
  fdata=(float*)malloc(pxlNr*sizeof(float));
  if(fdata==NULL) {imgSetStatus(img, STATUS_NOMEMORY); return(3);}
 
  /* Open file, write main header and initiate matrix list */
  fp=ecat7Create(fname, &main_header);
  if(fp==NULL) {free(fdata); imgSetStatus(img, STATUS_NOWRITEPERM); return(6);}
 
  /* Set (most of) subheader contents */
  imgSetEcat7SHeader(img, &polmap_header);
 
  /* Write each matrix */
  for(int fi=0; fi<img->dimt; fi++) {
 
    /* Create new matrix id (i.e. matnum) */
    matrixId=ecat7_val_to_id(fi+1, 1, 1, 0, 0);
 
    /* Copy matrix pixel values to fdata */
    fptr=fdata;
    for(int pi=0; pi<img->dimz; pi++)
      for(int yi=0; yi<img->dimy; yi++)
        for(int xi=0; xi<img->dimx; xi++)
          if(isfinite(img->m[pi][yi][xi][fi])) *fptr++=img->m[pi][yi][xi][fi]; else *fptr++=0.0;
 
    /* Write subheader and data */
    fptr=fdata;
    polmap_header.frame_start_time=(int)temp_roundf(1000.*img->start[fi]);
    polmap_header.frame_duration=
      (int)temp_roundf(1000.*(img->end[fi]-img->start[fi]));
    /*ecat7PrintImageheader(&image_header, stdout);*/
    ret=ecat7WritePolarmapMatrix(fp, matrixId, &polmap_header, fptr);
    if(ret) {
      if(IMG_TEST) {printf("matrixId=%d ret=%d\n", matrixId, ret);}
      free(fdata); fclose(fp); imgSetStatus(img, STATUS_DISKFULL); return(7);
    }
 
  } /* next matrix */
  free(fdata); fclose(fp);
 
  imgSetStatus(img, STATUS_OK);
  return(0);
}

Referenced by imgWrite().

◆ interfile_read()

int interfile_read	(	char	headerName[256],
		char	searchWord[256],
		char	returnValue[256],
		char	errorMessage[300] )

extern

The function searches the keyword in the header and passes the value belonging to that value back to the main program. The name of the header (string 'headerName') and the requested keyword (string 'searchWord') are passed to the function. It passes back the value of the keyword (string 'returnValue') and possibly an error message or warning (string 'errorMessage'). So the values are passed back as strings. The interpretation (conversion to integer, float, time etc) is up to the programmer.

The interfile header has to comply to the following rules:

first line in the file is '!INTERFILE'
maximal length of a line is 512 characters
A line has two fields sperated by ':=' (keyword := value)
maximal length of keyword and value is 256 characters.
no header entries after a line '!END OF INTERFILE'
a line starting with a semicolon ';' is a comment

Parameters

headerName	header file name
searchWord	keyword to look for
returnValue	value for keyword in header
errorMessage	error message/warnings. In case there is a error message it will be returnd as string in the variable 'errmsg'.

Returns: 0 if ok, 1 keyword appears more than once in the interfile header (value of last occurence of keyword is returned), 2 keyword not found in interfile header (returned value is empty (i.e. contains '/0's only)), 3 interfile header cold not be opened for reading (returned value is empty (i.e. contains '/0's only)), 4 wrong file format?! (No '!INTERFILE' in the first line) (returned value is empty (i.e. contains '/0's only))

Author: Roman Krais

Definition at line 43 of file interfile.c.

  {
  short int  i, pos;
  short int  count=0;    /* counter: How often appears keyword in the header? */
  int        n;
  char       *c[1];
  char       keyword[256], value[256];
  char       line[512];  /* max length of a line accepted in interfile header */
  FILE       *interfileHeader;
 
                                                        /* initialise strings */
  for (i=0;i<256;i++) returnValue[i] = '\0';
  for (i=0;i<300;i++) errorMessage[i] = '\0';
 
  /* open interfile header for reading */
  if ((interfileHeader = fopen(headerName,"r"))==NULL) {
    strcpy(errorMessage,headerName);
    strcat(errorMessage," could not be opened for reading");
    return 3;
  }
 
  /* check from first line if file is really interfile header */
  n=fread(&c,1,1,interfileHeader); if(n<1) {
    strcpy(errorMessage,"wrong file header format?! No '!INTERFILE' at start of ");
    strcat(errorMessage,headerName);
    fclose(interfileHeader);
    return 4;
  }
  i=0;
  memcpy(&line[i],c,1);
  while (memcmp(c,"\n",1) && memcmp(c,"\r",1)) {
    i++;
    n=fread(&c,1,1,interfileHeader); if(n<1) {
      strcpy(errorMessage,"wrong file header format?! No '!INTERFILE' at start of ");
      strcat(errorMessage,headerName);
      fclose(interfileHeader);
      return 4;
    }
    memcpy(&line[i],c,1);
  }
  if (memcmp(line,"!INTERFILE",10)) {
    strcpy(errorMessage,"wrong file header format?! No '!INTERFILE' at start of ");
    strcat(errorMessage,headerName);
    fclose(interfileHeader);
    return 4;
  }
 
 /* read file line by line */
 while (fread(&c,1,1,interfileHeader) == 1) {
    for (i=0;i<512;i++) line[i] = '\0';     /* initialise line */
    for (i=0;i<256;i++) keyword[i] = '\0';  /* initialise keyword */
    for (i=0;i<256;i++) value[i] = '\0';    /* initialise value */
    i=0;
    /* \n = end of line, \r = carriage return. Lines in  ASCII files */
    /* on Sun-Solaris end with \n, on Intel-Windows with \r\n        */
    while (memcmp(c,"\r",1) && memcmp(c,"\n",1) && i<512) {
      memcpy(&line[i],c,1);
      n=fread(&c,1,1,interfileHeader); if(n<1) {
        strcpy(errorMessage,"wrong file header format: ");
        strcat(errorMessage,headerName);
        fclose(interfileHeader);
        return 4;
      }
      i++;
    }
    /* comments are not processed */
    if (strncmp(&line[0],";",1)) {
      /* get keyword and value from line */
      /* find position of the field seperator ':=' */
      for (pos=1; pos<512; pos++)
        if (line[pos] == '=' && line[pos-1] == ':') break; 
      /* now get the first and the second field */
      for (i=0;i<pos-2 && i<256;i++) keyword[i] = line[i];
      for (i=pos+2;i<256+pos+2 && i<512;i++) {
        if (!memcmp(&line[i],"\0",1) || !memcmp(&line[i],"\r",1) || !memcmp(&line[i],"\n",1)) 
          break;      /* stop at the end of "line" */
        value[i-pos-2] = line[i];
      }
      if (!memcmp(keyword,"!END OF INTERFILE",17)) break;     /* are we done? */
      /* check if we found the keyword */
      else if (!strcmp(keyword,searchWord)) {
        strcpy(returnValue,value);
        count++;
      }
    }
  }
  fclose(interfileHeader);   /* done with reading */
  if (count == 0) {
    strcpy(errorMessage,"keyword '");
    strcat(errorMessage,searchWord);
    strcat(errorMessage,"' not found in header");
    return 2;
  }
  if (count > 1) {
    strcpy(errorMessage,"keyword '");
    strcat(errorMessage,searchWord);
    strcat(errorMessage,"' appears more than once in header");
    return 1;
  }
  return 0;
}

◆ interfileExists()

int interfileExists	(	const char *	fname,
		char *	hdrfile,
		char *	imgfile,
		int	verbose )

extern

Check if specified image file name is a Interfile data.

Returns: Returns 0 if it is not, 1 if it is, and both image and header is found.

See also: interfileIsHeader

Author: Vesa Oikonen

Parameters

fname	File name, either header file, image file, or base name without extensions.
hdrfile	If fname is Interfile, then header file name will be written in this char pointer (space needs to allocated by caller); NULL if not needed.
imgfile	If fname is Interfile, then image file name will be written in this char pointer (space needs to allocated by caller); NULL if not needed. Note that file name is stored without path.
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 193 of file interfile.c.

  {
  char *cptr, basefile[FILENAME_MAX], temp[FILENAME_MAX], temp2[FILENAME_MAX];
 
  if(fname==NULL || strlen(fname)==0) return(0);
  if(verbose>0) printf("\n%s(%s, *str, *str, %d)\n", __func__, fname, verbose);
 
  /* Construct the base file name wo extensions */
  strcpy(basefile, fname);
  cptr=strrchr(basefile, '.');
  if(cptr!=NULL) {
    if(strcasecmp(cptr, ".HDR")==0 || strcasecmp(cptr, ".I")==0 )
      *cptr=(char)0;
  } 
  cptr=strrchr(basefile, '.');
  if(cptr!=NULL) {
    if(strcasecmp(cptr, ".I")==0)
      *cptr=(char)0;
  }
  if(verbose>1) printf("\n  basefile := %s\n", basefile);
 
  /* Header file exists? */
  strcpy(temp, basefile); strcat(temp, ".i.hdr");
  if(access(temp, 0) == -1) {
    strcpy(temp, basefile); strcat(temp, ".hdr");
    if(access(temp, 0) == -1) {
      if(verbose>0) printf("\n  hdr file not found or accessible.\n");
      return(0);
    }
  }
  /* Is this Interfile header file? */
  if(interfileIsHeader(temp, temp2) < 2) {
    if(verbose>0)
      printf("\n  %s was not identified as Interfile header file.\n", temp);
    return(0);
  }
  /* Preserve header filename */
  if(hdrfile!=NULL) strcpy(hdrfile, temp);
 
  /* Image file exists? Add path from hdr file */
  cptr=strrchr(temp, '/'); if(cptr==NULL) cptr=strrchr(temp, '\\');
  if(cptr!=NULL) {
    cptr++; *cptr=(char)0; strcat(temp, temp2); strcpy(temp2, temp);} 
  if(strlen(temp2)<1 || access(temp2, 0) == -1) {
    if(verbose>0) printf("\n  %s not found or accessible.\n", temp2);
    return(0);
  }
  /* Preserve image filename */
  if(imgfile!=NULL) strcpy(imgfile, temp2);
 
  return 1;
}

Referenced by imgFormatDetermine().

◆ interfileIsHeader()

int interfileIsHeader	(	const char *	hdrfile,
		char *	imgfile )

extern

Verify that given file is a valid Interfile header file.

Returns: Returns 0 if not, and 1 if it is a valid header file. If image data file name is requested and found in header, then 2 is returned.

See also: interfileExists

Author: Vesa Oikonen

Parameters

hdrfile	Interfile header file name, with correct extension
imgfile	Pointer to allocated string where Interfile image data file name is written if found in header; enter NULL if not needed.

Definition at line 154 of file interfile.c.

  {
  char /*key[256], value[256],*/ temp[FILENAME_MAX];
  IFT ift;
  int li, ret;
 
  //printf("\n%s(%s, *imgfile)\n", __func__, hdrfile);
  if(hdrfile==NULL || strlen(hdrfile)<1) return 0;
  if(imgfile!=NULL) strcpy(imgfile, "");
  iftInit(&ift); strcpy(temp, hdrfile);
  ret=iftRead(&ift, temp, 0, 0);
  if(ret!=0 || ift.keyNr<2) {iftEmpty(&ift); return(0);}
  /* Check that file starts with !INTERFILE */
  //iftWriteItem(&ift, 0, stdout);
  if(ift.item[0].type!='!') {iftEmpty(&ift); return(0);}
  if(strcasecmp(ift.item[0].value, "INTERFILE")!=0) {iftEmpty(&ift); return(0);}
  /* If imgfile was not requested, then we are done */
  if(imgfile==NULL) {iftEmpty(&ift); return(1);}
  /* Find filename for image data */
  //iftWriteItem(&ift, 1, stdout);
  li=iftGetFrom(&ift, 1, "name of data file", 0);
  if(li<0 || strlen(ift.item[li].value)<1) {iftEmpty(&ift); return(1);}
  strcpy(imgfile, ift.item[li].value);
  iftEmpty(&ift);
  return(2);
}

Referenced by interfileExists().

◆ irdCheck()

int irdCheck	(	IMG_RANGE *	r,
		IMG *	img )

extern

Check that image range definition is inside image data. If time frames are zero, then fix those to image frame range.

See also: irdReorder, irdRead

Returns: Returns 0 if successful.

Parameters

r	Pointer to image volume range data.
img	Pointer to image data.

Definition at line 152 of file ird.c.

  {
  if(r==NULL || img==NULL) return(1);
  if(img->dimx<1 || img->dimy<1 || img->dimz<1 || img->dimt<1) return(2);
 
  if(r->x1<1 || r->x1>img->dimx) return(11);
  if(r->x2<1 || r->x2>img->dimx) return(12);
 
  if(r->y1<1 || r->y1>img->dimy) return(21);
  if(r->y2<1 || r->y2>img->dimy) return(22);
 
  if(r->z1<1 || r->z1>img->dimz) return(31);
  if(r->z2<1 || r->z2>img->dimz) return(32);
 
  /* If time frame range is not set, then set it now */
  if(r->f1<1 && r->f2<1) {
    r->f1=1; r->f2=img->dimt;
    return(0);
  }
  /* else check as usual */
  if(r->f1<1 || r->f1>img->dimt) return(41);
  if(r->f2<1 || r->f2>img->dimt) return(42);
  return(0);
}

◆ irdRead()

int irdRead	(	char *	irdfile,
		IMG_RANGE *	img_range,
		char *	status )

extern

Read Image Range Definition File.

Returns: Returns 0 if successful.

See also: irdCheck, string_to_xyzf, irdReorder

Parameters

irdfile	Image Range Definition File name, which contains 4D image volume corners (x y z f) in IFT format: corner1 = x y z f corner2 = x y z f; If time frames (f) are missing, then frame coordinate is set to 0.
img_range	Image volume range
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed

Definition at line 75 of file ird.c.

  {
  int ret, ii;
  IFT ift;
  char key[256];
  IMG_PIXEL v;
 
  /* Check that input is ok */
  if(irdfile==NULL || strnlen(irdfile, 2)<1 || img_range==NULL) {
    if(status!=NULL) strcpy(status, "program error");
    return 1;
  }
  /* Read IDF as IFT file */
  iftInit(&ift); ret=iftRead(&ift, irdfile, 1, 0); if(ret) {
    if(status!=NULL) strcpy(status, ift.status);
    iftEmpty(&ift); return 2;
  }
  /* Try to find keys 'corner1' and 'corner2' */
  strcpy(key, "corner1"); ii=iftGet(&ift, key, 0);
  if(ii>=0) {
    ret=string_to_xyzf(ift.item[ii].value, &v);
    if(ret==0) {
      img_range->x1=v.x; img_range->y1=v.y; img_range->z1=v.z; img_range->f1=v.f;
      strcpy(key, "corner2"); ii=iftGet(&ift, key, 0);
      if(ii>=0) {
        ret=string_to_xyzf(ift.item[ii].value, &v);
        img_range->x2=v.x; img_range->y2=v.y; img_range->z2=v.z; img_range->f2=v.f;
        if(ret==0) {
          irdReorder(img_range);
          if(status!=NULL) strcpy(status, "ok");
          iftEmpty(&ift); return 0;
        }
      }
    }
  }
  /* We are here only if keys were not found */
  /* Lets not care about keys at all */
  for(ii=0, ret=0; ii<ift.keyNr; ii++) {
    if(ret==0 && string_to_xyzf(ift.item[ii].value, &v)==0)
    {
      img_range->x1=v.x; img_range->y1=v.y; img_range->z1=v.z; img_range->f1=v.f;
      ret++; continue;
    }
    if(ret==1 && string_to_xyzf(ift.item[ii].value, &v)==0)
    {
      img_range->x2=v.x; img_range->y2=v.y; img_range->z2=v.z; img_range->f2=v.f;
      ret++; break;
    }
  }
  if(ret<2) {
    if(status!=NULL) strcpy(status, "volume definitions not found");
    iftEmpty(&ift); return 2;
  }
 
  irdReorder(img_range);
  if(status!=NULL) strcpy(status, "ok");
  iftEmpty(&ift);
  return 0;
}

◆ irdReorder()

int irdReorder ( IMG_RANGE * img_range )

extern

Reorder Image Range Definition.

See also: vrdReorder

Function name was previously ifrReorder

Returns: Returns 0 if successful.

Parameters

img_range Image volume range; start and end range are set in correct order

Definition at line 44 of file ird.c.

  {
  int i;
 
  /* Check that input is ok */
  if(img_range==NULL) return 1;
  /* Change the order if necessary */
  if(img_range->x1<0 || img_range->x2<0) return 2;
  if(img_range->x2<img_range->x1) {
    i=img_range->x1; img_range->x1=img_range->x2; img_range->x2=i;}
  if(img_range->y1<0 || img_range->y2<0) return 3;
  if(img_range->y2<img_range->y1) {
    i=img_range->y1; img_range->y1=img_range->y2; img_range->y2=i;}
  if(img_range->z1<0 || img_range->z2<0) return 4;
  if(img_range->z2<img_range->z1) {
    i=img_range->z1; img_range->z1=img_range->z2; img_range->z2=i;}
  if(img_range->f1<0 || img_range->f2<0) return 5;
  if(img_range->f2<img_range->f1) {
    i=img_range->f1; img_range->f1=img_range->f2; img_range->f2=i;}
 
  return 0;
}

Referenced by irdRead().

◆ mat_numcod()

int mat_numcod	(	int	frame,
		int	plane,
		int	gate,
		int	data,
		int	bed )

extern

Returns the matrix identifier

Parameters

frame	frame number [0..4096]
plane	plane number [0..256]
gate	gate number [0..64]
data	data number [0..8]
bed	bed position [0..16]

Returns: matrix identifier coding

Definition at line 242 of file ecat63ml.c.

  {
  return((frame&0xFFF)|((bed&0xF)<<12)|((plane&0xFF)<<16)|
         ((gate&0x3F)<<24)|((data&0x3)<<30));
}

Referenced by atnMake(), ecat63AddImg(), ecat63GatherMatlist(), ecat63WriteAllImg(), and imgWriteEcat63Frame().

◆ mat_numdoc()

void mat_numdoc	(	int	matnum,
		Matval *	matval )

extern

Conversion of matrix identifier to numerical values

Parameters

matnum	matrix identifier coding
matval	target matrix value structure

Definition at line 254 of file ecat63ml.c.

  {
  matval->frame = matnum&0xFFF;
  matval->plane = (matnum>>16)&0xFF;
  matval->gate  = (matnum>>24)&0x3F;
  matval->data  = (matnum>>30)&0x3;
  matval->bed   = (matnum>>12)&0xF;
}

Referenced by atnMake(), ecat63AddImg(), ecat63DeleteLateFrames(), ecat63GatherMatlist(), ecat63GetNums(), ecat63GetPlaneAndFrameNr(), ecat63PrintMatlist(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat63SortMatlistByFrame(), ecat63SortMatlistByPlane(), ecat6PrintSubheader(), imgReadEcat63Frame(), roi_mframe(), and roi_mplane().

◆ niftiCreateFNames()

int niftiCreateFNames	(	const char *	filename,
		char *	hdrfile,
		char *	imgfile,
		char *	siffile,
		int	fileformat )

extern

Construct the file names for NIfTI image.

Returns: Returns 0 if successful, otherwise <>0.

See also: niftiExists

Parameters

filename	Filename, either header file, image file, or base name without extensions, but possibly with path name. This string is never modified.
hdrfile	Header filename will be written in this char pointer (space needs to allocated by caller); If header and image are combined, then this will be the name of combined file; enter NULL if not needed.
imgfile	Image filename will be written in this char pointer (space needs to allocated by caller); If header and image are combined, then this will be the name of combined file; enter NULL if not needed.
siffile	SIF filename will be written in this char pointer (space needs to allocated by caller); enter NULL if not needed.
fileformat	NIfTI file format, either IMG_NIFTI_1D (31) or IMG_NIFTI_1S (32).

Definition at line 44 of file nifti.c.

  {
  int n;
  char basename[FILENAME_MAX];
 
  if(hdrfile!=NULL) strcpy(hdrfile, "");
  if(imgfile!=NULL) strcpy(imgfile, "");
  if(siffile!=NULL) strcpy(siffile, "");
  n=strlen(filename); if(n<1 || n>=FILENAME_MAX) {return(1);}
  strlcpy(basename, filename, FILENAME_MAX); 
  niftiRemoveFNameExtension(basename);
  
  /* Create database filenames */
  if(fileformat==IMG_NIFTI_1D) {
    if(hdrfile!=NULL) snprintf(hdrfile, FILENAME_MAX, "%s.hdr", basename);
    if(imgfile!=NULL) snprintf(imgfile, FILENAME_MAX, "%s.img", basename);
  } else if(fileformat==IMG_NIFTI_1S) {
    if(hdrfile!=NULL) snprintf(hdrfile, FILENAME_MAX, "%s.nii", basename);
    if(imgfile!=NULL) snprintf(imgfile, FILENAME_MAX, "%s.nii", basename);
  } else
    return(2);
  if(siffile!=NULL) snprintf(siffile, FILENAME_MAX, "%s.sif", basename);
  return(0);
}

Referenced by imgWriteNifti(), imgWriteNiftiFrame(), and niftiRemove().

◆ niftiExists()

int niftiExists	(	const char *	filename,
		char *	hdrfile,
		char *	imgfile,
		char *	siffile,
		NIFTI_DSR *	header,
		int	verbose,
		char *	status )

extern

Verify if specified filename is a NIfTI file.

Returns: Returns 0 if it is not, 1 if header and image data are found (either as one combined file or as separate files, and 2, if SIF is found too.

See also: niftiRemove

Parameters

filename	Filename, either header file, image file, or base name without extensions. This string is never modified.
hdrfile	If filename refers to a Nifti file, then header filename will be written in this char pointer (space needs to allocated by caller); If header and image are combined, then this will be the name of combined file; enter NULL if not needed.
imgfile	If filename refers to a Nifti file, then image filename will be written in this char pointer (space needs to allocated by caller); If header and image are combined, then this will be the name of combined file; enter NULL if not needed.
siffile	If filename refers to a Nifti file, and if SIF exists, then SIF filename will be written in this char pointer (space needs to allocated by caller); NULL if not needed.
header	Pointer to Nifti header, which is filled in this function; enter NULL, if not needed.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed.

Definition at line 160 of file nifti.c.

  {
  char basefile[FILENAME_MAX], temp[FILENAME_MAX], localhdrfile[FILENAME_MAX];
  NIFTI_DSR *dsr, local_dsr;
  int ret, combined=0; 
 
  if(filename==NULL || strlen(filename)==0) return(0);
  if(verbose>0) {printf("\nniftiExists(%s, ...)\n", filename); fflush(stdout);}
  if(status!=NULL) strcpy(status, "OK");
  if(header==NULL) dsr=&local_dsr; else dsr=header;
 
  localhdrfile[0]=(char)0;
 
  /* Construct the base file name wo extensions */
  strlcpy(basefile, filename, FILENAME_MAX); 
  niftiRemoveFNameExtension(basefile);
  if(verbose>1) printf("\n  basefile := %s\n", basefile);
 
  /* Combined header and image file exists? */
  strcpy(temp, basefile); strcat(temp, ".nii");
  if(access(temp, 0) == -1) {
    if(verbose>0) printf("  %s not found or accessible.\n", temp);
  } else {
    /* Preserve header and image filenames */
    strcpy(localhdrfile, temp);
    if(hdrfile!=NULL) strcpy(hdrfile, temp);
    if(imgfile!=NULL) strcpy(imgfile, temp);
    combined=1;
    if(verbose>1) printf("  %s is accessible.\n", temp);
  }
 
  /* If not, then check if header file exists */
  if(combined==0) {
    strcpy(temp, basefile); strcat(temp, ".hdr");
    if(access(temp, 0) == -1) {
      strcpy(temp, basefile); strcat(temp, ".img.hdr");
      if(access(temp, 0) == -1) {
        if(verbose>0) printf("  hdr file not found or accessible.\n");
        if(status!=NULL) strcpy(status, "file not accessible");
        return(0);
      }
    }
    /* Preserve header filename */
    strcpy(localhdrfile, temp);
    if(hdrfile!=NULL) strcpy(hdrfile, temp);
    if(verbose>1) printf("  %s is accessible.\n", temp);
  }
 
  /* If not combined, then does image file exists? */
  if(combined==0) {
    strcpy(temp, basefile); strcat(temp, ".img");
    if(access(temp, 0) == -1) {
      if(verbose>0) printf("  %s not found or accessible.\n", temp);
      if(status!=NULL) strcpy(status, "file not accessible");
      return(0);
    }
    /* Preserve image filename */
    if(imgfile!=NULL) strcpy(imgfile, temp);
    if(verbose>1) printf("  %s is accessible.\n", temp);
  }
 
  /* Is this Nifti file? */
  if((ret=niftiReadHeader(localhdrfile, dsr, verbose, temp))!=0) {
    if(status!=NULL) strcpy(status, "file is not Nifti");
    if(verbose>0) {
      printf("  %s was not identified as Nifti header file (%d).\n", localhdrfile, ret);
      printf("  %s\n", temp);
    }
    return(0);
  }
  if(verbose>1) printf("  %s is identified as Nifti.\n", localhdrfile);
  if(verbose>10) niftiPrintHeader(dsr, stdout);
 
  /* SIF exists? */
  strcpy(temp, basefile); strcat(temp, ".sif");
  if(verbose>3) printf("  checking if %s exists\n", temp);
  if(access(temp, 0) == -1) {
    strcpy(temp, basefile); strcat(temp, ".img.sif");
    if(verbose>3) printf("  checking if %s exists\n", temp);
    if(access(temp, 0) == -1) {
      strcpy(temp, basefile); strcat(temp, ".nii.sif");
      if(verbose>3) printf("  checking if %s exists\n", temp);
      if(access(temp, 0) == -1) {
        if(verbose>0) printf("\n  SIF not found or accessible.\n");
        if(siffile!=NULL) strcpy(siffile, "");
        if(status!=NULL) {
          if(combined) strcpy(status, "combined Nifti file is accessible");
          else strcpy(status, "Nifti files are accessible");
        }
        return(1); // but otherwise ok
      }
    }
  }
  /* Preserve SIF filename */
  if(siffile!=NULL) strcpy(siffile, temp);
  if(verbose>1) printf("  %s is accessible.\n", temp);
  if(status!=NULL) {
    if(combined) strcpy(status, "combined Nifti file and SIF are accessible");
    else strcpy(status, "Nifti files and SIF are accessible");
  }
  return(2);
}

Referenced by imgFormatDetermine(), imgRead(), imgReadNiftiFrame(), imgReadNiftiHeader(), and imgWriteNiftiFrame().

◆ niftiPrintHeader()

int niftiPrintHeader	(	NIFTI_DSR *	dsr,
		FILE *	fp )

extern

Print the contents of Nifti header to specified file pointer.

Returns: Returns 0 if ok, 1 if invalid input.

Parameters

dsr	Pointer to combined Nifti header.
fp	File pointer where header information is printed.

Definition at line 501 of file nifti.c.

  {
  int i;
  char *cptr, tmp[256];
 
  /* Check input */
  if(fp==NULL || dsr==NULL) return(1);
 
  fprintf(fp, "Nifti header:\n");
 
  /* Byte order */
  if(dsr->byte_order==0) strcpy(tmp, "big"); else strcpy(tmp, "little");
  fprintf(fp, "byte_order := %s endian\n", tmp);
  /* sizeof_hdr */
  fprintf(fp, "sizeof_hdr := %d\n", dsr->h.sizeof_hdr);
  /* data_type */
  strncpy(tmp, dsr->h.data_type, 10); tmp[10]=(char)0;
  cptr=tmp; while(*cptr) {if(!isprint(cptr[0])) cptr[0]=' '; cptr++;}
  fprintf(fp, "data_type := %s\n", tmp);
  /* db_name */
  strncpy(tmp, dsr->h.db_name, 18); tmp[18]=(char)0;
  cptr=tmp; while(*cptr) {if(!isprint(*cptr)) *cptr=' '; cptr++;}
  fprintf(fp, "db_name := %s\n", tmp);
  /* extents */
  fprintf(fp, "extents := %d\n", dsr->h.extents);
  /* session_error */
  fprintf(fp, "session_error := %d\n", dsr->h.session_error);
  /* regular */
  fprintf(fp, "regular := %d\n", dsr->h.regular);
  /* dim_info */
  fprintf(fp, "dim_info := %d\n", dsr->h.dim_info);
 
  /* Data array dimensions */
  i=0; fprintf(fp, "dim := {%d", dsr->h.dim[i]);
  for(i=1; i<8; i++) fprintf(fp, ", %d", dsr->h.dim[i]);
  fprintf(fp, "}\n");
 
  /* Intent parameters */
  fprintf(fp, "intent_p1 := %g\n", dsr->h.intent_p1);
  fprintf(fp, "intent_p2 := %g\n", dsr->h.intent_p2);
  fprintf(fp, "intent_p3 := %g\n", dsr->h.intent_p3);
  fprintf(fp, "intent_code := %d\n", dsr->h.intent_code);
 
  /*  */
  fprintf(fp, "datatype := %d\n", dsr->h.datatype);
  fprintf(fp, "bitpix := %d\n", dsr->h.bitpix);
  fprintf(fp, "slice_start := %d\n", dsr->h.slice_start);
  i=0; fprintf(fp, "pixdim := {%g", dsr->h.pixdim[i]);
  for(i=1; i<8; i++) fprintf(fp, ", %g", dsr->h.pixdim[i]);
  fprintf(fp, "}\n");
  fprintf(fp, "vox_offset := %g\n", dsr->h.vox_offset);
  fprintf(fp, "scl_slope := %g\n", dsr->h.scl_slope);
  fprintf(fp, "scl_inter := %g\n", dsr->h.scl_inter);
  fprintf(fp, "slice_end := %d\n", dsr->h.slice_end);
  fprintf(fp, "slice_code := %d\n", dsr->h.slice_code);
  fprintf(fp, "xyzt_units := %d\n", dsr->h.xyzt_units);
  fprintf(fp, "cal_max := %g\n", dsr->h.cal_max);
  fprintf(fp, "cal_min := %g\n", dsr->h.cal_min);
  fprintf(fp, "slice_duration := %g\n", dsr->h.slice_duration);
  fprintf(fp, "toffset := %g\n", dsr->h.toffset);
  fprintf(fp, "glmax := %d\n", dsr->h.glmax);
  fprintf(fp, "glmin := %d\n", dsr->h.glmin);
 
  /* Study description */
  strncpy(tmp, dsr->h.descrip, 80); tmp[80]=(char)0;
  cptr=tmp; while(*cptr) {if(!isprint(*cptr)) *cptr=' '; cptr++;}
  fprintf(fp, "descrip := %s\n", tmp);
  strncpy(tmp, dsr->h.aux_file, 24); tmp[24]=(char)0;
  cptr=tmp; while(*cptr) {if(!isprint(*cptr)) *cptr=' '; cptr++;}
  fprintf(fp, "aux_file := %s\n", tmp);
 
  /* Transformation parameters */
  fprintf(fp, "qform_code := %d\n", dsr->h.qform_code);
  fprintf(fp, "sform_code := %d\n", dsr->h.sform_code);
  fprintf(fp, "quatern_b := %g\n", dsr->h.quatern_b);
  fprintf(fp, "quatern_c := %g\n", dsr->h.quatern_c);
  fprintf(fp, "quatern_d := %g\n", dsr->h.quatern_d);
  fprintf(fp, "qoffset_x := %g\n", dsr->h.qoffset_x);
  fprintf(fp, "qoffset_y := %g\n", dsr->h.qoffset_y);
  fprintf(fp, "qoffset_z := %g\n", dsr->h.qoffset_z);
  i=0; fprintf(fp, "srow_x := {%g", dsr->h.srow_x[i]);
  for(i=1; i<4; i++) fprintf(fp, ", %g", dsr->h.srow_x[i]);
  fprintf(fp, "}\n");
  i=0; fprintf(fp, "srow_y := {%g", dsr->h.srow_y[i]);
  for(i=1; i<4; i++) fprintf(fp, ", %g", dsr->h.srow_y[i]);
  fprintf(fp, "}\n");
  i=0; fprintf(fp, "srow_z := {%g", dsr->h.srow_z[i]);
  for(i=1; i<4; i++) fprintf(fp, ", %g", dsr->h.srow_z[i]);
  fprintf(fp, "}\n");
 
  strncpy(tmp, dsr->h.intent_name, 16); tmp[16]=(char)0;
  cptr=tmp; while(*cptr) {if(!isprint(*cptr)) *cptr=' '; cptr++;}
  fprintf(fp, "intent_name := %s\n", tmp);
 
  /* Nifti magic number */
  fprintf(fp, "magic := %s\n", dsr->h.magic);
 
  /* Nifti header extender */
  i=0; fprintf(fp, "extension := {%d", dsr->e.extension[i]);
  for(i=1; i<4; i++) fprintf(fp, ", %d", dsr->e.extension[i]);
  fprintf(fp, "}\n");
 
  fflush(fp);
  return(0);
}

Referenced by niftiExists().

◆ niftiReadHeader()

int niftiReadHeader	(	char *	filename,
		NIFTI_DSR *	dsr,
		int	verbose,
		char *	status )

extern

Read Nifti header contents. Currently, does not read Nifti-1 header extension.

Returns: Returns 0, if successful, otherwise >0.

See also: niftiReadImagedata, niftiWriteHeader, niftiExists

Parameters

filename	Name of file to read (including path and extension)
dsr	Pointer to previously allocated header structure
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed

Definition at line 293 of file nifti.c.

  {
  FILE *fp;
  int little; // 1 if current platform is little endian (x86), else 0
  int same_order, extender=0;
  unsigned char buf[NIFTI_HEADER_SIZE];
  short int s;
 
  /* Check arguments */
  if(filename==NULL || strlen(filename)==0 || dsr==NULL) return(1);
  if(verbose>0) {
    printf("\nniftiReadHeader(%s, ...)\n", filename); fflush(stdout);}
  if(status!=NULL) strcpy(status, "OK");
  little=little_endian(); if(verbose>3) printf("  little := %d\n", little);
 
  /* Open file */
  fp=fopen(filename, "rb"); if(fp==NULL) {
    if(status!=NULL) strcpy(status, "cannot open file");
    if(verbose>0) fprintf(stderr, "Error: cannot open file %s\n", filename);
    return(2);
  }
 
  /* Read Nifti header */
  if(fread(buf, NIFTI_HEADER_SIZE, 1, fp)<1) {
    if(status!=NULL) strcpy(status, "complete Nifti header not found");
    if(verbose>0)
      fprintf(stderr, "Error: invalid Nifti header file %s\n", filename);
    return(3);
  }
  /* Read nifti1 extender */
  for(int n=0; n<4; n++) dsr->e.extension[n]=(char)0;
  if(fread(dsr->e.extension, 4, 1, fp)<1) {
    if(status!=NULL) strcpy(status, "complete Nifti header not found");
    if(verbose>1)
      fprintf(stdout, "Nifti header extender not found in %s\n", filename);
    extender=0;
  } else {
    extender=1;
  }
  /* Close file */
  fclose(fp);
 
  /* Read Nifti Magic number */
  memcpy(dsr->h.magic, buf+344, 4);
  if(strcasecmp(dsr->h.magic, "ni1")==0) {
    if(verbose>1) {printf("  separate hdr and img files.\n"); fflush(stdout);}
  } else if(strcasecmp(dsr->h.magic, "n+1")==0) {
    if(verbose>1) printf("  combined hdr and img data.\n");
  } else {
    if(status!=NULL) strcpy(status, "Nifti magic number not found");
    if(verbose>0) {
      fprintf(stderr, "Error: not a Nifti header file %s\n", filename);
      fflush(stderr);
    }
    if(verbose>2) {
      printf("magic := {%d, %d, %d, %d}\n", dsr->h.magic[0], dsr->h.magic[1],
              dsr->h.magic[2], dsr->h.magic[3]);
    } 
    return(4);
  }
  if(verbose>1) printf("  Nifti Magic number := %s\n", dsr->h.magic);
  /* Check that 4-byte header extender was found, if magic number is n+1 */
  if(strcasecmp(dsr->h.magic, "n+1")==0 && extender==0) {
    if(status!=NULL) strcpy(status, "Nifti header extender not found");
    if(verbose>0) {
      fprintf(stderr, "Error: not valid Nifti n+1 header file %s\n", filename);
      fflush(stderr);
    }
    return(5);
  }
  
  /* Determine from dim[0] if file is big or little endian */
  memcpy(&s, buf+40, 2); if(verbose>10) printf("  s := %d\n", s);
  if(s>0 && s<8) { // same order in file and current machine
    dsr->byte_order=little;
    same_order=1;
  } else {
    swabip(&s, 2); if(verbose>10) printf("  s := %d\n", s);
    if(s>0 && s<8) { // opposite order in file and in current machine
      if(little==1) dsr->byte_order=0; else dsr->byte_order=1;
      same_order=0;
    } else {
      if(status!=NULL) strcpy(status, "invalid Nifti byte order");
      if(verbose>0)
        fprintf(stderr, "Error: not a valid Nifti header file %s\n", filename);
      return(6);
    }
  }
  if(verbose>1) printf("  Nifti byte order := %d\n", dsr->byte_order);
 
  /* Size of header */
  {
    int n=0;
    memcpy(&n, buf+0, 4); if(!same_order) swawbip(&n, 4);
    if(n!=348) {
      if(status!=NULL) strcpy(status, "invalid Nifti sizeof_hdr");
      if(verbose>0)
        fprintf(stderr, "Error: not a valid Nifti header file %s\n", filename);
      return(7);
    }
    dsr->h.sizeof_hdr=n;
  }
 
  /*  */
  memcpy(&dsr->h.data_type, buf+4, 10);
  memcpy(&dsr->h.db_name, buf+14, 18);
  if(!same_order) swawbip(buf+32, 4);
  memcpy(&dsr->h.extents, buf+32, 4);
  if(!same_order) swabip(buf+36, 2);
  memcpy(&dsr->h.session_error, buf+36, 2);
  memcpy(&dsr->h.regular, buf+38, 1);
  memcpy(&dsr->h.dim_info, buf+39, 1);
 
  /* dim */
  if(!same_order) swabip(buf+40, 16);
  memcpy(dsr->h.dim, buf+40, 16);
  /* intent parameters */
  if(!same_order) swawbip(buf+56, 4);
  memcpy(&dsr->h.intent_p1, buf+56, 4);
  if(!same_order) swawbip(buf+60, 4);
  memcpy(&dsr->h.intent_p2, buf+60, 4);
  if(!same_order) swawbip(buf+64, 4);
  memcpy(&dsr->h.intent_p3, buf+64, 4);
  if(!same_order) swabip(buf+68, 2);
  memcpy(&dsr->h.intent_code, buf+68, 2);
 
  /*  */
  if(!same_order) swabip(buf+70, 2);
  memcpy(&dsr->h.datatype, buf+70, 2);
  if(!same_order) swabip(buf+72, 2);
  memcpy(&dsr->h.bitpix, buf+72, 2);
  if(!same_order) swabip(buf+74, 2);
  memcpy(&dsr->h.slice_start, buf+74, 2);
  if(!same_order) swawbip(buf+76, 32);
  memcpy(dsr->h.pixdim, buf+76, 32);
  if(!same_order) swawbip(buf+108, 4);
  memcpy(&dsr->h.vox_offset, buf+108, 4);
  if(!same_order) swawbip(buf+112, 4);
  memcpy(&dsr->h.scl_slope, buf+112, 4);
  if(!same_order) swawbip(buf+116, 4);
  memcpy(&dsr->h.scl_inter, buf+116, 4);
  if(!same_order) swabip(buf+120, 2);
  memcpy(&dsr->h.slice_end, buf+120, 2);
  memcpy(&dsr->h.slice_code, buf+122, 1);
  memcpy(&dsr->h.xyzt_units, buf+123, 1);
  if(!same_order) swawbip(buf+124, 4);
  memcpy(&dsr->h.cal_max, buf+124, 4);
  if(!same_order) swawbip(buf+128, 4);
  memcpy(&dsr->h.cal_min, buf+128, 4);
  if(!same_order) swawbip(buf+132, 4);
  memcpy(&dsr->h.slice_duration,buf+132,4);
  if(!same_order) swawbip(buf+136, 4);
  memcpy(&dsr->h.toffset, buf+136, 4);
  if(!same_order) swawbip(buf+140, 4);
  memcpy(&dsr->h.glmax, buf+140, 4);
  if(!same_order) swawbip(buf+144, 4);
  memcpy(&dsr->h.glmin, buf+144, 4);
 
  /* study description */
  memcpy(&dsr->h.descrip, buf+148, 80);
  /* Auxiliary filename */
  memcpy(&dsr->h.aux_file, buf+228, 24);
 
  /* Transformation parameters */
  if(!same_order) swabip(buf+252, 2);
  memcpy(&dsr->h.qform_code, buf+252, 2);
  if(!same_order) swabip(buf+254, 2);
  memcpy(&dsr->h.sform_code, buf+254, 2);
  if(!same_order) swawbip(buf+256, 4);
  memcpy(&dsr->h.quatern_b, buf+256, 4);
  if(!same_order) swawbip(buf+260, 4);
  memcpy(&dsr->h.quatern_c, buf+260, 4);
  if(!same_order) swawbip(buf+264, 4);
  memcpy(&dsr->h.quatern_d, buf+264, 4);
  if(!same_order) swawbip(buf+268, 4);
  memcpy(&dsr->h.qoffset_x, buf+268, 4);
  if(!same_order) swawbip(buf+272, 4);
  memcpy(&dsr->h.qoffset_y, buf+272, 4);
  if(!same_order) swawbip(buf+276, 4);
  memcpy(&dsr->h.qoffset_z, buf+276, 4);
  if(!same_order) swawbip(buf+280, 16);
  memcpy(dsr->h.srow_x, buf+280, 16);
  if(!same_order) swawbip(buf+296, 16);
  memcpy(dsr->h.srow_y, buf+296, 16);
  if(!same_order) swawbip(buf+312, 16);
  memcpy(dsr->h.srow_z, buf+312, 16);
 
  memcpy(&dsr->h.intent_name, buf+328, 16);
 
  if(status!=NULL) strcpy(status, "complete Nifti header was read");
  if(verbose>0) fflush(stdout);
  return(0);
}

Referenced by niftiExists().

◆ niftiReadImagedata()

int niftiReadImagedata	(	FILE *	fp,
		NIFTI_DSR *	dsr,
		int	frame,
		float *	data,
		int	verbose,
		char *	status )

extern

Read Nifti image data, convert byte order if necessary, and scale values to floats. Reads only one frame at a time!

Returns: Returns 0 if successful, >1 in case of an error, and specifically -1 in case that contents after the last image frame was requested.

See also: niftiReadHeader

Parameters

fp	File pointer to start of image data file, opened previously in binary mode.
dsr	Pointer to previously filled Nifti header structure
frame	Frame number to read [1..number of frames].
data	Pointer to image float data allocated previously for dimzdimydimx floats.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed.

Definition at line 619 of file nifti.c.

  {
  int dimNr, dimx, dimy, dimz=1, dimt=1;
  int little;
  char *mdata, *mptr;
  float *fptr, ss, si;
  short int *sptr;
  int *iptr;
  double d;
 
 
  if(verbose>0) {
    printf("niftiReadImagedata(fp, h, %d, data, %d)\n", frame, verbose);
    fflush(stdout);
  }
  /* Check the arguments */
  if(status!=NULL) sprintf(status, "invalid function input");
  if(frame<=0 || fp==NULL || dsr==NULL || data==NULL) return(1);
 
  /* Get the image data start location from header, in case of single file
     format */
  long long start_pos;
  {
    long long int s=0;
    if(strcasecmp(dsr->h.magic, "n+1")==0) s=(int)dsr->h.vox_offset; 
    if(s<0) start_pos=-s; else start_pos=s;
  }
  if(verbose>2) printf("  image_start_pos := %llu\n", start_pos);
  /* edit it later to move to the correct frame */
 
  /* Get the image dimensions from header */
  if(status!=NULL) sprintf(status, "invalid image dimensions");
  dimNr=dsr->h.dim[0]; if(dimNr<2 || dimNr>4) return(2);
  dimx=dsr->h.dim[1];
  dimy=dsr->h.dim[2];
  if(dimNr>2) dimz=dsr->h.dim[3];
  if(dimNr>3) dimt=dsr->h.dim[4];
  if(frame>dimt) return(-1);
  long long pxlNr=dimx*dimy*dimz; if(pxlNr<1) return(4);
 
  // data_type is unused in Nifti
  /* Check that datatype is supported */
  if(verbose>1) printf("  verifying datatype %d\n", dsr->h.datatype);
  {
    int n=0;
    if(dsr->h.datatype & NIFTI_DT_RGB) n+=NIFTI_DT_RGB;
    if(dsr->h.datatype & NIFTI_DT_COMPLEX) n+=NIFTI_DT_COMPLEX;
    if(dsr->h.datatype & NIFTI_DT_BINARY) n+=NIFTI_DT_BINARY;
    if(dsr->h.datatype==NIFTI_DT_UNKNOWN) n+=512;
    if(n!=0) {
      if(verbose>0) printf("datatype error %d\n", n);
      if(status!=NULL) sprintf(status, "unsupported pixel datatype %d", dsr->h.datatype);
      return(6);
    }
  }
 
  /* Allocate memory for the binary data */
  if(verbose>1) printf("  allocating memory for binary data\n");
  if(status!=NULL) sprintf(status, "invalid pixel data format");
  if(dsr->h.bitpix==0) { // Carimas Nifti Writer does not set bitpix
    if(dsr->h.datatype==NIFTI_DT_UNSIGNED_SHORT) dsr->h.bitpix=16;
  }
  if(dsr->h.bitpix<8) return(5); // We don't support bit data
  long long rawSize=pxlNr*(dsr->h.bitpix/8); if(rawSize<1) return(6);
  if(verbose>1) printf("  pxlNr=%lld  rawSize=%lld\n", pxlNr, rawSize);
  if(status!=NULL) sprintf(status, "out of memory");
  mdata=(char*)malloc(rawSize); if(mdata==NULL) return(11);
 
  /* Seek the start of current frame data */
  if(verbose>1) printf("  seeking file position\n");
  start_pos+=(frame-1)*rawSize;
  if(verbose>2) printf("start_pos=%lld\n", start_pos);
  fseeko(fp, start_pos, SEEK_SET);
  if(ftello(fp)!=start_pos) {
    if(status!=NULL) sprintf(status, "could not move to start_pos %lld", start_pos);
    free(mdata); return(7);
  }
 
  /* Read the data */
  if(verbose>1) printf("  reading binary data\n");
  mptr=mdata;
  {
    size_t n=fread(mptr, rawSize, 1, fp);
    if(n<1) {
      if(status!=NULL)
        sprintf(status, "could read only %zu bytes when request was %lld", n, rawSize);
      free(mdata); return(8);
    }
  }
 
  /* Convert byte order if necessary */
  little=little_endian(); mptr=mdata;
  if(little!=dsr->byte_order) {
    if(verbose>0) printf("byte conversion\n");
    switch(dsr->h.bitpix) {
      case 8: /* no conversion needed */ break;
      case 16: swabip(mptr, rawSize); break;
      case 32: swawbip(mptr, rawSize); break;
      case 64: swawbip(mptr, rawSize); break;
      default:
        if(verbose>5) printf("unsupported nifti bitpix := %d\n", dsr->h.bitpix);
        sprintf(status, "unsupported nifti bitpix := %d", dsr->h.bitpix);
        free(mdata); return(5);
    }
  }
 
  /* Get scaling factors */
  ss=dsr->h.scl_slope; if(ss==0) ss=1.0;
  si=dsr->h.scl_inter;
 
  /* Copy data to float pixel values */
  if(verbose>1) printf("  conversion to floating point voxel values\n");
  mptr=mdata;
  switch(dsr->h.datatype) {
    case NIFTI_DT_UNSIGNED_CHAR:
      if(dsr->h.bitpix!=8) {
        if(status!=NULL)
          sprintf(status, "invalid combination of datatype and bitpix (%d, %d)",
            dsr->h.datatype, dsr->h.bitpix);
        free(mdata); return(5);
      }
      fptr=data;
      for(long long i=0; i<pxlNr; i++, mptr++, fptr++)
        *fptr=si+ss*(float)(*mptr);
      break;
    case NIFTI_DT_UNSIGNED_SHORT:
      if(dsr->h.bitpix!=16) {
        if(status!=NULL)
          sprintf(status, "invalid combination of datatype and bitpix (%d, %d)",
            dsr->h.datatype, dsr->h.bitpix);
        free(mdata); return(5);
      }
      fptr=data;
      for(long long i=0; i<pxlNr; i++, mptr+=2, fptr++) {
        unsigned short int *uptr=(unsigned short int*)mptr; *fptr=si+ss*(float)(*uptr);
      }
      break;
    case NIFTI_DT_SIGNED_SHORT:
      if(dsr->h.bitpix!=16) {
        if(status!=NULL)
          sprintf(status, "invalid combination of datatype and bitpix (%d, %d)",
            dsr->h.datatype, dsr->h.bitpix);
        free(mdata); return(5);
      }
      fptr=data;
      for(long long i=0; i<pxlNr; i++, mptr+=2, fptr++) {
        sptr=(short int*)mptr; *fptr=si+ss*(float)(*sptr);
      }
      break;
    case NIFTI_DT_SIGNED_INT:
      if(dsr->h.bitpix!=16 && dsr->h.bitpix!=32) {
        if(status!=NULL)
          sprintf(status, "invalid combination of datatype and bitpix (%d, %d)",
            dsr->h.datatype, dsr->h.bitpix);
        free(mdata); return(5);
      }
      fptr=data;
      if(dsr->h.bitpix==16) {
        for(long long i=0; i<pxlNr; i++, mptr+=2, fptr++) {
          iptr=(int*)mptr; *fptr=si+ss*(float)(*iptr);
        }
      } else if(dsr->h.bitpix==32) {
        for(long long i=0; i<pxlNr; i++, mptr+=4, fptr++) {
          iptr=(int*)mptr; *fptr=si+ss*(float)(*iptr);
        }
      }
      break;
    case NIFTI_DT_FLOAT: // 16
      if(dsr->h.bitpix==32) {
        fptr=data; memcpy(fptr, mptr, pxlNr*4);
        fptr=data; for(long long i=0; i<pxlNr; i++, fptr++) *fptr*=ss;
        fptr=data; for(long long i=0; i<pxlNr; i++, fptr++) *fptr+=si;
      } else {
        if(status!=NULL)
          sprintf(status, "invalid combination of datatype and bitpix (%d, %d)",
            dsr->h.datatype, dsr->h.bitpix);
        free(mdata); return(5);
      }
      break;
    case NIFTI_DT_DOUBLE:
      if(dsr->h.bitpix!=64) {
        if(status!=NULL)
          sprintf(status, "invalid combination of datatype and bitpix (%d, %d)",
            dsr->h.datatype, dsr->h.bitpix);
        free(mdata); return(5);
      }
      fptr=data;
      for(long long i=0; i<pxlNr; i++, mptr+=8, fptr++) {
        memcpy(&d, mptr, 8); *fptr=si+ss*d;
      }
      break;
    default:
      if(status!=NULL)
        sprintf(status, "unsupported pixel datatype %d", dsr->h.datatype);
      free(mdata); return(5);
  }
 
  if(verbose>1) {printf("  data read successfully.\n"); fflush(stdout);}
  free(mdata);
  if(status!=NULL) sprintf(status, "ok");
  return 0;
}

Referenced by imgReadNiftiFrame().

◆ niftiRemove()

int niftiRemove	(	const char *	dbname,
		int	fileformat,
		int	verbose )

extern

Remove header and voxel data files or the single .nii file belonging to specified NIfTI database.

SIF is not deleted in any case. Validity of NIfTI is not verified, therefore this can be used to delete any files with similar name as NIfTI would have.

Returns: Returns 0 when call was successful, otherwise <>0. Call is considered successful, if files do not exist initially.

See also: niftiExists, niftiRemoveFNameExtension

Parameters

dbname	NIfTI database name with path, possibly with filename extension
fileformat	NIfTI file format, either IMG_NIFTI_1D (31) or IMG_NIFTI_1S (32), or IMG_UNKNOWN (0) in case both are to be deleted.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 100 of file nifti.c.

  {
  if(verbose>0) {
    printf("niftiRemove(%s, %d, ...)\n", dbname, fileformat);
    fflush(stdout);
  }
 
  char imgfile[FILENAME_MAX], hdrfile[FILENAME_MAX], siffile[FILENAME_MAX];
  int errNr=0;
  int ret=niftiCreateFNames(dbname, hdrfile, imgfile, siffile, fileformat);
  if(ret==0 && fileformat==IMG_NIFTI_1D) { // dual format
    if(access(hdrfile, 0)!=-1) {
      if(verbose>1) {printf("  removing %s\n", hdrfile); fflush(stdout);}
      if(remove(hdrfile)!=0) errNr++;
    }
    if(access(imgfile, 0)!=-1) {
      if(verbose>1) {printf("  removing %s\n", imgfile); fflush(stdout);}
      if(remove(imgfile)!=0) errNr++;
    }
  } else if(ret==0 && fileformat==IMG_NIFTI_1S) { // single format
    if(access(imgfile, 0)!=-1) {
      if(verbose>1) {printf("  removing %s\n", imgfile); fflush(stdout);}
      if(remove(imgfile)!=0) errNr++;
    }
  } else { // dual and single formats
    ret=niftiCreateFNames(dbname, hdrfile, imgfile, siffile, IMG_NIFTI_1D);
    if(ret!=0) return 1;
    if(access(hdrfile, 0)!=-1) {
      if(verbose>1) {printf("  removing %s\n", hdrfile); fflush(stdout);}
      if(remove(hdrfile)!=0) errNr++;
    }
    if(access(imgfile, 0)!=-1) {
      if(verbose>1) {printf("  removing %s\n", imgfile); fflush(stdout);}
      if(remove(imgfile)!=0) errNr++;
    }
 
    ret=niftiCreateFNames(dbname, hdrfile, imgfile, siffile, IMG_NIFTI_1S);
    if(ret!=0) return 1;
    if(access(imgfile, 0)!=-1) {
      if(verbose>1) {printf("  removing %s\n", imgfile); fflush(stdout);}
      if(remove(imgfile)!=0) errNr++;
    }
  }
  return errNr;
}

Referenced by imgWriteNifti().

◆ niftiRemoveFNameExtension()

void niftiRemoveFNameExtension ( char * fname )

extern

Remove any extensions from Nifti file name, leaving only base file name.

See also: niftiCreateFNames, niftiExists, niftiRemove

Parameters

fname Full name of file.

Definition at line 23 of file nifti.c.

  {
  char *cptr;
  cptr=strrchr(fname, '.'); if(cptr==NULL) return;
  if(strcasecmp(cptr, ".")==0 || strcasecmp(cptr, ".img")==0 ||
     strcasecmp(cptr, ".hdr")==0 || strcasecmp(cptr, ".sif")==0 ||
     strcasecmp(cptr, ".nii")==0)
       *cptr=(char)0;
  /* Remove also double extensions, e.g. from data.img.hdr */
  cptr=strrchr(fname, '.'); if(cptr==NULL) return;
  if(strcasecmp(cptr, ".img")==0 || strcasecmp(cptr, ".nii")==0) *cptr=(char)0;
}

Referenced by imgReadNiftiFrame(), imgReadNiftiHeader(), niftiCreateFNames(), and niftiExists().

◆ niftiWriteHeader()

int niftiWriteHeader	(	char *	filename,
		NIFTI_DSR *	dsr,
		int	verbose,
		char *	status )

extern

Write NIfTI-1 header contents.

Currently, does not write header extension. Header field 'byte_order' is used to determine the required byte order.

Returns: Returns 0, if successful, otherwise >0.

See also: niftiReadHeader, imgWriteNifti

Parameters

filename	Name of file to write (including path and extension).
dsr	Pointer to previously allocated header structure.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed.

Definition at line 844 of file nifti.c.

  {
  FILE *fp;
  int little; // 1 if current platform is little endian (x86), else 0
  int same_order;
  unsigned char buf1[NIFTI_HEADER_SIZE];
  unsigned char buf2[NIFTI_HEADER_EXTENDER_SIZE];
  unsigned char *bptr;
 
 
  if(verbose>0) {
    printf("\nniftiWriteHeader(%s, ...)\n", filename); fflush(stdout);
  }
 
  /* Check arguments */
  if(status!=NULL) strcpy(status, "invalid function input");
  if(filename==NULL || strlen(filename)==0 || dsr==NULL) return(1);
  /* Check magic number */
  if(strcmp(dsr->h.magic, "ni1")!=0 && strcmp(dsr->h.magic, "n+1")!=0)
    return(1);
 
  /* Check if byte swapping is needed */
  little=little_endian(); if(verbose>3) printf("  little := %d\n", little);
  if(little==dsr->byte_order) same_order=1; else same_order=0;
 
  /* Make sure that buffers are all zeroes to begin with */
  memset(buf1, 0, sizeof(NIFTI_HEADER_SIZE));
  memset(buf2, 0, sizeof(NIFTI_HEADER_EXTENDER_SIZE));
 
  /* Copy header contents into buffer */
  if(verbose>2) printf("  setting write buffer\n");
  bptr=buf1+0;
  memcpy(bptr, &dsr->h.sizeof_hdr, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+4;
  memcpy(bptr, &dsr->h.data_type, 10);
  bptr=buf1+14;
  memcpy(bptr, &dsr->h.db_name, 18);
  bptr=buf1+32;
  memcpy(bptr, &dsr->h.extents, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+36;
  memcpy(bptr, &dsr->h.session_error, 2); if(!same_order) swabip(bptr, 2);
  bptr=buf1+38;
  memcpy(bptr, &dsr->h.regular, 1);
  bptr=buf1+39;
  memcpy(bptr, &dsr->h.dim_info, 1);
 
  bptr=buf1+40;
  memcpy(bptr, dsr->h.dim, 16); if(!same_order) swabip(bptr, 16);
  bptr=buf1+56;
  memcpy(bptr, &dsr->h.intent_p1, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+60;
  memcpy(bptr, &dsr->h.intent_p2, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+64;
  memcpy(bptr, &dsr->h.intent_p3, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+68;
  memcpy(bptr, &dsr->h.intent_code, 2); if(!same_order) swabip(bptr, 2);
  bptr=buf1+70;
  memcpy(bptr, &dsr->h.datatype, 2); if(!same_order) swabip(bptr, 2);
  bptr=buf1+72;
  memcpy(bptr, &dsr->h.bitpix, 2); if(!same_order) swabip(bptr, 2);
  bptr=buf1+74;
  memcpy(bptr, &dsr->h.slice_start, 2); if(!same_order) swabip(bptr, 2);
  bptr=buf1+76;
  memcpy(bptr, dsr->h.pixdim, 32); if(!same_order) swawbip(bptr, 32);
  bptr=buf1+108;
  memcpy(bptr, &dsr->h.vox_offset, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+112;
  memcpy(bptr, &dsr->h.scl_slope, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+116;
  memcpy(bptr, &dsr->h.scl_inter, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+120;
  memcpy(bptr, &dsr->h.slice_end, 2); if(!same_order) swabip(bptr, 2);
  bptr=buf1+122;
  memcpy(bptr, &dsr->h.slice_code, 1);
  bptr=buf1+123;
  memcpy(bptr, &dsr->h.xyzt_units, 1);
  bptr=buf1+124;
  memcpy(bptr, &dsr->h.cal_max, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+128;
  memcpy(bptr, &dsr->h.cal_min, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+132;
  memcpy(bptr, &dsr->h.slice_duration, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+136;
  memcpy(bptr, &dsr->h.toffset, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+140;
  memcpy(bptr, &dsr->h.glmax, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+144;
  memcpy(bptr, &dsr->h.glmin, 4); if(!same_order) swawbip(bptr, 4);
 
  bptr=buf1+148;
  memcpy(bptr, dsr->h.descrip, 80);
  bptr=buf1+228;
  memcpy(bptr, dsr->h.aux_file, 24);
  bptr=buf1+252;
  memcpy(bptr, &dsr->h.qform_code, 2); if(!same_order) swabip(bptr, 2);
  bptr=buf1+254;
  memcpy(bptr, &dsr->h.sform_code, 2); if(!same_order) swabip(bptr, 2);
  bptr=buf1+256;
  memcpy(bptr, &dsr->h.quatern_b, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+260;
  memcpy(bptr, &dsr->h.quatern_c, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+264;
  memcpy(bptr, &dsr->h.quatern_d, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+268;
  memcpy(bptr, &dsr->h.qoffset_x, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+272;
  memcpy(bptr, &dsr->h.qoffset_y, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+276;
  memcpy(bptr, &dsr->h.qoffset_z, 4); if(!same_order) swawbip(bptr, 4);
  bptr=buf1+280;
  memcpy(bptr, dsr->h.srow_x, 16); if(!same_order) swawbip(bptr, 16);
  bptr=buf1+296;
  memcpy(bptr, dsr->h.srow_y, 16); if(!same_order) swawbip(bptr, 16);
  bptr=buf1+312;
  memcpy(bptr, dsr->h.srow_z, 16); if(!same_order) swawbip(bptr, 16);
  bptr=buf1+328;
  memcpy(bptr, dsr->h.intent_name, 16);
  bptr=buf1+344;
  memcpy(bptr, dsr->h.magic, 4);
 
  /* Open header file for write; do not delete old contents, since this
     function may be called to update single format NIfTI */
  if(strcmp(dsr->h.magic, "ni1")==0) { // dual file format
    if(verbose>2) printf("  creating NIfTI header %s\n", filename);
    fp=fopen(filename, "wb");
  } else if(access(filename, 0)==-1) { // single file format, not exists
    if(verbose>2) printf("  creating NIfTI header %s\n", filename);
    fp=fopen(filename, "wb");
  } else { // single file format, exists already
    if(verbose>2) printf("  opening NIfTI header %s\n", filename);
    fp=fopen(filename, "r+b");
  }
  if(fp==NULL) {
    if(status!=NULL) strcpy(status, "cannot open Nifti header for write");
    return(2);
  }
 
  /* Write header */
  if(verbose>2) printf("  writing NIfTI header\n");
  if(fwrite(buf1, 1, NIFTI_HEADER_SIZE, fp) != NIFTI_HEADER_SIZE) {
    if(status!=NULL) strcpy(status, "cannot write Nifti header");
    fclose(fp); return(3);
  }
 
  /* Write extender, if necessary (leave the contents 0 0 0 0 for now) */
  if(verbose>2) printf("  writing NIfTI extender\n");
  if(fwrite(buf2, 1, NIFTI_HEADER_EXTENDER_SIZE, fp)!= NIFTI_HEADER_EXTENDER_SIZE) {
    if(status!=NULL) strcpy(status, "cannot write Nifti header extender");
    fclose(fp); return(3);
  }
 
  fclose(fp);
 
  if(verbose>2) {printf("  complete Nifti header was written\n"); fflush(stdout);}
  if(status!=NULL) strcpy(status, "complete Nifti header was written");
  return(0);
}

Referenced by imgWriteNiftiFrame().

◆ pxlAdd()

int pxlAdd	(	IMG_PIXELS *	list,
		IMG_PIXEL *	pxl )

extern

Add given pixel into IMG_PIXELS data.

Returns: 0 if successful.

Author: Vesa Oikonen

See also: pxlInit, pxlFree, pxlAllocate, pxlMakeRoom, pxlRm, pxlRead, pxlWrite

Parameters

list	Pointer to IMG_PIXELS struct, which must be initiated. Memory is added if needed, and pxlNr increased.
pxl	Pointer to IMG_PIXEL struct to add.

Definition at line 139 of file pixel.c.

  {
  if(list==NULL || pxl==NULL) return(1);
  int ret;
  if((ret=pxlAllocateMore(list, 1))!=0) return(ret);
  list->p[list->pxlNr].x=pxl->x;
  list->p[list->pxlNr].y=pxl->y;
  list->p[list->pxlNr].z=pxl->z;
  list->p[list->pxlNr].f=pxl->f;
  list->pxlNr++;
  return(0);
}

Referenced by imgMaskFloodFill().

◆ pxlAddFromMask()

long long int pxlAddFromMask	(	IMG_PIXELS *	list,
		IMG *	img )

extern

Add pixel(s) from mask image into IMG_PIXELS data.

Returns: the nr of added pixels.

See also: pxlInit, pxlFree, pxlAdd

Author: Vesa Oikonen

Parameters

list	Pointer to IMG_PIXELS struct, which must be initiated. Memory is added if needed, and pxlNr increased.
img	Pointer to mask image.

Definition at line 185 of file pixel.c.

  {
  if(list==NULL || img==NULL) return(1);
  if(img->dimz<1 || img->dimy<1 || img->dimx<1 || img->dimt<1) return(0);
  long long int n=0;
  for(int zi=0; zi<img->dimz; zi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++)
        if(fabs(img->m[zi][yi][xi][0])>=0.5) n++;
  if(n==0) return(0);
  if(pxlAllocateMore(list, n)!=0) return(0);
  for(int zi=0; zi<img->dimz; zi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++)
        if(fabs(img->m[zi][yi][xi][0])>=0.5) {
          list->p[list->pxlNr].x=1+xi;
          list->p[list->pxlNr].y=1+yi;
          list->p[list->pxlNr].z=1+zi;
          list->p[list->pxlNr].f=0;
          list->pxlNr++;
        }
  return(n);
}

◆ pxlAllocate()

int pxlAllocate	(	IMG_PIXELS *	pxl,
		long long int	pxlNr )

extern

Allocate memory for IMG_PIXELS data. Any previous contents are deleted. Return Returns 0 when successful.

See also: pxlInit, pxlAllocateMore, pxlFree

Parameters

pxl	Pointer to initiated IMG_PIXELS struct data; any old contents are deleted. pxlNr inside the struct is set to or kept at zero.
pxlNr	Nr of pixels to allocate

Definition at line 44 of file pixel.c.

  {
  if(pxl==NULL) return(1);
  /* Delete any previous contents */
  pxlFree(pxl);
  /* If no memory is requested, then just return */
  if(pxlNr<1) return(0);
 
  /* Allocate memory for IMG_PIXEL data */
  pxl->p=(IMG_PIXEL*)malloc(pxlNr*sizeof(IMG_PIXEL));
  if(pxl->p==NULL) return(2);
  for(long long int i=0; i<pxlNr; i++) {
    pxl->p[i].x=pxl->p[i].y=pxl->p[i].z=pxl->p[i].f=0;
  }
  pxl->_pxlNr=pxlNr;
  return(0);
}

Referenced by pxlAllocateMore().

◆ pxlAllocateMore()

int pxlAllocateMore	(	IMG_PIXELS *	pxl,
		long long int	pxlNr )

extern

Allocate memory for more IMG_PIXELS data. Any previous contents are preserved. Return Returns 0 when successful.

See also: pxlInit, pxlFree, pxlAllocate, pxlMakeRoom

Parameters

pxl	Pointer to initiated IMG_PIXELS struct data; any old contents are preserved, but existing data is not required. pxlNr inside the struct is set to or kept at zero.
pxlNr	Nr of additional pixels to allocate; if struct contains unused space for requested pixels already, then nothing is done.

Definition at line 74 of file pixel.c.

  {
  if(pxl==NULL) return(1);
  /* If no memory is requested, then just return */
  if(pxlNr<1) return(0);
  /* If none allocated previously then use pxlAllocate */
  if(pxl->_pxlNr==0) return(pxlAllocate(pxl, pxlNr));
  /* Check if there is enough space already */
  long long int newPxlNr, addPxlNr;
  newPxlNr=pxl->pxlNr+pxlNr; addPxlNr=newPxlNr-pxl->_pxlNr;
  if(addPxlNr<=0) return(0);
  /* Reallocate */
  IMG_PIXEL *pxlPtr;
  pxlPtr=realloc(pxl->p, sizeof(IMG_PIXEL)*newPxlNr);
  if(pxlPtr==NULL) return(2);
  pxl->p=pxlPtr;
  for(int i=pxl->_pxlNr; i<newPxlNr; i++)
    pxl->p[i].x=pxl->p[i].y=pxl->p[i].z=pxl->p[i].f=0;
  pxl->_pxlNr=newPxlNr;
  return(0);
}

Referenced by pxlAdd(), pxlAddFromMask(), pxlMakeRoom(), and pxlRead().

◆ pxlFree()

void pxlFree ( IMG_PIXELS * pxl )

extern

Free memory allocated for IMG_PIXELS. All data is cleared.

See also: pxlInit, pxlAllocate

Parameters

pxl	Pointer to IMG_PIXELS struct

Definition at line 28 of file pixel.c.

  {
  if(pxl==NULL) return;
  free(pxl->p);
  pxlInit(pxl);
}

Referenced by imgMaskFloodFill(), and pxlAllocate().

◆ pxlGet()

int pxlGet	(	IMG_PIXELS *	list,
		long long int	i,
		IMG_PIXEL *	pxl )

extern

Get a pixel from IMG_PIXELS list.

See also: pxlInit, pxlFree, pxlAllocate, pxlMakeRoom, pxlAdd, pxlRead

Returns: 0 if successful.

Parameters

list	Pointer to IMG_PIXELS struct, containing the list of pixels.
i	Pixel list index [0..list->pxlNr-1].
pxl	Pointer to IMG_PIXEL struct into which pixel coordinates are written.

Definition at line 163 of file pixel.c.

  {
  if(list==NULL || pxl==NULL || i<0 || i>=list->pxlNr) return(1);
  pxl->x=list->p[i].x;
  pxl->y=list->p[i].y;
  pxl->z=list->p[i].z;
  return(0);
}

Referenced by imgMaskFloodFill().

◆ pxlInit()

void pxlInit ( IMG_PIXELS * pxl )

extern

Initiate the IMG_PIXELS struct before any use.

See also: pxlAllocate, pxlFree

Author: Vesa Oikonen

Parameters

pxl	Pointer to IMG_PIXELS

Definition at line 14 of file pixel.c.

  {
  if(pxl==NULL) return;
  pxl->pxlNr=pxl->_pxlNr=0;
  pxl->p=NULL;
}

Referenced by imgMaskFloodFill(), and pxlFree().

◆ pxlMakeRoom()

int pxlMakeRoom	(	IMG_PIXELS *	list,
		long long int	i,
		long long int	n )

extern

Make room for new pixels in the IMG_PIXELS list, allocating more memory if needed. Previous contents are preserved but moved in the list.

See also: pxlAllocateMore

Returns: 0 if successful.

Parameters

list	Pointer to IMG_PIXELS struct with existing contents.
i	Index [0..pxlNr] of the new room start position.
n	Nr of empty list items to add.

Definition at line 110 of file pixel.c.

  {
  if(list==NULL || i>list->pxlNr) return(1);
  /* Check whether anything needs to be added */
  if(n<1) return(0);
  /* If user wanted room in the end, then just add the memory */
  if(i==list->pxlNr) return(pxlAllocateMore(list, n));
  /* Otherwise, first add the space */
  if(pxlAllocateMore(list, n)!=0) return(2);
  /* and the move previous data forward in the list */
  for(long long int li=list->pxlNr-1; li>=i; li--) list->p[li+n]=list->p[li];
  /* and add pxlNr */
  list->pxlNr+=n;
  return(0);
}

Referenced by imgMaskFloodFill().

◆ pxlMove()

void pxlMove	(	IMG_PIXELS *	list,
		long long int	from,
		long long int	to )

extern

Move pixel from one slot to another inside IMG_PIXELS data, changing the position of others accordingly.

See also: pxlInit, pxlFree, pxlAllocate, pxlRm, pxlMakeRoom

Parameters

list	Pointer to IMG_PIXELS struct, which must be initiated.
from	Index [0.._pxlNr-1] of source position.
to	Index [0.._pxlNr-1] of target position.

Definition at line 220 of file pixel.c.

  {
  if(list==NULL || from<0 || to<0) return;
  if(from>=list->_pxlNr || to>=list->_pxlNr) return;
  if(from==to) return;
  long long int i=from;
  IMG_PIXEL tmp=list->p[from];
  if(from>to) {
    for(long long int i=from; i>to; i--) list->p[i]=list->p[i-1];
  } else {
    for(long long int i=from; i<to; i++) list->p[i]=list->p[i+1];
  }
  list->p[i]=tmp;
  return;
}

Referenced by pxlRm().

◆ pxlRead()

int pxlRead	(	IMG_PIXELS *	pxl,
		const char *	fname,
		char *	status )

extern

Read IMG_PIXELS data from specified file.

See also: pxlInit, pxlFree, pxlWrite

Returns: 0 if successful.

Author: Vesa Oikonen

Parameters

pxl	Pointer to IMG_PIXELS struct, into which contents of file are to be added; call pxlInit() once before using this function.
fname	Pointer to the file name; this string is not modified.
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed

Definition at line 331 of file pixel.c.

  {
  if(pxl==NULL) {
    if(status!=NULL) strcpy(status, "program error");
    return(1);
  }
  int i, c, n, longest, ret;
 
  /* Try to read the file */
  FILE *fp;
  fp=fopen(fname, "r");
  if(fp==NULL) {
    if(status!=NULL) strcpy(status, "cannot open file");
    return(2);
  }
  /* Get the length of the longest line */
  i=longest=0; 
  while((c=fgetc(fp))!=EOF) {
    if(c==10 || c==13) {if(i>longest) longest=i; i=0;} else i++;
  }
  if(i>longest) longest=i;
  rewind(fp); longest+=1;
  /* and allocate memory for string of that length */
  char *line, buf[20];
  line=(char*)malloc((longest+1)*sizeof(char));
  if(line==NULL) {
    if(status!=NULL) strcpy(status, "out of memory");
    fclose(fp); return(3);
  }
  /* Allocate space for a few pixels */
  if(pxlAllocateMore(pxl, 10)!=0) {
    if(status!=NULL) strcpy(status, "out of memory");
    fclose(fp); free(line); return(3);    
  }
  /* Read data lines */
  while(fgets(line, longest, fp)!=NULL) {
    /* forget comment lines */
    if(line[0]=='#') continue;
    /* get nr of tokens on this line */
    n=strTokenNr(line, " ,;\t\n\r"); if(n==0) continue;
    if(n<3 || n>4) { 
      if(status!=NULL) strcpy(status, "invalid format");
      fclose(fp); free(line); return(4);
    }
    /* Allocate more memory if necessary */
    if(pxl->pxlNr==pxl->_pxlNr) {
      if(pxlAllocateMore(pxl, 10)!=0) {
        if(status!=NULL) strcpy(status, "out of memory");
        fclose(fp); free(line); return(3);    
      }
    }
    /* Read the pixel coordinates */
    ret=0; //printf("line := %s", line); printf("n := %d\n", n);
    for(i=0; i<n; i++) {
      if(strTokenNCpy(line, " ,;\t\n\r", 1+i, buf, 20)<1) {ret=1; break;}
      //printf("  buf := %s\n", buf);
      if((ret=atoi_with_check(buf, &c))!=0) break;
      if(i==0) pxl->p[pxl->pxlNr].x=c;
      else if(i==1) pxl->p[pxl->pxlNr].y=c;
      else if(i==2) pxl->p[pxl->pxlNr].z=c;
      else if(i==3) pxl->p[pxl->pxlNr].f=c;
    }  
    if(ret) {
      if(status!=NULL) strcpy(status, "invalid coordinate");
      fclose(fp); free(line); return(4);
    }
    pxl->pxlNr++;
  }
  fclose(fp); free(line);
  return(0);
}

◆ pxlRm()

int pxlRm	(	IMG_PIXELS *	list,
		long long int	index )

extern

Remove specified pixel from IMG_PIXELS data.

Returns: 0 if successful.

Author: Vesa Oikonen

See also: pxlInit, pxlFree, pxlRmDuplicates, pxlAdd, pxlAllocate, pxlMakeRoom, pxlGet

Parameters

list	Pointer to IMG_PIXELS struct, which must be initiated. Allocated memory is not reduced, but pxlNr is decreased.
index	Index [0..pxlNr-1] of pixel to delete.

Definition at line 249 of file pixel.c.

  {
  if(list==NULL || index<0) return(1);
  if(index>=list->pxlNr) return(0);
  /* If last one, then just decrease the pxlNr */
  if(index==list->pxlNr-1) {list->pxlNr--; return(0);}
  /* Otherwise move it to the last place and then decrease the pxlNr */
  pxlMove(list, index, list->pxlNr-1);
  list->pxlNr--; 
  return(0);
}

Referenced by pxlRmDuplicates().

◆ pxlRmDuplicates()

long long int pxlRmDuplicates ( IMG_PIXELS * list )

extern

Remove duplicates from IMG_PIXELS data.

Returns: the nr of removed pixels.

Author: Vesa Oikonen

See also: pxlInit, pxlFree, pxlRm, pxlAdd, pxlAllocate, pxlMakeRoom, pxlGet

Parameters

list	Pointer to IMG_PIXELS struct, which must be initiated. Allocated memory is not reduced, but pxlNr is decreased.

Definition at line 273 of file pixel.c.

  {
  if(list==NULL || list->pxlNr<2) return(0);
  long long int i=list->pxlNr-1, j, n=0;
  while(i>0) {
    for(j=0; j<i; j++) {
      if(list->p[i].z!=list->p[j].z) continue;
      if(list->p[i].x!=list->p[j].x) continue;
      if(list->p[i].y!=list->p[j].y) continue;
      pxlRm(list, i); n++; break;
    }
    i--;
  }
  return(n);
}

◆ pxlWrite()

int pxlWrite	(	IMG_PIXELS *	pxl,
		FILE *	fp,
		char *	status )

extern

Write IMG_PIXELS data into specified file.

Returns: 0 if successful.

Author: Vesa Oikonen

See also: pxlRead, pxlFree, pxlGet, pxlAdd

Parameters

pxl	Pointer to IMG_PIXELS struct, contents of which are to be written
fp	Output file pointer
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed

Definition at line 299 of file pixel.c.

  {
  if(pxl==NULL || pxl->pxlNr<1 || pxl->p==NULL) {
    if(status!=NULL) strcpy(status, "no pixels to write");
    return(1);
  }
  int n=7;
  for(long long i=0; i<pxl->pxlNr && n>6; i++) 
    n=fprintf(fp, "%d,%d,%d,%d\n", 
              pxl->p[i].x, pxl->p[i].y, pxl->p[i].z, pxl->p[i].f);
  if(n<7) {
    if(status!=NULL) strcpy(status, "cannot write pixels into file");
    return(2);
  }
  if(status!=NULL) strcpy(status, "ok");
  return(0);
}

◆ sif2img()

int sif2img	(	SIF *	sif,
		IMG *	img,
		int	copy_header,
		int	copy_frames,
		int	copy_counts,
		int	verbose )

extern

Set IMG contents based on data in SIF.

Returns: Returns 0 if successful.

Parameters

sif	Pointer to SIF struct from which content is copied to IMG.
img	Pointer to IMG. Must be initiated with imgInit(), and allocated if frame time or count information is to be copied.
copy_header	Select whether SIF header contents are copied (1) or not (0)
copy_frames	Select whether SIF frame times are copied (1) or not (0).
copy_counts	Select whether SIF count contents are copied (1) or not (0).
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 13 of file img_sif.c.

  {
  if(verbose>0)
    printf("sif2img(sif, img, %d, %d, %d, ...)\n", copy_header, copy_frames, copy_counts);
  if(img==NULL || sif==NULL) return 1;
 
  if(copy_header) {
    if(verbose>1) printf("  copying header.\n");
    img->scanStart=sif->scantime;
    img->isotopeHalflife=60.0*hlFromIsotope(sif->isotope_name);
    if(strlen(sif->studynr)>0 && strcmp(sif->studynr, ".")!=0)
      strlcpy(img->studyNr, sif->studynr, MAX_STUDYNR_LEN+1);
    else
      strcpy(img->studyNr, "");
  }
 
  if(copy_frames) {
    if(verbose>1) printf("  copying frame times.\n");
    if(sif->frameNr!=img->dimt) return(3);
    for(int fi=0; fi<img->dimt; fi++) {
      img->start[fi]=sif->x1[fi];
      img->end[fi]=sif->x2[fi];
      img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
    }
  }
 
  if(copy_counts) {
    if(verbose>1) printf("  copying count data.\n");
    if(sif->frameNr!=img->dimt) return(3);
    if(sif->colNr<4) return(4);
    for(int fi=0; fi<img->dimt; fi++) {
      img->prompts[fi]=sif->prompts[fi];
      img->randoms[fi]=sif->randoms[fi];
      img->weight[fi]=sif->weights[fi];
    }
  }
 
  return 0;
}

Referenced by imgReadAnalyze().

◆ sifEmpty()

void sifEmpty ( SIF * data )

extern

Free memory allocated for SIF. All contents are destroyed.

See also: sifInit, sifSetmem

Parameters

data	Pointer to sif data struct.

Definition at line 33 of file sif.c.

  {
  if(SIF_TEST) printf("sifEmpty()\n");
  if(data==NULL) return;
  if(data->frameNr>0) {
    free((char*)(data->x1)); free((char*)(data->x2));
    free((char*)(data->prompts)); free((char*)(data->randoms));
    free((char*)(data->trues)); free((char*)(data->weights));
    data->frameNr=data->colNr=0;
  }
  data->scantime=(time_t)0; data->version=0;
  strcpy(data->studynr, ""); strcpy(data->isotope_name, "");
}

Referenced by imgReadAnalyze(), imgReadAnalyzeFrame(), imgReadAnalyzeHeader(), imgReadModelingData(), imgReadNiftiFrame(), imgReadNiftiHeader(), imgSetWeights(), imgWriteNifti(), sifAllocateWithIMG(), sifRead(), and sifSetmem().

◆ sifExistentCounts()

int sifExistentCounts ( SIF * sif )

extern

Verify that SIF contains prompts and randoms.

Returns: Returns 0 if neither prompts or randoms can be found, 1 or 2 if prompts or randoms can be found, and 3 if both prompts and randoms are there.

See also: sifInit, sifRead, sifWeight

Parameters

sif	Pointer to SIF struct

Definition at line 207 of file weight.c.

  {
  int fi, p=0, r=0;
  double v1, v2;
  if(sif==NULL || sif->frameNr<1) return 0;
  /* If just one frame, then value > 0 is fine */
  if(sif->frameNr==1) {
    if(sif->prompts[0]>0.00000001) p=1;
    if(sif->randoms[0]>0.00000001) r=2;
    return(p+r);
  }
  /* Otherwise, check also that frames have different count level */
  for(fi=1; fi<sif->frameNr; fi++) {
    v1=sif->prompts[fi]-sif->prompts[fi-1]; if(fabs(v1)>0.001) p=1;
    v2=sif->randoms[fi]-sif->randoms[fi-1]; if(fabs(v2)>0.001) r=2;
    if((p+r)>2) break;
  }
  return(p+r);
}

◆ sifInit()

void sifInit ( SIF * data )

extern

Initiate SIF structure. This should be called once before first use.

See also: sifEmpty, sifRead, sifSetmem

Parameters

data	Pointer to sif data struct.

Definition at line 17 of file sif.c.

  {
  if(SIF_TEST) printf("sifInit()\n");
  if(data==NULL) return;
  memset(data, 0, sizeof(SIF));
  data->frameNr=data->colNr=0;
}

Referenced by imgReadAnalyze(), imgReadAnalyzeFrame(), imgReadAnalyzeHeader(), imgReadModelingData(), imgReadNiftiFrame(), imgReadNiftiHeader(), imgSetWeights(), imgWriteAnalyze(), and imgWriteNifti().

◆ sifModerateTrues()

void sifModerateTrues	(	SIF *	sif,
		double	limit )

extern

Moderate the trues in SIF.

True values in SIF are used to calculate weight factors for time frames. If trues are very low in certain frames, the weight factors in other frames may become very low. This function finds the maximum trues, and adds max/limit to each trues value, if min trues < max trues / limit. Negative trues are always eliminated.

See also: sifWeight, sifModerateWeights, sifRead, sifWrite, sifWeightNorm

Parameters

sif	Pointer to SIF in which the trues are moderated
limit	Max trues / limit is added to all trues values; 100.0 might be good

Definition at line 131 of file weight.c.

  {
  if(SIF_TEST) printf("sifModerateTrues(*sif, %g)\n", limit);
 
  if(sif==NULL || sif->frameNr<2) return;
  if(limit<=1.0) return;
 
  int fi;
  double w, f;
  for(w=f=sif->trues[0], fi=1; fi<sif->frameNr; fi++) {
    if(sif->trues[fi]>w) w=sif->trues[fi];
    else if(sif->trues[fi]<f) f=sif->trues[fi];
  }
  if(f*limit<w) {
    for(w/=limit, fi=0; fi<sif->frameNr; fi++)
      if(sif->trues[fi]>0.0) sif->trues[fi]+=w; else sif->trues[fi]=w;
  } else {
    for(fi=0; fi<sif->frameNr; fi++)
      if(sif->trues[fi]<0.0) sif->trues[fi]=0.0;
  }
}

Referenced by imgSetWeights().

◆ sifModerateWeights()

void sifModerateWeights	(	SIF *	sif,
		double	limit )

extern

Moderate the weights in SIF.

This function finds the maximum weight, and adds max/limit to each weight value (except if weight is 0), if min weight < max/limit. Negative weights are set to zero.

See also: sifWeight, sifModerateTrues, sifRead, sifWrite, sifWeightNorm

Parameters

sif	Pointer to SIF in which the weights are moderated
limit	Max weight / limit is added to all weights; 100.0 might be good

Definition at line 167 of file weight.c.

  {
  if(SIF_TEST) printf("sifModerateWeights(*sif, %g)\n", limit);
 
  if(sif==NULL || sif->frameNr<2) return;
  if(limit<=1.0) return;
 
  int fi;
  double w, f;
  w=f=nan("");
  for(fi=0; fi<sif->frameNr; fi++) {
    if(isnan(sif->weights[fi])) continue;
    if(sif->weights[fi]<=0.0) {sif->weights[fi]=0.0; continue;}
    if(isnan(w)) w=sif->weights[fi];
    if(isnan(f)) f=sif->weights[fi];
    if(sif->weights[fi]>w) w=sif->weights[fi];
    if(sif->weights[fi]<f) f=sif->weights[fi];
  }
  if(isnan(w) || isnan(f)) return;
 
  if(f*limit<w) {
    for(w/=limit, fi=0; fi<sif->frameNr; fi++)
      if(sif->weights[fi]>0.0) sif->weights[fi]+=w;
  }
}

◆ sifPrint()

void sifPrint ( SIF * data )

extern

Prints to stdout the contents of SIF data structure.

See also: sifWrite, sifRead

Parameters

data	Pointer to SIF structure.

Definition at line 234 of file sifio.c.

  {
  char buf[32];
  
  if(!ctime_r_int((time_t*)&data->scantime, buf))
    strcpy(buf, "1900-01-01 00:00:00");
  printf("Scan time: %s\n", buf);
  printf("Isotope: %s\n", data->isotope_name);
  printf("Frame start   end      Prompts    Randoms      Trues   Weight\n");
  for(int i=0; i<data->frameNr; i++) {
    printf(" %03d %6.1f %6.1f  %10.0f %10.0f %10.0f %8.6f\n", i+1,
      data->x1[i], data->x2[i], data->prompts[i], data->randoms[i],
      data->trues[i], data->weights[i]);
  }
  return;
}

Referenced by imgSetWeights(), and sifAllocateWithIMG().

◆ sifRead()

int sifRead	(	char *	filename,
		SIF *	data )

extern

Reads SIF file contents to the specified data structure.

Weights are set to 1.

Returns: Returns 0 if ok, 1 invalid input, 2 failed to open file, 3 failed to allocate memory, 4 header parsing error, 5 wrong file type, 6 failed to allocate memory, 8 parse error, 9 wrong data format

See also: sifInit, sifEmpty, sifWrite, sifExistentCounts, textfileReadLines

Parameters

filename	SIF file name to be read.
data	Pointer to initiated SIF structure; any existing contents will be deleted.

Definition at line 21 of file sifio.c.

  {
  int i, n, frameNr, yy, mm, dd, h, m, s;
  int ret;
  struct tm *st;
  time_t timet;
 
 
  if(SIF_TEST) printf("sifRead(%s, *sif)\n", filename);
  if(filename==NULL || data==NULL) return(1);
  /* Empty data */
  sifEmpty(data);
 
  /* Read the lines of the SIF */
  STR_TOKEN_LIST tlst; str_token_list_init(&tlst);
  //printf("reading lines\n");
  ret=textfileReadLines(filename, &tlst);
  if(ret>2) {strcpy(siferrmsg, "cannot read file"); return(5);}
  else if(ret>0) {strcpy(siferrmsg, "cannot open file"); return(2);}
  if(0) {
    printf("lineNr:=%d\n", tlst.token_nr);
    for(int i=0; i<tlst.token_nr; i++) printf("token[%d] := '%s'\n", i, tlst.tok[i]);
  }
 
  /* Remove any comment or empty lines */
  //printf("removing any comment lines\n");
  i=tlst.token_nr-1;
  while(i>=0 && tlst.token_nr>0) {
    //printf("i=%d line='%s'\n", i, tlst.tok[i]);
    if(strnlen(tlst.tok[i], 2)<1 || asciiCommentLine(tlst.tok[i], NULL)) {
      //printf("-> remove\n");
      str_token_list_del(&tlst, 1+i);
    }
    i--;
  }
  if(tlst.token_nr<1) {
    str_token_list_empty(&tlst);
    strcpy(siferrmsg, "wrong format"); return(4);
  }
  if(0) {
    printf("lineNr:=%d\n", tlst.token_nr);
    for(int i=0; i<tlst.token_nr; i++)
      printf("token[%d] := '%s'\n", i, tlst.tok[i]);
  }
 
  /* Read the title line */
  if(SIF_TEST) printf("SIF title := '%s'\n", tlst.tok[0]);
  n=sscanf(tlst.tok[0], "%d/%d/%d %d:%d:%d %d %d %d %255s %7s",
      &dd, &mm, &yy, &h, &m, &s, &frameNr, &data->colNr, &data->version,
      data->studynr, data->isotope_name);
  //printf("tok_n := %d\n", n);
  if(n<9 || frameNr<1 || data->colNr<2 || data->version!=1) {
    if(SIF_TEST) printf("invalid SIF title line\n");
    strcpy(siferrmsg, "wrong filetype");
    str_token_list_empty(&tlst);
    return(4);
  }
  timet=time(NULL); st=gmtime(&timet);
  if(st!=NULL) {
    st->tm_mday=dd; st->tm_mon=mm-1; st->tm_year=yy-1900;
    st->tm_hour=h; st->tm_min=m; st->tm_sec=s; st->tm_isdst=-1;
    data->scantime=timegm(st); if(data->scantime==-1) data->scantime=0;
  } else {
    data->scantime=0;
  }
  //printf("frameNr := %d\n", frameNr);
 
  /* Allocate memory for SIF data */
  if(sifSetmem(data, frameNr)) {
    str_token_list_empty(&tlst);
    strcpy(siferrmsg, "cannot allocate SIF"); return(6);
  }
 
  /* Read data lines into SIF */
  i=0;
  while(i<data->frameNr && i<tlst.token_nr-1) {
    //printf("i := %d\n", i);
    data->prompts[i]=data->randoms[i]=0.0;
    n=sscanf(tlst.tok[1+i], "%lf %lf %lf %lf", &data->x1[i], &data->x2[i],
        &data->prompts[i], &data->randoms[i]);
    //printf("n := %d\n", n);
    //if(n<data->colNr || data->x2[i]<data->x1[i]) { 
    if(n<2) { 
      strcpy(siferrmsg, "wrong data format"); 
      str_token_list_empty(&tlst);
      sifEmpty(data);
      return(9);
    }
    if(data->x2[i]<data->x1[i]) { 
      strcpy(siferrmsg, "invalid time frames"); 
      str_token_list_empty(&tlst);
      sifEmpty(data);
      return(9);
    }
    i++;
  }
  str_token_list_empty(&tlst);
  if(i!=data->frameNr) {
    strcpy(siferrmsg, "wrong data format"); 
    sifEmpty(data);
    return(9);
  }
 
 
  /* Calculate trues */
  if(data->colNr>=4) for(i=0; i<data->frameNr; i++)
    data->trues[i]=data->prompts[i]-data->randoms[i];
  /* Set weights to 1.0 */
  for(i=0; i<data->frameNr; i++) data->weights[i]=1.0;
 
  return(0);
}

Referenced by imgReadAnalyze(), imgReadAnalyzeFrame(), imgReadAnalyzeHeader(), imgReadModelingData(), imgReadNiftiFrame(), imgReadNiftiHeader(), imgWriteAnalyze(), and imgWriteNifti().

◆ sifSetmem()

int sifSetmem	(	SIF *	data,
		int	frameNr )

extern

Allocates memory for SIF data.

See also: sifInit, sifEmpty

Returns: 0 if ok, 1 failed memory allocation

Parameters

data	Pointer to initiated sif data struct. Any existing data is destroyed.
frameNr	Number of PET time frames.

Definition at line 56 of file sif.c.

  {
  if(SIF_TEST) printf("sifSetmem()\n");
  if(data==NULL) return(1);
  /* Clear previous data, if necessary */
  if(data->frameNr>0) sifEmpty(data);
  if(frameNr<1) return(0);
  
  /* Allocate memory */
  data->x1=(double*)calloc(frameNr, sizeof(double));
  data->x2=(double*)calloc(frameNr, sizeof(double));
  data->prompts=(double*)calloc(frameNr, sizeof(double));
  data->randoms=(double*)calloc(frameNr, sizeof(double));
  data->trues=(double*)calloc(frameNr, sizeof(double));
  data->weights=(double*)calloc(frameNr, sizeof(double));
  if(data->x1==NULL || data->x2==NULL || data->prompts==NULL ||
     data->randoms==NULL || data->trues==NULL || data->weights==NULL) {
    strcpy(siferrmsg, "out of memory"); return(1);}
  data->frameNr=frameNr;
 
  return(0);
}

Referenced by img2sif(), imgGetMicropetSIF(), sifAllocateWithIMG(), and sifRead().

◆ sifWeight()

void sifWeight	(	SIF *	data,
		double	halflife )

extern

Calculate weights for frames in SIF data based on true counts. Weights are normalized to have an average of 1.0.

Weights are calculated from formula weight=(frame duration)^2 / (trues in a frame). Before calling this routine, trues must be calculated as total counts - randoms. Counts in SIF are not corrected for physical decay. Therefore, isotope halflife must be known, if weights are to be calculated for decay corrected TACs. Isotope halflife must be set to 0, if weights are used for TACs that are not corrected for decay.

Reference: Mazoyer BM, Huesman RH, Budinger TF, Knittel BL. Dynamic PET data analysis. J Comput Assist Tomogr 1986; 10:645-653.

See also: sifInit, sifRead, sifWrite, sifEmpty, sifModerateTrues, sifModerateWeights, sifExistentCounts, sifWeightByFrames, dftWeightByFreq, dftDecayCorrection

Parameters

data	Pointer to SIF data.
halflife	Halflife (in seconds) of the isotope; If halflife is 0, the weights are calculated for non-decay corrected data. If halflife is >0, the weights are calculated using decay corrected trues, but trues data in SIF are not changed.

Definition at line 28 of file weight.c.

  {
  int i;
  double f, d;
 
  if(SIF_TEST) printf("sifWeight(*sif, %g)\n", halflife);
  /* Calculate weights */
  for(i=0; i<data->frameNr; i++) {
    if(data->trues[i]<1.0) data->trues[i]=1.0;
    f=data->x2[i]-data->x1[i]; if(f<=0.0) f=1.0;
    if(halflife<=1.0E-8) 
      d=1.0;
    else
      d=exp( ((data->x1[i]+data->x2[i])/2.0)*0.693147/halflife );
    data->weights[i]=(f*f)/(d*data->trues[i]);
    /*printf("%3d %g %g\n", i, data->trues[i], data->weights[i]);*/
  }
 
  /* Scale weights so that average weight is 1.0 */
  sifWeightNorm(data);
 
  return;
}

Referenced by imgSetWeights().

◆ sifWeightByFrames()

void sifWeightByFrames	(	SIF *	data,
		double	halflife )

extern

Calculate weights for frames in SIF data based on frame lengths. Weights are normalized to have an average of 1.0.

Weights are calculated from the simple formula weight=(frame duration), if isotope halflife is set to 0, and using formula weight=(frame duration)*exp(-t*ln(2)/halflife), if isotope halflife is given (less weight for late frames, which may be more suitable for PET data that is corrected for physical decay).

See also: sifInit, sifRead, sifWrite, sifEmpty, sifWeight, dftWeightByFreq

Parameters

data	Pointer to SIF data.
halflife	Halflife (in seconds) of the isotope; If halflife is >0, the late frames are given less weight.

Definition at line 72 of file weight.c.

  {
  int i;
  double f, d;
 
  if(SIF_TEST) printf("sifWeightByFrames(*sif, %g)\n", halflife);
  /* Calculate weights */
  for(i=0; i<data->frameNr; i++) {
    f=data->x2[i]-data->x1[i]; if(f<=0.0) f=1.0;
    if(halflife<=1.0E-8) 
      d=1.0;
    else
      d=exp( -((data->x1[i]+data->x2[i])/2.0)*0.693147/halflife );
    data->weights[i]=f*d;
  }
 
  /* Scale weights so that average weight is 1.0 */
  sifWeightNorm(data);
 
  return;
}

◆ sifWeightNorm()

void sifWeightNorm ( SIF * d )

extern

Scale weights in SIF data so that average weight is 1.0, and the sum of weights equals the nr of frames.

See also: sifInit, sifRead, sifWrite, sifEmpty, sifWeight, sifWeightByFrames

Parameters

d	Pointer to SIF data.

Definition at line 105 of file weight.c.

  {
  if(SIF_TEST) printf("sifWeightNorm(*sif)\n");
  int i;
  double f=0.0;
  for(i=0; i<d->frameNr; i++) f+=d->weights[i];
  f/=(double)d->frameNr;
  for(i=0; i<d->frameNr; i++) d->weights[i]/=f;
  return;
}

Referenced by sifWeight(), and sifWeightByFrames().

◆ sifWrite()

int sifWrite	(	SIF *	data,
		char *	filename )

extern

Write SIF data to a standard SIF file, emptying files old contents.

Returns: Returns 0 if successful, 1 invalid input, 2 failed to open file, 3 failed to write into file.

See also: sifInit, sifEmpty, sifRead, sifPrint, sifWeight

Parameters

data	Pointer to SIF structure containing data to be written in file.
filename	File name for SIF; Set to 'stdout' to print the contents on console. File is overwritten without backup.

Definition at line 145 of file sifio.c.

  {
  int i, n, req_decimals=0;
  char buf[1024];
  struct tm tm; //*st;
 
 
  if(SIF_TEST) printf("sifWrite(*sif, %s)\n", filename);
  /* Check data */
  if(data->frameNr<1) {strcpy(siferrmsg, "no data to save"); return 1;}
 
  /* Set file pointer */
  FILE *fp;
  int intofile;
  if(strcasecmp(filename, "STDOUT")==0) {
    fp=stdout; intofile=0;
  } else {
    /* Open file */
    fp=fopen(filename, "w");
    if(fp==NULL) {strcpy(siferrmsg, "cannot open file"); return 2;}
    intofile=1;
  }
 
  /* Write title line */
  if(!gmtime_r((time_t*)&data->scantime, &tm) || !strftime(buf, 1024, "%d/%m/%Y %H:%M:%S", &tm))
    strcpy(buf, "1/1/1900 00:00:00");
  n=fprintf(fp, "%s %d %d %d", buf, data->frameNr, data->colNr, data->version);
  if(SIF_TEST) printf("%s %d %d %d\n", buf, data->frameNr, data->colNr, data->version);
  if(n<7) {
    strcpy(siferrmsg, "cannot write file"); if(intofile) fclose(fp); 
    return 2;
  }
  if(strlen(data->studynr)!=0 || strlen(data->isotope_name)!=0) {
    /* Write also study number and isotope */
    if(strlen(data->studynr)==0) fprintf(fp, " ."); else fprintf(fp, " %s", data->studynr);
    if(strlen(data->isotope_name)>0) fprintf(fp, " %s", data->isotope_name);
  }
  fprintf(fp, "\n");
 
  /* Check if frame times need to printed with decimals */
  for(i=1, req_decimals=0; i<data->frameNr; i++) {
    if(round(data->x1[i])==round(data->x1[i-1])) {req_decimals=1; break;}
    if(round(data->x2[i])==round(data->x2[i-1])) {req_decimals=1; break;}
  }
 
  /* Write data lines */
  for(i=0; i<data->frameNr; i++) {
    if(req_decimals==0) n=fprintf(fp, "%.0f %.0f", data->x1[i], data->x2[i]);
    else n=fprintf(fp, "%.1f %.1f", data->x1[i], data->x2[i]);
    if(n<3) {
      strcpy(siferrmsg, "cannot write file"); if(intofile) fclose(fp); 
      return 3;
    }
    if(data->colNr<=2) {n=fprintf(fp, "\n"); continue;}
    n=fprintf(fp, " %.0f %.0f", data->prompts[i], data->randoms[i]);
    if(n<1) {
      strcpy(siferrmsg, "cannot write file"); if(intofile) fclose(fp); 
      return 3;
    }
    if(data->colNr<5) {n=fprintf(fp, "\n"); continue;}
    n=fprintf(fp, " %.0f", data->trues[i]);
    if(n<1) {
      strcpy(siferrmsg, "cannot write file"); if(intofile) fclose(fp);
      return 3;
    }
    if(data->colNr<6) {n=fprintf(fp, "\n"); continue;}
    n=fprintf(fp, " %.5f\n", data->weights[i]);
    if(n<1) {
      strcpy(siferrmsg, "cannot write file"); if(intofile) fclose(fp);
      return 3;
    }
  }
 
  /* Close file */
  if(intofile) fclose(fp);
 
  return 0;
}

Referenced by imgWriteAnalyze(), and imgWriteNifti().

◆ string_to_xyz()

int string_to_xyz	(	char *	str,
		int *	x,
		int *	y,
		int *	z )

extern

Read pixel location from a string representation of it.

See also: string_to_xyzf, vrdRead

Returns: Returns 0 if successful, >0 if not.

Parameters

str	String in format x,y,z or x y z ; this string is not changed
x	Pixel location in x dimension
y	Pixel location in y dimension
z	Pixel location in z dimension

Definition at line 653 of file vol.c.

  {
  char *cptr, tmp[256];
 
  strncpy(tmp, str, 255); tmp[255]=(char)0;
  cptr=strtok(tmp, " ,;:()|-"); if(cptr==NULL) return 1;
  *x=atoi(cptr); if(*x<1) return 1;  
  cptr=strtok(NULL, " ,;:()|-"); if(cptr==NULL) return 2;
  *y=atoi(cptr); if(*y<1) return 1;
  cptr=strtok(NULL, " ,;:()|-"); if(cptr==NULL) return 3;
  *z=atoi(cptr); if(*z<1) return 1;
  return 0;
}

Referenced by vrdRead().

◆ string_to_xyzf()

int string_to_xyzf	(	const char *	str,
		IMG_PIXEL *	v )

extern

Read voxel coordinates including time frame from a string representation.

See also: string_to_xyz, irdRead

Returns: Returns 0 if successful, >0 if not.

Parameters

str	String in format x,y,z,f or x y z f; frame (f) is optional; if f is not specified, then 0 is written in its place.
v	Pointer to image pixel struct; obligatory.

Definition at line 14 of file ird.c.

  {
  if(v==NULL) return 1;
  v->x=v->y=v->z=v->f=0;
 
  char *cptr, tmp[256];
  strncpy(tmp, str, 255); tmp[255]=(char)0;
  cptr=strtok(tmp, " ,;:()|-"); if(cptr==NULL) return 1;
  v->x=atoi(cptr); if(v->x<1) return 1;  
  cptr=strtok(NULL, " ,;:()|-"); if(cptr==NULL) return 2;
  v->y=atoi(cptr); if(v->y<1) return 1;
  cptr=strtok(NULL, " ,;:()|-"); if(cptr==NULL) return 3;
  v->z=atoi(cptr); if(v->z<1) return 1;
  cptr=strtok(NULL, " ,;:()|-"); if(cptr==NULL) return 0;
  v->f=atoi(cptr);
  return 0;
}

Referenced by irdRead().

◆ svol2img()

int svol2img	(	SVOL *	svol,
		IMG *	img,
		int	frame )

extern

Copy 3D short int volume as one time frame (1..dimt) into 4D image. Img must be allocated.

Parameters

svol	short volume structure
img	image structure
frame	frame number [1..img->dimt]

Returns: 0 if ok, 1 invalid image, 2 invalid frame number, 3 (x,y) dimension inconsistency, 4 plane number inconsistency

Definition at line 385 of file vol.c.

                                              {
  unsigned short int zi, yi, xi, fi;
 
  if(VOL_TEST) printf("svol2img(svol, img, %d)\n", frame);
  /* Check input */
  if(svol==NULL || svol->status!=IMG_STATUS_OCCUPIED) return(1);
  svol->statmsg=_volStatusMessage[1];
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(frame<1 || img->dimt<frame) return(2);
  if(img->dimx!=svol->dimx || img->dimy!=svol->dimy) return(3);
  if(img->dimz!=svol->dimz) return(4);
 
  /* Copy data */
  fi=frame-1;
  for(zi=0; zi<svol->dimz; zi++)
    for(yi=0; yi<svol->dimy; yi++)
      for(xi=0; xi<svol->dimx; xi++)
        img->m[zi][yi][xi][fi]=(svol->scale_factor)*(float)svol->v[zi][yi][xi];
 
  return(0);
}

◆ svolAllocate()

int svolAllocate	(	SVOL *	svol,
		int	planes,
		int	rows,
		int	columns )

extern

Allocate memory for 3D short int volume. Returns 0 if ok.

Parameters

svol	short volume structure
planes	number of planes [>=1]
rows	number of rows [>=1]
columns	number of columns [>=1]

Returns: 0 if ok, 1 invalid image status, 2 invalid input, 5 failed to allocate memory for planes, 6 failed to allocate memory for rows, 8 failed to allocate memory for rows

Definition at line 204 of file vol.c.

                                                                {
  unsigned short int zi, ri;
  int vxlNr, vi;
  short int **rptr, *cptr;
 
  if(VOL_TEST) printf("svoiAllocate(*svol, %d, %d, %d)\n", planes, rows, columns);
  /* Check arguments */
  if(svol==NULL) return(1); else svol->statmsg=_volStatusMessage[1];
  if(svol->status==IMG_STATUS_UNINITIALIZED) return(1);
  if(planes<1 || rows<1 || columns<1) return(2);
  vxlNr=planes*rows*columns;
 
  /* Check if correct volume size is already allocated */
  if(svol->status>=IMG_STATUS_OCCUPIED) {
    if(planes==svol->dimz && rows==svol->dimy && columns==svol->dimx) {
      for(vi=0; vi<vxlNr; vi++) svol->_vxl[vi]=0;
      return(0); /* that's it */
    } else {
      svolEmpty(svol);
    }
  }
  /* Allocate memory for volume data */
  svol->_pln=(short int***)malloc((size_t)planes*sizeof(short int**));
  if(svol->_pln==NULL) {
    return(5);}
  svol->_row=(short int**)malloc((size_t)planes*rows*sizeof(short int*));
  if(svol->_row==NULL) {
    free(svol->_pln); return(6);}
  svol->_col=svol->_vxl=(short int*)calloc((size_t)planes*rows*columns, sizeof(short int));
  if(svol->_vxl==NULL) {
    free(svol->_pln); free(svol->_row); return(8);
  }
  /* Set data pointers */
  rptr=svol->_row; cptr=svol->_col;
  for(zi=0; zi<planes; zi++) {
    svol->_pln[zi]=rptr;
    for(ri=0; ri<rows; ri++) {
      *rptr++=cptr; cptr+=columns;
    }
  }
  svol->v=svol->_pln;
  svol->plane=svol->_pln;
  svol->column=svol->_col;
  svol->row=svol->_row;
  svol->voxel=svol->_vxl;
  /* Ok */
  svol->dimz=planes; svol->dimy=rows; svol->dimx=columns;
  svol->statmsg=_volStatusMessage[0];
  svol->status=IMG_STATUS_OCCUPIED;
  return(0);
}

Referenced by img2svol().

◆ svolEmpty()

void svolEmpty ( SVOL * svol )

extern

Free memory allocated for short int volume.

Parameters

svol	short int volume structure

Definition at line 103 of file vol.c.

                           {
  if(VOL_TEST) printf("svolEmpty()\n");
  if(svol==NULL || svol->status<IMG_STATUS_OCCUPIED) return;
  /* Free up memory */
  if(svol->_vxl!=NULL) free(svol->_vxl);
  //if(svol->_col!=NULL) free(svol->_col); Same as _vxl
  if(svol->_row!=NULL) free(svol->_row);
  if(svol->_pln!=NULL) free(svol->_pln);
  /* Set variables */
  svol->statmsg=_volStatusMessage[0];
  svol->orientation=0;
  svol->dimx=svol->dimy=svol->dimz=0;
  svol->sizex=svol->sizey=svol->sizez=0;
  svol->scale_factor=1.0;
  svol->v=(short int***)NULL;
  svol->voxel=(short int*)NULL;
  svol->column=(short int*)NULL;
  svol->row=(short int**)NULL;
  svol->plane=(short int***)NULL;
  /* Set status */
  svol->status=IMG_STATUS_INITIALIZED;
}

Referenced by svolAllocate().

◆ svolInfo()

void svolInfo	(	SVOL *	svol,
		FILE *	fp )

extern

Prints short int volume information to specified file pointer, e.g. stdout

Parameters

svol	short volume structure
fp	target file pointer

Definition at line 439 of file vol.c.

                                    {
  if(VOL_TEST) printf("svolInfo()\n");
  if(svol==NULL || svol->status<=IMG_STATUS_UNINITIALIZED) {
    fprintf(fp, "Volume data is not initialized.\n"); return;}
  if(svol->status==IMG_STATUS_INITIALIZED) {
    fprintf(fp, "Volume data is initialized but empty.\n"); return;}
  if(svol->status==IMG_STATUS_ERROR) fprintf(stdout, "Volume data has errors.\n");
  fprintf(fp, "Volume status: %s\n", svol->statmsg);
  fprintf(fp, "Patient orientation: %d\n", svol->orientation);
  fprintf(fp, "Voxel sizes (x, y, z): %g %g %g mm\n",
    svol->sizex, svol->sizey, svol->sizez);
  fprintf(fp, "Dimensions (x, y, z): %d %d %d\n",
    svol->dimx, svol->dimy, svol->dimz);
  fprintf(fp, "Scale factor: %g\n", svol->scale_factor);
  return;
}

◆ svolInit()

void svolInit ( SVOL * svol )

extern

Initiate short int volume before any use of SVOL data; this should be called once.

Parameters

svol	short int volume structure

Definition at line 50 of file vol.c.

                          {
  if(VOL_TEST) printf("svolInit()\n");
  if(svol==NULL) return;
  memset(svol, 0, sizeof(SVOL));
  svol->status=IMG_STATUS_INITIALIZED;
  svol->statmsg=_volStatusMessage[0];
  svol->orientation=0;
  svol->dimx=svol->dimy=svol->dimz=0;
  svol->sizex=svol->sizey=svol->sizez=0;
  svol->scale_factor=1.0;
  svol->v=(short int***)NULL;
  svol->voxel=(short int*)NULL;
  svol->column=(short int*)NULL;
  svol->row=(short int**)NULL;
  svol->plane=(short int***)NULL;
}

◆ upetExists()

int upetExists	(	const char *	upetname,
		char *	hdrfile,
		char *	imgfile,
		int	verbose )

extern

Check if specified image filename is a Concorde/microPET file

Returns: Returns 0 if it is not, and >0 if it is: 1 if header but not image is found, or 2 if both image and header are found.

Parameters

upetname	Filename, either header file, image file, or base name without extensions.
hdrfile	If upetname is a Concorde/microPET file, then header filename will be written in this char pointer (space needs to allocated by caller); NULL if not needed.
imgfile	If upetname is a Concorde/microPET file, then image filename will be written in this char pointer (space needs to allocated by caller); NULL if not needed.
verbose	Verbose level; if <=0, then nothing is printed into stdout

Definition at line 86 of file micropet.c.

  {
  char *cptr, basefile[FILENAME_MAX], temp[FILENAME_MAX];
 
  if(upetname==NULL || strlen(upetname)==0) return(0);
  if(verbose>0) printf("\n%s(%s, *str, *str)\n", __func__, upetname);
 
  /* Construct the base file name wo extensions */
  strlcpy(basefile, upetname, FILENAME_MAX);
  cptr=strrchr(basefile, '.');
  if(cptr!=NULL) {
    if(strncasecmp(cptr, ".HDR", 4)==0 || strncasecmp(cptr, ".IMG", 4)==0 )
      *cptr=(char)0;
  } 
  cptr=strrchr(basefile, '.');
  if(cptr!=NULL) {
    if(strncasecmp(cptr, ".IMG", 4)==0 )
      *cptr=(char)0;
  }
  if(verbose>1) printf("\n  basefile := %s\n", basefile);
 
  /* Header file exists? */
  strlcpy(temp, basefile, FILENAME_MAX-4); strcat(temp, ".hdr");
  if(access(temp, 0) == -1) {
    strlcpy(temp, basefile, FILENAME_MAX-8); strcat(temp, ".img.hdr");
    if(access(temp, 0) == -1) {
      if(verbose>0) printf("\n  hdr file not found or accessible.\n");
      return(0);
    }
  }
  /* Is this microPET header file? */
  if(upetIsHeader(temp)==0) {
    if(verbose>0)
      printf("\n  %s was not identified as microPET header file.\n", temp);
    return(0);
  }
  /* Preserve header filename */
  if(hdrfile!=NULL) strlcpy(hdrfile, temp, FILENAME_MAX);
 
  /* Image file exists? */
  strlcpy(temp, basefile, FILENAME_MAX); strcat(temp, ".img");
  if(access(temp, 0) == -1) {
    if(verbose>0) printf("\n  %s not found or accessible.\n", temp);
    return(1);
  }
  /* Preserve image filename */
  if(imgfile!=NULL) strlcpy(imgfile, temp, FILENAME_MAX);
 
  return(2);
}

Referenced by imgFormatDetermine(), imgMicropetToEcat7(), imgRead(), imgReadMicropetFrame(), and imgReadMicropetHeader().

◆ upetGetImageDimensions()

int upetGetImageDimensions	(	FILE *	fp,
		int *	z,
		int *	x,
		int *	y,
		int *	f )

extern

Read image dimensions from header.

Returns: Returns 0 when successful.

Parameters

fp	File pointer to MicroPET image header
z	Pointers to dimensions: planes
x	Pointers to dimensions: columns
y	Pointers to dimensions: rows
f	Pointers to dimensions: frames; if not existent (CT), enter NULL

Definition at line 154 of file micropet.c.

  {
  char tmp[MAX_MICROPET_LINE_LEN];
 
  if(fp==NULL) return 1;
  *z=*x=*y=0; if(f!=NULL) *f=0;
  rewind(fp);
 
  if(f!=NULL) {
    if(upetHeaderReadParameter(fp, "time_frames", tmp)!=0) {
      if(upetHeaderReadParameter(fp, "total_frames", tmp)!=0) return 11;
    }  
    *f=-1; (void)sscanf(tmp, "%d", f);
  }
  if(upetHeaderReadParameter(fp, "x_dimension", tmp)!=0) return 12;
  *x=-1; (void)sscanf(tmp, "%d", x);
  if(upetHeaderReadParameter(fp, "y_dimension", tmp)!=0) return 13;
  *y=-1; (void)sscanf(tmp, "%d", y);
  if(upetHeaderReadParameter(fp, "z_dimension", tmp)!=0) return 14;
  *z=-1; (void)sscanf(tmp, "%d", z);
  if(*z<1 || *x<1 || *y<1) return 2;
  if(f!=NULL && *f<1) return 2;
  return 0;
}

Referenced by imgMicropetCTToEcat7(), and imgMicropetPETToEcat7().

◆ upetHeaderReadParameter()

int upetHeaderReadParameter	(	FILE *	fp,
		char *	parameter,
		char *	value )

extern

Read specified parameter value from Concorde/MicroPET header.

Returns: Returns 0 if parameter was found, even if value is empty, and 1, if parameter was not found, and <0 in case of other errors.

Parameters

fp	File pointer to Concorde/MicroPET header; parameter is read starting from file pointer forward, therefore rewind file pointer before calling this routine if you want to search parameter from beginning.
parameter	Pointer to string which contains the header parameter name.
value	Pointer to allocated string where parameter value will be written; memory for at least MAX_MICROPET_LINE_LEN chars must be allocated; NULL if not needed.

Definition at line 16 of file micropet.c.

  {
  char *cptr, tmp[MAX_MICROPET_LINE_LEN];
 
  if(fp==NULL) return -1;
  if(parameter==NULL || strlen(parameter)<1) return -2;
  do {
    if(fgets(tmp, MAX_MICROPET_LINE_LEN-1, fp)==NULL) return 1;
    if(tmp[0]=='#') continue;
    if(strncasecmp(tmp, parameter, strlen(parameter))!=0) continue;
    /* Get parameter value, if one exists */
    cptr=tmp+strlen(parameter)+1;
    if(strlen(cptr)>0) {
      if(value!=0) strnCopyClean(value, cptr, MAX_MICROPET_LINE_LEN-1);
    } else {
      if(value!=0) strcpy(value, "");
    }
    /* In any case, we found the parameter */
    if(MICROPET_TEST>9) printf("%s := %s\n", parameter, value);
    return 0;
  } while(1);
  return 0;
}

Referenced by imgGetMicropetFrameHeader(), imgGetMicropetMainHeader(), imgGetMicropetSIF(), imgMicropetCTToEcat7(), imgMicropetToEcat7(), upetGetImageDimensions(), upetIsHeader(), and upetScanStart().

◆ upetIsHeader()

int upetIsHeader ( char * hdrfile )

extern

Verify that given file is a valid Concorde/microPET file header file.

Returns: Returns 0 if not, and 1 if it is a valid header file.

Parameters

hdrfile Concorde/microPET file header filename, with correct extension

Definition at line 55 of file micropet.c.

  {
  char tmp[MAX_MICROPET_LINE_LEN];
  FILE *fp;
  int ret;
 
  if(hdrfile==NULL || strlen(hdrfile)<5) return 0;
  if(MICROPET_TEST>1) printf("\n%s(%s)\n", __func__, hdrfile);
  if((fp=fopen(hdrfile, "r"))==NULL) return 0;
  /* Check that first line starts with '#' */
  if(fgets(tmp, MAX_MICROPET_LINE_LEN-1, fp)==NULL) {fclose(fp); return 0;}
  if(tmp[0]!='#') {fclose(fp); return 0;}
  /* Check that certain header parameters do exist */
  ret=upetHeaderReadParameter(fp, "version", tmp);
  if(ret!=0) {fclose(fp); return 0;}
  ret=upetHeaderReadParameter(fp, "model", tmp);
  if(ret!=0) {fclose(fp); return 0;}
  ret=upetHeaderReadParameter(fp, "institution", tmp);
  if(ret!=0) {fclose(fp); return 0;}
  fclose(fp);
  return 1;
}

Referenced by upetExists().

◆ upetReadImagedata()

int upetReadImagedata	(	FILE *	fp,
		IFT *	ift,
		int	frame,
		float *	data )

extern

Reads microPET image data, scaling values to floats if necessary.

Reads only one frame at a time!

Returns: 0 when successful, otherwise <>0.

Parameters

fp	file opened previously in binary mode
ift	microPET header in IFT struct
frame	frame number to read [1..number of frames]
data	pointer to image float data allocated previously

Definition at line 243 of file micropet.c.

  {
  int dimx, dimy, dimz=1, dimt=1;
  int i, fi, data_type, data_bytes, little;
  char *mdata, *mptr;
  float f, cf, bf, *fptr;
  short int *sptr;
  int *iptr;
  char key[MAX_MICROPET_LINE_LEN], value[MAX_MICROPET_LINE_LEN];
 
 
  if(MICROPET_TEST) printf("%s(fp, ift, %d, data)\n", __func__, frame);
 
  /* Check the arguments */
  if(frame<=0 || fp==NULL || ift==NULL || data==NULL) return(1);
 
  /* Get the image dimensions from header */
  i=iftGetIntValue(ift, 0, "time_frames", &dimt, 0);
  if(i<0 || dimt<1) {
    i=iftGetIntValue(ift, 0, "total_frames", &dimt, 0);
    if(i<0 || dimt<1) return 4;
  }
  i=iftGetIntValue(ift, 0, "x_dimension", &dimx, 0);
  if(i<0 || dimx<1) return 4;
  i=iftGetIntValue(ift, 0, "y_dimension", &dimy, 0);
  if(i<0 || dimy<1) return 4;
  i=iftGetIntValue(ift, 0, "z_dimension", &dimz, 0);
  if(i<0 || dimz<1) return 4;
  long long pxlNr=dimx*dimy*dimz;
  if(pxlNr<1) return(4);
  if(frame>dimt) return(3); // do not change this return value
 
  /* Get the data type (little=Intel, big=Sun) */
  i=iftGetIntValue(ift, 0, "data_type", &data_type, 0);
  if(i<0 || data_type<1) return 5;
  switch(data_type) {
    case 1: data_bytes=1; little=little_endian(); break;
    case 2: data_bytes=2; little=1; break;
    case 3: data_bytes=4; little=1; break;
    case 4: data_bytes=4; little=1; break;
    case 5: data_bytes=4; little=0; break;
    case 6: data_bytes=2; little=0; break;
    case 7: data_bytes=4; little=0; break;
    default: return 5;
  }
  long long rawSize=pxlNr*data_bytes;
  if(MICROPET_TEST>0) {
    printf("  data_type=%d\n  data_bytes=%d\n", data_type, data_bytes);
    printf("  pxlNr=%lld\n  rawSize=%lld\n", pxlNr, rawSize);
  }
 
  /* Allocate memory for the binary data */
  mdata=(char*)malloc(rawSize); if(mdata==NULL) return(11);
 
  /* Seek the start of current frame data */
  long long start_pos=(frame-1)*rawSize;
  if(MICROPET_TEST>2) printf("  start_pos=%lld\n", start_pos);
  fseeko(fp, start_pos, SEEK_SET);
  if(ftello(fp)!=start_pos) {
    if(MICROPET_TEST>5) printf("could not move to start_pos\n");
    free(mdata); return(7);
  }
 
  /* Read the data */
  mptr=mdata;
  {
    size_t n=fread(mptr, rawSize, 1, fp);
    if(n<1) {
      if(MICROPET_TEST>5)
        printf("could read only %zu bytes when request was %lld\n", n, rawSize);
      free(mdata); return(8);
    }
  }
 
  /* Convert byte order if necessary */
  mptr=mdata;
  if(little!=little_endian()) {
    if(MICROPET_TEST>0) {printf("byte conversion\n"); fflush(stdout);}
    switch(data_bytes) {
      case 1: /* no conversion needed */ break;
      case 2: swabip(mptr, rawSize); break;
      case 4: swawbip(mptr, rawSize); break;
      default: 
        if(MICROPET_TEST>5) printf("unsupported data_type := %d\n", data_type);
        free(mdata); return(5);
    }
  }
 
  /* Get scale factor for this frame */
  strcpy(key, "frame"); sprintf(value, "%d", frame-1);
  fi=iftGetFullmatchFrom(ift, 0, key, value, 0); if(fi<0) {free(mdata); return(6);}
  i=iftGetFloatValue(ift, fi+1, "scale_factor", &f, 0);
  if(i<0 || f<=0.0) {free(mdata); return(6);}
  if(MICROPET_TEST>5) printf("  scale_factor := %g\n", f);
 
  /* calibration factor */
  i=iftGetFloatValue(ift, 0, "calibration_factor", &cf, 0);
  if(i<0 || cf<0.0) {free(mdata); return 7;}
  if(MICROPET_TEST>5) printf("  calibration_factor := %g\n", cf);
  /* branching_fraction */
  i=iftGetFloatValue(ift, 0, "isotope_branching_fraction", &bf, 0);
  if(i<0 || bf<0.0) {free(mdata); return 7;}
  if(MICROPET_TEST>5) printf("  branching_fraction := %g\n", bf);
  if(cf>0.0) {f=cf; if(bf>0.0) f/=bf;}
  if(MICROPET_TEST>5) printf("  f := %g\n", f);
 
  /* Copy data to float pixel values */
  mptr=mdata; fptr=data;
  switch(data_type) {
    case 1: // unsigned char
      for(long long i=0; i<pxlNr; i++, mptr++, fptr++) *fptr=f*(float)(*mptr);
      break;
    case 2: // short int
    case 6:
      for(long long i=0; i<pxlNr; i++, mptr+=2, fptr++) {
        sptr=(short int*)mptr; *fptr=f*(float)(*sptr);
      }
      break;
    case 3: // int
    case 7:
      for(long long i=0; i<pxlNr; i++, mptr+=4, fptr++) {
        iptr=(int*)mptr; *fptr=f*(float)(*iptr);
      }
      break;
    case 4: // float
    case 5:
      memcpy(fptr, mptr, pxlNr*data_bytes);
      for(long long i=0; i<pxlNr; i++, fptr++) *fptr*=f;
      break;
    default:
      if(MICROPET_TEST>5)
        printf("unsupported data_type := %d\n", data_type);
      free(mdata); return(5);
  }
 
  free(mdata);
  if(MICROPET_TEST>1) printf("%s() succeeded\n", __func__);
  return(0);
}

Referenced by imgReadMicropetFrame().

◆ upetScanStart()

int upetScanStart	(	FILE *	fp,
		time_t *	scant )

extern

Read scan start time from Concorde/MicroPET header.

Returns: Returns 0 when successful.

Parameters

fp	File pointer to Concorde/MicroPET header
scant	Pointer to time_t where time and date will be saved

Definition at line 194 of file micropet.c.

  {
  char tmp[MAX_MICROPET_LINE_LEN], tmp2[64], tmp3[64];
  int n, i;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
  struct tm scanstart={0};
#pragma clang diagnostic pop
 
  if(fp==NULL || scant==NULL) return 1;
 
  rewind(fp);
  if(upetHeaderReadParameter(fp, "scan_time", tmp)!=0) return 2;
  n=sscanf(tmp, "%s %s %d %d:%d:%d %d", tmp2, tmp3, &scanstart.tm_mday,
           &scanstart.tm_hour, &scanstart.tm_min, &scanstart.tm_sec, &i);
  if(n==7) {
    scanstart.tm_year=i-1900;
    if(strcasecmp(tmp3, "Jan")==0)      scanstart.tm_mon=0;
    else if(strcasecmp(tmp3, "Feb")==0) scanstart.tm_mon=1;
    else if(strcasecmp(tmp3, "Mar")==0) scanstart.tm_mon=2;
    else if(strcasecmp(tmp3, "Apr")==0) scanstart.tm_mon=3;
    else if(strcasecmp(tmp3, "May")==0) scanstart.tm_mon=4;
    else if(strcasecmp(tmp3, "Jun")==0) scanstart.tm_mon=5;
    else if(strcasecmp(tmp3, "Jul")==0) scanstart.tm_mon=6;
    else if(strcasecmp(tmp3, "Aug")==0) scanstart.tm_mon=7;
    else if(strcasecmp(tmp3, "Sep")==0) scanstart.tm_mon=8;
    else if(strcasecmp(tmp3, "Oct")==0) scanstart.tm_mon=9;
    else if(strcasecmp(tmp3, "Nov")==0) scanstart.tm_mon=10;
    else if(strcasecmp(tmp3, "Dec")==0) scanstart.tm_mon=11;
    scanstart.tm_isdst=-1;
    //*scant=mktime(&scanstart); if(*scant<0) return 4;
    *scant=timegm(&scanstart); if(*scant<0) return 4;
  } else return 5;
 
  return 0;
}

Referenced by imgGetMicropetSIF(), imgMicropetCTToEcat7(), and imgMicropetPETToEcat7().

◆ vol2img()

int vol2img	(	VOL *	vol,
		IMG *	img,
		int	frame )

extern

Copy 3D volume as one time frame (1..dimt) into 4D image. Img must be allocated.

Parameters

vol	volume structure
img	image structure
frame	frame number [1..number of frames]

Returns: 0 if ok, 1 invalid image status, 2 invalid input, 3 image<->volume (x,y) dimensions do not match, 4 image<->volume planes do not match.

Definition at line 351 of file vol.c.

                                           {
  unsigned short int zi, yi, xi, fi;
 
  if(VOL_TEST) printf("vol2img(vol, img, %d)\n", frame);
  /* Check input */
  if(vol==NULL || vol->status!=IMG_STATUS_OCCUPIED) return(1);
  vol->statmsg=_volStatusMessage[1];
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(frame<1 || img->dimt<frame) return(2);
  if(img->dimx!=vol->dimx || img->dimy!=vol->dimy) return(3);
  if(img->dimz!=vol->dimz) return(4);
 
  /* Copy data */
  fi=frame-1;
  for(zi=0; zi<vol->dimz; zi++)
    for(yi=0; yi<vol->dimy; yi++)
      for(xi=0; xi<vol->dimx; xi++)
        img->m[zi][yi][xi][fi]=vol->v[zi][yi][xi];
 
  return(0);
}

◆ volAllocate()

int volAllocate	(	VOL *	vol,
		int	planes,
		int	rows,
		int	columns )

extern

Allocate memory for 3D image volume. Returns 0 if ok.

Parameters

vol	volume structure
planes	number of planes [>=1]
rows	number of rows [>=1]
columns	number of columns [>=1]

Returns: 0 if ok, 1 invalid image status, 2 invalid input, 5 failed to allocate memory for planes, 6 failed to allocate memory for rows, 8 failed to allocate memory for rows

Definition at line 139 of file vol.c.

                                                             {
  unsigned short int zi, ri;
  int vxlNr, vi;
  float **rptr, *cptr;
 
  if(VOL_TEST) printf("voiAllocate(*vol, %d, %d, %d)\n", planes, rows, columns);
  /* Check arguments */
  if(vol==NULL) return(1); else vol->statmsg=_volStatusMessage[1];
  if(vol->status==IMG_STATUS_UNINITIALIZED) return(1);
  if(planes<1 || rows<1 || columns<1) return(2);
  vxlNr=planes*rows*columns;
 
  /* Check if correct volume size is already allocated */
  if(vol->status>=IMG_STATUS_OCCUPIED) {
    if(planes==vol->dimz && rows==vol->dimy && columns==vol->dimx) {
      for(vi=0; vi<vxlNr; vi++) vol->_vxl[vi]=0;
      return(0); /* that's it */
    } else {
      volEmpty(vol);
    }
  }
  /* Allocate memory for volume data */
  vol->_pln=(float***)malloc((size_t)planes*sizeof(float**));
  if(vol->_pln==NULL) {
    return(5);}
  vol->_row=(float**)malloc((size_t)planes*rows*sizeof(float*));
  if(vol->_row==NULL) {
    free(vol->_pln); return(6);}
  vol->_col=vol->_vxl=(float*)calloc((size_t)planes*rows*columns, sizeof(float));
  if(vol->_vxl==NULL) {
    free(vol->_pln); free(vol->_row); return(8);
  }
  /* Set data pointers */
  rptr=vol->_row; cptr=vol->_col;
  for(zi=0; zi<planes; zi++) {
    vol->_pln[zi]=rptr;
    for(ri=0; ri<rows; ri++) {
      *rptr++=cptr; cptr+=columns;
    }
  }
  vol->v=vol->_pln;
  vol->plane=vol->_pln;
  vol->column=vol->_col;
  vol->row=vol->_row;
  vol->voxel=vol->_vxl;
  /* Ok */
  vol->dimz=planes; vol->dimy=rows; vol->dimx=columns;
  vol->statmsg=_volStatusMessage[0];
  vol->status=IMG_STATUS_OCCUPIED;
  return(0);
}

Referenced by img2vol().

◆ volAvg()

int volAvg	(	VOL *	vol,
		VOL_RANGE *	r,
		float *	avg )

extern

Calculates average voxel value inside specified volume range.

Returns: 0 if ok, 1 invalid image status, 2 inconsistent range ending, 3 inconsistent range dimensions, 4 inconsistent dimensions

Parameters

vol	Pointer to VOL image structure
r	Pointer to volume range inside VOL; enter NULL if whole VOL is used
avg	Target for mean value

Definition at line 562 of file vol.c.

  {
  int zi, yi, xi, n=0;
 
  if(vol==NULL || vol->status!=IMG_STATUS_OCCUPIED) return(1);
  if(r!=NULL) {
    if(r->z1<1 || r->y1<1 || r->x1<1) return(2);
    if(r->z2<r->z1 || r->y2<r->y1 || r->x2<r->x1) return(3);
    if(r->z2>vol->dimz || r->y2>vol->dimy || r->x2>vol->dimx) return(4);
  }
 
  *avg=0.0;
  if(r!=NULL) {
    for(zi=r->z1-1; zi<r->z2; zi++) {
      for(yi=r->y1-1; yi<r->y2; yi++) {
        for(xi=r->x1-1; xi<r->x2; xi++) {
          *avg+=vol->v[zi][yi][xi]; n++;
        }
      }
    }
  } else {
    for(zi=0; zi<vol->dimz; zi++) {
      for(yi=0; yi<vol->dimy; yi++) {
        for(xi=0; xi<vol->dimx; xi++) {
          *avg+=vol->v[zi][yi][xi]; n++;
        }
      }
    }
  }
  if(n>0) *avg/=(float)n;
  return(0);
}

◆ volContents()

void volContents	(	VOL *	vol,
		VOL_RANGE	r,
		FILE *	fp )

extern

Prints matrix values inside specified range to file pointer.

Parameters

vol	volume structure
r	volume range structure
fp	target file pointer

Definition at line 464 of file vol.c.

                                                  {
  int zi, yi, xi;
 
  if(vol==NULL || vol->status!=IMG_STATUS_OCCUPIED) return;
  if(r.z1<1 || r.y1<1 || r.x1<1) return;
  if(r.z2<r.z1 || r.y2<r.y1 || r.x2<r.x1) return;
  if(r.z2>vol->dimz || r.y2>vol->dimy || r.x2>vol->dimx) return;
 
  for(zi=r.z1-1; zi<r.z2; zi++) {
    fprintf(fp, "pl=%03d ", zi+1);
    for(xi=r.x1-1; xi<r.x2; xi++) fprintf(fp, " x=%05d", xi+1);
    fprintf(fp, "\n");
    for(yi=r.y1-1; yi<r.y2; yi++) {
      fprintf(fp, "y=%05d", yi+1);
      for(xi=r.x1-1; xi<r.x2; xi++)
        fprintf(fp, " %7.3f", vol->v[zi][yi][xi]);
      fprintf(fp, "\n");
    }
  }
}

◆ volEmpty()

void volEmpty ( VOL * vol )

extern

Free memory allocated for volume.

Parameters

vol	volume structure

Definition at line 74 of file vol.c.

                        {
  if(VOL_TEST) printf("volEmpty()\n");
  if(vol==NULL || vol->status<IMG_STATUS_OCCUPIED) return;
  /* Free up memory */
  if(vol->_vxl!=NULL) free(vol->_vxl);
  //if(vol->_col!=NULL) free(vol->_col); Same as _vxl
  if(vol->_row!=NULL) free(vol->_row);
  if(vol->_pln!=NULL) free(vol->_pln);
  /* Set variables */
  vol->statmsg=_volStatusMessage[0];
  vol->orientation=0;
  vol->dimx=vol->dimy=vol->dimz=0;
  vol->sizex=vol->sizey=vol->sizez=0;
  vol->v=(float***)NULL;
  vol->voxel=(float*)NULL;
  vol->column=(float*)NULL;
  vol->row=(float**)NULL;
  vol->plane=(float***)NULL;
  /* Set status */
  vol->status=IMG_STATUS_INITIALIZED;
}

Referenced by volAllocate().

◆ volInfo()

void volInfo	(	VOL *	vol,
		FILE *	fp )

extern

Prints volume information to specified file pointer, e.g. stdout

Parameters

vol	volume structure
fp	target file pointer

Definition at line 415 of file vol.c.

                                 {
  if(VOL_TEST) printf("volInfo()\n");
  if(vol==NULL || vol->status<=IMG_STATUS_UNINITIALIZED) {
    fprintf(fp, "Volume data is not initialized.\n"); return;}
  if(vol->status==IMG_STATUS_INITIALIZED) {
    fprintf(fp, "Volume data is initialized but empty.\n"); return;}
  if(vol->status==IMG_STATUS_ERROR) fprintf(stdout, "Volume data has errors.\n");
  fprintf(fp, "Volume status: %s\n", vol->statmsg);
  fprintf(fp, "Patient orientation: %d\n", vol->orientation);
  fprintf(fp, "Voxel sizes (x, y, z): %g %g %g mm\n",
    vol->sizex, vol->sizey, vol->sizez);
  fprintf(fp, "Dimensions (x, y, z): %d %d %d\n",
    vol->dimx, vol->dimy, vol->dimz);
  return;
}

◆ volInit()

void volInit ( VOL * vol )

extern

Initiate volume before any use of VOL data; this should be called once.

Parameters

vol	pointer to volume structure

Definition at line 26 of file vol.c.

                       {
  if(VOL_TEST) printf("volInit()\n");
  if(vol==NULL) return;
  memset(vol, 0, sizeof(VOL));
  vol->status=IMG_STATUS_INITIALIZED;
  vol->statmsg=_volStatusMessage[0];
  vol->orientation=0;
  vol->dimx=vol->dimy=vol->dimz=0;
  vol->sizex=vol->sizey=vol->sizez=0;
  vol->v=(float***)NULL;
  vol->voxel=(float*)NULL;
  vol->column=(float*)NULL;
  vol->row=(float**)NULL;
  vol->plane=(float***)NULL;
}

◆ volMax()

int volMax	(	VOL *	vol,
		VOL_RANGE *	r,
		VOL_PIXEL *	maxp,
		float *	maxv,
		VOL_PIXEL *	minp,
		float *	minv )

extern

Finds max and/or min voxel inside specified volume range.

Returns: 0 if ok, 1 invalid volume status, 2 invalid range endings, 3 inconsistent range dimensions, 4 inconsistent dimensions

Parameters

vol	Pointer to VOL image structure
r	Pointer to volume range inside VOL; enter NULL if whole VOL is used
maxp	Pixel where max pixel position is written; NULL if not needed
maxv	Target for max value; NULL if not needed
minp	Pixel where min pixel position is written; NULL if not needed
minv	Target for min value; NULL if not needed

Definition at line 492 of file vol.c.

  {
  int zi, yi, xi;
  float lmax, lmin;
 
  if(vol==NULL || vol->status!=IMG_STATUS_OCCUPIED) return(1);
 
  if(r!=NULL) {
    if(r->z1<1 || r->y1<1 || r->x1<1) return(2);
    if(r->z2<r->z1 || r->y2<r->y1 || r->x2<r->x1) return(3);
    if(r->z2>vol->dimz || r->y2>vol->dimy || r->x2>vol->dimx) return(4);
 
    zi=r->z1-1; yi=r->y1-1; xi=r->x1-1; lmax=lmin=vol->v[zi][yi][xi];
    if(maxp!=NULL) {maxp->z=zi+1; maxp->y=yi+1; maxp->x=xi+1;}
    if(minp!=NULL) {minp->z=zi+1; minp->y=yi+1; minp->x=xi+1;}
    for(zi=r->z1-1; zi<r->z2; zi++) {
      for(yi=r->y1-1; yi<r->y2; yi++) {
        for(xi=r->x1-1; xi<r->x2; xi++) {
          if(lmax<vol->v[zi][yi][xi]) {
            lmax=vol->v[zi][yi][xi];
            if(maxp!=NULL) {maxp->z=zi+1; maxp->y=yi+1; maxp->x=xi+1;}
          } else if(lmin>vol->v[zi][yi][xi]) {
            lmin=vol->v[zi][yi][xi];
            if(minp!=NULL) {minp->z=zi+1; minp->y=yi+1; minp->x=xi+1;}
          }
        }
      }
    }
  } else {
    zi=yi=xi=0; lmax=lmin=vol->v[zi][yi][xi];
    if(maxp!=NULL) {maxp->z=zi+1; maxp->y=yi+1; maxp->x=xi+1;}
    if(minp!=NULL) {minp->z=zi+1; minp->y=yi+1; minp->x=xi+1;}
    for(zi=0; zi<vol->dimz; zi++) {
      for(yi=0; yi<vol->dimy; yi++) {
        for(xi=0; xi<vol->dimx; xi++) {
          if(lmax<vol->v[zi][yi][xi]) {
            lmax=vol->v[zi][yi][xi];
            if(maxp!=NULL) {maxp->z=zi+1; maxp->y=yi+1; maxp->x=xi+1;}
          } else if(lmin>vol->v[zi][yi][xi]) {
            lmin=vol->v[zi][yi][xi];
            if(minp!=NULL) {minp->z=zi+1; minp->y=yi+1; minp->x=xi+1;}
          }
        }
      }
    }
  }
  if(maxv!=NULL) *maxv=lmax;
  if(minv!=NULL) *minv=lmin;
  return(0);
}

◆ vrd2vol()

int vrd2vol	(	VOL_RANGE *	r,
		VOL *	vol,
		float	in,
		float	out,
		char *	status )

extern

Set volume voxel values based on volume range definition.

Returns: Returns 0 if successful.

See also: vrdRead, vrdVxlNr, volAllocate, vol2img

Parameters

r	Image volume range.
vol	Pre-allocated image volume data structure.
in	Value to write into voxels inside the given volume range; enter nanf("") to not change the values.
out	Value to write into voxels outside the given volume range; enter nanf("") to not change the values.
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed

Definition at line 681 of file vol.c.

  {
  if(vol==NULL || vol->status!=IMG_STATUS_OCCUPIED) {
    if(status!=NULL) strcpy(status, "invalid VOL struct");
    return(1);
  }
  if(r->z2<r->z1 || r->y2<r->y1 || r->x2<r->x1) vrdReorder(r);
  if(r->z1<1 || r->y1<1 || r->x1<1 ||
     r->z2>vol->dimz || r->y2>vol->dimy || r->x2>vol->dimx) 
  {
    if(status!=NULL) strcpy(status, "invalid volume range");
    return(2);
  }
  if(isnan(in) && isnan(out)) {
    if(status!=NULL) strcpy(status, "new values not given");
    return(0);
  }
  int zi, yi, xi;
 
  if(!isnan(in)) { 
    for(zi=r->z1-1; zi<r->z2; zi++)
      for(yi=r->y1-1; yi<r->y2; yi++)
        for(xi=r->x1-1; xi<r->x2; xi++)
          vol->v[zi][yi][xi]=in;
  }
 
  if(!isnan(out)) { 
    for(zi=1; zi<=vol->dimz; zi++)
      for(yi=1; yi<=vol->dimy; yi++)
        for(xi=1; xi<=vol->dimx; xi++) {
          if(zi>=r->z1 && zi<=r->z2 && 
             yi>=r->y1 && yi<=r->y2 && 
             xi>=r->x1 && xi<=r->x2)
            continue; 
          vol->v[zi-1][yi-1][xi-1]=out;
        }
  }
 
  if(status!=NULL) strcpy(status, "ok");
  return(0);
}

◆ vrdRead()

int vrdRead	(	char *	vrdfile,
		VOL_RANGE *	vol_range,
		char *	status )

extern

Read Volume Range Definition File.

Returns: Returns 0 if successful.

See also: vrdReorder, vrdVxlNr, irdRead

Parameters

vrdfile	Volume Range Definition File filename, which contains image volume corners (x y z) in IFT format: corner1 = x y z corner2 = x y z
vol_range	Image volume range
status	Pointer to a string (allocated for at least 64 chars) where error message or other execution status will be written; enter NULL, if not needed

Definition at line 742 of file vol.c.

  {
  int ret, ii, x, y, z;
  IFT ift;
  char key[256];
 
  /* Check that input is ok */
  if(vrdfile==NULL || strlen(vrdfile)<1 || vol_range==NULL) {
    if(status!=NULL) strcpy(status, "program error");
    return 1;
  }
  /* Read VDF as IFT file */
  iftInit(&ift); ret=iftRead(&ift, vrdfile, 1, 0); if(ret) {
    if(status!=NULL) strcpy(status, ift.status);
    iftEmpty(&ift); return 2;
  }
  /* Try to find keys 'corner1' and 'corner2' */
  strcpy(key, "corner1"); ii=iftGet(&ift, key, 0);
  if(ii>=0) {
    ret=string_to_xyz(ift.item[ii].value, &x, &y, &z);
    if(ret==0) {
      vol_range->x1=x; vol_range->y1=y; vol_range->z1=z;
      strcpy(key, "corner2"); ii=iftGet(&ift, key, 0);
      if(ii>=0) {
        ret=string_to_xyz(ift.item[ii].value, &x, &y, &z);
        vol_range->x2=x; vol_range->y2=y; vol_range->z2=z;
        if(ret==0) {
          vrdReorder(vol_range);
          if(status!=NULL) strcpy(status, "ok");
          iftEmpty(&ift); return 0;
        }
      }
    }
  }
  /* We are here only if keys were not found */
  /* Lets not care about keys at all */
  for(ii=0, ret=0; ii<ift.keyNr; ii++) {
    if(ret==0 && string_to_xyz(ift.item[ii].value, &x, &y, &z)==0)
    {
      vol_range->x1=x; vol_range->y1=y; vol_range->z1=z;
      ret++; continue;
    }
    if(ret==1 && string_to_xyz(ift.item[ii].value, &x, &y, &z)==0)
    {
      vol_range->x2=x; vol_range->y2=y; vol_range->z2=z;
      ret++; break;
    }
  }
  if(ret<2) {
    if(status!=NULL) strcpy(status, "volume definitions not found");
    iftEmpty(&ift); return 2;
  }
 
  vrdReorder(vol_range);
  if(status!=NULL) strcpy(status, "ok");
  iftEmpty(&ift);
  return 0;
}

◆ vrdReorder()

int vrdReorder ( VOL_RANGE * vol_range )

extern

Reorder Volume Range Definition.

Returns: Returns 0 if successful.

See also: vrdRead, vrdVxlNr, irdRead

Parameters

vol_range Image volume range; start and end range are set in correct order

Definition at line 607 of file vol.c.

  {
  int i;
 
  /* Check that input is ok */
  if(vol_range==NULL) return 1;
  /* Change the order if necessary */
  if(vol_range->x1<0 || vol_range->x2<0) return 2;
  if(vol_range->x2<vol_range->x1) {
    i=vol_range->x1; vol_range->x1=vol_range->x2; vol_range->x2=i;}
  if(vol_range->y1<0 || vol_range->y2<0) return 3;
  if(vol_range->y2<vol_range->y1) {
    i=vol_range->y1; vol_range->y1=vol_range->y2; vol_range->y2=i;}
  if(vol_range->z1<0 || vol_range->z2<0) return 4;
  if(vol_range->z2<vol_range->z1) {
    i=vol_range->z1; vol_range->z1=vol_range->z2; vol_range->z2=i;}
  return 0;
}

Referenced by vrd2vol(), and vrdRead().

◆ vrdVxlNr()

int vrdVxlNr ( VOL_RANGE * vol_range )

extern

Get the number of voxels in Volume Range Definition.

Returns: Returns the nr of voxels in the volume range.

See also: vrdReorder, vrdRead

Parameters

vol_range Image volume range; start and end range must be in correct order

Definition at line 634 of file vol.c.

  {
  int x, y, z;
 
  if(vol_range==NULL) return(0);
  z=1+vol_range->z2-vol_range->z1;
  x=1+vol_range->x2-vol_range->x1;
  y=1+vol_range->y2-vol_range->y1;
  return(z*x*y);
}

Variable Documentation

◆ ANALYZE_TEST

int ANALYZE_TEST

extern

Verbose prints from Analyze functions

Definition at line 8 of file analyze.c.

Referenced by anaDatabaseExists(), anaExistsNew(), anaFlipping(), anaReadHeader(), anaReadImagedata(), anaRemove(), and anaWriteHeader().

◆ ECAT63_TEST

int ECAT63_TEST

extern

◆ ecat63errmsg

char ecat63errmsg[128]

extern

Error message from ECAT 6.3 functions

Definition at line 7 of file ecat63h.c.

Referenced by ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadAttnMatrix(), ecat63ReadImageMatrix(), ecat63ReadPlaneToImg(), ecat63ReadScanMatrix(), ecat63WriteAllImg(), ecat63WriteImageMatrix(), ecat63WriteScanMatrix(), imgRead(), and imgWriteEcat63Frame().

◆ ECAT7_TEST

int ECAT7_TEST

extern

Verbose prints from ECAT 7 functions

Definition at line 6 of file ecat7h.c.

◆ ecat7errmsg

char ecat7errmsg[128]

extern

Error message from ECAT 7 functions

Definition at line 7 of file ecat7h.c.

Referenced by ecat7Read2DScanMatrix(), ecat7ReadImageMatrix(), ecat7ReadPolarmapMatrix(), ecat7ReadScanMatrix(), ecat7Write2DScanMatrix(), ecat7WriteImageMatrix(), ecat7WritePolarmapMatrix(), ecat7WriteScanMatrix(), and imgReadEcat7().

◆ IMG_TEST

int IMG_TEST

extern

Verbose printing from IMG functions

Definition at line 6 of file img.c.

Referenced by ecat63AddImg(), ecat63ReadAllToImg(), ecat63ReadPlaneToImg(), ecat63WriteAllImg(), img2cube(), imgAllocate(), imgCopyhdr(), imgDecayCorrection(), imgDeleteFrameOverlap(), imgDeleteFrameOverlap_old(), imgEmpty(), imgExtractRange(), imgFormatFromFName(), imgGetAnalyzeHeader(), imgGetEcat63MHeader(), imgInfo(), imgInit(), imgRead(), imgReadAnalyze(), imgReadAnalyzeFirstFrame(), imgReadAnalyzeFrame(), imgReadAnalyzeHeader(), imgReadEcat63FirstFrame(), imgReadEcat63Frame(), imgReadEcat63Header(), imgReadEcat7(), imgReadEcat7FirstFrame(), imgReadEcat7Frame(), imgReadEcat7Header(), imgReadFrame(), imgReadHeader(), imgReadMicropet(), imgReadMicropetFirstFrame(), imgReadMicropetFrame(), imgReadMicropetHeader(), imgReadMinMax(), imgSetAnalyzeHeader(), imgSetEcat63MHeader(), imgSmoothOverFrames(), imgWrite(), imgWrite2DEcat7(), imgWriteAnalyze(), imgWriteAnalyzeFrame(), imgWriteEcat63Frame(), imgWriteEcat7(), imgWriteEcat7Frame(), imgWriteFrame(), and imgWritePolarmap().

◆ MICROPET_TEST

int MICROPET_TEST

extern

Verbose prints from microPET functions

Definition at line 6 of file micropet.c.

Referenced by imgGetMicropetHeader(), upetHeaderReadParameter(), upetIsHeader(), and upetReadImagedata().

◆ SIF_TEST

int SIF_TEST

extern

Verbose prints from SIF functions

Definition at line 6 of file sif.c.

Referenced by sifEmpty(), sifInit(), sifModerateTrues(), sifModerateWeights(), sifRead(), sifSetmem(), sifWeight(), sifWeightByFrames(), sifWeightNorm(), and sifWrite().

◆ siferrmsg

char siferrmsg[128]

extern

Error message from SIF functions

Definition at line 7 of file sif.c.

Referenced by imgReadModelingData(), sifRead(), sifSetmem(), and sifWrite().

◆ VOL_TEST

int VOL_TEST

extern

Verbose prints from Vol functions

Definition at line 6 of file vol.c.

Referenced by img2svol(), img2vol(), svol2img(), svolAllocate(), svolEmpty(), svolInfo(), svolInit(), vol2img(), volAllocate(), volEmpty(), volInfo(), and volInit().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ ANALYZE_DT_ALL

◆ ANALYZE_DT_BINARY

◆ ANALYZE_DT_COMPLEX

◆ ANALYZE_DT_DOUBLE

◆ ANALYZE_DT_FLOAT

◆ ANALYZE_DT_NONE

◆ ANALYZE_DT_RGB

◆ ANALYZE_DT_SIGNED_INT

◆ ANALYZE_DT_SIGNED_SHORT

◆ ANALYZE_DT_UNKNOWN

◆ ANALYZE_DT_UNSIGNED_CHAR

◆ ATTN_DATA

◆ BACKUP_EXTENSION

◆ BYTE_TYPE

◆ ECAT63_SYSTEM_TYPE_DEFAULT

◆ ECAT7_2DNORM

◆ ECAT7_2DSCAN

◆ ECAT7_3DNORM

◆ ECAT7_3DSCAN

◆ ECAT7_3DSCAN8

◆ ECAT7_3DSCANFIT

◆ ECAT7_ATTEN

◆ ECAT7_BYTE

◆ ECAT7_Feet_First_Decubitus_Left

◆ ECAT7_Feet_First_Decubitus_Right

◆ ECAT7_Feet_First_Prone

◆ ECAT7_Feet_First_Supine

◆ ECAT7_Head_First_Decubitus_Left

◆ ECAT7_Head_First_Decubitus_Right

◆ ECAT7_Head_First_Prone

◆ ECAT7_Head_First_Supine

◆ ECAT7_IEEER4

◆ ECAT7_IMAGE16

◆ ECAT7_IMAGE8

◆ ECAT7_POLARMAP

◆ ECAT7_PROJ

◆ ECAT7_PROJ16

◆ ECAT7_SUNI2

◆ ECAT7_SUNI4

◆ ECAT7_UNKNOWN

◆ ECAT7_Unknown_Orientation

◆ ECAT7_VAXI2

◆ ECAT7_VAXI4

◆ ECAT7_VAXR4

◆ ECAT7_VOLUME16

◆ ECAT7_VOLUME8

◆ IEEE_R4

◆ IMAGE_DATA

◆ IMG_ANA

◆ IMG_ANA_L

◆ IMG_DC_CORRECTED

◆ IMG_DC_NONCORRECTED

◆ IMG_DC_UNKNOWN

◆ IMG_DICOM

◆ IMG_E63

◆ IMG_E7

◆ IMG_E7_2D

◆ IMG_ERR_CALLING

◆ IMG_ERR_OK

◆ IMG_ERR_OOM

◆ IMG_FLAT

◆ IMG_INTERFILE

◆ IMG_MICROPET

◆ IMG_MODALITY_CT

◆ IMG_MODALITY_MRI

◆ IMG_MODALITY_PET

◆ IMG_MODALITY_SPECT

◆ IMG_MODALITY_UNKNOWN

◆ IMG_NIFTI_1D

◆ IMG_NIFTI_1S

◆ IMG_POLARMAP

◆ IMG_STATUS_ERROR

◆ IMG_STATUS_INITIALIZED