micropet.c

Go to the documentation of this file.

/*****************************************************************************

  Copyright (c) 2009,2011 by Turku PET Centre

  Library:      micropet.c
  Description:  Procedures for reading Siemens Inveon images.

  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
  Foundation; either version 2 of the License, or (at your option) any later
  version.

  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  Place, Suite 330, Boston, MA 02111-1307 USA.

  Turku PET Centre hereby disclaims all copyright interest in the program.
  Juhani Knuuti
  Director, Professor
  Turku PET Centre, Turku, Finland, http://www.turkupetcentre.fi/

  Modification history:
  2009-02-17 Vesa Oikonen
       First created.
  2009-02-25 VO
       SIF information extraction is removed from imgMicropetToEcat7().
       New functions imgMicropetPETToEcat7() and imgMicropetCTToEcat7().
  2009-09-28 VO
       If transaxial_bin_size is defined, it is used as pixel z size
       instead of pixel_size_z in imgGetMicropetMainHeader()
       as requested by M Bucci.
  2011-01-11 VO
       Fixed bugs in reading headers and in branching fraction correction.
  2011-08-12 VO
       Added more test prints.
       Works with header version 001.701, in addition to 001.830.
       Reads also version 001.717 but z pixel size is set to zero.
  2011-09-13 VO
       Frame times are read as floats instead of ints.


******************************************************************************/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
/*****************************************************************************/
#include "libtpcmisc.h"
/*****************************************************************************/
#include "include/imgio.h"
/*****************************************************************************/

/*****************************************************************************/
int upetHeaderReadParameter(
  FILE *fp,
  char *parameter,
  char *value
) {
  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) strcpy(value, cptr);
    } 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;
}
/*****************************************************************************/

/*****************************************************************************/
int upetIsHeader(
  char *hdrfile
) {
  char tmp[MAX_MICROPET_LINE_LEN];
  FILE *fp;
  int ret;

  if(hdrfile==NULL || strlen(hdrfile)<5) return 0;
  if(MICROPET_TEST>1) printf("\nupetIsHeader(%s)\n", 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;
}
/*****************************************************************************/

/*****************************************************************************/
int upetExists(
  char *upetname,
  char *hdrfile,
  char *imgfile
) {
  char *cptr, basefile[FILENAME_MAX], temp[FILENAME_MAX];

  if(upetname==NULL || strlen(upetname)==0) return(0);
  if(MICROPET_TEST>1) printf("\nupetExists(%s, *str, *str)\n", upetname);

  /* Construct the base file name wo extensions */
  strcpy(basefile, upetname);
  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(MICROPET_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(MICROPET_TEST) printf("\n  hdr file not found or accessible.\n");
      return(0);
    }
  }
  /* Is this microPET header file? */
  if(upetIsHeader(temp)==0) {
    if(MICROPET_TEST)
      printf("\n  %s was not identified as microPET header file.\n", temp);
    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(MICROPET_TEST) printf("\n  %s not found or accessible.\n", temp);
    return(0);
  }
  /* Preserve image filename */
  if(imgfile!=NULL) strcpy(imgfile, temp);

  return 1;
}
/*****************************************************************************/

/*****************************************************************************/
int upetGetImageDimensions(
  FILE *fp,
  int *z,
  int *x,
  int *y,
  int *f
) {
  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, "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;
}
/*****************************************************************************/

/*****************************************************************************/
int upetScanStart(
  FILE *fp,
  time_t *scant
) {
  char tmp[MAX_MICROPET_LINE_LEN], tmp2[64], tmp3[64];
  int n, i;
  struct tm scanstart={0};

  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;
  } else return 5;

  return 0;
}
/*****************************************************************************/

