Header file for libtpcimgp. 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"
#include "libtpcimgio.h"

Data Structures
struct	point

Macros
#define	PET_GRAYSCALE 1

#define	PET_GRAYSCALE_INV 2

#define	PET_RAINBOW 3

#define	PET_RAINBOW_WB 4

Functions
int	imgArithm (IMG img1, IMG img2, char operation, float ulimit, int verbose)

int	imgArithmConst (IMG *img, float operand, char operation, float ulimit, int verbose)

int	imgArithmFrame (IMG img1, IMG img2, char operation, float ulimit, int verbose)

int	imgLn (IMG *img)

int	imgLog10 (IMG *img)

int	imgAbs (IMG *img)

int	imgInv (IMG *img)

int	imgFrameIntegral (IMG img, int first, int last, IMG iimg, int verbose)

int	imgRawCountsPerTime (IMG *img, int operation)

int	imgConvertUnit (IMG img, char unit)

int	imgAUMC (IMG img, IMG oimg, int verbose)

int	imgMRT (IMG img, IMG oimg, int verbose)

int	imgAverageTAC (IMG img, float tac)

int	imgAverageMaskTAC (IMG img, IMG timg, float *tac)

int	imgAverageAUC (IMG img, float avgauc)

int	imgMaskTAC (IMG img, IMG mask, double *tac, int verbose)

int	imgMaskRoiNr (IMG img, INTEGER_LIST list)

int	imgVoiMaskTAC (IMG img, IMG mask, int mv, double *tac, int verbose)

int	imgGaussianFIRFilter (IMG *img, float xsd, float ysd, float zsd, double tolerance, int verbose)

int	imgGaussianAMFilter (IMG *img, float xsd, float ysd, float zsd, int passNr, double tolerance, int verbose)

int	filterAMGaussian (double *a, int n, int passNr, double nu, double scale, int termNr)

int	filterHSSBE (int n, int r)

double	filterAMLB (double *a, int n, double nu, int termNr)

int	imgGaussianEBoxFilter (IMG *img, float xsd, float ysd, float zsd, int passNr, int verbose)

int	filterEbox (double *a, int n, double wob, double wib, int rib, int passNr)

int	fMean1DFilter (float *data, const int n, const int s)

int	imgMeanFilter (IMG *img, int xn, int yn, int zn, int tn, int verbose)

void	imgFlipHorizontal (IMG *img)

void	imgFlipVertical (IMG *img)

void	imgFlipPlanes (IMG *img)

int	imgFlipRight (IMG *img)

int	imgFlipAbove (IMG *img)

int	imgMeanZ (IMG img1, IMG img2)

int	imgFramesCheck (IMG *img, int verbose)

int	imgFrameGapFill (IMG *img, int verbose)

int	imgDeleteFrameOverlap_old (IMG *img)

int	imgDeleteFrameOverlap (IMG *img)

int	imgSmoothOverFrames (IMG *img, int n)

int	imgGetFrameDiff (IMG img, IMG dimg, IMG *mimg, int verbose)

int	imgGetFrameDyn (IMG img, IMG iimg, IMG *dimg, int verbose)

int	imgSetScanner (IMG *img, int scanner_type)

int	imgsegmThresholdMask (IMG img, float minValue, float maxValue, IMG timg)

int	imgsegmThresholdByMask (IMG img, IMG template, float minValue, float maxValue)

int	imgsegmThreshold (IMG *img, float minValue, float maxValue)

int	imgsegmMaskToCluster (IMG *img)

int	imgsegmFindMaxOutsideClusters (IMG sumimg, IMG cluster, float max, int plane, int row, int col)

int	imgsegmClusterExpand (IMG cluster, IMG sum, IMG *dynamic, int clusterID, int pi, int ri, int ci, int pj, int rj, int cj, float CVlim, float CClim, int verbose)

float	imgsegmPearson (float x, float y, long long nr)

int	imgsegmClusterMean (IMG dimg, IMG cimg, int clusterID, float *avg, int verbose)

int	imgsegmCheckNeighbours (IMG *cimg, int pi, int ri, int ci)

int	imgsegmFindBestNeighbour (IMG dimg, IMG cimg, int pi, int ri, int ci)

int	imgsegmSimilar (IMG input, int smoothDim, int smoothNr, IMG output, int verbose)

int	imgsegmCalcMRL (float y1[], float y2[], long long n)

int	imgThresholding (IMG img, float threshold_level, long long thr_nr)

int	imgThresholdingLowHigh (IMG img, float lower_threshold_level, float upper_threshold_level, IMG timg, long long lower_thr_nr, long long upper_thr_nr)

int	imgOutlierFilter (IMG *img, float limit)

int	imgThresholdMaskCount (IMG img, float minValue, float maxValue, IMG timg, long long *count)

int	imgThresholdMask (IMG img, float minValue, float maxValue, IMG timg)

int	imgThresholdByMask (IMG img, IMG templt, float thrValue)

void	imgCutoff (IMG *image, float cutoff, int mode)

int	imgRegionGrowingByThreshold (IMG img, const int sz, const int sy, const int sx, float lthr, float uthr, IMG mask, int verbose)

int	tiffWriteImg (IMG img, int plane, int frame, float maxvalue, int colorscale, char fname, int matXdim, int matYdim, int verbose, char status)

int	img2cube (IMG img1, int dim, IMG img2)

void	imgScale (IMG src, IMG targ, float zoom, int method)

void	integerScale (int frame, float *src, float targ, int width, int height, int zoom)

int	imgShrink (IMG img1, IMG img2, int doz)

int	imgSwell (IMG img1, IMG img2, int doz)

long long	imgMaskCount (IMG *img)

int	imgMaskErode (IMG img, IMG se)

int	imgMaskDilate (IMG img, IMG se)

int	imgStructuringElement (IMG *img, const int structuring_element, int verbose)

void	imgMaskInvert (IMG *img)

int	imgMaskConjunction (IMG mask1, IMG mask2)

int	imgMaskRegionLabeling (IMG mask1, IMG mask2, int *n, int verbose)

int	imgMaskFloodFill (IMG m, int sz, int sy, int sx, int label, long long n, int verbose)

int	imgMaskCloak (IMG *img, int dim, float id)

int	pRound (float)

float	getDistance (point, point)

float	getAngle (point, point)

Detailed Description

Header file for libtpcimgp.

Author: Vesa Oikonen

Definition in file libtpcimgp.h.

Macro Definition Documentation

◆ PET_GRAYSCALE

#define PET_GRAYSCALE 1

PET image color scale

Definition at line 32 of file libtpcimgp.h.

Referenced by tiffWriteImg().

◆ PET_GRAYSCALE_INV

#define PET_GRAYSCALE_INV 2

PET image color scale

Definition at line 34 of file libtpcimgp.h.

◆ PET_RAINBOW

#define PET_RAINBOW 3

PET image color scale

Definition at line 36 of file libtpcimgp.h.

Referenced by tiffWriteImg().

◆ PET_RAINBOW_WB

#define PET_RAINBOW_WB 4

PET image color scale

Definition at line 38 of file libtpcimgp.h.

Referenced by tiffWriteImg().

Function Documentation

◆ filterAMGaussian()

int filterAMGaussian	(	double *	a,
		int	n,
		int	passNr,
		double	nu,
		double	scale,
		int	termNr )

extern

1D Alvarez-Mazorra Gaussian filtering.

See also: imgGaussianAMFilter

Returns: If an error is encountered, function returns a non-zero value. Otherwise 0 is returned.

Parameters

a	Pointer to source data array, overwritten by the results.
n	Sample number.
passNr	Number of filtering passes; usually 4.
nu	Filter coefficient.
scale	Filter scale.
termNr	Number of terms needed to approximate the sum with required accuracy for the left boundary.

Definition at line 314 of file imgfilter.c.

  {
  if(a==NULL || n<3) return(1);
  if(!(nu>0.0)) return(2);
  if(passNr<1) passNr=4;
  if(termNr<6) termNr=6;
 
  /* Scale the data. */
  for(int i=0; i<n; i++) a[i]*=scale;
 
  /* Loop through the passes of filtering */
  for(int pass=0; pass<passNr; pass++) {
    a[0]=filterAMLB(a, n, nu, termNr);
    for(int i=1; i<n; i++) a[i]+=nu*a[i-1]; // causal filter
    a[n-1]/=(1.0-nu);
    for(int i=n-1; i>0; i--) a[i-1]+=nu*a[i]; // anti-causal filter
  }
  return(0);
}

Referenced by imgGaussianAMFilter().

◆ filterAMLB()

double filterAMLB	(	double *	a,
		int	n,
		double	nu,
		int	termNr )

extern

Left boundary for 1D Alvarez-Mazorra Gaussian filtering.

See also: filterAMGaussian, filterHSSBE

Returns: The sum approximating the first filtered sample value, or NaN in case of an error.

Parameters

a	Pointer to source data array; not modified.
n	Sample number.
nu	Filtering parameter.
termNr	Number of terms.

Definition at line 372 of file imgfilter.c.

  {
  if(a==NULL || n<1) return(nan(""));
  double h=1.0, sum=a[0];
  for(int m=1; m<termNr; m++) {
    h*=nu;
    sum+=h*a[filterHSSBE(n, -m)];
  }
  return(sum);
}

Referenced by filterAMGaussian().

◆ filterEbox()

int filterEbox	(	double *	a,
		int	n,
		double	wob,
		double	wib,
		int	rib,
		int	passNr )

extern

1D extended box filtering .

See also: imgFast1DGaussianFilter

Returns: If an error is encountered, function returns a non-zero value. Otherwise 0 is returned.

Parameters

a	Pointer to source data array.
n	Sample number.
wob	Weight of the outer box.
wib	Weight of the inner box.
rib	Radius of the inner box.
passNr	Number of filtering passes.

Definition at line 558 of file imgfilter.c.

  {
  if(a==NULL || n<3 || wob<=0.0 || wib<=0.0 || rib<0) return(1);
  double buf[n];
  for(int pass=0; pass<passNr; pass++) {
    double accum=0.0;
    for(int i=-rib; i<=rib; i++) accum+=a[filterHSSBE(n, i)];
    buf[0]=wob*(a[filterHSSBE(n, rib+1)] + a[filterHSSBE(n, -rib-1)]) + (wob+wib)*accum;
    accum=buf[0];
    for(int i=1; i<n; i++) {
      accum += wob*(a[filterHSSBE(n, i+rib+1)] - a[filterHSSBE(n, i-rib-2)])
             + wib*(a[filterHSSBE(n, i+rib)] - a[filterHSSBE(n, i-rib-1)]);
      buf[i]=accum;
    }
    for(int i=0; i<n; i++) a[i]=buf[i];
  }
  return(0);
}

Referenced by imgGaussianEBoxFilter().

◆ filterHSSBE()

int filterHSSBE	(	int	n,
		int	r )

externinline

Half-sample symmetric boundary extension.

See also: filterEbox, filterAMLB

Returns: Reflected sample in array[0..n-1].

Parameters

n	Sample number.
r	Requested sample, possibly outside array[0..N-1].

Definition at line 352 of file imgfilter.c.

  {
  while(1) {
    if(r<0) r=-1-r;
    else if(r>=n) r=2*n-1-r;
    else break;
  }
  return(r);
}

Referenced by filterAMLB(), filterEbox(), and imgGaussianFIRFilter().

◆ fMean1DFilter()

int fMean1DFilter	(	float *	data,
		const int	n,
		const int	s )

extern

In-place mean 1D-filtering.

See also: imgMeanFilter

Returns: If an error is encountered, function returns a non-zero value. Otherwise 0 is returned.

Parameters

data	Pointer to array to be filtered.
n	Array size.
s	Filter size; should be odd number 3,5,7,... but not verified here.

Definition at line 595 of file imgfilter.c.

  {
  if(data==NULL || n<1 || s<1) return(1);
  float buf[n];
  for(int i=0; i<n; i++) buf[i]=data[i];
  for(int i=0; i<n; i++) {
    data[i]=0.0;
    int a=i-(s-1)/2; if(a<0) a=0;
    int b=i+(s-1)/2; if(b>=n) b=n-1;
    int m=1+b-a;
    for(int j=a; j<=b; j++) data[i]+=buf[j];
    data[i]/=(float)m;
  }
  return(0);
}

Referenced by imgMeanFilter().

◆ getAngle()

float getAngle	(	point	begin,
		point	center )

extern

Calculates xy-projection of angle FCX in degrees, where F=first point, C=centre point and X=point with higher x coordinate (y and z coordinate remain the same).

This is used to calculate polar angle with two dimensional points (z=constant).

Returns: Angle first - centre - x in degrees (0-360) and -360.0 if first point is equal to centre point.

See also: getDistance

Parameters

begin	First point.
center	Centre point.

Definition at line 55 of file point.c.

  {
  float dx, dy;
  dx = begin.x - center.x;  // Difference in x coordinates.
  dy = begin.y - center.y;  // Difference in y coordinates.
 
  // Check trivial cases.
  if(dx == 0.0){
    if(dy == 0.0) return -360.0;
    if(dy > 0.0) return 90.0;
    else return 270.0;
  }
  if(dy==0.0){
    if(dx > 0.0) return 0.0;
    else return 180.0;
  }
 
  // If it was not a trivial case, then calculate angle in...
  // ...the second and the third quarter.
  if(dx<0.0) return 180.0 + atan(dy/dx)*180.0/M_PI;
 
  // ...the first quarter.
  if(dy>0.0) return atan(dy/dx)*180.0/M_PI;
 
  // ...the fourth quarter.
  return 360.0 + atan(dy/dx)*180.0/M_PI;
}

◆ getDistance()

float getDistance	(	point	begin,
		point	end )

extern

Calculate distance between points

See also: getAngle

Returns: Distance.

Parameters

begin	First point
end	Second point

Definition at line 31 of file point.c.

  {
  float dx, dy, dz;
 
  dx = begin.x - end.x; // Difference in x coordinates.
  dy = begin.y - end.y; // Difference in y coordinates.
  dz = begin.z - end.z; // Difference in z coordinates.
  return sqrt(dx*dx + dy*dy + dz*dz);
}

◆ img2cube()

int img2cube	(	IMG *	img1,
		int	dim,
		IMG *	img2 )

extern

Resample image to cubic image volume, where all three dimensions are the same, with cubic voxel sizes. Note that some smoothing occurs in the process, therefore the use of this function should be limited to illustrations of image data.

See also: imgFlipHorizontal, imgFlipVertical, imgFlipAbove, imgScale, imgSwell, imgShrink

Returns: Returns 0 if successful, otherwise <>0.

Parameters

img1	Pointer to IMG to be resliced; this image is not modified.
dim	New dimension; enter 0 to use the largest dimension in image.
img2	Pointer to initiated IMG where resliced data will be stored.

Definition at line 16 of file imgtransform.c.

  {
  int ret, n, testf;
  int xi, yi, zi, xj, yj, zj, fi, xp, yp, zp;
  double xsize, ysize, zsize, newsize;
  double xdist, ydist, zdist;
  double xpc, ypc, zpc, xd, yd, zd;
  double w, wsum, d;
 
  if(IMG_TEST>0) printf("img2cube(img1, img2)\n"); 
  if(img1->status!=IMG_STATUS_OCCUPIED) return(1);
  if(img2->status==IMG_STATUS_OCCUPIED) imgEmpty(img2);
 
  if(IMG_TEST>1)
    printf("original dimensions (x,y,z) := %d,%d,%d\n", img1->dimx, img1->dimy, img1->dimz);
  if(dim<1) {
    /* Get the largest dimension of original image volume */
    dim=img1->dimz; n=0;
    if(img1->dimx>dim) {dim=img1->dimx; n++;}
    if(img1->dimy>dim) {dim=img1->dimy; n++;}
  }
  if(IMG_TEST>1) printf("new dimensions (x,y,z) := %d,%d,%d\n", dim, dim, dim);
  testf=dim*dim*dim/10;
 
  /* Allocate memory for the new IMG */
  ret=imgAllocate(img2, dim, dim, dim, img1->dimt);
  if(ret) return(10+ret);
  imgCopyhdr(img1, img2);
 
  /* Calculate the physical extensions of original image volume */
  xsize=img1->dimx*(img1->sizex + img1->gapx); 
  ysize=img1->dimy*(img1->sizey + img1->gapy); 
  zsize=img1->dimz*(img1->sizez + img1->gapz);
  if(IMG_TEST>1) printf("original image size (x,y,z) in mm := %g,%g,%g\n", xsize, ysize, zsize);
  /* New image volume will be a cube of highest size of those */
  newsize=xsize; n=0;
  if(ysize>newsize) {newsize=ysize; n++;}
  if(zsize>newsize) {newsize=zsize; n++;}
  if(IMG_TEST>1) {
    printf("original image size (x,y,z) in mm := %g,%g,%g\n",
      xsize, ysize, zsize);
    if(n>0) printf("new image size (x,y,z) in mm:= %g,%g,%g\n",
      newsize, newsize, newsize);
    else printf("original image size needs not to be changed.\n");
  }
  img2->gapx=img2->gapy=img2->gapz=0.0;
  img2->sizex=img2->sizey=img2->sizez=newsize/(double)dim;
 
  /* Resample the image volume */
  n=0;
  for(zj=0; zj<dim; zj++) for(yj=0; yj<dim; yj++) for(xj=0; xj<dim; xj++) {
    if(IMG_TEST>3 && n%testf==0) printf("zj=%d yj=%d xj=%d\n", zj, yj, xj);
    /* Calculate the distance of this voxel from the mid of new image volume */
    xdist=((double)xj+0.5)*img2->sizex - 0.5*newsize;
    ydist=((double)yj+0.5)*img2->sizey - 0.5*newsize;
    zdist=((double)zj+0.5)*img2->sizez - 0.5*newsize;
    if(IMG_TEST>3 && n%testf==0)
      printf("  xdist=%g ydist=%g zdist=%g\n", xdist, ydist, zdist);
    /* The place in coordinates of original image */
    xpc=(0.5*xsize+xdist)/(img1->sizex + img1->gapx);
    ypc=(0.5*ysize+ydist)/(img1->sizey + img1->gapy);
    zpc=(0.5*zsize+zdist)/(img1->sizez + img1->gapz);
    /* Inside which voxel it resides? */
    xp=(int)(xpc+0.5); yp=(int)(ypc+0.5); zp=(int)(zpc+0.5);
    if(IMG_TEST>3 && n%testf==0)
      printf("  inside pixel %d,%d,%d\n", xp, yp, zp);
    /* Calculate 1/distance-weighted average of 3x3x3 pixels around it */
    for(fi=0; fi<img1->dimt; fi++) img2->m[zj][yj][xj][fi]=0.0;
    wsum=0.0;
    for(zi=zp-1; zi<=zp+1; zi++)
      for(yi=yp-1; yi<=yp+1; yi++) for(xi=xp-1; xi<=xp+1; xi++) {
        /* Distance between voxels */
        xd=(0.5+xi)-xpc; yd=(0.5+yi)-ypc; zd=(0.5+zi)-zpc;
        d=xd*xd+yd*yd+zd*zd; //if(d>0.0) d=sqrt(d); else d=0.0;
        if(IMG_TEST>3 && n%testf==0)
          printf("    distance^2 from (%d,%d,%d) := %g\n", xi, yi, zi, d);
        /* Add weight to the weight sum */
        w=exp(-d); wsum+=w;
        if(IMG_TEST>3 && n%testf==0) printf("    weight := %g\n", w);
        /* If voxel is inside the image, add value to the sum */
        if(zi>=0 && yi>=0 && xi>=0 && zi<img1->dimz && yi<img1->dimy && xi<img1->dimx) {
          for(fi=0; fi<img1->dimt; fi++) {
            img2->m[zj][yj][xj][fi]+=w*img1->m[zi][yi][xi][fi];
          }
        }
      }
    /* Divide the sum with sum weight */
    for(fi=0; fi<img1->dimt; fi++) img2->m[zj][yj][xj][fi]/=wsum;
    if(IMG_TEST>3 && n%testf==0)
      printf("  weighted avg in 1st frame := %g\n", img2->m[zj][yj][xj][0]);
    n++;
  }
 
  return 0;
}

◆ imgAbs()

int imgAbs ( IMG * img )

extern

Replace IMG data values by their absolute values.

See also: imgLog10, imgLn, imgArithm, imgMatch

Returns: Returns 0, if ok.

Parameters

img	Pointer to IMG data.

Definition at line 292 of file imgarithm.c.

  {
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(2);
  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]=fabsf(img->m[pi][yi][xi][fi]);
  return(0);
}

◆ imgArithm()

int imgArithm	(	IMG *	img1,
		IMG *	img2,
		char	operation,
		float	ulimit,
		int	verbose )

extern

Simple arithmetics between matching IMG planes and frames. Specify the operation as one of characters +, -, /, :, *, ., x. Results that are higher than ulimit are set to ulimit.

See also: imgArithmConst, imgArithmFrame, imgRawCountsPerTime, imgConvertUnit, imgSS

Returns: Returns 0, if ok.

Parameters

img1	The first IMG data.
img2	The second IMG data.
operation	Operation, one of the characters +, -, /, :, *, ., x.
ulimit	Results that are higher than ulimit are set to ulimit; set to <=0 if not needed.
verbose	Verbose level; if <=0, then nothing is printed into stderr.

Definition at line 16 of file imgarithm.c.

  {
  if(verbose>0) printf("%s(img1, img2, '%c', %g, %d)\n", __func__, operation, ulimit, verbose);
 
  /* Check the arguments */
  if(img1->status!=IMG_STATUS_OCCUPIED || img2->status!=IMG_STATUS_OCCUPIED) {
    if(verbose>0) fprintf(stderr, "Invalid image status.\n");
    return(1);
  }
  int ret=0;
  if(img1->dimx!=img2->dimx || img1->dimy!=img2->dimy) ret=1;
  /* Check the plane numbers */
  if(img1->dimz!=img2->dimz) ret=2;
  if(ret==0) for(int pi=0; pi<img1->dimz; pi++)
    if(img1->planeNumber[pi]!=img2->planeNumber[pi]) ret=2;
  /* Check the frame numbers */
  if(img1->dimt!=img2->dimt) ret=3;
  if(ret>0) {
    if(verbose>0) fprintf(stderr, "Image dimensions do not match.\n");
    return(ret);
  }
 
  /* Operate */
  switch(operation) {
    case '+':
      for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
        for(int xi=0; xi<img1->dimx; xi++) for(int fi=0; fi<img1->dimt; fi++)
          img1->m[pi][yi][xi][fi]+=img2->m[pi][yi][xi][fi];
      break;
    case '-':
      for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
        for(int xi=0; xi<img1->dimx; xi++) for(int fi=0; fi<img1->dimt; fi++)
          img1->m[pi][yi][xi][fi]-=img2->m[pi][yi][xi][fi];
      break;
    case '/':
    case ':':
      for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
        for(int xi=0; xi<img1->dimx; xi++) for(int fi=0; fi<img1->dimt; fi++) {
          if(fabs(img2->m[pi][yi][xi][fi])>1.0E-5)
            img1->m[pi][yi][xi][fi]/=img2->m[pi][yi][xi][fi];
          else img1->m[pi][yi][xi][fi]=0.0;
        }
      break;
    case '*':
    case 'x':
    case '.':
      for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
        for(int xi=0; xi<img1->dimx; xi++) for(int fi=0; fi<img1->dimt; fi++)
          img1->m[pi][yi][xi][fi]*=img2->m[pi][yi][xi][fi];
      break;
    default:
      if(verbose>0) fprintf(stderr, "Invalid operation.\n");
      return(10);
  }
 
  /* Check for limits */
  if(ulimit>0.0) {
    for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
      for(int xi=0; xi<img1->dimx; xi++) for(int fi=0; fi<img1->dimt; fi++)
        if(img1->m[pi][yi][xi][fi]>ulimit) img1->m[pi][yi][xi][fi]=ulimit;
  }
 
  return(0);
}

