imgeval.c

Go to the documentation of this file.

 
/*****************************************************************************/
#include "libtpcimgp.h"
/*****************************************************************************/
 
/*****************************************************************************/
int imgAverageTAC(
  IMG *img,
  float *tac
) {
  return(imgAverageMaskTAC(img, NULL, tac));
}
/*****************************************************************************/
 
/*****************************************************************************/
int imgAverageMaskTAC(
  IMG *img,
  IMG *timg,
  float *tac
) {
  unsigned long long int pxlNr;
  
  if(img==NULL || img->status<IMG_STATUS_OCCUPIED) return(1);
  if(tac==NULL) return(2);
  if(timg!=NULL) {
    if(timg->status<IMG_STATUS_OCCUPIED) return(3);
    /* check that image dimensions are the same */
    if(timg->dimz!=img->dimz || timg->dimz<1) return(5);
    if(timg->dimy!=img->dimy || timg->dimy<1) return(5);
    if(timg->dimx!=img->dimx || timg->dimx<1) return(5);
  }
  /* compute the nr of pixels in the mask */
  if(timg==NULL) {
    pxlNr=img->dimz*img->dimy*img->dimx; 
  } else {
    pxlNr=0;
    for(int zi=0; zi<timg->dimz; zi++)
      for(int yi=0; yi<timg->dimy; yi++) 
        for(int xi=0; xi<timg->dimx; xi++)
          if(timg->m[zi][yi][xi][0]!=0.0) pxlNr++;
  }
  if(pxlNr<1) return(4);
 
  /* compute the TAC */
  for(int fi=0; fi<img->dimt; fi++) {
    tac[fi]=0.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(timg==NULL) tac[fi]+=img->m[zi][yi][xi][fi];
          else if(timg->m[zi][yi][xi][0]!=0.0) tac[fi]+=img->m[zi][yi][xi][fi];
        }
      }
    }
    tac[fi]/=(float)pxlNr;
    //printf("pxlNr=%llu/%llu\n", pxlNr, (unsigned long long)img->dimz*img->dimy*img->dimx);
  }
  return(0);
}
/*****************************************************************************/
 
/*****************************************************************************/
int imgAverageAUC(
  IMG *img,
  float *avgauc
) {
  
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(avgauc==NULL) return(2);
  *avgauc=0.0;
  unsigned long long pxlNr=img->dimz*img->dimy*img->dimx;
  if(pxlNr<1) return(3);
  for(int fi=0; fi<img->dimt; fi++) {
    float fv=0.0;
    float fl=img->end[fi]-img->start[fi]; if(fl<=0.0) return(4);
    for(int pi=0; pi<img->dimz; pi++)
      for(int yi=0; yi<img->dimy; yi++)
        for(int xi=0; xi<img->dimx; xi++)
          fv+=img->m[pi][yi][xi][fi];
    fv/=(float)pxlNr;
    *avgauc+=fv*fl;
  }
  return(0);
}
/*****************************************************************************/
 
/*****************************************************************************/
int imgMaskTAC(
  IMG *img,
  IMG *mask,
  double *tac,
  int verbose
) {
  if(verbose>0) printf("imgMaskTAC()\n");
 
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(mask->status<IMG_STATUS_OCCUPIED) return(2);
  if(mask->dimz!=img->dimz) return(3);
  if(mask->dimy!=img->dimy) return(4);
  if(mask->dimx!=img->dimx) return(5);
  if(img->dimt<1 || mask->dimt<1) return(6);
  if(tac==NULL) return(7);
 
  /* Initiate TAC */
  for(int fi=0; fi<img->dimt; fi++) tac[fi]=0.0;
  /* Add weighted sum to TAC */
  double w=0.0;
  for(int zi=0; zi<mask->dimz; zi++)
    for(int yi=0; yi<mask->dimy; yi++)
      for(int xi=0; xi<mask->dimx; xi++) if(mask->m[zi][yi][xi][0]>0.0) {
        for(int fi=0; fi<img->dimt; fi++)
          tac[fi]+=mask->m[zi][yi][xi][0]*img->m[zi][yi][xi][fi];
        w+=mask->m[zi][yi][xi][0];
      }
  /* Divide sum TAC by sum weights */
  for(int fi=0; fi<img->dimt; fi++) tac[fi]/=w;
  if(verbose>1) printf("mask_sum := %g\n", w);
  if(w<=0.0 && verbose>0)
    fprintf(stderr, "Warning: zero mask applied to image.\n");
 
  return(0);
}
/*****************************************************************************/
 
