ecat6_utils.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000- 2008, Hammersmith Imanet Ltd
    This file is part of STIR.

    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license

    See STIR/LICENSE.txt for details
*/

/* History:
  KT 18/08/2000 added  file_data_to_host, get_attnheaders
  KT 11/01/2002 added  normalisation file things, removed get_attndata
  KT 13/01/2008 replace original CTI code with calls to LLN matrix library:
                introduced mhead_ptr in various functions
                have #define STIR_ORIGINAL_ECAT6 to be able to switch between old and new version
*/

#ifndef __stir_IO_ecat6_utils_h
#define __stir_IO_ecat6_utils_h

#include "stir/IO/ecat6_types.h"

#include <stdlib.h>

START_NAMESPACE_STIR
START_NAMESPACE_ECAT
START_NAMESPACE_ECAT6

// CTI UTILITIES

long cti_numcod(int frame, int plane, int gate, int data, int bed);
void cti_numdoc(long matnum, Matval* matval);
int cti_rings2plane(short nrings, short ring0, short ring1);

// FILE ACCESS

FILE* cti_create(const char* fname, const ECAT6_Main_header* mhead);

int cti_rblk(FILE* fptr, int blkno, void* bufr, int nblks);
int cti_wblk(FILE* fptr, int blkno, void* bufr, int nblks);
int cti_read_ECAT6_Main_header(FILE* fptr, ECAT6_Main_header* h);
int cti_read_scan_subheader(FILE* fptr, const ECAT6_Main_header*, int blknum, Scan_subheader*);

int cti_read_attn_subheader(FILE* fptr, const ECAT6_Main_header* h, int blknum, Attn_subheader* header_ptr);

int cti_read_norm_subheader(FILE* fptr, const ECAT6_Main_header* h, int blknum, Norm_subheader* header_ptr);

int cti_read_image_subheader(FILE* fptr, const ECAT6_Main_header* h, int blknum, Image_subheader* header_ptr);

int cti_enter(FILE* fptr, const ECAT6_Main_header* mhead_ptr, long matnum, int nblks);
int cti_lookup(FILE* fptr, const ECAT6_Main_header* mhead_ptr, long matnum, MatDir* entry);
int cti_write_idata(FILE* fptr, int blk, const short* data, int isize);
int cti_write_image_subheader(FILE* fptr, const ECAT6_Main_header* h, int blknum, const Image_subheader* header_ptr);
int cti_write_ECAT6_Main_header(FILE* fptr, const ECAT6_Main_header* header_ptr);
int cti_write_scan_subheader(FILE* fptr, const ECAT6_Main_header* h, int blknum, const Scan_subheader* header_ptr);

int cti_write_image(FILE* fptr,
                    long matnum,
                    const ECAT6_Main_header* mhead_ptr,
                    const Image_subheader* header_ptr,
                    const short* data,
                    int data_size);
int cti_write_scan(FILE* fptr,
                   long matnum,
                   const ECAT6_Main_header* mhead_ptr,
                   const Scan_subheader* header_ptr,
                   const short* data,
                   int data_size);
int get_scanheaders(FILE* fptr, long matnum, ECAT6_Main_header* mhead, Scan_subheader* shead, ScanInfoRec* scanParams);
// KT 18/05/2000 changed type from short to char

int get_scandata(FILE* fptr, char* scan, ScanInfoRec* scanParams);

int get_attnheaders(FILE* fptr, long matnum, ECAT6_Main_header* mhead, Attn_subheader* shead, ScanInfoRec* attnParams);

int get_normheaders(FILE* fptr, long matnum, ECAT6_Main_header* mhead, Norm_subheader* shead, ScanInfoRec* nrmParams);

// OTHER UTILITIES

int file_data_to_host(char* dptr, int nblks, int dtype);

#ifdef STIR_ORIGINAL_ECAT6

/*
  \brief Find minimum and maximum values in a buffer of floats
  \ingroup ECAT

  \param buf    array of count floats
  \param min    will be set to the smallest positive float in buf
  \param max    will be set to the largest float contained in buf
  \param count  number of elements in buf
*/
void ffind_minmax(float* buf, float* min, float* max, int bufsize);
/*
  \brief Find minimum and maximum values in a buffer of shorts

  \param buf      array of bufsize shorts
  \param min      will be set to the smallest positive short in buf
  \param max      will be set to the largest short contained in buf
  \param bufsize  number of elements in array
*/
void sfind_minmax(short* buf, short* min, short* max, int bufsize);
/*
  \brief Copy array, swapping bytes as we go

  \param from    input array
  \param to      output array (may be same as input array)ibytes
  \param length  total number of bytes to copy
*/
void swab(char* from, char* to, int length);
/*
  \brief Copy array, swapping 16-bit words as we go.

  \param from    data buffer to copy.
  \param to      where to copy the data.  may be same as (or overlap) from.
  \param length  number of 16-bit words to swap
*/
void swaw(short* from, short* to, int length);
/*
  \brief Get indexed value from buffer, a vax float, and return it as an IEEE float.
  (a swab has to be performed first on bigendian machines)

  \param bufr  input data buffer.
  \param off   offset into buffer of first 16-bit half of the 32-bit value to convert.
*/
float get_vax_float(const unsigned short* bufr, int off);
/*
  \brief Get the indexed value from a buffer, a 32-bit vax long, and convert it by swapping the words.
  (a swab has to be performed first on bigendian machines)

  \param bufr  input data buffer.
  \param off   index into buffer of first 16-bit word of the 32-bit value to convert.
*/
long get_vax_long(const unsigned short* bufr, int off);
void dump_ECAT6_Main_header(FILE* fptr, const ECAT6_Main_header* mhead);
/*
  \brief Convert a sun long int to a vax long int, i.e. swap the 16-bit words of the 32-bit long.
  (sun long = sun int = 32 bits)
  (a swab has to be performed afterwards on bigendian machines)

  \param in   value to convert.
  \param out  result.
*/
void hostltovaxl(const long in, unsigned short out[2]);
/*
  \brief Convert a host float to a vax float
  (a swab has to be performed afterwards on bigendian machines)

  \param in   value to convert.
  \param out  result.
*/
void hostftovaxf(const float in, unsigned short out[2]);

ECAT6_Main_header main_zero_fill();
#endif // STIR_ORIGINAL_ECAT6

Scan_subheader scan_zero_fill();
Image_subheader img_zero_fill();

END_NAMESPACE_ECAT6
END_NAMESPACE_ECAT
END_NAMESPACE_STIR
#endif