◆ imgArithmConst()

int imgArithmConst	(	IMG *	img,
		float	operand,
		char	operation,
		float	ulimit,
		int	verbose )

extern

Simple arithmetic between IMG and specified constant.

Specify the operation as one of characters +, -, /, :, *, ., x. Results that are higher than ulimit are set to ulimit.

See also: imgArithm, imgScale, imgInv, imgArithmFrame, imgRawCountsPerTime, imgConvertUnit

Returns: Returns 0, if ok.

Parameters

img	IMG data which is modified.
operand	Constant value which is used to modify the data.
operation	Operation, one of the characters +, -, /, :, *, ., x.
ulimit	Results that are higher than ulimit are set to ulimit; set to <=0 if not needed.
verbose	Verbose level; if <=0, then nothing is printed into stderr.

Definition at line 100 of file imgarithm.c.

  {
  if(verbose>0) printf("%s(img, %g, '%c', %g, %d)\n", __func__, operand, operation, ulimit, verbose);
 
  /* Check the arguments */
  if(img->status!=IMG_STATUS_OCCUPIED) {
    if(verbose>0) fprintf(stderr, "Invalid image status.\n");
    return(1);
  }
  switch(operation) {
    case '+':
      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]+=operand;
      break;
    case '-':
      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]-=operand;
      break;
    case '/':
    case ':':
      if(fabs(operand)<1.0e-100) return(2);
      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]/=operand;
      break;
    case '*':
    case 'x':
    case '.':
      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]*=operand;
      break;
    default:
      if(verbose>0) fprintf(stderr, "Invalid operation.\n");
      return(10);
  }
 
  /* Check for limits */
  if(ulimit>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++)
        if(img->m[pi][yi][xi][fi]>ulimit) img->m[pi][yi][xi][fi]=ulimit;
  }
 
  return(0);
}

Referenced by imgConvertUnit(), and imgTimeIntegral().

◆ imgArithmFrame()

int imgArithmFrame	(	IMG *	img1,
		IMG *	img2,
		char	operation,
		float	ulimit,
		int	verbose )

extern

Simple arithmetic between matching IMG planes and the first frame of img2.

Specify the operation as one of characters +, -, /, :, *, ., x. Results that are higher than ulimit are set to ulimit.

See also: imgArithmConst, imgArithm, imgFrameIntegral

Returns: Returns 0, if ok.

Parameters

img1	IMG data which is modified.
img2	Operand IMG data, only the first frame is used.
operation	Operation, one of the characters +, -, /, :, *, ., x.
ulimit	Results that are higher than ulimit are set to ulimit; set to <=0 if not needed.
verbose	Verbose level; if <=0, then nothing is printed into stderr.

Definition at line 168 of file imgarithm.c.

  {
  if(verbose>0) printf("%s(img1, img2, '%c', %g, %d)\n", __func__, operation, ulimit, verbose);
 
  /* Check the arguments */
  if(img1->status!=IMG_STATUS_OCCUPIED || img2->status!=IMG_STATUS_OCCUPIED) {
    if(verbose>0) fprintf(stderr, "Invalid image status.\n");
    return(1);
  }
  int ret=0;
  if(img1->dimx!=img2->dimx || img1->dimy!=img2->dimy) ret=1;
  /* Check the plane numbers */
  if(img1->dimz!=img2->dimz) ret=2;
  if(ret==0) for(int pi=0; pi<img1->dimz; pi++)
    if(img1->planeNumber[pi]!=img2->planeNumber[pi]) ret=2;
  if(ret>0) {
    if(verbose>0) fprintf(stderr, "Image dimensions do not match.\n");
    return(ret);
  }
 
  /* Operate */
  switch(operation) {
    case '+':
      for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
        for(int xi=0; xi<img1->dimx; xi++) for(int fi=0; fi<img1->dimt; fi++)
          img1->m[pi][yi][xi][fi]+=img2->m[pi][yi][xi][0];
      break;
    case '-':
      for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
        for(int xi=0; xi<img1->dimx; xi++) for(int fi=0; fi<img1->dimt; fi++)
          img1->m[pi][yi][xi][fi]-=img2->m[pi][yi][xi][0];
      break;
    case '/':
    case ':':
      for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
        for(int xi=0; xi<img1->dimx; xi++) {
          if(fabs(img2->m[pi][yi][xi][0])>1.0E-8)
            for(int fi=0; fi<img1->dimt; fi++)
              img1->m[pi][yi][xi][fi]/=img2->m[pi][yi][xi][0];
          else for(int fi=0; fi<img1->dimt; fi++) img1->m[pi][yi][xi][fi]=0.0;
        }
      break;
    case '*':
    case 'x':
    case '.':
      for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
        for(int xi=0; xi<img1->dimx; xi++) for(int fi=0; fi<img1->dimt; fi++)
          img1->m[pi][yi][xi][fi]*=img2->m[pi][yi][xi][0];
      break;
    default:
      if(verbose>0) fprintf(stderr, "Invalid operation.\n");
      return(10);
  }
 
  /* Check for limits */
  if(ulimit>0.0) {
    for(int pi=0; pi<img1->dimz; pi++) for(int yi=0; yi<img1->dimy; yi++)
      for(int xi=0; xi<img1->dimx; xi++) for(int fi=0; fi<img1->dimt; fi++)
        if(img1->m[pi][yi][xi][fi]>ulimit) img1->m[pi][yi][xi][fi]=ulimit;
  }
 
  return(0);
}

◆ imgAUMC()

int imgAUMC	(	IMG *	img,
		IMG *	oimg,
		int	verbose )

extern

Calculate (incomplete) area under moment curve (AUMC) for every pixel in a dynamic image.

Data is not extrapolated. Frame gaps or overlaps are not accepted.

See also: imgMRT, imgGetMaxTime, imgGetPeak, imgGetMaxFrame, imgFramesCheck, imgMaxDifference, imgSS

Returns: Returns 0, if ok.

Parameters

img	Pointer to dynamic image; not modified. Frame times are obligatory.
oimg	Pointer to empty IMG struct in which the AUMC will be written; any old contents are deleted.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 540 of file imgarithm.c.

  {
  if(verbose>0) printf("%s(*img, *oimg)\n", __func__);
  
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<2) {
    if(verbose>1) fprintf(stderr, "Error: dynamic image required.\n");
    return(2);
  }
  if(!imgExistentTimes(img)) {
    if(verbose>1) fprintf(stderr, "Error: unknown frame times.\n");
    return(2);
  }
  if(oimg==NULL) return(3);
  if(oimg->status==IMG_STATUS_OCCUPIED) imgEmpty(oimg);
 
  if(imgFramesCheck(img, verbose-1)>0) {
    if(verbose>1) fprintf(stderr, "Error: gaps or overlap between time frames.\n");
    return(4);
  }
 
  /* 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(oimg, img->dimz, img->dimy, img->dimx, 1);
  if(ret) return(ret);
  /* set image header information */
  imgCopyhdr(img, oimg);
  oimg->start[0]=img->start[0]; oimg->end[0]=img->end[img->dimt-1];
  oimg->mid[0]=(oimg->start[0]+oimg->end[0])/2.0;
  oimg->unit=CUNIT_UNKNOWN;
 
  /* Calculate sum of (frame time * pixel value) */
  for(int zi=0; zi<img->dimz; zi++) {
    for(int yi=0; yi<img->dimy; yi++) {
      for(int xi=0; xi<img->dimx; xi++) {
        oimg->m[zi][yi][xi][0]=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=0.0;
          oimg->m[zi][yi][xi][0]+=img->m[zi][yi][xi][ti]*img->mid[ti]*fdur;
        }
      }
    }
  }
 
  return(0);
}

◆ imgAverageAUC()

int imgAverageAUC	(	IMG *	img,
		float *	avgauc )

extern

Calculates the Area-Under-Curve of an average time-activity curve of all pixels or bins in the specified IMG data.

See also: imgAverageMaskTAC, imgAverageTAC, imgAvg

Returns: Returns 0, if ok.

Parameters

img	(Dynamic) IMG data.
avgauc	Pointer to a float were the average TAC AUC will be written.

Definition at line 91 of file imgeval.c.

  {
  
  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);
}

◆ imgAverageMaskTAC()

int imgAverageMaskTAC	(	IMG *	img,
		IMG *	timg,
		float *	tac )

extern

Calculates an average time-activity curve of pixels or bins in the specified IMG data.

Mask image specifies the pixels that are included in the average. If all pixels are to be averaged, then NULL can be given instead of mask image.

See also: imgMaskTAC, imgThresholdingLowHigh, imgThresholdMaskCount, imgAverageAUC, imgAverageTAC

Returns: Returns 0, if ok.

Parameters

img	(Dynamic) IMG data from which cluster TAC is computed.
timg	Mask: 0=excluded, otherwise included. Enter NULL to include all pixels in the average.
tac	Allocated float array for the TAC.

Definition at line 34 of file imgeval.c.

  {
  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);
}

Referenced by imgAverageTAC().

◆ imgAverageTAC()

int imgAverageTAC	(	IMG *	img,
		float *	tac )

extern

Calculates an average time-activity curve of all pixels or bins in the specified IMG data.

See also: imgAverageMaskTAC, imgAverageAUC, imgRangeMinMax

Returns: Returns 0, if ok.

Parameters

img	(Dynamic) IMG data from which TAC is computed.
tac	Allocated float array for the TAC.

Definition at line 15 of file imgeval.c.

  {
  return(imgAverageMaskTAC(img, NULL, tac));
}

Referenced by imgNoiseTemplate(), and sifAllocateWithIMG().

◆ imgConvertUnit()

int imgConvertUnit	(	IMG *	img,
		char *	unit )

extern

Converts the unit of pixel values in IMG based to specified unit string.

See also: imgArithmConst, imgArithm, imgFrameIntegral

Returns: Returns 0 if successful.

Parameters

img	Pointer to IMG struct.
unit	String containing the new unit.

Definition at line 480 of file imgarithm.c.

  {
  int ret, new_unit=0;
  float conversion_factor=1.0;
 
  if(img==NULL || unit==NULL) return(1);
  if(img->unit==CUNIT_UNKNOWN) return(1);
  /* Try to identify requested unit */
  new_unit=imgUnitId(unit); if(new_unit<0) return(1-new_unit);
  /* Check if unit needs no conversion */
  if(img->unit==new_unit) return(0);
  /* Get conversion factor */
  if(img->unit==CUNIT_KBQ_PER_ML && new_unit==CUNIT_BQ_PER_ML)
    conversion_factor=1000.0;
  else if(img->unit==CUNIT_BQ_PER_ML && new_unit==CUNIT_KBQ_PER_ML)
    conversion_factor=0.001;
  else if(img->unit==CUNIT_KBQ_PER_ML && new_unit==CUNIT_NCI_PER_ML)
    conversion_factor=27.027;
  else if(img->unit==CUNIT_NCI_PER_ML && new_unit==CUNIT_KBQ_PER_ML)
    conversion_factor=0.037;
  else if(img->unit==CUNIT_NCI_PER_ML && new_unit==CUNIT_BQ_PER_ML)
    conversion_factor=37.0;
  else if(img->unit==CUNIT_KBQ_PER_ML && new_unit==CUNIT_MBQ_PER_ML)
    conversion_factor=0.001;
  else if(img->unit==CUNIT_MBQ_PER_ML && new_unit==CUNIT_KBQ_PER_ML)
    conversion_factor=1000.0;
  else if(img->unit==CUNIT_PER_SEC && new_unit==CUNIT_PER_MIN)
    conversion_factor=60.0;
  else if(img->unit==CUNIT_PER_MIN && new_unit==CUNIT_PER_SEC)
    conversion_factor=1.0/60.0;
  else if(img->unit==CUNIT_ML_PER_ML && new_unit==CUNIT_ML_PER_DL)
    conversion_factor=0.01;
  else if(img->unit==CUNIT_ML_PER_DL && new_unit==CUNIT_ML_PER_ML)
    conversion_factor=100.0;
  else
    return(10);
 
  /* Convert pixel values */
  ret=imgArithmConst(img, conversion_factor, '*', FLT_MAX, 0);
  if(ret) return(10+ret);
 
  /* Set the unit id */
  img->unit=new_unit;
 
  return(0);
}

◆ imgCutoff()

void imgCutoff	(	IMG *	image,
		float	cutoff,
		int	mode )

extern

Pixel values that exceed or go under a user-defined limit are set to that limit value.

See also: imgFast3DGaussianFilter, imgThresholdingLowHigh, imgAverageAUC, imgsegmThreshold, imgAverageTAC, imgMinMax

Parameters

image	Pointer to IMG struct which will be filtered here.
cutoff	Cut-off value.
mode	Mode of operation: 0=pixels exceeding the limit are cut off, 1=pixels which go under the limit are cut off.

Definition at line 306 of file imgthreshold.c.

  {
  int zi, yi, xi, ti;
 
  if(mode==0) {
    for(zi=0; zi<image->dimz; zi++)
      for(yi=0; yi<image->dimy; yi++)
        for(xi=0; xi<image->dimx; xi++)
          for(ti=0; ti<image->dimt; ti++)
            if(image->m[zi][yi][xi][ti]>cutoff) image->m[zi][yi][xi][ti]=cutoff;
  } else {
    for(zi=0; zi<image->dimz; zi++)
      for(yi=0; yi<image->dimy; yi++)
        for(xi=0; xi<image->dimx; xi++)
          for(ti=0; ti<image->dimt; ti++)
            if(image->m[zi][yi][xi][ti]<cutoff) image->m[zi][yi][xi][ti]=cutoff;
  }
  return;
}

◆ imgDeleteFrameOverlap()

int imgDeleteFrameOverlap ( IMG * img )

extern

Correct frame times if frames are slightly overlapping or have small gaps in between. Large gap is not corrected and it does not lead to an error.

See also: imgFramesCheck, imgFrameGapFill, imgTimeIntegral

Returns: If overlap is considerable (>1 s), or other error is encountered, function returns a non-zero value. Otherwise 0 is returned.

Parameters

img	Pointer to IMG struct containing the 4D image data.

Definition at line 77 of file imgframe.c.

  {
  int fi;
  float overlap, overlap_limit=1.8, flen1, flen2;
 
  if(IMG_TEST) {fprintf(stdout, "%s()\n", __func__); fflush(stdout);}
  if(img->status!=IMG_STATUS_OCCUPIED || img->dimt<1) return(1);
  for(fi=0; fi<img->dimt-1; fi++) {
    overlap=img->end[fi] - img->start[fi+1];
    if(overlap==0.0) continue; // no gap or overlap
    else if(overlap<-overlap_limit) continue; // gap is large, then do nothing
    else if(overlap>overlap_limit) return(2); // overlap is large: error
    /* Correct the small gap/overlap by making frame durations more similar */
    flen1=img->end[fi]-img->start[fi]; flen2=img->end[fi+1]-img->start[fi+1];
    if(overlap>0.0) { // overlap
      if(flen1>flen2) img->end[fi]=img->start[fi+1]; else img->start[fi+1]=img->end[fi];
    } else { // gap
      if(flen1>flen2) img->start[fi+1]=img->end[fi]; else img->end[fi]=img->start[fi+1];
    }
  }
  return(0);
}

Referenced by imgReadModelingData().

◆ imgDeleteFrameOverlap_old()

int imgDeleteFrameOverlap_old ( IMG * img )

extern

Correct frame times so that frames are not overlapping.

See also: imgDeleteFrameOverlap, imgTimeIntegral

Returns: If overlap is considerable (>1 s), or other error is encountered, function returns a non-zero value. Otherwise 0 is returned.

Parameters

img	Pointer to IMG struct containing the 4D image data.

Definition at line 109 of file imgframe.c.

  {
  int fi;
  float overlap;
 
  if(IMG_TEST) {fprintf(stdout, "%s()\n", __func__); fflush(stdout);}
  if(img->status!=IMG_STATUS_OCCUPIED || img->dimt<1) return(1);
  for(fi=0; fi<img->dimt-1; fi++) {
    overlap=img->end[fi] - img->start[fi+1];
    if(overlap==0.0) continue;
    else if(overlap>1.0) return(2);
    img->end[fi]=img->start[fi+1];
  }
  return(0);
}

◆ imgFlipAbove()

int imgFlipAbove ( IMG * img )

extern

Flip IMG data like viewed from above.

See also: imgFlipHorizontal, imgFlipVertical, imgFlipPlanes, imgFlipRight, img2cube, imgMeanZ

Returns: Returns 0 if successful.

Parameters

img	Pointer to IMG which will be flipped.

Definition at line 115 of file imgflips.c.

  {
  int xi, yi, zi, fi, ret;
  IMG omg;
 
  /* Make copy of the original image */
  imgInit(&omg); ret=imgDup(img, &omg); if(ret!=0) return(100+ret);
 
  /* Empty the user-specified image structure. */
  imgEmpty(img);
  /* Allocate it again with new dimensions */
  ret=imgAllocateWithHeader(img, omg.dimy, omg.dimz, omg.dimx, omg.dimt, &omg);
  if(ret!=0) {imgEmpty(&omg); return(200+ret);}
 
  /* Copy the voxel values */
  for(zi=0; zi<omg.dimz; zi++)
    for(yi=0; yi<omg.dimy; yi++)
      for(xi=0; xi<omg.dimx; xi++)
        for(fi=0; fi<omg.dimt; fi++) {
          img->m[yi][img->dimy-1-zi][xi][fi]=omg.m[zi][yi][xi][fi];
        }
 
  /* Switch pixel sizes */
  img->sizey=omg.sizez;
  img->sizez=omg.sizey;
  img->resolutiony=omg.resolutionz;
  img->resolutionz=omg.resolutiony;
 
  /* Free the memory of the copy of original image */
  imgEmpty(&omg);
 
  return(0);
}

◆ imgFlipHorizontal()

void imgFlipHorizontal ( IMG * img )

extern

Flip IMG data horizontally (left-right).

See also: imgFlipRight, imgFlipVertical, imgFlipPlanes, imgFlipAbove, img2cube

Definition at line 13 of file imgflips.c.

{
  int zi, yi, from, to;
  float *col_ptr;
 
  for(zi=0; zi<img->dimz; zi++) {
    for(yi=0; yi<img->dimy; yi++) {
      for(from=0, to=img->dimx-1; from<to; from++, to--) {
        col_ptr=img->m[zi][yi][from];
        img->m[zi][yi][from]=img->m[zi][yi][to];
        img->m[zi][yi][to]=col_ptr;
      }
    }
  }
}

◆ imgFlipPlanes()

void imgFlipPlanes ( IMG * img )

extern

Flip IMG data planes (head-toes).

To work properly, the plane numbers must be contiguous.

See also: imgFlipHorizontal, imgFlipVertical, imgFlipRight, imgFlipAbove

Definition at line 55 of file imgflips.c.

{
  int from, to;
  float ***plane_ptr;
 
  for(from=0, to=img->dimz-1; from<to; from++, to--) {
    plane_ptr=img->m[from];
    img->m[from]=img->m[to];
    img->m[to]=plane_ptr;
  }
}

Referenced by imgAnalyzeToEcat().

◆ imgFlipRight()

int imgFlipRight ( IMG * img )

extern

Flip IMG data like viewed from right side.

See also: imgFlipHorizontal, imgFlipVertical, imgFlipPlanes, imgFlipAbove

Returns: Returns 0 if successful.

Parameters

img	Pointer to IMG which will be flipped

Definition at line 73 of file imgflips.c.

  {
  int xi, yi, zi, fi, ret;
  IMG omg;
 
  /* Make copy of the original image */
  imgInit(&omg); ret=imgDup(img, &omg); if(ret!=0) return(100+ret);
 
  /* Empty the user-specified image struct */
  imgEmpty(img);
  /* Allocate it again with new dimensions */
  ret=imgAllocateWithHeader(img, omg.dimx, omg.dimy, omg.dimz, omg.dimt, &omg);
  if(ret!=0) {imgEmpty(&omg); return(200+ret);}
 
  /* Copy the voxel values */
  for(zi=0; zi<omg.dimz; zi++)
    for(yi=0; yi<omg.dimy; yi++)
      for(xi=0; xi<omg.dimx; xi++)
        for(fi=0; fi<omg.dimt; fi++) {
          img->m[xi][yi][zi][fi]=omg.m[zi][yi][xi][fi];
        }
 
  /* Switch pixel sizes */
  img->sizex=omg.sizez;
  img->sizez=omg.sizex;
  img->resolutionx=omg.resolutionz;
  img->resolutionz=omg.resolutionx;
 
  /* Free the memory of the copy of original image */
  imgEmpty(&omg);
 
  return(0);
}

◆ imgFlipVertical()

void imgFlipVertical ( IMG * img )

extern

Flip IMG data vertically (up-down).

See also: imgFlipHorizontal, imgFlipRight, imgFlipPlanes, imgFlipAbove

Definition at line 34 of file imgflips.c.

{
  int zi, from, to;
  float **row_ptr;
 
  for(zi=0; zi<img->dimz; zi++) {
    for(from=0, to=img->dimy-1; from<to; from++, to--) {
      row_ptr=img->m[zi][from];
      img->m[zi][from]=img->m[zi][to];
      img->m[zi][to]=row_ptr;
    }
  }
}

◆ imgFrameGapFill()

int imgFrameGapFill	(	IMG *	img,
		int	verbose )

extern

Fill gaps between time frames by extending adjacent frames over the gap. Overlaps, and gap before the first frame is ignored.

See also: imgFramesCheck, imgDeleteFrameOverlap, imgExistentTimes, imgTimeIntegral

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

Parameters

img	Pointer to IMG struct containing the 4D image data.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 50 of file imgframe.c.

  {
  if(verbose>0) {printf("%s(*img)\n", __func__); fflush(stdout);}
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED || img->dimt<2) return(0);
 
  for(int fi=1; fi<img->dimt; fi++) {
    float gap=img->start[fi] - img->end[fi-1];
    if(gap<1.0E-07) continue;
    if(verbose>2) printf("gap between frames %d and %d: %g\n", fi, fi+1, gap);
    img->start[fi] -= 0.5*gap; img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
    img->end[fi-1]=img->start[fi]; img->mid[fi-1]=0.5*(img->start[fi-1]+img->end[fi-1]);
  }
  return(0);
}

◆ imgFrameIntegral()

int imgFrameIntegral	(	IMG *	img,
		int	first,
		int	last,
		IMG *	iimg,
		int	verbose )

