catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/clib_build/src/negative_log.cpp

@@ -0,0 +1,233 @@
+// Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+//#include "negative_log.h"
+#include <cmath>
+#include <string.h>
+#include <stdlib.h>
+#ifdef WIN32
+#define DLLEXPORT __declspec(dllexport)
+//https://stackoverflow.com/questions/33696092/whats-the-correct-replacement-for-posix-memalign-in-window
+#define posix_memalign(p, a, s) (((*(p)) = _aligned_malloc((s), (a))), *(p) ?0 :errno)
+#else
+#define DLLEXPORT
+#endif
+//#include "p_nlog_inline.h"
+#define USE_C_LOG
+
+#define NLOG_ZERO_REPLACEMENT     1.175494351E-38F
+static void negative_log_with_das_underrange_corr(int row_count, int col_count, float *iview, float *oview);
+
+static void negative_log_without_das_underrange_corr(int row_count, int col_count, float *input, float *output);
+
+static void log_replace_lte_zero(float *input, float zero_replacement, int length);
+
+extern "C" void p_nlog_inline(float*, float*, int);
+void min_vector(float *input, float *min, int length) {
+  float local_min = input[0];
+  for (int i = 1; i < length; i++)
+    if (input[i] < local_min)
+      local_min = input[i];
+  *min = local_min;
+}
+
+void nlog(float *dest, float *src, int numpoints) {
+  #ifdef USE_C_LOG
+    for (int i = 0; i < numpoints; i++)
+      dest[i] = -logf(src[i]);
+  #else
+    static void *source_aligned, *dest_aligned;
+    static int aligned_size = 0;
+    // it would be better to cache these arrays and only allocate if/when the size changes
+    if (aligned_size != numpoints) {
+      if (aligned_size != 0) {
+        free(source_aligned);
+        free(dest_aligned);
+      }
+      posix_memalign(&source_aligned, 32, numpoints*sizeof(float));
+      posix_memalign(&dest_aligned, 32, numpoints*sizeof(float));
+      aligned_size = numpoints;
+    }
+    memcpy(source_aligned, src, numpoints*sizeof(float));
+    p_nlog_inline((float *)dest_aligned, (float *)source_aligned, numpoints);
+    memcpy(dest, dest_aligned, numpoints*sizeof(float));
+  #endif
+}
+
+// ***********************************************************************
+// Function applyAAR_AARi (5-point kernel)
+// ***********************************************************************
+int applyAAR_AARi(float *input, float *scratch, float lowClip, int length) {
+  float alpha;
+  float alphaInv;
+  float fiveAlpha;
+  float noiseChan;
+  float smoothingGain;
+  float x;
+  float viewError;
+  int count = 0;
+  int lenm2;
+  int i;
+
+  // INITIALIZE
+  alpha = 0.001f;
+  alphaInv = 1.0f/alpha;
+  fiveAlpha = 5.0f * alpha;
+  lenm2 = length - 2;
+
+  // COPY INPUT INTO SCATCH BUFFER
+  for (i = 0; i < length; i++)
+    scratch[i] = input[i];
+
+  // SMOOTH OUT LOW SIGNAL AREAS
+  for (i = 2; i < lenm2; i++) {
+    if (input[i] <= fiveAlpha) {
+      // HIGH PASS FILTER USING 5 POINT KERNEL
+      noiseChan = 0.625f*scratch[i] - 0.25f*(scratch[i+1] + scratch[i-1]) - 0.0625f*(scratch[i+2] + scratch[i-2]);
+
+      // SMOOTHING GAIN IS FIFTH ORDER POLYNOMIAL ESTIMATE OF exp()
+      x = input[i] * alphaInv;
+      smoothingGain = ((((-0.000973364f*x + 0.01664038f)*x - 0.1181265f)*x + 0.4528541f)*x - 0.9823636f)*x + 0.9990775f;
+      if (smoothingGain > 1.0f)
+        smoothingGain = 1.0f;
+
+      // COMPUTE VIEW ERROR
+      viewError = noiseChan * smoothingGain;
+
+      // SUBTRACT ERROR FROM SIGNAL
+      input[i] -= viewError;
+      count++;
+    }
+  }
+  return(count);
+}
+
+
+// ***********************************************************************
+// Function applyAAR_AARi2 (7-point kernel)
+// This is a newer version of improved AAR for some improvement in the IQ
+// ***********************************************************************
+int applyAAR_AARi2(float *input, float *scratch, float lowClip, int length) {
+  float alpha;
+  float alphaInv;
+  float fiveAlpha;
+  float noiseChan;
+  float smoothingGain;
+  float x;
+  float viewError;
+  int count = 0;
+  int lenm3;
+  int i;
+
+  // INITIALIZE
+  alpha = 0.001f;
+  alphaInv = 1.0f/alpha;
+  fiveAlpha = 5.0f * alpha;
+  lenm3 = length - 3;
+
+  // COPY INPUT INTO SCATCH BUFFER
+  for (i = 0; i < length; i++)
+    scratch[i] = input[i];
+
+  // SMOOTH OUT LOW SIGNAL AREAS
+  for (i = 3; i < lenm3; i++) {
+    if (input[i] <= fiveAlpha) {
+      // HIGH PASS FILTER USING 7 POINT KERNEL
+      noiseChan = scratch[i] - ((scratch[i] + scratch[i+1] + scratch[i-1] +
+                  scratch[i+2] + scratch[i-2] + scratch[i+3] + scratch[i-3]) / 7.0f);
+
+      // SMOOTHING GAIN IS FIFTH ORDER POLYNOMIAL ESTIMATE OF exp()
+      x = input[i] * alphaInv;
+      smoothingGain = ((((-0.000973364f*x + 0.01664038f)*x - 0.1181265f)*x + 0.4528541f)*x - 0.9823636f)*x + 0.9990775f;
+      if (smoothingGain > 1.0f)
+        smoothingGain = 1.0f;
+
+      // COMPUTE VIEW ERROR
+      viewError = noiseChan * smoothingGain;
+
+      // SUBTRACT ERROR FROM SIGNAL
+      input[i] -= viewError;
+      count++;
+    }
+  }
+  return(count);
+}
+
+// If das_underrange_corr is non-zero, then we do das underrange correction (AARi2).  Otherwise, we
+// only replace pre-log values of <= 0 with NLOG_ZERO_REPLACEMENT
+extern "C" {
+DLLEXPORT
+void negative_log(int row_count, int col_count, float *iview, float *oview, int das_underrange_corr) {
+  if (das_underrange_corr) {
+    negative_log_with_das_underrange_corr(row_count, col_count, iview, oview);
+  } else {
+    negative_log_without_das_underrange_corr(row_count, col_count, iview, oview);
+  }
+}
+}
+
+
+static void negative_log_with_das_underrange_corr(int row_count, int col_count, float *iview, float *oview) {
+  float lowClip = expf(-13.0f);
+  float lowThr = expf(-10.3f);
+  float pThr = expf(-8.0f);
+  int length = col_count;
+
+  for (int row = 0; row < row_count; row++) {
+    float *input = iview + row * col_count;
+    float *output = oview + row * col_count;
+    float min;
+    int i;
+
+    min_vector(input, &min, length);
+
+    // Clip 3 edge channels, to be consistent with the product
+    for (i = 0; i < 3; i++) {
+      if (input[i] < lowClip)
+        input[i] = lowClip;
+      if (input[length-i-1] < lowClip)
+        input[length-i-1] = lowClip;
+    }
+
+    if (min < lowThr) {
+      for (i = 0; i < length; i++)
+        if (input[i] <= lowClip)
+          input[i] = lowClip * (1.0 + input[i] * 50.0f);
+      applyAAR_AARi2(input, output, lowClip, length);
+      min_vector(input, &min, length);
+    }
+
+    if (min < pThr)
+      applyAAR_AARi(input, output, lowClip, length);
+
+    for (i = 0; i < length; i++)
+      if (input[i] < lowClip)
+        input[i] = lowClip;
+
+    nlog(output, input, length);
+  }
+}
+
+
+static void negative_log_without_das_underrange_corr(int row_count, int col_count, float *input, float *output) {
+  int length = row_count * col_count;
+  float min;
+
+  min_vector(input, &min, length);
+  if (min <= 0)
+    log_replace_lte_zero(input, NLOG_ZERO_REPLACEMENT, length);
+
+  nlog(output, input, length);
+}
+
+
+// lte == less than or equal
+static void log_replace_lte_zero(float *input, float zero_replacement, int length) {
+  int i;
+
+  for (i = 0; i < length; i++) {
+    if (input[i] == 0)
+      input[i] = zero_replacement;
+    else if (input[i] < 0)
+      input[i] = -input[i];
+  }
+}