/*****************************************************************************/
int imgMaskRoiNr(
  IMG *img,
  INTEGER_LIST *list
) {
  /* Check the input */
  if(img==NULL || list==NULL) return 1;
 
  /* Clear any previous list contents */
  if(list->nr>0) {integerListEmpty(list);}
 
  /* Go through the mask image */
  for(int zi=0; zi<img->dimz; zi++)
    for(int yi=0; yi<img->dimy; yi++)
      for(int xi=0; xi<img->dimx; xi++) {
        int v=temp_roundf(img->m[zi][yi][xi][0]);
        if(v>0) {
          int ret=integerListAdd(list, v, 1);
          if(ret<0) return(100+ret);
        }
      }
  /* Sort the list */
  integerListSort(list);
 
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int imgVoiMaskTAC(
  IMG *img,
  IMG *mask,
  int mv,
  double *tac,
  int verbose
) {
  if(verbose>0) printf("imgVoiMaskTAC(img, mask, %d, tac, %d)\n", mv, verbose);
 
  if(img->status<IMG_STATUS_OCCUPIED) return(-1);
  if(mask->status<IMG_STATUS_OCCUPIED) return(-2);
  if(mask->dimz!=img->dimz) return(-3);
  if(mask->dimy!=img->dimy) return(-4);
  if(mask->dimx!=img->dimx) return(-5);
  if(img->dimt<1 || mask->dimt<1) return(-6);
  if(tac==NULL) return(-7);
 
  /* Initiate TAC */
  for(int fi=0; fi<img->dimt; fi++) tac[fi]=0.0;
 
  /* Add the sum to TAC */
  int pxlNr[img->dimt], badNr[img->dimt];
  for(int fi=0; fi<img->dimt; fi++) pxlNr[fi]=badNr[fi]=0;
  for(int zi=0; zi<mask->dimz; zi++) {
    for(int yi=0; yi<mask->dimy; yi++) {
      for(int xi=0; xi<mask->dimx; xi++) {
        double mf=(int)temp_roundf(mask->m[zi][yi][xi][0]);
        if(mf!=mv) continue;
        for(int fi=0; fi<img->dimt; fi++) {
          if(!isfinite(img->m[zi][yi][xi][fi])) {badNr[fi]++; continue;}
          tac[fi]+=img->m[zi][yi][xi][fi]; pxlNr[fi]++;
        }
      }
    }
  }
 
  /* Divide sum TAC by sum weights */
  int minNr=pxlNr[0];
  for(int fi=0; fi<img->dimt; fi++) {
    if(badNr[fi]>0 && verbose>1) {
      fprintf(stderr, "Warning: %d missing pixel values in frame %d.\n", badNr[fi], 1+fi); 
      fflush(stderr);
    }
    if(pxlNr[fi]==0) {
      if(verbose>0) {
        fprintf(stderr, "Warning: zero valid pixels in frame %d.\n", 1+fi); fflush(stderr);
      }
      tac[fi]=nan("");
    }
    if(verbose>1) {
      printf("%d valid pixels inside mask in frame %d\n", pxlNr[fi], 1+fi); fflush(stdout);
    }
    tac[fi]/=(double)pxlNr[fi];
    if(pxlNr[fi]<minNr) minNr=pxlNr[fi];
  }
 
  return(minNr);
}
/*****************************************************************************/
 
/*****************************************************************************/