extern

Integration from first frame (0..last) to last frame (first..dimt) to iimg, which is allocated here.

Frames do not have to be continuous in time. Time unit in integral is sec. Raw data (sinogram) must be divided by frame durations before calling this. If dynamic image data does not contain frame times (e.g. Analyze image) then just the sum is calculated.

See also: imgArithm, imgRawCountsPerTime, imgTimeIntegral, imgAUMC

Returns: Returns 0 if ok, otherwise >0.

Parameters

img	(Dynamic) IMG data.
first	First frame to include in AUC; 0..dimt-1.
last	Last frame to include in AUC; 0..dimt-1.
iimg	Pointer to initiated and empty AUC IMG data.
verbose	Verbose level; if <=0, then nothing is printed into stderr.

Definition at line 346 of file imgarithm.c.

  {
  if(verbose>0) printf("%s(img, %d, %d, iimg, %d)\n", __func__, first, last, verbose);
 
  int zi, yi, xi, fi, ret, times_exist;
  float fstart, fend, dur, x, y, k;
 
  /* Check the arguments */
  if(img==NULL || iimg==NULL || first<0 || first>last) return(1);
  if(img->status!=IMG_STATUS_OCCUPIED) return(2);
  times_exist=imgExistentTimes(img);
  fstart=img->start[first]; fend=img->end[last];
  if(verbose>1) printf("  time_range := %g - %g\n", fstart, fend);
 
  /* Allocate memory for the integral */
  imgEmpty(iimg);
  ret=imgAllocateWithHeader(iimg, img->dimz, img->dimy, img->dimx, 1, img);
  if(ret) {
    if(verbose>0) fprintf(stderr, "Error %d in allocating memory for sum image.\n", ret);
    imgEmpty(iimg); return(3);
  }
 
  /* Set header information */
  iimg->start[0]=fstart; iimg->end[0]=fend;
  iimg->mid[0]=0.5*(iimg->start[0]+iimg->end[0]);
  if(img->type==IMG_TYPE_RAW) iimg->decayCorrection=IMG_DC_NONCORRECTED;
  else iimg->decayCorrection=IMG_DC_CORRECTED;
  iimg->decayCorrFactor[0]=0.0;
  /* Change also the unit, if possible */
  if(img->type==IMG_TYPE_IMAGE) {
    if(img->unit==CUNIT_KBQ_PER_ML) iimg->unit=CUNIT_SEC_KBQ_PER_ML;
  }
 
  /* Integrate the first frame */
  fi=first;
  if(times_exist) {
    dur=img->end[fi]-img->start[fi]; if(dur<0.0) {imgEmpty(iimg); return(4);}
  } else dur=1.0;
  for(zi=0; zi<img->dimz; zi++)
    for(yi=0; yi<img->dimy; yi++)
      for(xi=0; xi<img->dimx; xi++)
        iimg->m[zi][yi][xi][0]=dur*img->m[zi][yi][xi][fi];
  /* Add integrals of the following frames */
  for(fi=first+1; fi<=last; fi++) {
    if(times_exist) {
      dur=img->end[fi]-img->start[fi]; if(dur<0.0) {imgEmpty(iimg); return(4);}
    } else dur=1.0;
    /* Add the integral of this frame to the previous integral */
    for(zi=0; zi<img->dimz; zi++)
      for(yi=0; yi<img->dimy; yi++)
        for(xi=0; xi<img->dimx; xi++)
          iimg->m[zi][yi][xi][0]+=dur*img->m[zi][yi][xi][fi];
    if(times_exist) {
      /* Check whether frames are contiguous */
      dur=img->start[fi]-img->end[fi-1]; if(dur<=1.0E-10) continue;
      /* When not, calculate the integral between frames */
      x=0.5*(img->start[fi]+img->end[fi-1]);
      for(zi=0; zi<img->dimz; zi++)
        for(yi=0; yi<img->dimy; yi++)
          for(xi=0; xi<img->dimx; xi++) {
            k=(img->m[zi][yi][xi][fi]-img->m[zi][yi][xi][fi-1])
              /(img->mid[fi]-img->mid[fi-1]);
            y=img->m[zi][yi][xi][fi-1]+k*(x-img->mid[fi-1]);
            iimg->m[zi][yi][xi][0]+=dur*y;
          }
    }    
  } /* next frame */
 
  /* Set frame times */
  iimg->start[0]=img->start[first];
  iimg->end[0]=img->end[last];
  iimg->mid[0]=0.5*(iimg->start[0]+iimg->end[0]);
 
  return(0);
}

Referenced by imgsegmSimilar(), imgThresholding(), imgThresholdingLowHigh(), and imgTimeIntegral().

◆ imgFramesCheck()

int imgFramesCheck	(	IMG *	img,
		int	verbose )

extern

Check for gaps or overlap between frame times. Gap before the first frame is ignored.

See also: imgExistentTimes, imgDeleteFrameOverlap, imgTimeIntegral, imgFrameGapFill

Returns: 0, if no overlaps or gaps are found, 1 if overlaps are found, 2 if gaps are found, and 3 if both overlaps and gaps are found.

Parameters

img	Pointer to IMG struct containing the 4D image data. Data is not modified.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 15 of file imgframe.c.

  {
  if(verbose>0) {printf("%s(*img)\n", __func__); fflush(stdout);}
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED || img->dimt<2) return(0);
 
  int gapNr=0, overlapNr=0;
  for(int fi=1; fi<img->dimt; fi++) {
    float gap=img->start[fi] - img->end[fi-1];
    if(verbose>2 && fabs(gap)>1.0E-06)
      printf("gap between frames %d and %d: %g\n", fi, fi+1, gap);
    if(gap>1.0E-06) gapNr++;
    else if(gap<-1.0E-06) overlapNr++;
  }
  if(verbose>1) {
    printf("  %d overlap(s)\n", overlapNr);
    printf("  %d gap(s)\n", gapNr);
    fflush(stdout);
  }
  int ret=0;
  if(overlapNr>0) ret+=1;
  if(gapNr>0) ret+=2;
  return(ret);
}

Referenced by imgAUMC(), and imgMRT().

◆ imgGaussianAMFilter()

int imgGaussianAMFilter	(	IMG *	img,
		float	xsd,
		float	ysd,
		float	zsd,
		int	passNr,
		double	tolerance,
		int	verbose )

extern

Alvarez-Mazorra approximate Gaussian image filtering in 1-3 dimensions.

References:

Getreuer P. A survey of Gaussian convolution algorithms. https://doi.org/10.5201/ipol.2013.87
Alvarez L, Mazorra L, Signal and image restoration using shock Filters and anisotropic Diffusion. https://www.jstor.org/stable/2158018

See also: imgGaussianFIRFilter, imgSS

Returns: If an error is encountered, function returns a non-zero value. Otherwise 0 is returned.

Parameters

img	Image data to be processed; data is overwritten with filtered image. All image frames are processed.
xsd	Gaussian S.D. in pixels in x dimension; SD=FWHM/2.355. Enter 0 to not filter in x dimension.
ysd	Gaussian S.D. in pixels in y dimension; SD=FWHM/2.355. Enter 0 to not filter in y dimension.
zsd	Gaussian S.D. in pixels in z dimension; SD=FWHM/2.355. Enter 0 to not filter in z dimension.
passNr	Number of filtering passes, usually 4 or more; enter 0 to use the default steps (4).
tolerance	Tolerance; enter 0.0 to use the default (1.0E-06).
verbose	Verbose level; if zero, then only warnings are printed into stderr.

Definition at line 173 of file imgfilter.c.

  {
  if(verbose>0) printf("%s(*img, %g, %g, %g, %d, %d)\n", __func__, xsd, ysd, zsd, passNr, verbose); 
 
  if(img==NULL || img->dimz<1 || img->dimy<1 || img->dimx<1 || img->dimt<1) return 1;
  int dimx=img->dimx, dimy=img->dimy, dimz=img->dimz, dimt=img->dimt;
  if(dimx==1) xsd=0.0;
  if(dimy==1) ysd=0.0;
  if(dimz==1) zsd=0.0;
  if(xsd>0.0 && (dimx<4 || !(img->sizex>0.0))) return(2);
  if(ysd>0.0 && (dimy<4 || !(img->sizey>0.0))) return(3);
  if(zsd>0.0 && (dimz<4 || !(img->sizez>0.0))) return(4);
  if(!(xsd>0.0) && !(ysd>0.0) && !(zsd>0.0)) {
    if(verbose>1) printf("  no filtering done.\n");
    fflush(stdout); return(0);
  }
  if(passNr<=0) passNr=4;
  if(!(tolerance>0.0)) tolerance=1.0E-06;
 
 
  /* 
   *  Filtering in x dimension
   */
  if(xsd>0.0) {
    if(verbose>1) {printf("  filtering in x dimension\n"); fflush(stdout);}
    double q=xsd;
    if(0) { // Adjust SD for improved accuracy at low step numbers
      double f=0.7818+(double)passNr;
      q*= 1.0 + (0.3165*(double)passNr + 0.5695)/(f*f);
    }
    double lambda=(q*q)/(2.0*(double)passNr);
    double nu=(1.0 + 2.0*lambda - sqrt(1.0 + 4.0*lambda))/(2.0*lambda);
    double scale=pow(nu/lambda, passNr);
    int termNr=ceil(log((1.0-nu)*tolerance)/log(nu));
    if(verbose>2) printf("  nu=%g scale=%g termNr=%d\n", nu, scale, termNr);
 
    for(int t=0; t<dimt; t++) { // Image time frames are processed as separate images
      if(verbose>5) {printf("    frame %d\n", 1+t); fflush(stdout);}
      double sum1=0.0, sum2=0.0;
      for(int z=0; z<dimz; z++) for(int y=0; y<dimy; y++) {
        double d[dimx];
        for(int x=0; x<dimx; x++) sum1+=d[x]=img->m[z][y][x][t];
        filterAMGaussian(d, dimx, passNr, nu, scale, termNr);
        for(int x=0; x<dimx; x++) sum2+=img->m[z][y][x][t]=d[x];
      }
      double f=sum1/sum2;
      if(verbose>1 && fabs(1.0-f)>1.0E-10) {
        printf("  frame %d: sum of voxels differs pre/post filtering %g/%g=%g\n", 1+t, sum1, sum2, f);
      }
    }
  }
 
  /* 
   *  Filtering in y dimension
   */
  if(ysd>0.0) {
    if(verbose>1) {printf("  filtering in y dimension\n"); fflush(stdout);}
    double q=ysd;
    if(0) { // Adjust SD for improved accuracy at low step numbers
      double f=0.7818+(double)passNr;
      q*= 1.0 + (0.3165*(double)passNr + 0.5695)/(f*f);
    }
    double lambda=(q*q)/(2.0*(double)passNr);
    double nu=(1.0 + 2.0*lambda - sqrt(1.0 + 4.0*lambda))/(2.0*lambda);
    double scale=pow(nu/lambda, passNr);
    int termNr=ceil(log((1.0-nu)*tolerance)/log(nu));
    if(verbose>2) printf("  nu=%g scale=%g termNr=%d\n", nu, scale, termNr);
 
    for(int t=0; t<dimt; t++) { // Image time frames are processed as separate images
      if(verbose>5) {printf("    frame %d\n", 1+t); fflush(stdout);}
      double sum1=0.0, sum2=0.0;
      for(int z=0; z<dimz; z++) for(int x=0; x<dimx; x++) {
        double d[dimy];
        for(int y=0; y<dimy; y++) sum1+=d[y]=img->m[z][y][x][t];
        filterAMGaussian(d, dimy, passNr, nu, scale, termNr);
        for(int y=0; y<dimy; y++) sum2+=img->m[z][y][x][t]=d[y];
      }
      double f=sum1/sum2;
      if(verbose>1 && fabs(1.0-f)>1.0E-10) {
        printf("  frame %d: sum of voxels differs pre/post filtering %g/%g=%g\n", 1+t, sum1, sum2, f);
      }
    }
  }
 
  /* 
   *  Filtering in z dimension
   */
  if(zsd>0.0) {
    if(verbose>1) {printf("  filtering in z dimension\n"); fflush(stdout);}
    double q=xsd;
    if(0) { // Adjust SD for improved accuracy at low step numbers
      double f=0.7818+(double)passNr;
      q*= 1.0 + (0.3165*(double)passNr + 0.5695)/(f*f);
    }
    double lambda=(q*q)/(2.0*(double)passNr);
    double nu=(1.0 + 2.0*lambda - sqrt(1.0 + 4.0*lambda))/(2.0*lambda);
    double scale=pow(nu/lambda, passNr);
    int termNr=ceil(log((1.0-nu)*tolerance)/log(nu));
    if(verbose>2) printf("  nu=%g scale=%g termNr=%d\n", nu, scale, termNr);
 
    for(int t=0; t<dimt; t++) { // Image time frames are processed as separate images
      if(verbose>5) {printf("    frame %d\n", 1+t); fflush(stdout);}
      double sum1=0.0, sum2=0.0;
      for(int y=0; y<dimy; y++) for(int x=0; x<dimy; x++) {
        double d[dimz];
        for(int z=0; z<dimz; z++) sum1+=d[z]=img->m[z][y][x][t];
        filterAMGaussian(d, dimz, passNr, nu, scale, termNr);
        for(int z=0; z<dimz; z++) sum2+=img->m[z][y][x][t]=d[z];
      }
      double f=sum1/sum2;
      if(verbose>1 && fabs(1.0-f)>1.0E-10) {
        printf("  frame %d: sum of voxels differs pre/post filtering %g/%g=%g\n", 1+t, sum1, sum2, f);
      }
    }
  }
 
 
  return(0);
}

◆ imgGaussianEBoxFilter()

int imgGaussianEBoxFilter	(	IMG *	img,
		float	xsd,
		float	ysd,
		float	zsd,
		int	passNr,
		int	verbose )

extern

Gaussian extended box image filtering in 1-3 dimensions.

References:

Getreuer P. A survey of Gaussian convolution algorithms. https://doi.org/10.5201/ipol.2013.87
Gwosdek et al. Theoretical foundations of Gaussian convolution by extended box filtering. https://doi.org/10.1007/978-3-642-24785-9_38
Elboher E, Werman M. Efficient and accurate Gaussian image filtering using running sums. https://arxiv.org/pdf/1107.4958.pdf
Wells WM. Efficient synthesis of Gaussian filters by cascaded uniform filters. https://doi.org/10.1109/TPAMI.1986.4767776

See also: imgFast2DGaussianFilter, imgGaussianFilter, imgSS

Returns: If an error is encountered, function returns a non-zero value. Otherwise 0 is returned.

Parameters

img	Image data to be processed; data is overwritten with filtered image. All image frames are processed.
xsd	Gaussian S.D. in pixels in x dimension; SD=FWHM/2.355. Enter 0 to not filter in x dimension.
ysd	Gaussian S.D. in pixels in y dimension; SD=FWHM/2.355. Enter 0 to not filter in y dimension.
zsd	Gaussian S.D. in pixels in z dimension; SD=FWHM/2.355. Enter 0 to not filter in z dimension.
passNr	Number of filtering passes, usually 3-5; enter 0 to use the default steps (4).
verbose	Verbose level; if zero, then only warnings are printed into stderr.

Definition at line 408 of file imgfilter.c.

  {
  if(verbose>0) printf("%s(*img, %g, %g, %g, %d, %d)\n", __func__, xsd, ysd, zsd, passNr, verbose); 
 
  if(img==NULL || img->dimz<1 || img->dimy<1 || img->dimx<1 || img->dimt<1) return 1;
  int dimx=img->dimx, dimy=img->dimy, dimz=img->dimz, dimt=img->dimt;
  if(dimx==1) xsd=0.0;
  if(dimy==1) ysd=0.0;
  if(dimz==1) zsd=0.0;
  if(xsd>0.0 && (dimx<4 || !(img->sizex>0.0))) return(2);
  if(ysd>0.0 && (dimy<4 || !(img->sizey>0.0))) return(3);
  if(zsd>0.0 && (dimz<4 || !(img->sizez>0.0))) return(4);
  if(!(xsd>0.0) && !(ysd>0.0) && !(zsd>0.0)) {
    if(verbose>1) printf("  no filtering done.\n");
    return(0);
  }
  if(passNr<=0) passNr=4;
 
 
  /* 
   *  Filtering in x dimension
   */
  if(xsd>0.0) {
    if(verbose>1) {printf("  filtering in x dimension\n"); fflush(stdout);}
    int rib;
    double wob, wib, s2p=xsd*xsd/(double)passNr;
    /* Calculate inner box radius (by Wells) */
    rib=0.5*sqrt(1.0 + 12.0*s2p) - 0.5;
    if(verbose>3) printf("  precise_r := %f\n", 0.5*sqrt(1.0+12.0*s2p));
    /* Alpha */
    double a=(2*rib+1)*(rib*(rib+1) - 3.0*s2p) / (6.0*(s2p - (rib+1)*(rib+1)));
    /* Outer box weight */
    wob = a/(2.0*(a+rib)+1.0);
    /* Inner box weight */
    wib = 1.0-wob;
    if(verbose>2) {printf("  rib=%d wob=%g wib=%g a=%g\n", rib, wob, wib, a); fflush(stdout);}
 
    for(int t=0; t<dimt; t++) { // Image time frames are processed as separate images
      if(verbose>5) {printf("    frame %d\n", 1+t); fflush(stdout);}
      double sum1=0.0, sum2=0.0;
      for(int z=0; z<dimz; z++) for(int y=0; y<dimy; y++) {
        double d[dimx];
        for(int x=0; x<dimx; x++) sum1+=d[x]=img->m[z][y][x][t];
        filterEbox(d, dimx, wob, wib, rib, passNr);
        for(int x=0; x<dimx; x++) sum2+=img->m[z][y][x][t]=d[x];
      }
      double f=sum1/sum2;
      if(fabs(1.0-f)>1.0E-10) {
        if(verbose>1)
          printf("  frame %d: sum of voxels differs pre/post filtering %g/%g=%g\n", 1+t, sum1, sum2, f);
        for(int z=0; z<dimz; z++) for(int y=0; y<dimy; y++) for(int x=0; x<dimx; x++)
          img->m[z][y][x][t]*=f;
      }
    }
  }
 
  /* 
   *  Filtering in y dimension
   */
  if(ysd>0.0) {
    if(verbose>1) {printf("  filtering in y dimension\n"); fflush(stdout);}
    int rib;
    double wob, wib, s2p=ysd*ysd/(double)passNr;
    /* Calculate inner box radius */
    rib=0.5*sqrt(1.0 + 12.0*s2p) - 0.5;
    /* Alpha */
    double a=(2*rib+1)*(rib*(rib+1) - 3.0*s2p) / (6.0*(s2p - (rib+1)*(rib+1)));
    /* Outer box weight */
    wob = a/(2.0*(a+rib)+1);
    /* Inner box weight */
    wib = 1.0-wob;
    if(verbose>2) {printf("  rib=%d wob=%g wib=%g a=%g\n", rib, wob, wib, a); fflush(stdout);}
 
    for(int t=0; t<dimt; t++) { // Image time frames are processed as separate images
      if(verbose>5) {printf("    frame %d\n", 1+t); fflush(stdout);}
      double sum1=0.0, sum2=0.0;
      for(int z=0; z<dimz; z++) for(int x=0; x<dimx; x++) {
        double d[dimy];
        for(int y=0; y<dimy; y++) sum1+=d[y]=img->m[z][y][x][t];
        filterEbox(d, dimy, wob, wib, rib, passNr);
        for(int y=0; y<dimy; y++) sum2+=img->m[z][y][x][t]=d[y];
      }
      double f=sum1/sum2;
      if(fabs(1.0-f)>1.0E-10) {
        if(verbose>1)
          printf("  frame %d: sum of voxels differs pre/post filtering %g/%g=%g\n", 1+t, sum1, sum2, f);
        for(int z=0; z<dimz; z++) for(int y=0; y<dimy; y++) for(int x=0; x<dimx; x++)
          img->m[z][y][x][t]*=f;
      }
    }
  }
 
  /* 
   *  Filtering in z dimension
   */
  if(zsd>0.0) {
    if(verbose>1) {printf("  filtering in z dimension\n"); fflush(stdout);}
    int rib;
    double wob, wib, s2p=zsd*zsd/(double)passNr;
    /* Calculate inner box radius */
    rib=0.5*sqrt(1.0 + 12.0*s2p) - 0.5;
    /* Alpha */
    double a=(2*rib+1)*(rib*(rib+1) - 3.0*s2p) / (6.0*(s2p - (rib+1)*(rib+1)));
    /* Outer box weight */
    wob = a/(2.0*(a+rib)+1);
    /* Inner box weight */
    wib = 1.0-wob;
    if(verbose>2) {printf("  rib=%d wob=%g wib=%g a=%g\n", rib, wob, wib, a); fflush(stdout);}
 
    for(int t=0; t<dimt; t++) { // Image time frames are processed as separate images
      if(verbose>5) {printf("    frame %d\n", 1+t); fflush(stdout);}
      double sum1=0.0, sum2=0.0;
      for(int y=0; y<dimy; y++) for(int x=0; x<dimx; x++) {
        double d[dimz];
        for(int z=0; z<dimz; z++) sum1+=d[z]=img->m[z][y][x][t];
        filterEbox(d, dimz, wob, wib, rib, passNr);
        for(int z=0; z<dimz; z++) sum2+=img->m[z][y][x][t]=d[z];
      }
      double f=sum1/sum2;
      if(fabs(1.0-f)>1.0E-10) {
        if(verbose>1)
          printf("  frame %d: sum of voxels differs pre/post filtering %g/%g=%g\n", 1+t, sum1, sum2, f);
        for(int z=0; z<dimz; z++) for(int y=0; y<dimy; y++) for(int x=0; x<dimx; x++)
          img->m[z][y][x][t]*=f;
      }
    }
  }
 
  return(0);
}

◆ imgGaussianFIRFilter()

int imgGaussianFIRFilter	(	IMG *	img,
		float	xsd,
		float	ysd,
		float	zsd,
		double	tolerance,
		int	verbose )

extern

Gaussian finite impulse response (FIR) isotropic or anisotropic image filtering in 1-3 dimensions.

Based on the code in: Getreuer P. A survey of Gaussian convolution algorithms. Image Processing On Line 2013;3:286–310. https://doi.org/10.5201/ipol.2013.87

See also: imgGaussianAMFilter, imgSS

Returns: If an error is encountered, function returns a non-zero value. Otherwise 0 is returned.

Parameters

img	Image data to be processed; data is overwritten with filtered image. All image frames are processed.
xsd	Gaussian S.D. in pixels in x dimension; SD=FWHM/2.355. Enter 0 to not filter in x dimension.
ysd	Gaussian S.D. in pixels in y dimension; SD=FWHM/2.355. Enter 0 to not filter in y dimension.
zsd	Gaussian S.D. in pixels in z dimension; SD=FWHM/2.355. Enter 0 to not filter in z dimension.
tolerance	Tolerance; enter 0.0 to use the default (1.0E-03).
verbose	Verbose level; if zero, then only warnings are printed into stderr.