gecatsim/clib_build/src/negative_log.h

@@ -0,0 +1,23 @@
+// Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+#include <cmath>
+#include <string.h>
+#include <stdlib.h>
+//#include "p_nlog_inline.h"
+
+#define NLOG_ZERO_REPLACEMENT     1.175494351E-38F
+void min_vector(float *input, float *min, int length);
+
+void nlog(float *dest, float *src, int numpoints);
+
+int applyAAR_AARi(float *input, float *scratch, float lowClip, int length);
+
+int applyAAR_AARi2(float *input, float *scratch, float lowClip, int length);
+
+void negative_log(int row_count, int col_count, float *iview, float *oview, int das_underrange_corr);
+
+static void negative_log_with_das_underrange_corr(int row_count, int col_count, float *iview, float *oview);
+
+static void negative_log_without_das_underrange_corr(int row_count, int col_count, float *input, float *output);
+
+static void log_replace_lte_zero(float *input, float zero_replacement, int length);

gecatsim/clib_build/src/pd2dbpcurved.c

@@ -0,0 +1,98 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#include <math.h>
+
+#ifndef M_PI
+#define M_PI (4.0*atan(1.0))
+#endif
+
+static void innerLoop(int N, float initialC, float deltaC,
+		      float initialB, float deltaB,
+		      float recipAlpha, float detUCenter,
+		      float *imgPtr, float *viewPtr,
+		      int detUCount) {
+  int n;
+  float alphaval;
+  float alpha_rescaled, alpha_residual;
+  int alpha_discrete;
+  float weight_val;
+  float *dp;
+  float c, b;
+  float toadd;
+  
+  dp = imgPtr;
+  c = initialC;
+  b = initialB;
+  
+  for (n=0;n<N;n++) {
+    alphaval = atan(c/b);
+    alpha_rescaled = alphaval*recipAlpha+detUCenter;
+    alpha_discrete = ((int) (alpha_rescaled+10)) - 10;
+    alpha_residual = alpha_rescaled - alpha_discrete;
+    weight_val = 1.0/(b*b+c*c);
+    toadd = 0.0;
+    if ((alpha_discrete >= 0) && (alpha_discrete < detUCount-1))
+      toadd += viewPtr[alpha_discrete]*(1-alpha_residual);
+    if ((alpha_discrete >= -1) && (alpha_discrete < detUCount-2))
+      toadd += viewPtr[alpha_discrete+1]*alpha_residual;
+    dp[n] += toadd*weight_val;
+    b += deltaB;
+    c += deltaC;
+  }
+}
+
+#ifdef WIN32
+__declspec(dllexport)
+#endif
+void pd2dbpcurved(float detUCenter, int detUCount, float detUSize,
+		  float pixelXSize, float pixelYSize,
+		  float pixelXCenter, float pixelYCenter,
+		  int pixelXCount, int pixelYCount,
+		  float SID, float SDD,
+		  int viewCount, float *viewAngles,
+		  float *sino, float *image) {
+  int i, k;
+  float costheta, sintheta;
+  float theta;
+  float xVal, yVal;
+  float recipAlpha;
+  float initialB, initialC;
+  float deltaB, deltaC;
+
+  /*
+    We also need to calculate 1/(detector_size) in inverse radians.
+  */
+  recipAlpha = 1.0/atan(detUSize/SDD);
+  for (i=0;i<viewCount;i++) {
+    theta = viewAngles[i];
+    /**
+       Calculate the cosine and sine of this angle
+       for use.
+    */
+    costheta = cos(theta);
+    sintheta = sin(theta);
+    for (k=0;k<pixelYCount;k++) {
+      /**
+	 For this row of the image, we calculate the \f$(x,y)\f$ position
+	 of the first pixel in the row.
+      */
+      xVal = pixelXCenter - (pixelXCount-1)/2.0*pixelXSize;
+      yVal = pixelYCenter - ((pixelYCount-1)/2.0-k)*pixelYSize;
+      /*
+	We map this to a modified coordinate system (explanation forthcoming...)
+      */
+      initialB = SID - xVal*costheta - yVal*sintheta;
+      initialC = -xVal*sintheta + yVal*costheta;
+      deltaB = -costheta*pixelXSize;
+      deltaC = -sintheta*pixelYSize;
+      innerLoop(pixelXCount, initialC, deltaC,
+		initialB, deltaB, recipAlpha,
+		detUCenter, image + k*pixelXCount, 
+		sino + i*detUCount, detUCount);
+    }
+  }
+  for (i=0;i<pixelXCount*pixelYCount;i++)
+    image[i] *= 2.0*M_PI/viewCount;
+}
+
+

