Beispiel #1
0
/*!
 * 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.
 *
 * @param fp ECAT file pointer
 * @param first_block Subheader record number
 * @param last_block Last data block number
 * @param h Ptr to subheader data which is filled
 * @param fdata Ptr to the address of the matrix data
 * @return 0 if ok, 1 invalid input, 5 failed to read sub header, 
 * 6 invalid (x,y,z) dimesions, 8 failed to allocate memory for meta-data,
 * 9 failed to read matrix data, 11 failed to allocate memory for image data
 */
int ecat63ReadImageMatrix(FILE *fp, int first_block, int last_block, ECAT63_imageheader *h, float **fdata) {
  int i, ret, blockNr, pxlNr;
  char *mdata, *mptr;
  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);
  if(ret) {
    sprintf(ecat63errmsg, "cannot read subheader (%d).\n", ret);
    return(5);
  }
  if(ECAT63_TEST>4) ecat63PrintImageheader(h, stdout);
  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(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(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(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(i=0; i<pxlNr; i++, mptr+=2, fptr++) {
      sptr=(short int*)mptr;
      *fptr=h->quant_scale*(float)(*sptr);
    }
  } else if(h->data_type==VAX_I4 || h->data_type==SUN_I4) {
    for(i=0; i<pxlNr; i++, mptr+=4, fptr++) {
      iptr=(int*)mptr;
      *fptr=h->quant_scale*(float)(*iptr);
    }
  } else if(h->data_type==VAX_R4 || h->data_type==IEEE_R4) {
    memcpy(fptr, mptr, pxlNr*4);
    for(i=0; i<pxlNr; i++, fptr++) *fptr *= h->quant_scale;
  }
  free(mdata);
  *fdata=_fdata;

  return(0);
}
Beispiel #2
0
/** Print ECAT63 subheader contents into specified file pointer.
\return Returns 0 when successful.
 */
int ecat6PrintSubheader(
  /** ECAT 6.3 mainheader (not printed but needed here) */
  ECAT63_mainheader mh,
  /** File pointer to ECAT 6.3 file */
  FILE *fp,
  /** ECAT 6.3 plane */
  int plane,
  /** ECAT 6.3 frame */
  int frame,
  /** Output is written to this file pointer; it can be stdout */
  FILE *ofp
) {
  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);
  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
   */
  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;
    /* Read subheader */
    if(mh.file_type==IMAGE_DATA)
      ret=ecat63ReadImageheader(fp, mlist.matdir[mi].strtblk, &image_header);
    else if(mh.file_type==RAW_DATA)
      ret=ecat63ReadScanheader(fp, mlist.matdir[mi].strtblk, &scan_header);
    else if(mh.file_type==ATTN_DATA)
      ret=ecat63ReadAttnheader(fp, mlist.matdir[mi].strtblk, &attn_header);
    else if(mh.file_type==NORM_DATA)
      ret=ecat63ReadNormheader(fp, mlist.matdir[mi].strtblk, &norm_header);
    if(ret) {
      fprintf(stderr, "Error: cannot read matrix %u subheader.\n",
         mlist.matdir[mi].matnum);
      ecat63EmptyMatlist(&mlist); return 4;
    }
    /* Print subheader */
    fprintf(fp, "Matrix: plane %d frame %d gate %d bed %d\n",
      matval.plane, matval.frame, matval.gate, matval.bed);
    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(nr==0 && (plane>=0 || frame>=0)) {
    fprintf(stderr, "Error: specified matrices not found.\n");
    return(11);
  }

  return(0);
}