Definition at line 18 of file imgfilter.c.

  {
  if(verbose>0) printf("%s(*img, %g, %g, %g, %g, %d)\n", __func__, xsd, ysd, zsd, tolerance, verbose); 
 
  if(img==NULL || img->dimz<1 || img->dimy<1 || img->dimx<1 || img->dimt<1) return 1;
  int dimx=img->dimx, dimy=img->dimy, dimz=img->dimz, dimt=img->dimt;
  if(dimx==1) xsd=0.0;
  if(dimy==1) ysd=0.0;
  if(dimz==1) zsd=0.0;
  if(xsd>0.0 && (dimx<4 || !(img->sizex>0.0))) return(2);
  if(ysd>0.0 && (dimy<4 || !(img->sizey>0.0))) return(3);
  if(zsd>0.0 && (dimz<4 || !(img->sizez>0.0))) return(4);
  if(!(xsd>0.0) && !(ysd>0.0) && !(zsd>0.0)) {
    if(verbose>1) printf("  no filtering done.\n");
    return(0);
  }
  if(!(tolerance>0.0)) tolerance=1.0E-03;
  if(tolerance>=1.0) return(5);
 
  double sqrt_pi2=sqrt(M_PI)/M_SQRT2; // sqrt(pi)/sqrt(2)
 
  /* 
   *  Filtering in x dimension
   */
  if(xsd>0.0) {
    if(verbose>1) {printf("  filtering in x dimension\n"); fflush(stdout);}
    int r=ceil(M_SQRT2*xsd*inverfc(0.5*tolerance)); // Radius of the filter
    double gtrunc[r+1]; // Truncated Gaussian filter for FIR convolution
    double sdsqrt2=M_SQRT2*xsd;
    gtrunc[0]=1.0;
//    for(int i=1; i<=r; i++) gtrunc[i]=exp(-0.5*((double)i/xsd)*((double)i/xsd));
    for(int i=1; i<=r; i++)
      gtrunc[i]=sqrt_pi2*xsd*(erf(((double)i+0.5)/sdsqrt2) - erf(((double)i-0.5)/sdsqrt2));
    double sum=gtrunc[0]; for(int i=1; i<=r; i++) sum+=2.0*gtrunc[i];
    for(int i=0; i<=r; i++) gtrunc[i]/=sum;
    if(verbose>2) printf("  r=%d \n", r);
    if(verbose>3) {
      printf("  gtrunc[]= %g", gtrunc[0]); for(int i=1; i<=r; i++) printf(",%g", gtrunc[i]);
      printf("\n");
    }
 
    for(int t=0; t<dimt; t++) { // Image time frames are processed as separate images
      if(verbose>5) {printf("    frame %d\n", 1+t); fflush(stdout);}
      for(int z=0; z<dimz; z++) for(int y=0; y<dimy; y++) {
        double a[dimx];
        for(int x=0; x<dimx; x++) a[x]=img->m[z][y][x][t];
        for(int x=0; x<dimx; x++) {
          double v=gtrunc[0]*a[x];
          for(int m=1; m<=r; m++)
            v+=gtrunc[m]*(a[filterHSSBE(dimx, x-m)] + a[filterHSSBE(dimx, x+m)]);
          img->m[z][y][x][t]=v;
        }
      }
    }
  }
 
 
  /* 
   *  Filtering in y dimension
   */
  if(ysd>0.0) {
    if(verbose>1) {printf("  filtering in y dimension\n"); fflush(stdout);}
    int r=ceil(M_SQRT2*ysd*inverfc(0.5*tolerance)); // Radius of the filter
    double gtrunc[r+1]; // Truncated Gaussian filter for FIR convolution
    double sdsqrt2=M_SQRT2*ysd;
    gtrunc[0]=1.0;
//    for(int i=1; i<=r; i++) gtrunc[i]=exp(-0.5*((double)i/ysd)*((double)i/ysd));
    for(int i=1; i<=r; i++)
      gtrunc[i]=sqrt_pi2*ysd*(erf(((double)i+0.5)/sdsqrt2) - erf(((double)i-0.5)/sdsqrt2));
    double sum=gtrunc[0]; for(int i=1; i<=r; i++) sum+=2.0*gtrunc[i];
    for(int i=0; i<=r; i++) gtrunc[i]/=sum;
    if(verbose>2) printf("  r=%d \n", r);
    if(verbose>3) {
      printf("  gtrunc[]= %g", gtrunc[0]); for(int i=1; i<=r; i++) printf(",%g", gtrunc[i]);
      printf("\n");
    }
 
    for(int t=0; t<dimt; t++) { // Image time frames are processed as separate images
      if(verbose>5) {printf("    frame %d\n", 1+t); fflush(stdout);}
      for(int z=0; z<dimz; z++) for(int x=0; x<dimx; x++) {
        double a[dimy];
        for(int y=0; y<dimy; y++) a[y]=img->m[z][y][x][t];
        for(int y=0; y<dimy; y++) {
          double v=gtrunc[0]*a[y];
          for(int m=1; m<=r; m++)
            v+=gtrunc[m]*(a[filterHSSBE(dimy, y-m)] + a[filterHSSBE(dimy, y+m)]);
          img->m[z][y][x][t]=v;
        }
      }
    }
  }
 
 
  /* 
   *  Filtering in z dimension
   */
  if(zsd>0.0) {
    if(verbose>1) {printf("  filtering in z dimension\n"); fflush(stdout);}
    int r=ceil(M_SQRT2*zsd*inverfc(0.5*tolerance)); // Radius of the filter
    double gtrunc[r+1]; // Truncated Gaussian filter for FIR convolution
    double sdsqrt2=M_SQRT2*zsd;
    gtrunc[0]=1.0;
//    for(int i=1; i<=r; i++) gtrunc[i]=exp(-0.5*((double)i/zsd)*((double)i/zsd));
    for(int i=1; i<=r; i++)
      gtrunc[i]=sqrt_pi2*zsd*(erf(((double)i+0.5)/sdsqrt2) - erf(((double)i-0.5)/sdsqrt2));
    double sum=gtrunc[0]; for(int i=1; i<=r; i++) sum+=2.0*gtrunc[i];
    for(int i=0; i<=r; i++) gtrunc[i]/=sum;
    if(verbose>2) printf("  r=%d \n", r);
    if(verbose>3) {
      printf("  gtrunc[]= %g", gtrunc[0]); for(int i=1; i<=r; i++) printf(",%g", gtrunc[i]);
      printf("\n");
    }
 
    for(int t=0; t<dimt; t++) { // Image time frames are processed as separate images
      if(verbose>5) {printf("    frame %d\n", 1+t); fflush(stdout);}
      for(int y=0; y<dimy; y++) for(int x=0; x<dimx; x++) {
        double a[dimz];
        for(int z=0; z<dimz; z++) a[z]=img->m[z][y][x][t];
        for(int z=0; z<dimz; z++) {
          double v=gtrunc[0]*a[z];
          for(int m=1; m<=r; m++)
            v+=gtrunc[m]*(a[filterHSSBE(dimz, z-m)] + a[filterHSSBE(dimz, z+m)]);
          img->m[z][y][x][t]=v;
        }
      }
    }
  }
  return(0);
}

Referenced by imgPVCRRL(), and imgPVCRVC().

◆ imgGetFrameDiff()

int imgGetFrameDiff	(	IMG *	img,
		IMG *	dimg,
		IMG *	mimg,
		int	verbose )

extern

Compute sum absolute difference and/or sum absolute average between consecutive frames.

See also: imgGetPeak, imgGetMaxFrame, imgSmoothOverFrames

Returns: Returns 0, if ok.

Parameters

img	Dynamic image; not modified.
dimg	Pointer to an empty IMG struct in which the sum of absolute differences will be written; any old contents are deleted; NULL, if not needed.
mimg	Pointer to an empty IMG struct in which the sum of absolute means will be written; any old contents are deleted; NULL, if not needed.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 180 of file imgframe.c.

  {
  if(verbose>0) {printf("%s()\n", __func__); fflush(stdout);}
  
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<2) {
    if(verbose>0) {fprintf(stderr, "only dynamic image can be processed!\n"); fflush(stderr);}
    return(1);
  }
  if(dimg==NULL && mimg==NULL) return(0);
  if(dimg!=NULL && dimg->status==IMG_STATUS_OCCUPIED) imgEmpty(dimg);
  if(mimg!=NULL && mimg->status==IMG_STATUS_OCCUPIED) imgEmpty(mimg);
 
 
  /* Allocate memory for one frame */
  int ret=0;
  if(verbose>1) {
    printf("allocating memory for %dx%dx%d pixels\n", img->dimz, img->dimy, img->dimx);
    fflush(stdout);
  }
  if(dimg!=NULL) ret=imgAllocate(dimg, img->dimz, img->dimy, img->dimx, 1); else ret=0;
  if(!ret && mimg!=NULL) ret=imgAllocate(mimg, img->dimz, img->dimy, img->dimx, 1);
  if(ret) return(ret);
  /* set image header information */
  if(dimg!=NULL) {
    imgCopyhdr(img, dimg);
    dimg->start[0]=img->start[0]; dimg->end[0]=img->end[img->dimt-1];
    dimg->mid[0]=(dimg->start[0]+dimg->end[0])/2.0;
  }
  if(mimg!=NULL) {
    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;
  for(zi=0; zi<img->dimz; zi++) {
    for(yi=0; yi<img->dimy; yi++) for(xi=0; xi<img->dimx; xi++) {
      for(ti=1; ti<img->dimt; ti++) {
        if(dimg!=NULL) {
          dimg->m[zi][yi][xi][0]+=fabs(img->m[zi][yi][xi][ti]-img->m[zi][yi][xi][ti-1]);
        }
        if(mimg!=NULL) {
          mimg->m[zi][yi][xi][0]+=0.5*fabs(img->m[zi][yi][xi][ti]+img->m[zi][yi][xi][ti-1]);
        }
      }
    }
  }
 
  return(0);
}

◆ imgGetFrameDyn()

int imgGetFrameDyn	(	IMG *	img,
		IMG *	iimg,
		IMG *	dimg,
		int	verbose )

extern

Compute the number of increases and decreases between consecutive frames.

See also: imgGetPeak, imgGetMaxFrame

Returns: Returns 0, if ok.

Parameters

img	Dynamic image; not modified.
iimg	Pointer to an empty IMG struct in which the nr of increases will be written; any old contents are deleted; NULL, if not needed.
dimg	Pointer to an empty IMG struct in which the nr of decreases will be written; any old contents are deleted; NULL, if not needed.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 249 of file imgframe.c.

  {
  if(verbose>0) {printf("%s()\n", __func__); fflush(stdout);}
  
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<2) {
    if(verbose>0) {fprintf(stderr, "only dynamic image can be processed!\n"); fflush(stderr);}
    return(1);
  }
  if(iimg==NULL && dimg==NULL) return(0);
  if(iimg!=NULL && iimg->status==IMG_STATUS_OCCUPIED) imgEmpty(iimg);
  if(dimg!=NULL && dimg->status==IMG_STATUS_OCCUPIED) imgEmpty(dimg);
 
 
  /* Allocate memory for one frame */
  int ret=0;
  if(verbose>1) {
    printf("allocating memory for %dx%dx%d pixels\n", img->dimz, img->dimy, img->dimx);
    fflush(stdout);
  }
  if(dimg!=NULL) ret=imgAllocate(dimg, img->dimz, img->dimy, img->dimx, 1); else ret=0;
  if(!ret && iimg!=NULL) ret=imgAllocate(iimg, img->dimz, img->dimy, img->dimx, 1);
  if(ret) return(ret);
  /* set image header information */
  if(dimg!=NULL) {
    imgCopyhdr(img, dimg);
    dimg->start[0]=img->start[0]; dimg->end[0]=img->end[img->dimt-1];
    dimg->mid[0]=(dimg->start[0]+dimg->end[0])/2.0;
  }
  if(iimg!=NULL) {
    imgCopyhdr(img, iimg);
    iimg->start[0]=img->start[0]; iimg->end[0]=img->end[img->dimt-1];
    iimg->mid[0]=(iimg->start[0]+iimg->end[0])/2.0;
  }
  iimg->unit=dimg->unit=CUNIT_UNITLESS;
 
  /* Go through every pixel */
  int ti, zi, xi, yi;
  if(iimg!=NULL) {
    for(zi=0; zi<img->dimz; zi++) {
      for(yi=0; yi<img->dimy; yi++) for(xi=0; xi<img->dimx; xi++) {
        for(ti=1; ti<img->dimt; ti++)
          if(img->m[zi][yi][xi][ti]>img->m[zi][yi][xi][ti-1]) iimg->m[zi][yi][xi][0]+=1.0;
        if(verbose>2) {printf("increases m[%d][%d][%d]=%g\n", zi, yi, xi, iimg->m[zi][yi][xi][0]);}
      }
    }
  }
  if(dimg!=NULL) {
    for(zi=0; zi<img->dimz; zi++) {
      for(yi=0; yi<img->dimy; yi++) for(xi=0; xi<img->dimx; xi++) {
        for(ti=1; ti<img->dimt; ti++)
          if(img->m[zi][yi][xi][ti]<img->m[zi][yi][xi][ti-1]) dimg->m[zi][yi][xi][0]+=1.0;
        if(verbose>2) {printf("decreases m[%d][%d][%d]=%g\n", zi, yi, xi, dimg->m[zi][yi][xi][0]);}
      }
    }
  }
 
  return(0);
}

◆ imgInv()

int imgInv ( IMG * img )

extern

Replace IMG data values by their inverse value (1/activity).

Pixels with <=0 are set to zero.

See also: imgLn, imgLog10, imgAbs, imgArithm

Returns: Returns 0, if ok.

Parameters

img	Pointer to IMG data.

Definition at line 314 of file imgarithm.c.

  {
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(2);
  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(img->m[pi][yi][xi][fi]<=0.0) img->m[pi][yi][xi][fi]=0.0;
          else {
            img->m[pi][yi][xi][fi]=1.0/img->m[pi][yi][xi][fi];
            if(!isfinite(img->m[pi][yi][xi][fi])) img->m[pi][yi][xi][fi]=0.0;
          }
        }
  return(0);
}

◆ imgLn()

int imgLn ( IMG * img )

extern

Replace IMG data values by their natural logarithms.

See also: imgLog10, imgAbs, imgArithm, imgInv, imgSS

Returns: Returns 0, if ok.

Parameters

img	Pointer to IMG data.

Definition at line 248 of file imgarithm.c.

  {
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(2);
  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(img->m[pi][yi][xi][fi]<=0.0) img->m[pi][yi][xi][fi]=0.0;
          else img->m[pi][yi][xi][fi]=log(img->m[pi][yi][xi][fi]);
        }
  return(0);
}

◆ imgLog10()

int imgLog10 ( IMG * img )

extern

Replace IMG data values by their log10 values.

See also: imgLn, imgAbs, imgArithm

Returns: Returns 0, if ok.

Parameters

img	Pointer to IMG data.

Definition at line 270 of file imgarithm.c.

  {
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(2);
  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(img->m[pi][yi][xi][fi]<=0.0) img->m[pi][yi][xi][fi]=0.0;
          else img->m[pi][yi][xi][fi]=log10(img->m[pi][yi][xi][fi]);
        }
  return(0);
}

◆ imgMaskCloak()

int imgMaskCloak	(	IMG *	img,
		int	dim,
		float	id )

extern

Cloak mask.

See also: imgMaskDilate, imgMaskErode

Returns: Returns 0 when successful.

Parameters

img	Pointer to 2D/3D mask image.
dim	Cloak the existing mask in xy (2) or xyz (3) dimensions.
id	Id number for the cloak mask. Should be different from existing IDs.

Definition at line 429 of file mask.c.

  {
  if(img==NULL) return(1);
  int dimx=img->dimx, dimy=img->dimy, dimz=img->dimz;
  if(dimx<1 || dimy<1 || dimz<1) return(2);
 
  for(int z=0; z<dimz; z++) {
    for(int y=0; y<dimy; y++) {
      for(int x=0; x<dimx; x++) if(!(img->m[z][y][x][0]<0.5) && img->m[z][y][x][0]!=id) {
        int x1=x, x2=x, y1=y, y2=y, z1=z, z2=z;
        if(x>0) x1=x-1;
        if(x<dimx-1) x2=x+1;
        if(y>0) y1=y-1;
        if(y<dimy-1) y2=y+1;
        if(dim==3) {
          if(z>0) z1=z-1;
          if(z<dimz-1) z2=z+1;
        }
        for(int nz=z1; nz<=z2; nz++)
          for(int ny=y1; ny<=y2; ny++)
            for(int nx=x1; nx<=x2; nx++)
              if(z!=nz || y!=ny || x!=nx)
                if(img->m[nz][ny][nx][0]<0.5)
                  img->m[nz][ny][nx][0]=id;
      }
    }
  }
 
  return(0);
}

◆ imgMaskConjunction()

int imgMaskConjunction	(	IMG *	mask1,
		IMG *	mask2 )

extern

Conjunction (AND, wedge) for two 3D mask images.

See also: imgMaskInv, imgMaskDilate, imgMaskCount, imgMaskFloodFill

Returns: Returns 0 when successful.

Parameters

mask1	Pointer to IMG structure containing the first mask image; will be overwritten by the conjunction mask.
mask2	Pointer to IMG structure containing the second mask image; not modified.

Definition at line 238 of file mask.c.

  {
  if(mask1==NULL || mask2==NULL) return(1);
  if(mask1->dimx<1 || mask1->dimy<1 || mask1->dimz<1) return(2);
  if(mask1->dimx!=mask2->dimx) return(3); 
  if(mask1->dimy!=mask2->dimy) return(4); 
  if(mask1->dimz!=mask2->dimz) return(5); 
 
  int zi, yi, xi;
  for(zi=0; zi<mask1->dimz; zi++)
    for(yi=0; yi<mask1->dimy; yi++)
      for(xi=0; xi<mask1->dimx; xi++) {
        if(fabs(mask1->m[zi][yi][xi][0])<1.0E-12 ||
           fabs(mask2->m[zi][yi][xi][0])<1.0E-12)
        {
          mask1->m[zi][yi][xi][0]=0.0;
        } else {
          mask1->m[zi][yi][xi][0]=1.0;
        }
      }
 
  return(0);
}

◆ imgMaskCount()

long long imgMaskCount ( IMG * img )

extern

Count the nr of positive values inside 3D mask image.

See also: imgMaskRoiNr, imgThresholdMask, imgMaskInvert, imgMaskFloodFill

Returns: Returns the number of positive voxels.

Parameters

img	Pointer to mask IMG structure.

Definition at line 15 of file mask.c.

  {
  long long n=0;
  int zi, yi, xi;
  for(zi=0; zi<img->dimz; zi++)
    for(yi=0; yi<img->dimy; yi++)
      for(xi=0; xi<img->dimx; xi++)
        if(img->m[zi][yi][xi][0]>0.0) n++;
   return(n);
}

◆ imgMaskDilate()

int imgMaskDilate	(	IMG *	img,
		IMG *	se )

extern

Dilate the 3D mask image.

See also: imgStructuringElement, imgMaskErode, imgMaskCloak, imgMaskCount, imgMaskFloodFill, imgSwell

Returns: Returns the number of dilated voxels, or <0 in case of an error.

Parameters

img	Pointer to IMG structure containing the mask image.
se	Pointer to IMG structure containing the structuring element; all dimensions must be odd numbers.

Definition at line 80 of file mask.c.

  {
  if(img==NULL || se==NULL) return(-1);
  if(img->dimx<1 || img->dimy<1 || img->dimz<1) return(-2);
  if(se->dimx<1 || se->dimy<1 || se->dimz<1) return(-3);
  if(se->dimx%2==0 || se->dimy%2==0 || se->dimz%2==0) return(-4);
 
 
  /* make a copy of original data */
  IMG orig; imgInit(&orig);
  if(imgDup(img, &orig)!=0) return(-5);
  long long n=0;
  int zi, yi, xi, zj, yj, xj;
  for(zi=0; zi<orig.dimz; zi++)
    for(yi=0; yi<orig.dimy; yi++)
      for(xi=0; xi<orig.dimx; xi++)
        if(orig.m[zi][yi][xi][0]==0.0) { 
          int zs, ys, xs;
          float mav=-1.0E+20;
          for(zs=0; zs<se->dimz; zs++)
            for(ys=0; ys<se->dimy; ys++)
              for(xs=0; xs<se->dimx; xs++)
                if(se->m[zs][ys][xs][0]>0.0) {
                  zj=zi+(zs-se->dimz/2); if(zj<0 || zj>=orig.dimz) continue;
                  yj=yi+(ys-se->dimy/2); if(yj<0 || yj>=orig.dimy) continue;
                  xj=xi+(xs-se->dimx/2); if(xj<0 || xj>=orig.dimx) continue;
                  if(orig.m[zj][yj][xj][0]>mav) mav=orig.m[zj][yj][xj][0];
                }
          if(mav>0.0) {img->m[zi][yi][xi][0]=mav; n++;}
        }
  imgEmpty(&orig);
 
  return(n);
}

◆ imgMaskErode()

int imgMaskErode	(	IMG *	img,
		IMG *	se )

extern

Erode the 3D mask image.

See also: imgStructuringElement, imgMaskDilate, imgMaskCount, imgShrink

Returns: Returns the number of eroded voxels, or <0 in case of an error.

Parameters

img	Pointer to IMG structure containing the mask image.
se	Pointer to IMG structure containing the structuring element; all dimensions must be odd numbers.

Definition at line 34 of file mask.c.

  {
  if(img==NULL || se==NULL) return(-1);
  if(img->dimx<1 || img->dimy<1 || img->dimz<1) return(-2);
  if(se->dimx<1 || se->dimy<1 || se->dimz<1) return(-3);
  if(se->dimx%2==0 || se->dimy%2==0 || se->dimz%2==0) return(-4);
 
 
  /* make a copy of original data */
  IMG orig; imgInit(&orig);
  if(imgDup(img, &orig)!=0) return(-5);
  long long n=0;
  int zi, yi, xi, zj, yj, xj;
  for(zi=0; zi<orig.dimz; zi++)
    for(yi=0; yi<orig.dimy; yi++)
      for(xi=0; xi<orig.dimx; xi++)
        if(orig.m[zi][yi][xi][0]>0.0) { 
          int zs, ys, xs;
          float miv=+1.0E+20;
          for(zs=0; zs<se->dimz; zs++)
            for(ys=0; ys<se->dimy; ys++)
              for(xs=0; xs<se->dimx; xs++)
                if(se->m[zs][ys][xs][0]>0.0) {
                  zj=zi+(zs-se->dimz/2); if(zj<0 || zj>=orig.dimz) continue;
                  yj=yi+(ys-se->dimy/2); if(yj<0 || yj>=orig.dimy) continue;
                  xj=xi+(xs-se->dimx/2); if(xj<0 || xj>=orig.dimx) continue;
                  if(orig.m[zj][yj][xj][0]<miv) miv=orig.m[zj][yj][xj][0];
                }
          if(!(miv>1.0E-20)) {img->m[zi][yi][xi][0]=0.0; n++;}
        }
  imgEmpty(&orig);
 
  return(n);
}

◆ imgMaskFloodFill()