gecatsim/clib_build/src/pd2dbpflat.c

@@ -0,0 +1,101 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#include <math.h>
+
+#ifndef M_PI
+#define M_PI (4.0*atan(1.0))
+#endif
+
+
+static void innerLoop(int N, float initialC, float deltaC,
+		      float initialB, float deltaB,
+		      float recipAlpha, float detUCenter,
+		      float *imgPtr, float *viewPtr,
+		      int detUCount) {
+  int n;
+  float alphaval;
+  float alpha_rescaled, alpha_residual;
+  int alpha_discrete;
+  float weight_val;
+  float *dp;
+  float c, b, recipb;
+  float toadd;
+  
+  dp = imgPtr;
+  c = initialC;
+  b = initialB;
+  
+  for (n=0;n<N;n++) {
+    recipb = 1.0f/b;
+    alphaval = c*recipb;
+    alpha_rescaled = alphaval*recipAlpha+detUCenter;
+    alpha_discrete = ((int) (alpha_rescaled+10)) - 10;
+    alpha_residual = alpha_rescaled - alpha_discrete;
+    weight_val = recipb*recipb;
+    toadd = 0.0;
+    if ((alpha_discrete >= 0) && (alpha_discrete < detUCount-1))
+      toadd += viewPtr[alpha_discrete]*(1-alpha_residual);
+    if ((alpha_discrete >= -1) && (alpha_discrete < detUCount-2))
+      toadd += viewPtr[alpha_discrete+1]*alpha_residual;
+    dp[n] += toadd*weight_val;
+    b += deltaB;
+    c += deltaC;
+  }
+}
+
+#ifdef WIN32
+__declspec(dllexport)
+#endif
+void pd2dbpflat(float detUCenter, int detUCount, float detUSize,
+		  float pixelXSize, float pixelYSize,
+		  float pixelXCenter, float pixelYCenter,
+		  int pixelXCount, int pixelYCount,
+		  float SID, float SDD,
+		  int viewCount, float *viewAngles,
+		  float *sino, float *image) {
+  int i, k;
+  float costheta, sintheta;
+  float theta;
+  float xVal, yVal;
+  float SDDOverDelU;
+  float initialB, initialC;
+  float deltaB, deltaC;
+
+  /*
+    This should be very close to recipAlpha, but we'll calculate it seperately
+    anyway.
+  */
+  SDDOverDelU = SDD/detUSize;
+  for (i=0;i<viewCount;i++) {
+    theta = viewAngles[i];
+    /**
+       Calculate the cosine and sine of this angle
+       for use.
+    */
+    costheta = cos(theta);
+    sintheta = sin(theta);
+    for (k=0;k<pixelYCount;k++) {
+      /**
+	 For this row of the image, we calculate the \f$(x,y)\f$ position
+	 of the first pixel in the row.
+      */
+      xVal = pixelXCenter - (pixelXCount-1)/2.0*pixelXSize;
+      yVal = pixelYCenter - ((pixelYCount-1)/2.0-k)*pixelYSize;
+      /*
+	We map this to a modified coordinate system (explanation forthcoming...)
+      */
+      initialB = SID - xVal*costheta - yVal*sintheta;
+      initialC = -xVal*sintheta + yVal*costheta;
+      deltaB = -costheta*pixelXSize;
+      deltaC = -sintheta*pixelYSize;
+      innerLoop(pixelXCount, initialC, deltaC,
+		initialB, deltaB, SDDOverDelU,
+		detUCenter, image + k*pixelXCount, 
+		sino + i*detUCount, detUCount);
+    }
+  }
+  for (i=0;i<pixelXCount*pixelYCount;i++)
+    image[i] *= 2.0*M_PI/viewCount*SID*SID;
+}
+
+