/*****************************************************************************/
int imgMicropetToEcat7(
  char *upetname,
  char *ecatfile,
  int verbose
) {
  char upetheader[FILENAME_MAX], upetimage[FILENAME_MAX];
  int n, ret;
  int acquisition_mode, data_type;
  FILE *fph, *fpi;
  char tmp[MAX_MICROPET_LINE_LEN];


  if(MICROPET_TEST) printf("\nimgMicropetToEcat7(%s, %s, %d)\n",
    upetname, ecatfile, verbose);
  /* Check the arguments */
  if(upetname==NULL || ecatfile==NULL) return STATUS_FAULT;
  ret=upetExists(upetname, upetheader, upetimage);
  if(ret!=1) return STATUS_NOFILE;

  /*
   *  Open Micropet Header and binary data files
   */
  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(MICROPET_TEST>1) printf("checking that image format is supported\n");
  n=-1; if(upetHeaderReadParameter(fph, "file_type", tmp)==0)
    (void)sscanf(tmp, "%d", &n);
  if(MICROPET_TEST>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(MICROPET_TEST>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(MICROPET_TEST>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
    return(STATUS_UNSUPPORTED);
  fclose(fph); fclose(fpi);
  return ret;
}
/*****************************************************************************/

/*****************************************************************************/
int imgMicropetPETToEcat7(
  FILE *fph,
  FILE *fpi,
  char *ecatfile,
  int verbose
) {
  IMG img;
  int n, pxlnr, zi, xi, yi, ti, zdim, xdim, ydim, tdim, ret;
  float *fptr, calibration_factor;
  char *mdata, *mptr;


  if(MICROPET_TEST>1) printf("imgMicropetPETToEcat7(*fph, *fpi, %s, %d)\n",
                             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
   */
  ret=upetGetImageDimensions(fph, &zdim, &xdim, &ydim, &tdim);
  if(ret) {return(STATUS_INVALIDHEADER);}
  if(MICROPET_TEST>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
   */
  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, &calibration_factor);
  if(ret) {
    if(MICROPET_TEST) printf("ret := %d\n", ret);
    imgEmpty(&img); return(STATUS_INVALIDHEADER);
  }
  if(MICROPET_TEST) 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 */
  pxlnr=xdim*ydim*zdim;
  mdata=(char*)malloc(pxlnr*sizeof(float)); if(mdata==NULL) {
    imgEmpty(&img); return(STATUS_NOMEMORY);
  }
  /* Frame-by-frame */
  for(ti=0; ti<tdim; ti++) {
    if(MICROPET_TEST>3) {printf("ti=%d\n", ti); fflush(stdout);}
    /* Read frame information from MicroPET  header into IMG */
    ret=imgGetMicropetFrameHeader(fph, &img, ti);
    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(MICROPET_TEST>1) printf("    frame written.\n");
    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;
}
/*****************************************************************************/

/*****************************************************************************/
int imgMicropetCTToEcat7(
  FILE *fph,
  FILE *fpi,
  char *ecatfile,
  int verbose
) {
  IMG img;
  int n, pxlnr, zi, xi, yi, zdim, xdim, ydim, ret;
  float f, scale_factor;
  char *mdata, *mptr;
  char tmp[MAX_MICROPET_LINE_LEN];
  short int *si;


  if(MICROPET_TEST>1) printf("imgMicropetCTToEcat7(*fph, *fpi, %s, %d)\n",
                             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(MICROPET_TEST>1) {
    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(MICROPET_TEST>1) {
    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);
  if(ret) {
    if(MICROPET_TEST) 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 */
  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;
        f=(float)*si*scale_factor;
        if(f>=0.0) img.m[zi][yi][xi][0]=f; else img.m[zi][yi][xi][0]=0.0;
        mptr+=2;
      }
    if(MICROPET_TEST>1) 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;
}
/*****************************************************************************/

/*****************************************************************************/
int imgGetMicropetMainHeader(
  FILE *fp,
  IMG *img,
  float *calibration_factor
) {
  char tmp[MAX_MICROPET_LINE_LEN];
  int n;
  float f, branching_fraction=1.0;


  if(MICROPET_TEST>1) printf("imgGetMicropetMainHeader(*fp, *img, *f)\n");
  if(fp==NULL) return 1;
  if(img==NULL) return 2;

  /* scanner model */
  rewind(fp);
  if(MICROPET_TEST>9) 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(MICROPET_TEST>9) 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;


  /* pixel size x */
  rewind(fp);
  if(MICROPET_TEST>9) 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;
  } else {
    rewind(fp);
    if(MICROPET_TEST>9) printf("  reading 'pixel_size'\n");
    if(upetHeaderReadParameter(fp, "pixel_size", tmp)!=0) return 12;
    f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 12;
    f*=10.;
  }
  img->sizex=f;

  /* pixel size y */
  rewind(fp);
  if(MICROPET_TEST>9) 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;
  } else {
    rewind(fp);
    if(MICROPET_TEST>9) printf("  reading 'pixel_size'\n");
    if(upetHeaderReadParameter(fp, "pixel_size", tmp)!=0) return 13;
    f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 12;
    f*=10.;
  }
  img->sizey=f;

  /* pixel size z; note that this is replaced below by transaxial_bin_size */
  rewind(fp);
  if(MICROPET_TEST>9) 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;
  } else {
    rewind(fp);
    if(MICROPET_TEST>9) printf("  reading 'axial_plane_size'\n");
    if(upetHeaderReadParameter(fp, "axial_plane_size", tmp)!=0) {
      if(MICROPET_TEST) printf("  cannot find z pixel size\n");
      f=0.0;
    } else {
      f=-1; (void)sscanf(tmp, "%f", &f); if(f<0) return 14;
      f*=10.;
    }
  }
  img->sizez=f;

  /* transaxial_bin_size */
  rewind(fp);
  if(MICROPET_TEST>9) printf("  reading 'transaxial_bin_size'\n");
  if(upetHeaderReadParameter(fp, "transaxial_bin_size", tmp)==0) {
    f=-1; (void)sscanf(tmp, "%f", &f); if(f>0) img->sizez=10.0*f;
  }

  /* isotope halflife */
  rewind(fp);
  if(MICROPET_TEST>9) 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(MICROPET_TEST>9) 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;
    branching_fraction=f;
  }

  /* decay correction applied */
  rewind(fp);
  if(MICROPET_TEST>9) 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;
    img->decayCorrected=n;
  }

  /* calibration units */
  rewind(fp);
  if(MICROPET_TEST>9) 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=IMGUNIT_NCI_PER_ML; break;
      case 2: img->unit=IMGUNIT_BQ_PER_ML; break;
      case 0:
      default: img->unit=IMGUNIT_UNKNOWN; break;
    }
  }

  /* calibration factor */
  rewind(fp);
  if(MICROPET_TEST>9) 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(branching_fraction>0.0) *calibration_factor/=branching_fraction;
  }

  /* FOV */
  rewind(fp);
  if(MICROPET_TEST>9) 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;
}
/*****************************************************************************/

/*****************************************************************************/
int imgGetMicropetFrameHeader(
  /* File pointer to Concorde/MicroPET header */
  FILE *fp,
  /* Pointer to IMG struct, allocated for one frame; frame information is
     written in frame 0. */
  IMG *img,
  /* Frame index [0..tdim-1] */
  int frame_index
) {
  char tmp[MAX_MICROPET_LINE_LEN];
  float f;


  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(upetHeaderReadParameter(fp, tmp, tmp)!=0) return 5;

  /* frame start time */
  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 */
  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(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(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;
}
/*****************************************************************************/

/*****************************************************************************/
int imgGetMicropetSIF(
  FILE *fp,
  SIF *sif
) {
  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;
  strncpy(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;
}
/*****************************************************************************/

/*****************************************************************************/