int imgMaskFloodFill	(	IMG *	m,
		int	sz,
		int	sy,
		int	sx,
		int	label,
		long long *	n,
		int	verbose )

extern

Flood filling for the Region labelling.

Processes only the first frame, even if several do exist.

Based on Burger W and Burge MJ: Principles of Digital Image Processing - Core Algorithms, Springer, 2009, DOI 10.1007/978-1-84800-195-4.

See also: imgMaskRegionLabeling, imgMaskErode, imgMaskCount, imgMaskConjunction, imgMaskRoiNr

Returns: Returns 0 when successful.

Parameters

m	Pointer to IMG structure containing the mask image to be flood filled. Pixels with value 1 are flood filled with label, pixels with value <1 are considered as background, and pixels with values >1 are considered to belong to another already labelled region.
sz	Z coordinate of the starting point [0..dimz-1].
sy	Y coordinate of the starting point [0..dimy-1].
sx	X coordinate of the starting point [0..dimx-1].
label	The label to be assigned to the region; at least 2.
n	The number of pixels that got labelled; enter NULL, if not needed.
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr.

Definition at line 352 of file mask.c.

  {
  if(verbose>0) {
    printf("%s(mask, %d, %d, %d, %d)\n", __func__, sz, sy, sx, label);
    fflush(stdout);
  }
  if(m==NULL || m->status!=IMG_STATUS_OCCUPIED) return(1);
  if(m->dimx<1 || m->dimy<1 || m->dimz<1) return(2);
  if(sx<0 || sy<0 || sz<0 || sx>=m->dimx || sy>=m->dimy || sz>=m->dimz) return(3);
  if(label<2) return(4);
  if(n!=NULL) *n=0;
 
  /* Create empty stack of pixel coordinates */
  IMG_PIXELS pxls; pxlInit(&pxls);
 
  /* Put the start coordinate into the stack */
  IMG_PIXEL pxl; pxl.x=sx; pxl.y=sy; pxl.z=sz;
  if(pxlAdd(&pxls, &pxl)!=0) {
    if(verbose>0) fprintf(stderr, "Error: cannot add seed pixel to stack.\n");
    pxlFree(&pxls); return(11);
  }
 
  /* Process the stack until empty */
  unsigned long long int pxlNr=0;
  while(pxls.pxlNr>0) {
    /* Take the last pixel from the list */
    if(pxlGet(&pxls, pxls.pxlNr-1, &pxl)!=0) break;
    pxls.pxlNr--;
    /* Should this pixel be labelled? */
    if(verbose>100) printf("  m[%d][%d][%d] := %g\n", pxl.z, pxl.y, pxl.x, m->m[pxl.z][pxl.y][pxl.x][0]);
    if(pxl.z<0 || pxl.z>=m->dimz || pxl.y<0 || pxl.y>=m->dimy || pxl.x<0 || pxl.x>=m->dimx)
      continue; // certainly not since outside of the image
    if(m->m[pxl.z][pxl.y][pxl.x][0]!=1.0) continue; // no since labelled or part of background
    m->m[pxl.z][pxl.y][pxl.x][0]=(float)label; // yes
    if(verbose>100) printf("  -> m[%d][%d][%d] := %g\n", pxl.z, pxl.y, pxl.x, m->m[pxl.z][pxl.y][pxl.x][0]);
    pxlNr++;
    /* Add the 26 neighbours to the beginning of the stack */
    if(pxlMakeRoom(&pxls, 0, 26)!=0) break;
    if(pxls.pxlNr==0) pxls.pxlNr=26;
    if(verbose>100) printf("  pxls.pxlNr := %lld\n", pxls.pxlNr);
    unsigned long long int i=0;
    for(int dz=-1; dz<2; dz++) for(int dy=-1; dy<2; dy++) for(int dx=-1; dx<2; dx++) {
      if(dz==0 && dy==0 && dx==0) continue;
      pxls.p[i].z=pxl.z+dz; pxls.p[i].y=pxl.y+dy; pxls.p[i].x=pxl.x+dx;
      i++;
    }
  }
  pxlFree(&pxls);
  if(verbose>1) printf("  %lld pixels labelled.\n", pxlNr);
  if(n!=NULL) *n=pxlNr;
  if(pxlNr==0) return(21);
  return(0);
}

Referenced by imgMaskRegionLabeling().

◆ imgMaskInvert()

void imgMaskInvert ( IMG * img )

extern

Invert the 3D mask image, setting zeroes to ones, and non-zeroes to zeroes.

Processes only the first frame, even if several do exist.

See also: imgMaskCount, imgMaskRoiNr, imgThresholdMask, imgMaskFloodFill

Parameters

img	Pointer to mask IMG structure.

Definition at line 216 of file mask.c.

  {
  if(img==NULL) return;
  int zi, yi, xi;
  for(zi=0; zi<img->dimz; zi++)
    for(yi=0; yi<img->dimy; yi++)
      for(xi=0; xi<img->dimx; xi++)
        if(fabs(img->m[zi][yi][xi][0])>1.0E-12)
          img->m[zi][yi][xi][0]=0.0;
        else
          img->m[zi][yi][xi][0]=1.0;
  return;
}

◆ imgMaskRegionLabeling()

int imgMaskRegionLabeling	(	IMG *	mask1,
		IMG *	mask2,
		int *	n,
		int	verbose )

extern

Region labelling with flood filling.

Processes only the first frame, even if several do exist.

Based on Burger W and Burge MJ: Principles of Digital Image Processing - Core Algorithms, Springer, 2009, DOI 10.1007/978-1-84800-195-4.

Returns: Returns 0 when successful.

See also: imgMaskFloodFill

Parameters

mask1	Pointer to IMG structure containing the mask image to be region labelled; not modified. All pixels with value < 0.1 are considered to belong to background, others to foreground.
mask2	Pointer to an empty but initiated IMG structure for the output, the region labelled mask image.
n	The number of regions that were found; enter NULL, if not needed.
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 279 of file mask.c.

  {
  if(verbose>0) {printf("%s()\n", __func__); fflush(stdout);}
  if(mask1==NULL || mask2==NULL || mask1==mask2) return(1);
  if(mask1->status!=IMG_STATUS_OCCUPIED) return(2);
  if(mask1->dimx<1 || mask1->dimy<1 || mask1->dimz<1) return(3);
  if(verbose>1) printf("mask dimensions := %d x %d x %d\n", mask1->dimx, mask1->dimy, mask1->dimz);
  if(n!=NULL) *n=0;
 
  /* Make a copy of the mask */
  imgEmpty(mask2);
  long long nr;
  if(imgThresholdMaskCount(mask1, 0.1, 1.0E+22, mask2, &nr)!=0) {
    if(verbose>0) fprintf(stderr, "Error: cannot make initial copy of mask.\n");
    return(11);
  }
  if(nr==0) {
    if(verbose>0) fprintf(stderr, "Warning: empty mask.\n");
    return(0);
  }
  if(verbose>1) printf("mask contains %lld foreground pixels.\n", nr);
  if(verbose>80) {
    for(int zi=0; zi<mask2->dimz; zi++)
      for(int yi=0; yi<mask2->dimy; yi++)
        for(int xi=0; xi<mask2->dimx; xi++)
          if(mask2->m[zi][yi][xi][0]!=0.0)
            printf("  %d,%d,%d\n", zi, yi, xi);
  }
 
  /* Label regions */
  int ret=0, nextLabel=2;
  for(int zi=0; zi<mask2->dimz; zi++)
    for(int yi=0; yi<mask2->dimy; yi++)
      for(int xi=0; xi<mask2->dimx; xi++)
        if(mask2->m[zi][yi][xi][0]==1.0) {
          ret=imgMaskFloodFill(mask2, zi, yi, xi, nextLabel, &nr, verbose);
          if(ret!=0) break;
          if(verbose>2) printf("%lld pixels labelled as %d\n", nr, nextLabel);
          nextLabel++;
        }
  if(ret!=0) {
    if(verbose>0) fprintf(stderr, "Error: Flood fill failed.\n");
    imgEmpty(mask2); return(21);
  }
  if(verbose>0) printf("%d regions labelled.\n", nextLabel-2);
  if(n!=NULL) *n=nextLabel-2;
 
  return(0);
}

◆ imgMaskRoiNr()

int imgMaskRoiNr	(	IMG *	img,
		INTEGER_LIST *	list )

extern

Get the list of ROIs in the mask image.

See also: imgMaskCount, imgThresholdMaskCount, imgThresholdMask

Returns: Returns 0 if successful.

Parameters

img	Pointer to mask image. Pixel values <=0 represent pixels outside any ROI, and each rounded positive integer value represents one ROI.
list	Initiated list of integers.

Definition at line 176 of file imgeval.c.

  {
  /* 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;
}

◆ imgMaskTAC()

int imgMaskTAC	(	IMG *	img,
		IMG *	mask,
		double *	tac,
		int	verbose )

extern

Calculate TAC as weighted average of voxels in specified image data with relative weights given in a mask image.

See also: imgsegmThresholdMask, imgAverageMaskTAC, imgThresholdingLowHigh, imgThresholdMask

Returns: Returns 0 if successful.

Parameters

img	Pointer to allocated image from which the weighted TAC is calculated.
mask	Pointer to mask image; x, y, and z dimensions must be the same as in the image to which the mask is applied.
tac	Pointer to an array where weighted pixel averages are written; it must be allocated for size >= dimt.
verbose	Verbose level; set to <=0 to prevent all prints to stdout.

Definition at line 126 of file imgeval.c.

  {
  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);
}

◆ imgMeanFilter()

int imgMeanFilter	(	IMG *	img,
		int	xn,
		int	yn,
		int	zn,
		int	tn,
		int	verbose )

extern

Image mean filtering in 1-4 dimensions.

See also: imgSmoothOverFrames, imgGaussianAMFilter, imgSS, fMean1DFilter

Returns: If an error is encountered, function returns a non-zero value. Otherwise 0 is returned.

Parameters

img	Image data to be processed; data is overwritten with filtered image. All image frames are processed.
xn	Number of adjacent pixels in x dimension; Enter 0 to not filter in x dimension.
yn	Number of adjacent pixels in y dimension; Enter 0 to not filter in y dimension.
zn	Number of adjacent pixels in z dimension; Enter 0 to not filter in z dimension.
tn	Number of adjacent pixels in t dimension; Enter 0 to not filter in t dimension.
verbose	Verbose level; if zero, then only warnings are printed into stderr.

Definition at line 624 of file imgfilter.c.

  {
  if(verbose>0) printf("%s(*img, %d, %d, %d, %d)\n", __func__, xn, yn, zn, verbose); 
 
  if(img==NULL || img->dimz<1 || img->dimy<1 || img->dimx<1 || img->dimt<1) return(1);
  int dimx=img->dimx, dimy=img->dimy, dimz=img->dimz, dimt=img->dimt;
  if(dimx==1) xn=0;
  if(dimy==1) yn=0;
  if(dimz==1) zn=0;
  if(dimt==1) tn=0;
  if(!(xn>0) && !(yn>0) && !(zn>0) && !(tn>0)) {
    if(verbose>1) printf("  no filtering done.\n");
    return(0);
  }
  if((xn>0 && xn<3) || (yn>0 && yn<3) || (zn>0 && zn<3) || (tn>0 && tn<3)) {
    if(verbose>1) printf("  invalid pixel number.\n");
    return(1);
  }
  if((xn>0 && xn%2==0) || (yn>0 && yn%2==0) || (zn>0 && zn%2==0) || (tn>0 && tn%2==0)) {
    if(verbose>1) printf("  invalid pixel number.\n");
    return(1);
  }
  if((xn>0 && dimx<=xn) || (yn>0 && dimy<=yn) || (zn>0 && dimz<=zn) || (tn>0 && dimt<=tn)) {
    if(verbose>1) printf("  invalid pixel number.\n");
    return(1);
  }
 
 
  /* 
   *  Filtering in x dimension
   */
  if(xn>=3) {
    if(verbose>1) {printf("  filtering in x dimension\n"); fflush(stdout);}
    float buf[dimx];
    for(int z=0; z<dimz; z++)
      for(int y=0; y<dimy; y++)
        for(int t=0; t<dimt; t++) {
          for(int x=0; x<dimx; x++) buf[x]=img->m[z][y][x][t];
          if(!fMean1DFilter(buf, dimx, xn))
            for(int x=0; x<dimx; x++) img->m[z][y][x][t]=buf[x];
        }
  }
 
  /* 
   *  Filtering in y dimension
   */
  if(yn>=3) {
    if(verbose>1) {printf("  filtering in y dimension\n"); fflush(stdout);}
    float buf[dimy];
    for(int z=0; z<dimz; z++)
      for(int x=0; x<dimx; x++)
        for(int t=0; t<dimt; t++) {
          for(int y=0; y<dimy; y++) buf[y]=img->m[z][y][x][t];
          if(!fMean1DFilter(buf, dimy, yn))
            for(int y=0; y<dimy; y++) img->m[z][y][x][t]=buf[y];
        }
  }
 
  /* 
   *  Filtering in z dimension
   */
  if(zn>=3) {
    if(verbose>1) {printf("  filtering in z dimension\n"); fflush(stdout);}
    float buf[dimz];
    for(int y=0; y<dimy; y++)
      for(int x=0; x<dimx; x++)
        for(int t=0; t<dimt; t++) {
          for(int z=0; z<dimz; z++) buf[z]=img->m[z][y][x][t];
          if(!fMean1DFilter(buf, dimz, zn))
            for(int z=0; z<dimz; z++) img->m[z][y][x][t]=buf[z];
        }
  }
 
  /* 
   *  Filtering in t dimension
   */
  if(tn>=3) {
    if(verbose>1) {printf("  filtering in t dimension\n"); fflush(stdout);}
    float buf[dimt];
    for(int z=0; z<dimz; z++)
      for(int y=0; y<dimy; y++)
        for(int x=0; x<dimx; x++) {
          for(int t=0; t<dimt; t++) buf[t]=img->m[z][y][x][t];
          if(!fMean1DFilter(buf, dimt, tn))
            for(int t=0; t<dimt; t++) img->m[z][y][x][t]=buf[t];
        }
  }
 
 
  return(0);
}

◆ imgMeanZ()

int imgMeanZ	(	IMG *	img1,
		IMG *	img2 )

extern

Calculate image average over z dimension (image planes).

See also: imgFlipAbove, img2cube

Returns: Returns 0 if successful.

Parameters

img1	Pointer to input IMG data structure; not modified.
img2	Pointer to output IMG data structure; allocated here.

Definition at line 157 of file imgflips.c.

  {
  if(img1==NULL || img2==NULL) return(1);
  if(img1->dimz<1 || img1->dimy<1 || img1->dimx<1 || img1->dimt<1) return(1);
 
  /* If z dim is already 1, then just duplicate the image */
  if(img1->dimz==1) return(imgDup(img1, img2));
 
  /* Allocate memory for the output image */
  if(imgAllocateWithHeader(img2, 1, img1->dimy, img1->dimx, img1->dimt, img1)!=0)
    return(3);
 
  /* Sum over z dimension */
  for(int zi=0; zi<img1->dimz; zi++)
    for(int yi=0; yi<img1->dimy; yi++)
      for(int xi=0; xi<img1->dimx; xi++)
        for(int ti=0; ti<img1->dimt; ti++)
          img2->m[0][yi][xi][ti]+=img1->m[zi][yi][xi][ti];
 
  /* Divide by original z dimension */
  for(int yi=0; yi<img2->dimy; yi++)
    for(int xi=0; xi<img2->dimx; xi++)
      for(int ti=0; ti<img2->dimt; ti++)
        img2->m[0][yi][xi][ti]/=(float)img1->dimz;
 
  return(0);
}

◆ imgMRT()

int imgMRT	(	IMG *	img,
		IMG *	oimg,
		int	verbose )

extern

Calculate (incomplete) mean residence time (MRT) for every pixel in dynamic image.

MRT = area under moment curve (AUMC) / area under curve (AUC). Data is not extrapolated. Frame gaps or overlaps are not accepted.

See also: imgAUMC, imgGetMaxTime, imgGetPeak, imgGetMaxFrame, imgFramesCheck

Returns: Returns 0, if ok.

Parameters

img	Pointer to dynamic image; not modified. Frame times are obligatory.
oimg	Pointer to empty IMG struct in which the AUMC will be written; any old contents are deleted.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 606 of file imgarithm.c.

  {
  if(verbose>0) printf("%s(*img, *oimg)\n", __func__);
  
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<2) {
    if(verbose>1) fprintf(stderr, "Error: dynamic image required.\n");
    return(2);
  }
  if(!imgExistentTimes(img)) {
    if(verbose>1) fprintf(stderr, "Error: unknown frame times.\n");
    return(2);
  }
  if(oimg==NULL) return(3);
  if(oimg->status==IMG_STATUS_OCCUPIED) imgEmpty(oimg);
 
  if(imgFramesCheck(img, verbose-1)>0) {
    if(verbose>1) fprintf(stderr, "Error: gaps or overlap between time frames.\n");
    return(4);
  }
 
  /* 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(oimg, img->dimz, img->dimy, img->dimx, 1);
  if(ret) return(ret);
  /* set image header information */
  imgCopyhdr(img, oimg);
  oimg->start[0]=img->start[0]; oimg->end[0]=img->end[img->dimt-1];
  oimg->mid[0]=(oimg->start[0]+oimg->end[0])/2.0;
  oimg->unit=CUNIT_UNKNOWN;
 
  /* Calculate AUMC, AUC, and MRT */
  for(int zi=0; zi<img->dimz; zi++) {
    for(int yi=0; yi<img->dimy; yi++) {
      for(int xi=0; xi<img->dimx; xi++) {
        float aumc=0.0, auc=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=0.0;
          aumc+=img->m[zi][yi][xi][ti]*img->mid[ti]*fdur;
          auc+=img->m[zi][yi][xi][ti]*fdur;
        }
        float mrt=aumc/auc;
        if(isfinite(mrt)) oimg->m[zi][yi][xi][0]=mrt; else oimg->m[zi][yi][xi][0]=0.0;
      }
    }
  }
 
  return(0);
}

◆ imgOutlierFilter()

int imgOutlierFilter	(	IMG *	img,
		float	limit )

extern

Filter out pixels that are over limit x higher than their closest 8 neighbour pixels.

See also: imgFast2DGaussianFilter, imgFast3DGaussianFilter, imgThresholdingLowHigh

Returns: Returns the nr of filtered pixels, and negative value in case of an error.

Parameters

img	Pointer to IMG struct which will be filtered here.
limit	Cut-off value.

Definition at line 339 of file imgthreshold.c.

  {
  int zi, yi, xi, fi;
  long long nr=0;
  float f;
  IMG tmp;
 
  if(img->status!=IMG_STATUS_OCCUPIED || img->dimt<1) return(-1);
  imgInit(&tmp);
  if(imgAllocate(&tmp, img->dimz, img->dimy, img->dimx, 1)!=0) return(-2);
  /* Process one frame at a time */  
  for(fi=0; fi<img->dimt; fi++) {
    /* Copy one frame to safety */
    for(zi=0; zi<tmp.dimz; zi++)
      for(yi=0; yi<tmp.dimy; yi++)
        for(xi=0; xi<tmp.dimx; xi++)
          tmp.m[zi][yi][xi][0]=img->m[zi][yi][xi][fi];
    /* Go through it */
    for(zi=0; zi<img->dimz; zi++) {
      for(yi=1; yi<img->dimy-1; yi++) for(xi=1; xi<img->dimx-1; xi++) {
        f=tmp.m[zi][yi][xi-1][0]+
          tmp.m[zi][yi][xi+1][0]+
          tmp.m[zi][yi-1][xi][0]+
          tmp.m[zi][yi+1][xi][0]+
          tmp.m[zi][yi+1][xi-1][0]+
          tmp.m[zi][yi+1][xi+1][0]+
          tmp.m[zi][yi-1][xi-1][0]+
          tmp.m[zi][yi-1][xi+1][0];
        f/=8.0;
        if(img->m[zi][yi][xi][fi]>(limit*f)) {img->m[zi][yi][xi][fi]=f; nr++;}
      }
    } /* next plane */
  } /* next frame */
  imgEmpty(&tmp);
 
  return(nr);
}

◆ imgRawCountsPerTime()

int imgRawCountsPerTime	(	IMG *	img,
		int	operation )

extern

Divide or multiply raw data (sinogram) counts by frame duration.

If IMG is not raw data, division is quietly not done. Error is returned if sinogram does not contain frame times, except if sinogram contains only one time frame, also then division is not done.

See also: imgArithmConst, imgArithm, imgFrameIntegral

Returns: Returns 0 if ok.

Parameters

img	IMG containing raw data.
operation	1=division, 0=multiply.

Definition at line 442 of file imgarithm.c.

  {
  int fi, zi, xi, yi, notime=0;
  float f;
 
  /* Check the input data */
  if(operation!=0 && operation!=1) return(1);
  if(img==NULL) return(2);
  if(img->status!=IMG_STATUS_OCCUPIED) return(3);
  if(img->type!=IMG_TYPE_RAW) return(0);
  for(fi=0; fi<img->dimt; fi++) {
    f=img->end[fi]-img->start[fi]; if(f<=1.0E-12) notime++;
  }
  if(notime>0) {
    if(img->dimt>1) return(4);
    else return(0); /* just one frame; might be parametric or transmission sinogram,
                       therefore no error. */
  }
  for(fi=0; fi<img->dimt; fi++) {
    f=img->end[fi]-img->start[fi]; if(operation==1) f=1.0/f;
    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][fi]*=f;
  }
  return(0);
}

◆ imgRegionGrowingByThreshold()

int imgRegionGrowingByThreshold	(	IMG *	img,
		const int	sz,
		const int	sy,
		const int	sx,
		float	lthr,
		float	uthr,
		IMG *	mask,
		int	verbose )

extern

Seeded region growing based on thresholds.

Calls itself recursively until neighbouring pixels fall outside thresholds. Because of recursion, program which uses this function needs a large space for stack.

See also: imgMaskErode, imgMaskDilate, imgsegmClusterExpand

Returns: Returns 0, if seed pixel was added to mask, and 1 if not, and >1 in case of an error.

Parameters

img	Pointer to static image data, to which the threshold is applied.
sz	Seed pixel position [z,y,x] as indices.
sy	Seed pixel position [z,y,x] as indices.
sx	Seed pixel position [z,y,x] as indices.
lthr	Lower threshold as absolute value.
uthr	Upper threshold as absolute value.
mask	Pointer to mask image; must have the same dimensions as the static image.
verbose	Verbose level; if zero, then only warnings are printed into stderr.