gecatsim/clib_build/src/pd3dbpsemi.c

@@ -0,0 +1,177 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#include <math.h>
+
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+#define MIN(a,b) (((a) > (b)) ? (b) : (a))
+#define SAT(t,tmax) (MAX(MIN(t,tmax-1),0))
+#define LOOKUP(u,v) projData[SAT(v,detVcount)*detScount+SAT(u,detScount)]
+
+/*
+ * Backproject a view onto a 2D image using a 3D imaging geometry that corresponds
+ * to a fan-rebinned view from a cone beam system. =P
+ */
+#ifdef WIN32
+__declspec(dllexport)
+#endif
+void pd3dbpsemi(float *projData,  /* View data, should be detScount x detVcount */
+		float *imgData,   /* Image data - pass by reference, should be pixCount x pixCount */
+		int pixCount,     /* Number of image pixels (linear count) */
+		float xcenter,    /* Center of image in x coordinate */
+		float ycenter,    /* Center of image in y coordinate */
+		float pixSize,    /* Size of pixels in mm */
+		int detScount,    /* Number of detectors in S direction (parallel beam) */
+		int detVcount,    /* Number of detectors in V direction (row direction) */
+		float SID,        /* Source to isocenter distance */
+		float SDD,        /* Source to detector distance */
+		float detVsize,   /* Size of detector pixels */
+		float detVcenter, /* Index (fractional) of center row */
+		float sMin,       /* Smallest s value */
+		float sDelt,      /* Delta s */
+		float beta,       /* Rotation angle for this view */
+		float zoffset,    /* Distance (in Z) between current slice and view axis */
+		float pitch) {    /* Helix pitch, expressed in mm/rotation */
+  int row, col;
+  float xcoord, ycoord;
+  float cosbeta, sinbeta;
+  float tcoord, scoord, pixHalf;
+  float delbeta, delZ, gamma, Zdet;
+  float normalized_pitch;
+  float detZmin;
+  float ureal, vreal;
+  float puv, pu1v, puv1, pu1v1;
+  int uind, vind;
+  float ueps, veps;
+  float pustarv, pustarv1;
+  
+  cosbeta = cos(beta);
+  sinbeta = sin(beta);
+  pixHalf = (pixCount-1.0)/2.0;
+  normalized_pitch = pitch/(2.0*M_PI);
+  detZmin = -detVcenter*detVsize;
+  for (row=0;row<pixCount;row++) {
+    ycoord = (row-pixHalf)*pixSize + ycenter;
+    for (col=0;col<pixCount;col++) {
+      xcoord = (col-pixHalf)*pixSize + xcenter;
+      /* Map (x,y) location to position along parallel-beam axis */
+      scoord = xcoord*cosbeta + ycoord*sinbeta;
+      tcoord = -xcoord*sinbeta + ycoord*cosbeta;
+      /* 
+	 Calculate how much the source had to rotate (relative to current)
+         to line up with the current point (along the parallel ray axis)
+      */
+      delbeta = asin(scoord/SID);
+      /* Calculate how much the source moved in z with this rotation */
+      delZ = delbeta * normalized_pitch;
+      /* Calculate the distance from source to iso as seen along the parallel ray axis */
+      gamma = SID*cos(delbeta);
+      /* Adjust delZ for the magnification to the detector */
+      Zdet = (zoffset+delZ)*SDD/(gamma-tcoord);
+      /* map scoord to a u coordinate */
+      ureal = (scoord-sMin)/sDelt;
+      /* map Zdet to a v coordinate */
+      vreal = (Zdet-detZmin)/detVsize;
+      uind = (int) floor(ureal);
+      vind = (int) floor(vreal);
+      /* retrieve the four values */
+      puv = LOOKUP(uind,vind);
+      pu1v = LOOKUP(uind+1,vind);
+      puv1 = LOOKUP(uind,vind+1);
+      pu1v1 = LOOKUP(uind+1,vind+1);
+      /* linearly interpolate in the u directions */
+      ueps = ureal - uind;
+      pustarv = puv + (ueps)*(pu1v-puv);
+      pustarv1 = puv1 + (ueps)*(pu1v1-puv1);
+      veps = vreal - vind;
+      /* Update the pixel using bilinear interpolation */
+      imgData[row*pixCount+col] +=  pustarv + (veps)*(pustarv1-pustarv);
+    }
+  }
+}
+		
+		
+		
+#ifdef WIN32
+__declspec(dllexport)
+#endif
+void pd3dbpsemi_flat(float *projData,  /* View data, should be detScount x detVcount */
+		     float *imgData,   /* Image data - pass by reference, should be pixCount x pixCount */
+		     int pixCount,     /* Number of image pixels (linear count) */
+		     float xcenter,    /* Center of image in x coordinate */
+		     float ycenter,    /* Center of image in y coordinate */
+		     float pixSize,    /* Size of pixels in mm */
+		     int detScount,    /* Number of detectors in S direction (parallel beam) */
+		     int detVcount,    /* Number of detectors in V direction (row direction) */
+		     float SID,        /* Source to isocenter distance */
+		     float SDD,        /* Source to detector distance */
+		     float detVsize,   /* Size of detector pixels */
+		     float detVcenter, /* Index (fractional) of center row */
+		     float sMin,       /* Smallest s value */
+		     float sDelt,      /* Delta s */
+		     float beta,       /* Rotation angle for this view */
+		     float zoffset,    /* Distance (in Z) between current slice and view axis */
+		     float pitch) {    /* Helix pitch, expressed in mm/rotation */
+  int row, col;
+  float xcoord, ycoord;
+  float cosbeta, sinbeta;
+  float tcoord, scoord, pixHalf;
+  float delbeta, delZ, gamma, Zdet;
+  float normalized_pitch;
+  float detZmin;
+  float ureal, vreal;
+  float puv, pu1v, puv1, pu1v1;
+  int uind, vind;
+  float ueps, veps;
+  float pustarv, pustarv1;
+  float H;
+  
+  cosbeta = cos(beta);
+  sinbeta = sin(beta);
+  pixHalf = (pixCount-1.0)/2.0;
+  normalized_pitch = pitch/(2.0*M_PI);
+  detZmin = -detVcenter*detVsize;
+  for (row=0;row<pixCount;row++) {
+    ycoord = (row-pixHalf)*pixSize + ycenter;
+    for (col=0;col<pixCount;col++) {
+      xcoord = (col-pixHalf)*pixSize + xcenter;
+      /* Map (x,y) location to position along parallel-beam axis */
+      scoord = xcoord*cosbeta + ycoord*sinbeta;
+      tcoord = -xcoord*sinbeta + ycoord*cosbeta;
+      /* 
+	 Calculate how much the source had to rotate (relative to current)
+         to line up with the current point (along the parallel ray axis)
+      */
+      delbeta = asin(scoord/SID);
+      /* Calculate how much the source moved in z with this rotation */
+      delZ = delbeta * normalized_pitch;
+      /* Calculate the distance from source to iso as seen along the parallel ray axis */
+      gamma = SID*cos(delbeta);
+      H = SDD/cos(delbeta);
+      /* Adjust delZ for the magnification to the detector */
+      Zdet = (zoffset+delZ)*H/(gamma-tcoord);
+      /* map scoord to a u coordinate */
+      ureal = (scoord-sMin)/sDelt;
+      /* map Zdet to a v coordinate */
+      vreal = (Zdet-detZmin)/detVsize;
+      uind = (int) floor(ureal);
+      vind = (int) floor(vreal);
+      /* retrieve the four values */
+      puv = LOOKUP(uind,vind);
+      pu1v = LOOKUP(uind+1,vind);
+      puv1 = LOOKUP(uind,vind+1);
+      pu1v1 = LOOKUP(uind+1,vind+1);
+      /* linearly interpolate in the u directions */
+      ueps = ureal - uind;
+      pustarv = puv + (ueps)*(pu1v-puv);
+      pustarv1 = puv1 + (ueps)*(pu1v1-puv1);
+      veps = vreal - vind;
+      /* Update the pixel using bilinear interpolation */
+      imgData[row*pixCount+col] +=  pustarv + (veps)*(pustarv1-pustarv);
+    }
+  }
+}
+		
+		
+		
+
+