Definition at line 394 of file imgthreshold.c.

  {
  if(verbose>0) {
    printf("imgRegionGrowingByThreshold(img, %d, %d, %d, %g, %g, mask, %d)\n",
       sz, sy, sx, lthr, uthr, verbose);
    fflush(stdout);
  }
  if(img==NULL || img->status!=IMG_STATUS_OCCUPIED) return(2);
  if(mask==NULL || mask->status!=IMG_STATUS_OCCUPIED) return(3);
  if(img->dimz!=mask->dimz || img->dimy!=mask->dimy || img->dimx!=mask->dimx) return(4);
  int dimz=img->dimz, dimy=img->dimy, dimx=img->dimx;
 
  /* Check that seed pixel resides inside image volume */
  if(sz<0 || sy<0 || sx<0 || sz>=dimz || sy>=dimy || sx>=dimx) {
    if(verbose>1) printf("pixels does not reside inside image\n");
    return(1);
  }
 
  /* Check that seed pixel is not already part of mask */
  if(mask->m[sz][sy][sx][0]>0.5) {
    if(verbose>1) printf("seed already belongs to mask\n");
    return(1);
  }
 
  /* Threshold */
  if(img->m[sz][sy][sx][0]<lthr || img->m[sz][sy][sx][0]>uthr) {
    if(verbose>1) {
      printf("  [%d][%d][%d] outside thresholds\n", sz, sy, sx);
      fflush(stdout);
    }
    mask->m[sz][sy][sx][0]=0.0;
    return(1);
  }
  if(verbose>1) {
    printf("  [%d][%d][%d] added to mask\n", sz, sy, sx);
    fflush(stdout);
  }
  mask->m[sz][sy][sx][0]=1.0;
 
  /* Check the neighbouring pixels */
  int nsz, nsy, nsx;
  nsz=sz; nsy=sy; nsx=sx-1;
  imgRegionGrowingByThreshold(img, nsz, nsy, nsx, lthr, uthr, mask, verbose);
  nsz=sz; nsy=sy; nsx=sx+1;
  imgRegionGrowingByThreshold(img, nsz, nsy, nsx, lthr, uthr, mask, verbose);
  nsz=sz; nsy=sy-1; nsx=sx;
  imgRegionGrowingByThreshold(img, nsz, nsy, nsx, lthr, uthr, mask, verbose);
  nsz=sz; nsy=sy+1; nsx=sx;
  imgRegionGrowingByThreshold(img, nsz, nsy, nsx, lthr, uthr, mask, verbose);
  nsz=sz-1; nsy=sy; nsx=sx;
  imgRegionGrowingByThreshold(img, nsz, nsy, nsx, lthr, uthr, mask, verbose);
  nsz=sz+1; nsy=sy; nsx=sx;
  imgRegionGrowingByThreshold(img, nsz, nsy, nsx, lthr, uthr, mask, verbose);
 
  return(0);
}

Referenced by imgRegionGrowingByThreshold().

◆ imgScale()

void imgScale	(	IMG *	src,
		IMG *	targ,
		float	zoom,
		int	method )

extern

Image size scaling using the defined method.

See also: integerScale, imgArithm, imgSwell, imgShrink

Parameters

src	Source image to be scaled.
targ	Scaled image; must be allocated to the size of resulting image.
zoom	Scaling factor (integer); currently must be >=1.
method	Method code number (not used yet).

Definition at line 123 of file imgtransform.c.

  {
  int frame, plane, x, y;
  float **tmp_targ;
 
  if(method==0) {} // prevent compiler warning
 
  // Allocate memory for temporary target matrix:
  tmp_targ = malloc(targ->dimy * sizeof(float*));
  for(y=0; y<targ->dimy; y++)
    tmp_targ[y] = malloc(targ->dimx * sizeof(float));
 
  for(plane=0; plane<src->dimz; plane++)
    for(frame=0; frame<src->dimt; frame++){
      integerScale(frame, src->m[plane], tmp_targ, src->dimx, src->dimy, (int)roundf(zoom));
      // Copy scaled image matrix to target image buffer:
      for(y=0; y<targ->dimy; y++)
        for(x=0; x<targ->dimx; x++)
          targ->m[plane][y][x][frame] = tmp_targ[y][x]; 
    }
}

◆ imgsegmCalcMRL()

int imgsegmCalcMRL	(	float	y1[],
		float	y2[],
		long long	n )

extern

Calculates the maximum run length between given n length arrays of data.

See also: imgsegmPearson, imgsegmSimilar, imgsegmFindBestNeighbour, imgThresholdingLowHigh

Returns: Returns the maximum run length between given n length arrays of data.

Parameters

y1	Array 1.
y2	Array 2.
n	Length of arrays.

Definition at line 567 of file imgsegm.c.

  {
  long long i, mrl=0, rl=0;
  char last_sign=0, sign;
  
  for(i=0; i<n; i++) {
    if(y1[i]>y2[i]) sign=1; else if(y1[i]<y2[i]) sign=-1; else sign=0;
    if(sign!=last_sign) {
      rl=0; last_sign=sign;
    } else {
      if(sign!=0) {rl++; if(rl>mrl) mrl=rl;}
    }
  }
  return(mrl);
}

Referenced by imgsegmSimilar().

◆ imgsegmCheckNeighbours()

int imgsegmCheckNeighbours	(	IMG *	cimg,
		int	pi,
		int	ri,
		int	ci )

extern

Checks if neighbours of the specified pixel belong to any cluster.

See also: imgsegmFindBestNeighbour

Returns: Returns 1, if all are in clusters, and 0, if at least one is 'free'.

Parameters

cimg	Cluster image.
pi	Pixel definition [z,y,x].
ri	Pixel definition [z,y,x].
ci	Pixel definition [z,y,x].

Definition at line 398 of file imgsegm.c.

  {
  int pj, rj, cj;
  
  for(pj=pi-1; pj<=pi+1; pj++) if(pj>=0 && pj<cimg->dimz)
    for(rj=ri-1; rj<=ri+1; rj++) if(rj>=0 && rj<cimg->dimy)
      for(cj=ci-1; cj<=ci+1; cj++) if(cj>=0 && cj<cimg->dimx)
        if((pi!=pj || ri!=rj || ci!=cj) && cimg->m[pj][rj][cj][0]<-0.1) return(0);
  return(1);
}

◆ imgsegmClusterExpand()

int imgsegmClusterExpand	(	IMG *	cimg,
		IMG *	simg,
		IMG *	dimg,
		int	clusterID,
		int	pi,
		int	ri,
		int	ci,
		int	pj,
		int	rj,
		int	cj,
		float	CVlim,
		float	CClim,
		int	verbose )

extern

Expands the cluster locally to its neighbour pixels.

Calls itself recursively until neighbouring pixels do not belong to cluster. Because of recursion, program which uses this function needs a large space for stack: add the following line to your program: unsigned _stklen = 4194304;

See also: imgMaskErode, imgMaskDilate

Returns: Returns 0, if test pixel belongs to cluster, and 1 if not, and >1 in case of an error.

Parameters

cimg	pointer to cluster image data.
simg	pointer to sum image data.
dimg	pointer to dynamic image data.
clusterID	number of cluster to be tested.
pi	coordinates of test pixel [z,y,x].
ri	coordinates of test pixel [z,y,x].
ci	coordinates of test pixel [z,y,x].
pj	coordinates of cluster start [z,y,x].
rj	coordinates of cluster start [z,y,x].
cj	coordinates of cluster start [z,y,x].
CVlim	CV limit.
CClim	CC limit.
verbose	Verbose level; if zero, then only warnings are printed into stderr.

Definition at line 219 of file imgsegm.c.

  {
  if(verbose>0) {
    printf("imgsegmClusterExpand(cimg, simg, dimg, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d)\n",
       clusterID, pi, ri, ci, pj, rj, cj, CVlim, CClim, verbose);
    fflush(stdout);
  }
  if(cimg==NULL || cimg->status!=IMG_STATUS_OCCUPIED) return(2);
  if(simg==NULL || simg->status!=IMG_STATUS_OCCUPIED) return(3);
  if(dimg==NULL || dimg->status!=IMG_STATUS_OCCUPIED) return(4);
 
  /* Check that test pixel resides inside image volume */
  if(pi<0 || ri<0 || ci<0 || pi>=cimg->dimz || ri>=cimg->dimy || ci>=cimg->dimx) {
    if(verbose>1) printf("pixels does not reside inside image\n");
    return(1);
  }
 
  /* Check that test pixel is not already part of any cluster */
  if(cimg->m[pi][ri][ci][0]>=-0.1) {
    if(verbose>1) 
      printf("pixel already belongs to cluster %g\n", cimg->m[pi][ri][ci][0]);
    return(1);
  }
 
  /* Check that AUCs are matching */
  {
  float mean=0.5*(simg->m[pi][ri][ci][0]+simg->m[pj][rj][cj][0]);
  float a=simg->m[pi][ri][ci][0]-mean; 
  float b=simg->m[pj][rj][cj][0]-mean;
  float cv;
  if(fabs(mean)>1.0e-10) cv=(a*a + b*b) / mean; else cv=0.0;
  if(verbose>2) printf("cv=%g CVlim=%g mean=%g\n", cv, CVlim, mean);
  if(cv>CVlim) {
    if(verbose>2) printf("AUCs are not matching, %g>%g\n", cv, CVlim);
    return(1);
  }
  }
 
  /* Check that TACs are correlating */
  {
  float r=imgsegmPearson(dimg->m[pj][rj][cj], dimg->m[pi][ri][ci], dimg->dimt);
  if(verbose>3) printf("  r=%g CClim=%g\n", r, CClim);
  if(r<CClim) {
    if(verbose>2) printf("TACs are not correlating, %g<%g\n", r, CClim);
    return(1);
  }
  }
 
  /* If we got this far, the test pixel belongs to the cluster */
  cimg->m[pi][ri][ci][0]=clusterID;
  if(verbose>1) {
    printf("  [%d][%d][%d] belongs to cluster %d\n", pi, ri, ci, clusterID);
    fflush(stdout);
  }
 
  /* Check if the neighbouring pixels belong to this cluster */
  for(int pk=pi-1; pk<=pi+1; pk++) if(pk>=0 && pk<cimg->dimz)
    for(int rk=ri-1; rk<=ri+1; rk++) if(rk>=0 && rk<cimg->dimy)
      for(int ck=ci-1; ck<=ci+1; ck++) if(ck>=0 && ck<cimg->dimx)
        if((pk!=pi || rk!=ri || ck!=ci) && cimg->m[pk][rk][ck][0]<-0.1) {
          int ret=imgsegmClusterExpand(cimg, simg, dimg, clusterID,
                 pk, rk, ck, pj, rj, cj, CVlim, CClim, verbose);
          if(ret>1) return(ret);
        }
 
  return(0);
}

Referenced by imgsegmClusterExpand().

◆ imgsegmClusterMean()

int imgsegmClusterMean	(	IMG *	dimg,
		IMG *	cimg,
		int	clusterID,
		float *	avg,
		int	verbose )

extern

Calculates the average of pixels belonging to the specified cluster, and returns this average for each frame in the specified float array.

Cluster pixels do not have to be adjacent!

See also: imgsegmSimilar

Returns: Returns the nr of pixels that belong to this cluster, or <0 in case of an error.

Parameters

dimg	Dynamic image.
cimg	Cluster image.
clusterID	Cluster number 0...
avg	Pointer to a float array where cluster average TAC is written.
verbose	Verbose level; if zero, then only warnings are printed into stderr.

Definition at line 357 of file imgsegm.c.

  {
  int fi, pi, ri, ci;
 
  /* Check the arguments */
  if(dimg==NULL || cimg==NULL || avg==NULL) return(-1);
  if(cimg->dimx!=dimg->dimx || cimg->dimy!=dimg->dimy || cimg->dimz!=dimg->dimz)
    return(-2);
  
  if(verbose>0) printf("calculating avg of cluster %d:", clusterID);
  for(fi=0; fi<dimg->dimt; fi++) avg[fi]=0.0;
  long long n=0;
  for(pi=0; pi<cimg->dimz; pi++)
    for(ri=0; ri<cimg->dimy; ri++)
      for(ci=0; ci<cimg->dimx; ci++)
        if(fabs(cimg->m[pi][ri][ci][0]-(float)clusterID)<0.1) {
          for(fi=0; fi<dimg->dimt; fi++)
            avg[fi]+=dimg->m[pi][ri][ci][fi];
          n++;
        }
  if(n>0) for(fi=0; fi<dimg->dimt; fi++) avg[fi]/=(float)n;
  if(verbose>0) printf(" %lld pixels\n", n);
  return(n);
}

Referenced by clusterTACs().

◆ imgsegmFindBestNeighbour()

int imgsegmFindBestNeighbour	(	IMG *	dimg,
		IMG *	cimg,
		int	pi,
		int	ri,
		int	ci )

extern

Combines this pixel to the cluster of the neighbour which has the best correlation.

All neighbours of the specified pixel must belong to some cluster (must be checked before calling this function).

See also: imgsegmCalcMRL, imgsegmCheckNeighbours

Returns: If ok, returns 0.

Parameters

dimg	Dynamic image.
cimg	Cluster image.
pi	Pixel definition [z,y,x].
ri	Pixel definition [z,y,x].
ci	Pixel definition [z,y,x].

Definition at line 427 of file imgsegm.c.

  {
  int pj, rj, cj;
  float cc, best_cc, best_ID;
 
  best_ID=-1.0; best_cc=-1.0e+20;
  for(pj=pi-1; pj<=pi+1; pj++) if(pj>=0 && pj<cimg->dimz)
    for(rj=ri-1; rj<=ri+1; rj++) if(rj>=0 && rj<cimg->dimy)
      for(cj=ci-1; cj<=ci+1; cj++) if(cj>=0 && cj<cimg->dimx)
        if((pi!=pj || ri!=rj || ci!=cj)) {
          cc=imgsegmPearson(dimg->m[pj][rj][cj], dimg->m[pi][ri][ci], dimg->dimt);
          if(cc>best_cc) {
            best_cc=cc; 
            best_ID=cimg->m[pj][rj][cj][0];
          }
        }
  if(best_ID<0.0) return(1);
  cimg->m[pi][ri][ci][0]=best_ID;
  return(0);
}

◆ imgsegmFindMaxOutsideClusters()

int imgsegmFindMaxOutsideClusters	(	IMG *	sumimg,
		IMG *	cluster,
		float *	max,
		int *	plane,
		int *	row,
		int *	col )

extern

Finds the maximum sumimg pixel value, excluding all pixels which already belong to clusters (cluster>=0).

Returns: Returns 0, if max was found, >1 in case of an error, and -1, if all pixels already belong to clusters.

Parameters

sumimg	Integral image.
cluster	Cluster image.
max	Found max value.
plane	Found max pixel [Z,y,x].
row	Found max pixel [z,Y,x].
col	Found max pixel [z,y,X].

Definition at line 166 of file imgsegm.c.

  {
  int p, i, j, maxp=0, maxi=0, maxj=0;
 
  if(sumimg->status!=IMG_STATUS_OCCUPIED) return(1);
  if(cluster->status!=IMG_STATUS_OCCUPIED) return(2);
  if(sumimg->dimt>1) return(3);
  if(cluster->dimt>1) return(4);
  if(sumimg->dimx!=cluster->dimx || sumimg->dimy!=cluster->dimy) return(5);
  if(sumimg->dimz!=cluster->dimz) return(6);
 
  *max=-1.0e8;
  long long n=0;
  for(p=0; p<sumimg->dimz; p++) {
    for(j=0; j<sumimg->dimy; j++) for(i=0; i<sumimg->dimx; i++) 
      if(cluster->m[p][j][i][0]<-0.1) {
        if(sumimg->m[p][j][i][0]>*max) {
          *max=sumimg->m[p][j][i][0]; maxp=p; maxj=j; maxi=i;
        }
        n++;
      }
  }
  if(n==0) return(-1);
  *plane=maxp; *row=maxj; *col=maxi;
  return(0);
}

◆ imgsegmMaskToCluster()

int imgsegmMaskToCluster ( IMG * img )

extern

Sets 0 values in mask image to -1, and others to value 0.

Returns: Returns 0 if ok.

Parameters

img	Pointer to the mask image.

Definition at line 142 of file imgsegm.c.

  {
  int plane, i, j;
 
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt>1) return(2);
  for(plane=0; plane<img->dimz; plane++)
    for(j=0; j<img->dimy; j++) for(i=0; i<img->dimx; i++) {
      if(img->m[plane][j][i][0]>0.0) img->m[plane][j][i][0]=0.0;
      else img->m[plane][j][i][0]=-1.0;
    }
  return(0);
}

◆ imgsegmPearson()

float imgsegmPearson	(	float *	x,
		float *	y,
		long long	nr )

extern

Calculates Pearson's correlation coefficient between x[] and y[] values.

Not corrected for sample size.

See also: regr_line, best_pearson, highest_slope, pearson, mean, imgsegmCalcMRL

Returns: Returns Pearson's correlation coefficient; in case of an error returns 0.

Parameters

x	x axis values.
y	y axis values.
nr	nr of samples.

Definition at line 322 of file imgsegm.c.

  {
  int i;
  float sumx=0.0, sumy=0.0, sumsx=0.0, sumsy=0.0, sumxy=0.0, r, q;
 
  if(nr<1 || x==NULL || y==NULL) return(0.0);
  if(nr<3) return(1.0);
  for(i=0; i<nr; i++) {
    sumx+=x[i]; sumy+=y[i];
    sumsx+=x[i]*x[i]; sumsy+=y[i]*y[i];
    sumxy+=x[i]*y[i];
  }
  q=(sumsx - sumx*sumx/(float)nr) * (sumsy - sumy*sumy/(float)nr);
  if(q<=0.0) return(1.0);
  r=(sumxy-((sumx*sumy)/(float)nr)) / sqrt(q);
  return(r);
}

Referenced by imgsegmClusterExpand(), and imgsegmFindBestNeighbour().

◆ imgsegmSimilar()

int imgsegmSimilar	(	IMG *	input,
		int	smoothDim,
		int	smoothNr,
		IMG *	output,
		int	verbose )

extern

Computes a smoothed image from the specified dynamic image with noise.

The TACs inside a matrix smoothDim*smoothDim*smoothDim are sorted by the MRL and AUC, and each TAC is replaced by the mean of the best smoothNr TACs. This function allocates memory for output and copies the header info.

See also: imgsegmCalcMRL, imgsegmFindBestNeighbour, imgFast3DGaussianFilter, imgAverageTAC

Returns: Returns 0 if ok.

Parameters

input	Dynamic input image.
smoothDim	Smoothing mask dimensions; either 3 or 5 (default).
smoothNr	Nr of TACs to average; default is 9.
output	Smoothed image.
verbose	Verbose level; if zero, then only warnings are printed into stderr.

Definition at line 478 of file imgsegm.c.

  {
  int ret, pi, ri, ci, pj, rj, cj, mi, mj, fi, maskNr, smod;
  IMG sum;
  IMGSEGMMASK mask[125];
  
 
  if(verbose>0) printf("in filterSimilar(input, %d, %d, output)\n", smoothDim, smoothNr);
  /* Check the parameters */
  if(input->status!=IMG_STATUS_OCCUPIED) return(1);
  if(input->dimt<2) return(2);
  if(smoothDim==3) smod=1; else smod=2;
  if(smoothNr<2) smoothNr=9;
  
  /* Compute AUC image */
  imgInit(&sum);
  ret=imgFrameIntegral(input, 0, input->dimt-1, &sum, verbose);
  if(ret) return(10+ret);
  
  /* Allocate space for smoothed image */
  ret=imgAllocateWithHeader(
    output, input->dimz, input->dimy, input->dimx, input->dimt, input);
  if(ret) {imgEmpty(&sum); return(20+ret);}
    
  /* One pixel at a time */
  for(pi=0; pi<input->dimz; pi++) {
    if(input->dimz>1) {fprintf(stdout, "."); fflush(stdout);}
    for(ri=0; ri<input->dimy; ri++) {
      for(ci=0; ci<input->dimx; ci++) {
        /* Fill the smoothing mask values */
        for(mi=0; mi<125; mi++) mask[mi].order=0;
        mi=0;
        for(pj=pi-smod; pj<=pi+smod; pj++) if(pj>=0 && pj<input->dimz) {
          for(rj=ri-smod; rj<=ri+smod; rj++) if(rj>=0 && rj<input->dimy) {
            for(cj=ci-smod; cj<=ci+smod; cj++) if(cj>=0 && cj<input->dimx) {
              mask[mi].p=pj; mask[mi].r=rj; mask[mi].c=cj;
              /* Calculate the AUC difference */
              mask[mi].dauc=fabs(sum.m[pi][ri][ci][0]-sum.m[pj][rj][cj][0]);
              /* Calculate the MRL */
              mask[mi].mrl=imgsegmCalcMRL(input->m[pi][ri][ci], input->m[pj][rj][cj], input->dimt);
              mi++;
            }
          }
        }
        maskNr=mi;
        /* Put mask values in similarity order */
        for(mi=0; mi<maskNr; mi++) {
          mask[mi].order=0;
          for(mj=0; mj<maskNr; mj++) {
            if(mask[mj].dauc>mask[mi].dauc) mask[mi].order++;
            if(mask[mj].mrl>mask[mi].mrl) mask[mi].order++;
          }
        }
        qsort(mask, maskNr, sizeof(IMGSEGMMASK), imgsegmSimilarSort);
        /* Calculate average */
        mj=smoothNr; if(mj>maskNr/2) mj=maskNr/2;
        for(fi=0; fi<input->dimt; fi++) {
          output->m[pi][ri][ci][fi]=0.0;
          for(mi=0; mi<mj; mi++) {
            /*printf("order=%d pj=%d rj=%d cj=%d\n", mask[mi].order, mask[mi].p, mask[mi].r, mask[mi].c);*/
            output->m[pi][ri][ci][fi]+=
              input->m[mask[mi].p][mask[mi].r][mask[mi].c][fi];
          }
          output->m[pi][ri][ci][fi]/=(double)mj;
        }
      }
    }
  }
  if(input->dimz>1) {fprintf(stdout, "\n"); fflush(stdout);}
  imgEmpty(&sum);
  return(0);
}

◆ imgsegmThreshold()

int imgsegmThreshold	(	IMG *	img,
		float	minValue,
		float	maxValue )

extern

Sets values <minValue to zero, and values >maxValue to maxValue.

See also: imgThresholdingLowHigh, imgsegmThresholdByMask

Returns: Returns 0 if ok.

Parameters

img	Dynamic or static image.
minValue	Min pixel value.
maxValue	Max pixel value.

Definition at line 116 of file imgsegm.c.

  {
  int frame, plane, i, j;
 
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  for(plane=0; plane<img->dimz; plane++)
    for(j=0; j<img->dimy; j++) for(i=0; i<img->dimx; i++)
      for(frame=0; frame<img->dimt; frame++)
        if(img->m[plane][j][i][frame]<minValue) 
          img->m[plane][j][i][frame]=0.0;
        else if(img->m[plane][j][i][frame]>maxValue) 
          img->m[plane][j][i][frame]=maxValue;
  return(0);
}

◆ imgsegmThresholdByMask()

int imgsegmThresholdByMask	(	IMG *	img,
		IMG *	template,
		float	minValue,
		float	maxValue )

extern

Sets pixel values in img to minValue, if corresponding pixel value in the mask is == 2, and to maxValue, if mask value is == 1.

Only first plane of the mask is used.

See also: imgThresholdingLowHigh, imgsegmThreshold, imgThresholdMaskCount

Returns: Returns 0 if ok.

Parameters

img	Dynamic image which is modified based on the mask.
template	Mask image.
minValue	This value is put into img if template value is =2.
maxValue	This value is put into img if template value is =1.

Definition at line 83 of file imgsegm.c.

  {
  int frame, plane, i, j;
 
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(template->status!=IMG_STATUS_OCCUPIED) return(2);
  for(plane=0; plane<img->dimz; plane++)
    for(j=0; j<img->dimy; j++) for(i=0; i<img->dimx; i++)
      if(template->m[plane][j][i][0]==1.0) {  
        for(frame=0; frame<img->dimt; frame++)
          img->m[plane][j][i][frame]=minValue;
      } else if(template->m[plane][j][i][0]==2.0) {
        for(frame=0; frame<img->dimt; frame++)
          img->m[plane][j][i][frame]=maxValue;
      }
  return(0);
}

◆ imgsegmThresholdMask()

int imgsegmThresholdMask	(	IMG *	img,
		float	minValue,
		float	maxValue,
		IMG *	timg )

extern

Allocate and fill a mask image based on the specified image and threshold values.

If pixel value in original image is <minValue, sets the mask pixel to 1, if >maxValue, sets mask pixel to 2, and to 0, if value is between minValue and maxValue. Only first frame is used, allocated and filled.

See also: imgVoiMaskTAC, imgMaskTAC, imgThresholdMaskCount, imgMaskDilate, imgMaskErode

Returns: Returns 0 if ok.

Parameters

img	Pointer to original (static) image.
minValue	Lower threshold limit.
maxValue	Upper threshold limit.
timg	Pointer to initiated and empty mask image.

Definition at line 39 of file imgsegm.c.

  {
  int frame, plane, i, j, ret;
 
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  /* Allocate memory for the mask data */
  ret=imgAllocateWithHeader(timg, img->dimz, img->dimy, img->dimx, 1, img);
  if(ret) return(ret);
  timg->start[0]=img->start[0]; timg->end[0]=img->end[img->dimt-1];
  timg->mid[0]=(timg->start[0]+timg->end[0])/2.0;
  timg->isWeight=0;
 
  /* Make the mask data */
  for(plane=0; plane<img->dimz; plane++)
    for(j=0; j<img->dimy; j++) for(i=0; i<img->dimx; i++) {
      frame=0;
      if(img->m[plane][j][i][frame]<minValue) 
        timg->m[plane][j][i][frame]=1.0;
      else if(img->m[plane][j][i][frame]>maxValue) 
        timg->m[plane][j][i][frame]=2.0;
      else
        timg->m[plane][j][i][frame]=0.0;
    }
  return(0);
}

◆ imgSetScanner()

int imgSetScanner	(	IMG *	img,
		int	scanner_type )

extern

Sets scanner specific parameters in IMG data. If possible, set image zoom before calling this.

Returns: Returns 0, if ok.

Parameters

img	IMG data which is filled with scanner specific information
scanner_type	SCANNER_ECAT931, SCANNER_ADVANCE, SCANNER_HRPLUS, SCANNER_HRRT, SCANNER_STEVCT_PET, as defined in libtpcimgio.h

Definition at line 14 of file imgscanner.c.

  {
  int rayNr;
  
  if(img->status<IMG_STATUS_OCCUPIED) return(1);
  img->scanner=scanner_type;
  /* Set zoom to 1.0, if it is not set */
  if(img->zoom<=0.0) img->zoom=1.0;
  /* Then the others */
  if(scanner_type==SCANNER_ECAT931) {
    // dimz 15
    rayNr=192;
    img->axialFOV=108.;
    img->transaxialFOV=600.826;
    img->sampleDistance=3.12932;
    img->sizez=6.75;
  } else if(scanner_type==SCANNER_ADVANCE) {
    // dimz 35
    rayNr=281;
    img->axialFOV=153.;
    img->transaxialFOV=550.;
    img->sampleDistance=1.970177;
    img->sizez=4.25;
  } else if(scanner_type==SCANNER_HRPLUS) {
    rayNr=288;
    img->axialFOV=155.2;
    img->transaxialFOV=583.;
    img->sampleDistance=2.25; /* bin size */
    img->sizez=2.425;
  } else if(scanner_type==SCANNER_HRRT) {
    rayNr=256;
    img->axialFOV=252.28;
    img->transaxialFOV=312.;
    img->sampleDistance=1.08; /* bin size */
    img->sizez=img->sizex=img->sizey=1.218750;
  } else if(scanner_type==SCANNER_STEVCT_PET) {
    // dimz 47
    rayNr=0;
    img->sizez=3.27;
    img->sizex=img->sizey=5.46875;
/*} else if(scanner_type==SCANNER_DMI_PET) { // Aino
    rayNr=544;
    img->axialFOV=200.;
    img->transaxialFOV=700.;
    img->sizez=nan("");
    img->sizex=img->sizey=nan("");
*/
  } else
    return(2);
  /* If this is image, then set also pixel sizes */
  if(img->type==IMG_TYPE_IMAGE) {
    if(scanner_type!=SCANNER_HRRT && scanner_type!=SCANNER_STEVCT_PET) {
      img->sizex=img->sizey=
        img->sampleDistance*(float)rayNr / ( (float)img->dimx*img->zoom );
    } else {
      img->sizex=img->sizey=
        img->transaxialFOV / ( (float)img->dimx*img->zoom );
    }
  }
  
  return(0);
}

Referenced by imgAnalyzeToEcat(), and imgNiftiToEcat().

◆ imgShrink()

int imgShrink	(	IMG *	img1,
		IMG *	img2,
		int	doz )

extern

Shrink the image data matrix into half of the original size in each dimension.

Eight neighbouring pixels are averaged into one pixel, without any interpolation etc.

See also: img2cube, imgScale, imgSwell, imgMaskErode

Returns: Returns 0 if ok.

Parameters

img1	Pointer to the original image; not changed.
img2	Pointer to the shrunken image; must be initiated. If allocated for correct size, then only pixel values are set; if not, then any previous contents are deleted, memory is allocated, header information is set, and of course the pixel values are set.
doz	Shrink (1) the image in z dimension (over image planes), or shrink only in x and y dimensions (0).