gecatsim/clib_build/src/phantom.l

@@ -0,0 +1,72 @@
+%{
+/* -----------------------------------------------------------------------
+*   Program Name: phantom.l            
+*   Authors:  Samit Basu, Bruno De Man, Jed Pack (GE Global Research)
+*   Organization: GE Global Research and GE Healthcare, General Electric Company
+*   Version:  6.0.3
+*   Date:  Feb 3, 2015
+* -----------------------------------------------------------------------*/
+#include <stdio.h>
+#include <string.h>
+#include "phantom.tab.hpp"
+// added by wrr/ejn
+int linecount = 0;
+extern YYSTYPE phantomlval;
+#include "stdlib.h"
+#include "math.h"
+%}
+
+INT				[0-9]+
+
+%%
+Sphere				return SPHERE;
+Box				return BOX;
+Cylinder_x			return CYLX;
+Cylinder_y			return CYLY;
+Cylinder_z			return CYLZ;
+Cylinder			return CYL;
+Ellipsoid			return ELLIP;
+Ellipsoid_free			return ELLIPFREE;
+Ellipt_Cyl			return ELLIPCYL;
+Ellipt_Cyl_x			return ECYLX;
+Ellipt_Cyl_y			return ECYLY;
+Ellipt_Cyl_z			return ECYLZ;
+Cone				return CONE;
+Cone_x				return CONEX;
+Cone_y				return CONEY;
+Cone_z				return CONEZ;
+dx				return LENGTHX;
+dy				return LENGTHY;
+dz				return LENGTHZ;
+r1				return RADIUS1;
+r2				return RADIUS2;
+axis				return AXIS;
+achse				return AXIS;
+a_x				return AX;
+a_y				return AY;
+a_z				return AZ;
+dichte				return RHO;
+density				return RHO;
+rho				return RHO;
+material                        return MATERIAL;
+{INT}("."{INT}?)? 		phantomlval.val = atof(phantomtext); return NUMBER;
+"."{INT}			phantomlval.val = atof(phantomtext); return NUMBER;
+[\'][^\'\n\r]*[\']              {
+strcpy(phantomlval.str,phantomtext+1); 
+phantomlval.str[strlen(phantomlval.str)-1] = 0;
+return STRING;
+}
+[ \t]+				/* Skip */;
+sin				return SIN;
+cos				return COS;
+sqrt				return SQRT;
+#[^\n]*				/* Skip */;
+\n				linecount++; 
+.				return (int) phantomtext[0];
+
+%%
+
+int phantomwrap()
+{
+  return 1;
+}