Definition at line 263 of file imgtransform.c.

  {
  if(img1==NULL || img2==NULL) return(1);
  if(img1->dimz<1 || img1->dimy<2 || img1->dimx<2 || img1->dimt<1) return(2);
 
  /* Set correct dimensions for the shrunken image */
  int dimz, dimy, dimx;
  if(doz!=0) dimz=0.5*img1->dimz; else dimz=img1->dimz;
  dimy=0.5*img1->dimy; 
  dimx=0.5*img1->dimx; 
  /* Correct dimensions (add 1) if the original ones were odd */
  if((img1->dimz % 2!=0.0) && doz!=0) dimz+=1;
  if(img1->dimy % 2!=0.0) dimy+=1;
  if(img1->dimx % 2!=0.0) dimx+=1;
 
  /* If output image does not yet have these dimensions, then re-allocate it and set headers */
  if(img2->dimz!=dimz || img2->dimy!=dimy || img2->dimx!=dimx || img2->dimt!=img1->dimt) {
    /* Allocate memory for the image */
    int ret=imgAllocateWithHeader(img2, dimz, dimy, dimx, img1->dimt, img1); 
    if(ret) return(10+ret);
    /* Correct the pixel sizes so that the actual size (cm x cm) of the image won't change */
    if(doz!=0) {img2->sizez=2.0*img1->sizez; img2->gapz=2.0*img1->gapz;}
    img2->sizey=2.0*img1->sizey; img2->gapy=2.0*img1->gapy;
    img2->sizex=2.0*img1->sizex; img2->gapx=2.0*img1->gapx;
  }
 
  /* Calculate the averages of 2x2x2 or 2x2 pixel areas */
  if(doz!=0) {
    int fi, pi, yi, xi, pc, yc, xc;
    for(fi=0; fi<img2->dimt; fi++){
      for(pi=0, pc=1; pi<img2->dimz; pi++) {
        for(yi=0, yc=1; yi<img2->dimy; yi++) for(xi=0, xc=1; xi<img2->dimx; xi++) {
          img2->m[pi][yi][xi][fi]=0.0;
          if(2*pi+1==img1->dimz) pc=0;
          if(2*yi+1==img1->dimy) yc=0;
          if(2*xi+1==img1->dimx) xc=0;
          img2->m[pi][yi][xi][fi]+=img1->m[2*pi][2*yi][2*xi][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[2*pi][2*yi][2*xi+xc][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[2*pi][2*yi+yc][2*xi][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[2*pi][2*yi+yc][2*xi+xc][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[2*pi+pc][2*yi][2*xi][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[2*pi+pc][2*yi][2*xi+xc][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[2*pi+pc][2*yi+yc][2*xi][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[2*pi+pc][2*yi+yc][2*xi+xc][fi];
          img2->m[pi][yi][xi][fi]/=8.0;
        } /* next row and column */
      } /* next plane */
    } /*next frame */
  } else {
    int fi, pi, yi, xi, yc, xc;
    for(fi=0; fi<img2->dimt; fi++){
      for(pi=0; pi<img2->dimz; pi++) {
        for(yi=0, yc=1; yi<img2->dimy; yi++) for(xi=0, xc=1; xi<img2->dimx; xi++) {
          img2->m[pi][yi][xi][fi]=0.0;
          if(2*yi+1==img1->dimy) yc=0;
          if(2*xi+1==img1->dimx) xc=0;
          img2->m[pi][yi][xi][fi]+=img1->m[pi][2*yi][2*xi][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[pi][2*yi][2*xi+xc][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[pi][2*yi+yc][2*xi][fi];
          img2->m[pi][yi][xi][fi]+=img1->m[pi][2*yi+yc][2*xi+xc][fi];
          img2->m[pi][yi][xi][fi]/=4.0;
        } /* next row and column */
      } /* next plane */
    } /*next frame */
  }
 
  return(0);
}

◆ imgSmoothOverFrames()

int imgSmoothOverFrames	(	IMG *	img,
		int	n )

extern

Smooth dynamic image data over specified number of time frames.

Average is weighted by frame durations. Gaps or overlaps in frame times are not taken into account. Do not use this for quantitative analysis, but only for robust peak search etc.

See also: imgGetFrameDiff, imgGaussianFilter, imgMeanFilter, imgMeanZ

Returns: Non-zero value, if error is encountered, otherwise 0 is returned.

Parameters

img	Pointer to IMG structure containing the 4D image data.
n	Nr of frames to average; n must be an odd number and at least 3.

Definition at line 136 of file imgframe.c.

  {
  int zi, yi, xi, fi, fj, m, f1, f2;
 
  if(IMG_TEST) {fprintf(stdout, "%s(img, %d)\n", __func__, n); fflush(stdout);}
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(n<3) n=3; else if((n%2)==0) return(1);
  if(img->dimt<n) return(0); // too few frames for smoothing
  m=n/2;
  double orig[img->dimt], vsum, fsum, fdur;
  for(zi=0; zi<img->dimz; zi++) {
    for(yi=0; yi<img->dimy; yi++) for(xi=0; xi<img->dimx; xi++) {
      /* preserve original data for now */
      for(fi=0; fi<img->dimt; fi++) orig[fi]=img->m[zi][yi][xi][fi];
      /* frame-by-frame */
      for(fi=0; fi<img->dimt; fi++) {
        /* set frame range */
        f1=fi-m; if(f1<0) f1=0; 
        f2=fi+m; if(f2>img->dimt-1) f2=img->dimt-1;
        /* mean */
        fsum=vsum=0.0;
        for(fj=f1; fj<=f2; fj++) {
          fdur=img->end[fj]-img->start[fj];
          vsum+=fdur*orig[fj];
          fsum+=fdur;
        }
        if(fsum<1.0E-010) return(2);
        img->m[zi][yi][xi][fi]=vsum/fsum;
      }
    }
  }
  return(0);
}

◆ imgStructuringElement()

int imgStructuringElement	(	IMG *	img,
		const int	structuring_element,
		int	verbose )

extern

Make 3D structuring element for eroding and dilation.

See also: imgMaskDilate, imgMaskErode

Returns: Returns 0 when successful.

Parameters

img	Pointer to empty IMG struct for the element.
structuring_element	Structuring element: 3x3x3 cube rounded 3x3x3 cube (23 voxels) cube on its corner (star, consisting of 7 voxels).
verbose	Verbose level; if zero, then only warnings are printed into stderr

Definition at line 126 of file mask.c.

  {
  if(img==NULL) return(1);
  imgEmpty(img);
 
  int ret=0;
  if(structuring_element==1) {
    if(verbose>0) printf("making cube as the structuring element\n");
    ret=imgAllocate(img, 3, 3, 3, 1);
  } else if(structuring_element==2) {
    if(verbose>0) printf("making rounded cube as the structuring element\n");
    ret=imgAllocate(img, 3, 3, 3, 1);
  } else if(structuring_element==3) {
    if(verbose>0) printf("making star as the structuring element\n");
    ret=imgAllocate(img, 3, 3, 3, 1);
  } else {
    fprintf(stderr, "Error: unsupported structuring element.\n");
    return(2);
  }
  if(verbose>0) {fflush(stdout);}
  if(ret) {
    fprintf(stderr, "Error: cannot allocate memory.\n");
    imgEmpty(img);
    return(3);
  }
 
  int z, y, x, n;
 
  if(structuring_element==1) { // 3x3x3 cube
    for(z=0; z<3; z++)
      for(y=0; y<3; y++)
        for(x=0; x<3; x++)
          img->m[z][y][x][0]=1.0;
  } else if(structuring_element==2) { // rounded 3x3x3 cube
    for(z=0; z<3; z++)
      for(y=0; y<3; y++)
        for(x=0; x<3; x++)
          if(z==1 || y==1 || x==1)
            img->m[z][y][x][0]=1.0;
          else
            img->m[z][y][x][0]=0.0;
  } else if(structuring_element==3) { // 7-voxel star
    for(z=0; z<3; z++)
      for(y=0; y<3; y++)
        for(x=0; x<3; x++) {
          n=0; 
          if(z==1) n++;
          if(y==1) n++;
          if(x==1) n++;
          if(n>1)
            img->m[z][y][x][0]=1.0;
          else
            img->m[z][y][x][0]=0.0;
        }
  }
 
  if(verbose>3) {
    int z, y, x;
    printf("\nplanes 1-3\n");
    for(x=0; x<3; x++) {
      for(z=0; z<3; z++) {
        for(y=0; y<3; y++)
          printf(" %g", img->m[z][y][x][0]);
        printf("  ");
      }
      printf("\n");
    }
    printf("\n");
  }
  return(0);
}

◆ imgSwell()

int imgSwell	(	IMG *	img1,
		IMG *	img2,
		int	doz )

extern

Inflate the image data matrix into twice the original size in each dimension.

Each pixel is inflated into eight pixels, without any interpolation etc.

See also: imgShrink, img2cube, imgScale

Returns: Returns 0 if ok.

Parameters

img1	Pointer to the original image; not changed.
img2	Pointer to the swollen image; must be initiated. If allocated for correct size, then only pixel values are set; if not, then any previous contents are deleted, memory is allocated, header information is set, and of course the pixel values are set.
doz	Inflate (1) the image in z dimension (over image planes), or only in x,y dimensions (0).

Definition at line 202 of file imgtransform.c.

  {
  if(img1==NULL || img2==NULL) return(1);
  if(img1->dimz<1 || img1->dimy<1 || img1->dimx<1 || img1->dimt<1) return(2);
 
  /* Set correct dimensions for the swollen image */
  int dimz, dimy, dimx;
  if(doz!=0) dimz=2*img1->dimz; else dimz=img1->dimz;
  dimy=2*img1->dimy; 
  dimx=2*img1->dimx; 
 
  /* If output image does not yet have these dimensions, then re-allocate it and set headers */
  if(img2->dimz!=dimz || img2->dimy!=dimy || img2->dimx!=dimx || img2->dimt!=img1->dimt) {
    /* Allocate memory for the image */
    int ret=imgAllocateWithHeader(img2, dimz, dimy, dimx, img1->dimt, img1); 
    if(ret) return(10+ret);
    /* Correct the pixel sizes so that the actual size (cm x cm) of the image won't change */
    if(doz!=0) {img2->sizez=0.5*img1->sizez; img2->gapz=0.5*img1->gapz;}
    img2->sizey=0.5*img1->sizey; img2->gapy=0.5*img1->gapy;
    img2->sizex=0.5*img1->sizex; img2->gapx=0.5*img1->gapx;
  }
 
  /* Fill the output image matrix */
  if(doz!=0) {
    int x, y, z;
    for(z=0; z<img1->dimz; z++) for(y=0; y<img1->dimy; y++) for(x=0; x<img1->dimx; x++) {
      int nz, ny, nx;
      for(nz=2*z; nz<2+2*z; nz++) for(ny=2*y; ny<2+2*y; ny++) for(nx=2*x; nx<2+2*x; nx++) {
        for(int t=0; t<img1->dimt; t++) img2->m[nz][ny][nx][t]=img1->m[z][y][x][t];
      }
    }
  } else {
    int x, y, z;
    for(z=0; z<img1->dimz; z++) for(y=0; y<img1->dimy; y++) for(x=0; x<img1->dimx; x++) {
      int ny, nx;
      for(ny=2*y; ny<2+2*y; ny++) for(nx=2*x; nx<2+2*x; nx++) {
        for(int t=0; t<img1->dimt; t++) img2->m[z][ny][nx][t]=img1->m[z][y][x][t];
      }
    }
  }
 
  return(0);
}

◆ imgThresholdByMask()

int imgThresholdByMask	(	IMG *	img,
		IMG *	templt,
		float	thrValue )

extern

Threshold IMG by a mask image (template).

Sets pixel values in img to thrValue, if corresponding pixel value in template is == 0. Only first frame of template is used.

See also: imgThresholdMask, imgThresholdMaskCount, imgMaskTAC

Returns: Returns 0, if ok.

Parameters

img	Image to threshold.
templt	Threshold template (mask image with 1 frame) where 0=cut off.
thrValue	Value which is written in cut off pixels.

Definition at line 282 of file imgthreshold.c.

  {
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(templt->status!=IMG_STATUS_OCCUPIED) return(2);
  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(templt->m[zi][yi][xi][0]==0.0) {  
        for(int fi=0; fi<img->dimt; fi++) img->m[zi][yi][xi][fi]=thrValue;
      }
  return(0);
}

◆ imgThresholding()

int imgThresholding	(	IMG *	img,
		float	threshold_level,
		long long *	thr_nr )

extern

Threshold dynamic or static IMG data.

Pixel time-activity curves (TACs) which have AUC less than Threshold*Max_AUC will be set to zero.

See also: imgsegmThresholdByMask, imgThresholdingLowHigh, imgFast3DGaussianFilter, imgsegmThreshold, imgMax, imgMinMax, imgFrameIntegral

Returns: Returns 0, if ok.

Parameters

img	IMG data.
threshold_level	Threshold level, e.g. 0.50 will set to zero all pixels that are less than 50% of maximum pixel.
thr_nr	Number of pixels that will fall below the threshold level; give NULL pointer, if not needed.

Definition at line 19 of file imgthreshold.c.

  {
  int zi, yi, xi, fi, ret;
  long long nr=0;
  IMG aucimg;
  float maxauc, thr_limit;
 
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt>1) { // dynamic image
    /* Calculate AUC image */
    imgInit(&aucimg);
    ret=imgFrameIntegral(img, 0, img->dimt-1, &aucimg, 0);
    if(ret) return(ret);
    /* Search the max AUC */
    ret=imgMax(&aucimg, &maxauc); if(ret) {imgEmpty(&aucimg); return(ret);}
    /* Calculate the limit value */
    thr_limit=threshold_level*maxauc;
    /* Set to zero the pixels with AUC less than this limit */
    for(zi=0; zi<img->dimz; zi++)
      for(yi=0; yi<img->dimy; yi++)
        for(xi=0; xi<img->dimx; xi++)
          if(aucimg.m[zi][yi][xi][0]<thr_limit) {
            for(fi=0; fi<img->dimt; fi++) img->m[zi][yi][xi][fi]=0.0;
            nr++;
          }
    imgEmpty(&aucimg);
  } else { // static image
    /* Search the max value */
    ret=imgMax(img, &maxauc); if(ret) return(ret);
    /* Calculate the limit value */
    thr_limit=threshold_level*maxauc;
    /* Set to zero the pixels with AUC less than this limit */
    for(zi=0; zi<img->dimz; zi++)
      for(yi=0; yi<img->dimy; yi++)
        for(xi=0; xi<img->dimx; xi++)
          if(img->m[zi][yi][xi][0]<thr_limit) {
            for(fi=0; fi<img->dimt; fi++) img->m[zi][yi][xi][fi]=0.0;
            nr++;
          }
  }
  if(thr_nr!=NULL) *thr_nr=nr;
  return(0);
}

◆ imgThresholdingLowHigh()

int imgThresholdingLowHigh	(	IMG *	img,
		float	lower_threshold_level,
		float	upper_threshold_level,
		IMG *	timg,
		long long *	lower_thr_nr,
		long long *	upper_thr_nr )

extern

Threshold dynamic or static IMG data.

Checks whether pixel AUCs are lower or higher than the specified threshold levels * Max_AUC. Those pixel TACs are set to zero, or alternatively, if mask IMG is given, corresponding mask image pixel is set to 0.

See also: imgsegmThresholdByMask, imgVoiMaskTAC, imgMaskTAC, imgsegmThreshold, imgFrameIntegral

Returns: Returns 0, if ok.

Parameters

img	(Dynamic) IMG data.
lower_threshold_level	Lower threshold level, e.g. 0.10 will set to zero all pixels that are less than 10% of maximum pixel
upper_threshold_level	Upper threshold level, e.g. 0.90 will set to zero all pixels that are over 90% of maximum pixel
timg	Mask image; if empty, then it will be allocated here; if pre-allocated, then mask image value changed to 0 when necessary, but 0 is never changed to 1; enter NULL, if original TACs are to be thresholded to zeroes
lower_thr_nr	Number of pixels that will fall below the lower threshold level; give NULL pointer, if not needed.
upper_thr_nr	Number of pixels rejected because above the upper threshold level; give NULL pointer, if not needed.

Definition at line 79 of file imgthreshold.c.

  {
  int zi, yi, xi, fi, ret;
  long long lnr=0, unr=0;
  IMG aucimg;
  float maxauc, lower_thr_limit, upper_thr_limit;
  
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
 
  /* Check if mask image is given and if it exists */
  if(timg!=NULL && timg->status!=IMG_STATUS_OCCUPIED) {
    /* Allocate memory for the mask data */
    ret=imgAllocate(timg, img->dimz, img->dimy, img->dimx, 1);
    if(ret) return(ret);
    /* set mask image header information */
    imgCopyhdr(img, timg);
    timg->start[0]=img->start[0]; timg->end[0]=img->end[img->dimt-1];
    timg->mid[0]=(timg->start[0]+timg->end[0])/2.0;
    /* Initiate mask to 1 */
    for(zi=0; zi<img->dimz; zi++)
      for(yi=0; yi<img->dimy; yi++)
        for(xi=0; xi<img->dimx; xi++)
          timg->m[zi][yi][xi][0]=1.0;
  } else if(timg!=NULL) {
    /* Check that mask dimensions are ok */
    if(timg->dimz!=img->dimz || timg->dimy!=img->dimy || timg->dimx!=img->dimx) return 2;
    if(timg->dimt<1) return 3;
  }
 
  /* Threshold */
  if(img->dimt>1) { // dynamic image
    /* Calculate AUC image */
    imgInit(&aucimg);
    ret=imgFrameIntegral(img, 0, img->dimt-1, &aucimg, 0);
    if(ret) return(ret);
    /* Search the max AUC */
    ret=imgMax(&aucimg, &maxauc); if(ret) {imgEmpty(&aucimg); return(ret);}
    /* Calculate the limit values */
    lower_thr_limit=lower_threshold_level*maxauc;
    upper_thr_limit=upper_threshold_level*maxauc;
    /* Set to zero the pixels with AUC less/more than these limits */
    for(zi=0; zi<img->dimz; zi++)
      for(yi=0; yi<img->dimy; yi++)
        for(xi=0; xi<img->dimx; xi++)
          if(aucimg.m[zi][yi][xi][0]<lower_thr_limit) {
            if(timg==NULL) for(fi=0; fi<img->dimt; fi++) img->m[zi][yi][xi][fi]=0.0;
            else timg->m[zi][yi][xi][0]=0.0;
            lnr++;
          } else if(aucimg.m[zi][yi][xi][0]>upper_thr_limit) {
            if(timg==NULL) for(fi=0; fi<img->dimt; fi++) img->m[zi][yi][xi][fi]=0.0;
            else timg->m[zi][yi][xi][0]=0.0;
            unr++;
          }
    imgEmpty(&aucimg);
  } else { // static image
    /* Search the max value */
    ret=imgMax(img, &maxauc); if(ret) return(ret);
    /* Calculate the limit values */
    lower_thr_limit=lower_threshold_level*maxauc;
    upper_thr_limit=upper_threshold_level*maxauc;
    /* Set to zero the pixels with AUC less/more than these limits */
    for(zi=0; zi<img->dimz; zi++)
      for(yi=0; yi<img->dimy; yi++)
        for(xi=0; xi<img->dimx; xi++)
          if(img->m[zi][yi][xi][0]<lower_thr_limit) {
            if(timg==NULL) for(fi=0; fi<img->dimt; fi++) img->m[zi][yi][xi][fi]=0.0;
            else timg->m[zi][yi][xi][0]=0.0;
            lnr++;
          } else if(img->m[zi][yi][xi][0]>upper_thr_limit) {
            if(timg==NULL) for(fi=0; fi<img->dimt; fi++) img->m[zi][yi][xi][fi]=0.0;
            else timg->m[zi][yi][xi][0]=0.0;
            unr++;
          }
  }
 
  if(lower_thr_nr!=NULL) *lower_thr_nr=lnr;
  if(upper_thr_nr!=NULL) *upper_thr_nr=unr;
  return(0);
}

◆ imgThresholdMask()

int imgThresholdMask	(	IMG *	img,
		float	minValue,
		float	maxValue,
		IMG *	timg )

extern

Creates a mask (template) image based on lower and upper threshold values.

This function allocates memory for the mask image. If pixel value in original image is >=minValue and <=maxValue, the corresponding mask pixel is set to 1, otherwise to 0. Only the first frame of images are used.

See also: imgThresholdMaskCount, imgsegmThresholdByMask, imgAverageMaskTAC, imgMinMax, imgMaskDilate, imgMaskErode, imgThresholdingLowHigh, imgsegmThreshold

Returns: Returns 0 if ok.

Parameters

img	Original image; only first frame is used here.
minValue	Lower threshold.
maxValue	Upper threshold.
timg	Mask image; if empty, then it will be allocated here; if pre-allocated, then mask pixel value changed to 0 when necessary, but 0 is never changed to 1.

Definition at line 257 of file imgthreshold.c.

  {
  return(imgThresholdMaskCount(img, minValue, maxValue, timg, NULL));
}

◆ imgThresholdMaskCount()

int imgThresholdMaskCount	(	IMG *	img,
		float	minValue,
		float	maxValue,
		IMG *	timg,
		long long *	count )

extern

Creates a mask (template) image based on lower and upper threshold values.

This function allocates memory for the mask image. If pixel value in original image is >=minValue and <=maxValue, the corresponding mask pixel is set to 1, otherwise to 0. Only the first frame of images are used.

See also: imgThresholdMask, imgThresholdByMask, imgsegmThresholdByMask, imgMaskRoiNr, imgMaskDilate, imgMaskErode, imgMinMax

Returns: Returns 0 if ok.

Parameters

img	Original image; only first frame is used here.
minValue	Lower threshold.
maxValue	Upper threshold.
timg	Mask image; if empty, then it will be allocated here; if pre-allocated, then template value changed to 0 when necessary, but 0 is never changed to 1.
count	The number of pixels that pass the threshold limits is written here; set to NULL if not needed.

Definition at line 191 of file imgthreshold.c.

  {
  int fi=0, zi, xi, yi, ret;
 
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(count!=NULL) *count=0;
  /* Check if mask image exists */
  if(timg->status!=IMG_STATUS_OCCUPIED) {
    /* Allocate memory for the template data */
    ret=imgAllocate(timg, img->dimz, img->dimy, img->dimx, 1);
    if(ret) return(ret);
    /* set mask image header information */
    imgCopyhdr(img, timg);
    timg->start[0]=img->start[0]; timg->end[0]=img->end[img->dimt-1];
    timg->mid[0]=(timg->start[0]+timg->end[0])/2.0;
    /* Initiate template to 1 */
    for(zi=0; zi<img->dimz; zi++)
      for(yi=0; yi<img->dimy; yi++)
        for(xi=0; xi<img->dimx; xi++)
          timg->m[zi][yi][xi][0]=1.0;
  } else {
    /* Check that mask image dimensions are ok */
    if(timg->dimz!=img->dimz || timg->dimy!=img->dimy || timg->dimx!=img->dimx)
      return 2;
    if(timg->dimt<1) return(3);
  }
  /* Set mask contents */
  fi=0; 
  long long n=0;
  for(zi=0; zi<img->dimz; zi++)
    for(yi=0; yi<img->dimy; yi++)
      for(xi=0; xi<img->dimx; xi++) {
        /*printf("pxl=%g (%g - %g)\n", img->m[zi][yi][xi][fi], minValue, maxValue);*/
        if(img->m[zi][yi][xi][fi]<minValue || img->m[zi][yi][xi][fi]>maxValue) 
          timg->m[zi][yi][xi][0]=0.0;
        else n++;
      }
  if(count!=NULL) *count=n;
  return(0);
}

Referenced by imgMaskRegionLabeling(), and imgThresholdMask().

◆ imgVoiMaskTAC()

int imgVoiMaskTAC	(	IMG *	img,
		IMG *	mask,
		int	mv,
		double *	tac,
		int	verbose )

extern

Calculate TAC as average of voxels in image data, including only voxels which have specified value in the mask image.

See also: imgsegmThresholdMask, imgMaskTAC, imgMaskDilate, imgMaskErode

Returns: Returns the nr of voxels included, or <0 in case of an error.

Parameters

img	Pointer to allocated image from which the mean TAC is calculated.
mask	Pointer to mask image; x, y, and z dimensions must be the same as in the image to which the mask is applied.
mv	Voxels with this value in mask image are included in the average.
tac	Pointer to an array where weighted pixel averages are written; it must be allocated for size >= dimt.
verbose	Verbose level; set to <=0 to prevent all prints to stdout.

Definition at line 214 of file imgeval.c.

  {
  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);
}

◆ integerScale()

void integerScale	(	int	frame,
		float ***	src,
		float **	targ,
		int	width,
		int	height,
		int	zoom )

extern

Magnify one frame of dynamic 2D image by integer zoom factor. Pixel values are simply duplicated.

See also: imgScale

Parameters

frame	Index of the frame to be scaled.
src	Source data in dynamic 2D array: srcp[y][x][frame].
targ	Pre-allocated target static 2D data matrix: targ[y][x]; actual matrix size is allowed to be larger than what is used here.
width	Width (x dim) of the source data matrix.
height	Height (y dim) of the source data matrix.
zoom	Zoom factor. If less than 2, then matrix is just copied.

Definition at line 159 of file imgtransform.c.

  {
  if(frame<0) frame=0;
  if(zoom<1) zoom=1;
 
  int w, h, z;
 
  for(h=0; h<height; h++){
    for(w=0; w<width; w++){
      float val=src[h][w][frame];
      for(z=0; z<zoom; z++) {
        targ[h*zoom][w*zoom + z]=val;
      }
    }
    /* Copy to next rows */
    for(z=1; z<zoom; z++) {
      for(int i=0; i<zoom*width; i++) targ[h*zoom+z][i]=targ[h*zoom+z-1][i];
      //memcpy(targ[h*zoom+z], targ[h*zoom], width*zoom*sizeof(float));
    }
  }
}

Referenced by imgScale().

◆ pRound()

int pRound ( float number )

extern

Round float to int.

Returns: Rounded value.

Parameters

number Any number

Definition at line 15 of file point.c.

  {
  if(number - floor(number) < 0.5){
    return floor(number);
  }
  return ceil(number);
}

◆ tiffWriteImg()

int tiffWriteImg	(	IMG *	img,
		int	plane,
		int	frame,
		float *	maxvalue,
		int	colorscale,
		char *	fname,
		int	matXdim,
		int	matYdim,
		int	verbose,
		char *	status )

extern

Write one frame or plane in IMG data as a TIFF 6.0 format image. Overwrites existing TIFF file.

Returns: Returns 0, if ok.

See also: img2cube, imgFlipHorizontal, imgShrink, imgSwell, imgScale

Parameters

img	IMG containing PET image/sinogram data.
plane	matrix index of plane (0..dimz-1); all if <0.
frame	matrix index of frame (0..dimt-1); all if <0.
maxvalue	colours are scaled between 0 and maxvalue; if <=0, then searches max and sets maxvalue.
colorscale	PET_GRAYSCALE, PET_GRAYSCALE_INV or PET_RAINBOW.
fname	name of output TIFF file.
matXdim	Nr of matrices tiled horizontally; enter 0 for automatic calculation.
matYdim	Nr of matrices tiled vertically; enter 0 for automatic calculation.
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 15 of file imgtiff.c.

  {
  FILE        *fp;
  short int    svar, svars[2048];
  char         buf[4096], *cdata, *cptr;
  int          ivar, ivars[1024];
  /* Rainbow color scale */
  struct { int   n,   r,  g,  b, dr, dg, db; }
  bitty[] = {  {32,   0,  0,  0,  2,  0,  4},   /* violet to indigo */
               {32,  64,  0,128, -2,  0,  4},   /* indigo to blue */
               {32,   0,  0,255,  0,  8, -8},   /* blue to green */
               {64,   0,255,  0,  4,  0,  0},   /* green to yellow */
               {32, 255,255,  0,  0, -2,  0},   /* yellow to orange */
               {64, 255,192,  0,  0, -3,  0} }; /* orange to red */
 
  if(verbose>0) printf("tiffWriteImg(*img, %d, %d, %g, %d, %s, status, %d)\n",
    plane, frame, *maxvalue, colorscale, fname, verbose);
 
  /* Check input data */
  if(status!=NULL) strcpy(status, "fault in calling routine");
  if(img->status!=IMG_STATUS_OCCUPIED) return(1);
  if(img->dimt<(frame+1) || img->dimz<(plane+1)) return(2);
  int pxlNr=img->dimx*img->dimy; if(pxlNr<1) return(3);
  if(status!=NULL) strcpy(status, "ok");
 
  /* If color scale maximum was not specified, then determine it here */
  if(*maxvalue<=0.0) {
    *maxvalue=-1.0e-12;
    for(int pi=0; pi<img->dimz; pi++) if(plane<0 || plane==pi)
      for(int ri=0; ri<img->dimy; ri++) for(int ci=0; ci<img->dimx; ci++)
        for(int fi=0; fi<img->dimt; fi++) if(frame<0 || frame==fi)
          if(img->m[pi][ri][ci][fi]>*maxvalue)
            *maxvalue=img->m[pi][ri][ci][fi];
    if(*maxvalue<=0.0) {
      if(status!=NULL) strcpy(status, "no positive pixel values");
      return(6);
    }
  }
 
  /* Calculate image dimensions */
  /* image matrix number */
  int matNr=0;
  if(plane<0) matNr=img->dimz; else matNr=1;
  if(frame<0) matNr*=img->dimt; else matNr*=1;
  if(verbose>1) printf("matNr=%d\n", matNr);
  /* image matrix x*y number */
  if(matXdim<=0 && matYdim<=0) {
    matXdim=(int)ceil(sqrt((double)matNr));
    matYdim=matNr/matXdim; if(matNr%matXdim) matYdim++;
  } else {
    if(matXdim>matNr) {
      matXdim=matNr; matYdim=1;
    } else if(matYdim>matNr) {
      matYdim=matNr; matXdim=1;
    } else if(matXdim>0) {
      matYdim=matNr/matXdim; if(matNr%matXdim) matYdim++;
    } else {
      matXdim=matNr/matYdim; if(matNr%matYdim) matXdim++;
    }
  }
  if(verbose>1) printf("matXdim:=%d\nmatYdim:=%d\n", matXdim, matYdim);
 
 
  /* Open TIFF file */
  if((fp=fopen(fname, "wb")) == NULL) {
    if(status!=NULL) strcpy(status, "cannot open file for write");
    return(11);
  }
 
  /* Construct TIFF header */
  memset(buf, 0, 4096);
  /* set the byte format */
  if(little_endian()) memcpy(buf, "II", 2); else memcpy(buf, "MM", 2);
  /* set file identifier */
  svar=42; memcpy(buf+2, &svar, 2);
  /* set byte offset of first IFD */
  ivar=8; memcpy(buf+4, &ivar, 4);
  /* Construct the (first) Image File Directory (IFD) */
  /* set nr of directory entries */
  if(colorscale==PET_RAINBOW || colorscale==PET_RAINBOW_WB)
    svar=12; else svar=11;
  memcpy(buf+8, &svar, 2);
  /* move into start of first entry */
  cptr=buf+10;
  /* tag: ImageWidth */
  svars[0]=256; svars[1]=4; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; ivars[1]=matXdim*img->dimx; memcpy(cptr, ivars, 8); cptr+=8;
  /* tag: ImageLength */
  svars[0]=257; svars[1]=4; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; ivars[1]=matYdim*img->dimy; memcpy(cptr, ivars, 8); cptr+=8;
  /* tag: BitsPerSample (xv3 on Sun/Solaris gives warning but works) */
  svars[0]=258; svars[1]=3; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; memcpy(cptr, ivars, 4); cptr+=4;
  svars[0]=(unsigned short int)8; memcpy(cptr, svars, 2); cptr+=4; /* 256 shades */
  /* tag: Compression */
  svars[0]=259; svars[1]=3; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; memcpy(cptr, ivars, 4); cptr+=4;
  svars[0]=1; memcpy(cptr, svars, 2); cptr+=4; /* no compression */
  /* tag: Photometric Interpretation */
  svars[0]=262; svars[1]=3; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; memcpy(cptr, ivars, 4); cptr+=4;
  if(colorscale==PET_RAINBOW || colorscale==PET_RAINBOW_WB)
    svars[0]=3; /* palette */
  else if(colorscale==PET_GRAYSCALE)
    svars[0]=1; /* black is zero */
  else
    svars[0]=0; /* white is zero */
  memcpy(cptr, svars, 2); cptr+=4;
  /* tag: StripOffsets */
  svars[0]=273; svars[1]=4; memcpy(cptr, svars, 4); cptr+=4;
  /* byte offset of strip(s) of data */
  ivars[0]=1; ivars[1]=4096; memcpy(cptr, ivars, 8); cptr+=8;
  /* tag: RowsPerStrip */
  svars[0]=278; svars[1]=4; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; ivars[1]=matYdim*img->dimy; memcpy(cptr, ivars, 8); cptr+=8;
  /* tag: StripByteCounts */
  svars[0]=279; svars[1]=4; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; ivars[1]=matXdim*matYdim*pxlNr; memcpy(cptr, ivars, 8); cptr+=8;
  /* tag: XResolution */
  ivars[0]=33; ivars[1]=1; ivars[2]=33; ivars[3]=1; memcpy(buf+1024, ivars, 16);
  svars[0]=282; svars[1]=5; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; ivars[1]=1024; memcpy(cptr, ivars, 8); cptr+=8;
  /* tag: YResolution */
  svars[0]=283; svars[1]=5; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; ivars[1]=1032; memcpy(cptr, ivars, 8); cptr+=8;
  /* tag: ResolutionUnit */
  svars[0]=296; svars[1]=3; memcpy(cptr, svars, 4); cptr+=4;
  ivars[0]=1; memcpy(cptr, ivars, 4); cptr+=4;
  svars[0]=3; memcpy(cptr, svars, 2); cptr+=4; /* cm */
  if(colorscale!=PET_RAINBOW && colorscale!=PET_RAINBOW_WB) {
    /* offset of the next IFD, or 0000 */
    for(int i=0; i<4; i++) *cptr++=(char)0;
  } else {
    int i, j;
    /* tag: ColorMap */
    svars[0]=320; svars[1]=3; memcpy(cptr, svars, 4); cptr+=4;
    ivars[0]=3*256; memcpy(cptr, ivars, 4); cptr+=4;
    //svars[0]=2048; memcpy(cptr, svars, 2); cptr+=4;
    ivars[0]=2048; memcpy(cptr, ivars, 4); cptr+=4;
    /* offset of the next IFD, or 0000 */
    for(i=0; i<4; i++) *cptr++=(char)0;
    /* Color table */
    cptr=buf+2048;
    /* red */
    for(i=0, j=0; j<6; j++) {
      svars[i++]=bitty[j].r;
      for(int k=1; k<bitty[j].n; k++, i++) svars[i]=svars[i-1]+bitty[j].dr;
    }
    if(colorscale==PET_RAINBOW_WB) svars[0]=255;
    memcpy(cptr, svars, 512); cptr+=512;
    /* green */
    for(i=0, j=0; j<6; j++) {
      svars[i++]=bitty[j].g;
      for(int k=1; k<bitty[j].n; k++, i++) svars[i]=svars[i-1]+bitty[j].dg;
    }
    if(colorscale==PET_RAINBOW_WB) svars[0]=255;
    memcpy(cptr, svars, 512); cptr+=512;
    /* blue */
    for(i=0, j=0; j<6; j++) {
      svars[i++]=bitty[j].b;
      for(int k=1; k<bitty[j].n; k++, i++) svars[i]=svars[i-1]+bitty[j].db;
    }
    if(colorscale==PET_RAINBOW_WB) svars[0]=255;
    memcpy(cptr, svars, 512); cptr+=512;
  }
 
  /* write the IFD */
  if(fwrite(buf, 1, 4096, fp) != 4096) {
    fclose(fp); remove(fname);
    if(status!=NULL) strcpy(status, "cannot write file");
    return(13);
  }
 
  /* Write pixel data */
  cdata=(char*)calloc(matXdim*matYdim*pxlNr, sizeof(char));
  if(cdata==NULL) {
    fclose(fp); remove(fname);
    if(status!=NULL) strcpy(status, "out of memory");
    return(14);
  }
  cptr=cdata;
  int mi=0; int mc=0; int mr=1;
  for(int fi=0; fi<img->dimt; fi++) if(frame<0 || frame==fi) {
    for(int pi=0; pi<img->dimz; pi++) if(plane<0 || plane==pi) {
      mi++; mc++; 
      for(int ri=0; ri<img->dimy; ri++)
        for(int ci=0; ci<img->dimx; ci++) {
          cptr=cdata + (mr-1)*matXdim*pxlNr + ri*matXdim*img->dimx + (mc-1)*img->dimx + ci;
          if(img->m[pi][ri][ci][fi]>0.0) {
            if((img->m[pi][ri][ci][fi])<(*maxvalue))
              *cptr=(unsigned char)(255.*(img->m[pi][ri][ci][fi])/(*maxvalue));
            else *cptr=(unsigned char)255;
          } else
            *cptr=(unsigned char)0;
        }
      if(mc==matXdim) {mc=0; mr++;}
    }
  }
  cptr=cdata;
  if(fwrite(cptr, 1, matXdim*matYdim*pxlNr, fp) != (unsigned int)matXdim*matYdim*pxlNr) {
    fclose(fp); remove(fname); free(cdata);
    if(status!=NULL) strcpy(status, "cannot write file");
    return(15);
  }
  free(cdata);
 
  fclose(fp);
  if(status!=NULL) strcpy(status, "ok");
  return(0);
}

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ PET_GRAYSCALE

◆ PET_GRAYSCALE_INV

◆ PET_RAINBOW

◆ PET_RAINBOW_WB

Function Documentation

◆ filterAMGaussian()

◆ filterAMLB()

◆ filterEbox()

◆ filterHSSBE()

◆ fMean1DFilter()

◆ getAngle()

◆ getDistance()

◆ img2cube()

◆ imgAbs()

◆ imgArithm()

◆ imgArithmConst()

◆ imgArithmFrame()

◆ imgAUMC()

◆ imgAverageAUC()

◆ imgAverageMaskTAC()

◆ imgAverageTAC()

◆ imgConvertUnit()

◆ imgCutoff()

◆ imgDeleteFrameOverlap()

◆ imgDeleteFrameOverlap_old()

◆ imgFlipAbove()

◆ imgFlipHorizontal()

◆ imgFlipPlanes()

◆ imgFlipRight()

◆ imgFlipVertical()

◆ imgFrameGapFill()

◆ imgFrameIntegral()

◆ imgFramesCheck()

◆ imgGaussianAMFilter()

◆ imgGaussianEBoxFilter()

◆ imgGaussianFIRFilter()

◆ imgGetFrameDiff()

◆ imgGetFrameDyn()

◆ imgInv()

◆ imgLn()

◆ imgLog10()

◆ imgMaskCloak()

◆ imgMaskConjunction()

◆ imgMaskCount()

◆ imgMaskDilate()

◆ imgMaskErode()

◆ imgMaskFloodFill()

◆ imgMaskInvert()

◆ imgMaskRegionLabeling()

◆ imgMaskRoiNr()

◆ imgMaskTAC()

◆ imgMeanFilter()

◆ imgMeanZ()

◆ imgMRT()

◆ imgOutlierFilter()

◆ imgRawCountsPerTime()

◆ imgRegionGrowingByThreshold()

◆ imgScale()

◆ imgsegmCalcMRL()

◆ imgsegmCheckNeighbours()

◆ imgsegmClusterExpand()

◆ imgsegmClusterMean()

◆ imgsegmFindBestNeighbour()

◆ imgsegmFindMaxOutsideClusters()

◆ imgsegmMaskToCluster()

◆ imgsegmPearson()

◆ imgsegmSimilar()

◆ imgsegmThreshold()

◆ imgsegmThresholdByMask()

◆ imgsegmThresholdMask()

◆ imgSetScanner()

◆ imgShrink()

◆ imgSmoothOverFrames()

◆ imgStructuringElement()

◆ imgSwell()