catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/reconstruction/src/Parallel_FDK_Helical_3DWeighting.c

@@ -0,0 +1,211 @@
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define pi 3.14159265358979
+
+typedef struct TestStruct {
+    float    ScanR;
+    float    DistD;
+    int       YL;
+    int       ZL;
+    float    dectorYoffset;
+    float    dectorZoffset;
+    float    XOffSet;
+    float    YOffSet;
+    float    ZOffSet;
+    float    phantomXOffSet;
+    float    phantomYOffSet;
+    float    phantomZOffSet;
+    float    DecFanAng;
+    float    DecHeight;
+    float    DecWidth;
+    float    dx;
+    float    dy;
+    float    dz;
+    float    h;
+    float    BetaS;
+    float    BetaE;
+    int       AngleNumber;
+    int       N_2pi;
+    float    Radius;
+    int       RecSize;
+    int       RecSizeZ;
+//    int       FOILength;
+//    int       FOIWidth;
+//    int       FOIHeight;
+    float    delta;
+    float    HSCoef;
+    float    k1;
+    float    ***GF;
+    float    ***RecIm;
+} TestStruct;
+
+extern void fbp(TestStruct *t) {
+
+	float ScanR, DistD,DecL,DecHeight,DecWidth,ObjR,dectorYoffset,dectorZoffset;
+	float dx,dy,dz,dYL,dZL,DeltaFai,YLC,ZLC,RadiusSquare,XOffSet,YOffSet,ZOffSet;
+	float XNC, YNC, ZNC,startangle;
+	float h,h1, BetaE, BetaS, delta, HSCoef, k1;
+	int YL,ZL,PN,RecSize, RecSizeZ, N_2pi,N_pi,XN, YN, ZN;
+//	int FOILength,FOIWidth,FOIHeight;
+
+	ScanR = t->ScanR;        /*source object distance*/
+    DistD = t->DistD;
+	DecL = t->DecFanAng;     /*Project Angle*/
+	YL = t->YL;              /*Detection Number */
+    ZL = t->ZL;
+    DecHeight = t->DecHeight;
+    DecWidth = t->DecWidth;
+    h1 = t->h;
+	ObjR = t->Radius;      /*Radius of the field of view*/
+	RecSize = t->RecSize;  /*reconstruction size x*/
+	RecSizeZ = t->RecSizeZ;  /*reconstruction size x*/
+	delta = t->delta;
+	HSCoef = t->HSCoef;
+	k1 = t->k1;
+
+    BetaS = t->BetaS;
+    N_2pi = t->N_2pi;
+    PN = t->AngleNumber;
+    dx = t->dx;   
+	dy = t->dy;
+    dz = t->dz;
+    dectorYoffset = t->dectorYoffset;
+//    dectorZoffset = t->dectorZoffset;
+//    startangle = t->startangle;
+    XOffSet = t->XOffSet;
+    YOffSet = t->YOffSet;
+    ZOffSet = t->ZOffSet;
+    XN = RecSize;
+    XNC = (XN-1)*0.5;
+    YN = RecSize;
+    YNC = (YN-1)*0.5;
+    ZN = RecSizeZ;
+    ZNC = (ZN-1)*0.5;
+    h = h1*DecHeight;
+
+	dYL= DecL/YL;       /*Each move Angle of projection*/
+	dZL= DecHeight/(ZL);       /*Each move Angle of projection*/
+	YLC    = (YL-1)*0.5;
+	ZLC    = (ZL-1)*0.5 + dectorZoffset;
+
+	RadiusSquare= ObjR*ObjR;
+	DeltaFai = 2*pi/N_2pi;
+    N_pi = N_2pi/2;
+
+    dYL = DecWidth/YL;
+    dZL = DecHeight/ZL;
+    DeltaFai = 2*pi/N_2pi;
+
+    float *w;
+    w     = (float*)malloc(sizeof(float)*N_2pi);
+
+     //////begin of the  main code
+     float x,y,z,Dey,Dez,touying,UU,U1,V1,Beta0,Yr,Zr,View,weight,weight1,weight2,Gama,Gama_C,m1,m2;
+     int ProjInd,xi,yi,zi,U,V,s0,s1,s2,d1,d2,L,Shift;
+
+	 for(zi = 0; zi<ZN; zi++)  // create two slices for testing
+	 {
+         printf("   recon slice %d/%d...\n", zi, ZN);
+		 ///compute the projection position for every grid on the image plane
+         z = (zi-ZNC) * dz+ZOffSet;
+         Beta0 = 2 * pi * z / h;
+         s0 = ceil((Beta0-BetaS) / DeltaFai-0.5);
+         s1 = s0-ceil(N_pi*HSCoef);       //s1 = ceil((Beta0 + N_Circle * pi - pi ) /DeltaFai);
+         s2 = s0+ceil(N_pi*HSCoef)-1;     //s2 = ceil((Beta0 + N_Circle * pi + pi ) /DeltaFai);
+
+         if ((s1<PN)||(s2>0))
+         {
+           if (s1 < 0)  {s1 = 0;}
+           if (s2 > PN-1) {s2 = PN-1;}
+          //////////////////////////////////////////
+         ////Producing the weighting function
+         for (int k=0;k<N_2pi;k++)
+           { w[k] = 0;}
+         L = s2-s1+1;
+         Shift = N_pi - (s0-s1);
+
+         if (L<2*delta)
+         {
+             for (int k=0;k<L;k++)
+               w[k+Shift]= pow(cos((pi/2)*(2*k-L+1)/L),2);
+         }
+         else
+         {
+           for (int k=0;k<L;k++)
+           {
+             if (0 <= k && k<delta)
+                 w[k+Shift]= pow(cos((pi/2)*(delta-k-0.5)/delta),2);
+                
+             else if(L-delta<=k && k < L)
+                 w[k+Shift]= pow(cos((pi/2)*(k-(L-delta)+0.5)/delta),2);
+             else
+                 w[k+Shift] = 1;
+          }
+         }//if(L<2*delta)
+         ///////////////////////////////////////////
+         for (ProjInd = s1; ProjInd <= s2; ProjInd++ )
+         {
+             View = BetaS + ProjInd * DeltaFai;
+             d1   = N_pi-(s0-ProjInd); //d1 = ProjInd;
+             if (ProjInd < s0)
+             {
+                 d2 = d1+N_pi;
+             }
+             else //(ProjInd >= s0)
+             {
+                 d2 = d1-N_pi;
+             }
+
+             for(yi=0;yi<YN;yi++)
+             {
+                 y = -(yi-YNC)*dy-YOffSet;
+                 #pragma omp parallel for private(xi,x, UU, Yr, Zr, U1, U,V1,V, Dey,Dez,touying,weight1,weight2,Gama,Gama_C,m1,m2,weight)
+                 for(xi=0;xi<XN;xi++)
+                 {
+                    x  = -(xi-XNC)*dx-XOffSet;
+                    UU = -x*cos(View)-y*sin(View);
+				    Yr = -x*sin(View)+y*cos(View);
+                    Zr = (z-h*(View+asin(Yr/ScanR))/(2.0*pi))*(DistD)/(sqrt(ScanR*ScanR-Yr*Yr)+UU);///03/05/23 Yu
+                    U1 = Yr/dYL+YLC;
+                    U  = ceil(U1);
+                    V1 = Zr/dZL+ZLC;
+                    V  = ceil(V1);
+                    Dey = U-U1;
+                    Dez = V-V1;
+                    //Linear interploate
+                    if ((U>0)&&(U<YL)&&(V>0)&&(V<ZL))
+                    {
+                          touying = Dey*Dez*t->GF[U-1][V-1][ProjInd]
+                                    +Dey*(1-Dez)*t->GF[U-1][V][ProjInd]
+                                   +(1-Dey)*Dez*t->GF[U][V-1][ProjInd]
+                                   +(1-Dey)*(1-Dez)*t->GF[U][V][ProjInd];
+
+                           weight1 = w[d1];
+                           weight2 = w[d2];
+                       
+                           Gama   = fabs((z-h*View/(2.0*pi))/(sqrt(ScanR*ScanR-Yr*Yr)+UU));
+                           if (ProjInd < s0)
+                           {
+                               Gama_C = fabs((z-h*(View+pi)/(2.0*pi))/(sqrt(ScanR*ScanR-Yr*Yr)-UU));
+                           }
+                           else
+                           {
+                               Gama_C = fabs((z-h*(View-pi)/(2.0*pi))/(sqrt(ScanR*ScanR-Yr*Yr)-UU));
+                           }
+                           m1 = pow(Gama,  k1);    //m1     = std::real(std::pow(Gama,k1*h));
+                           m2 = pow(Gama_C, k1);  //m2     = std::real(std::pow(Gama_C,k1*h));
+                           weight = (weight1*m2)/(weight2*m1+weight1*m2);
+                           
+                           t->RecIm[yi][xi][zi]=t->RecIm[yi][xi][zi]+weight*touying*DeltaFai;
+                    }
+                   }	//yi
+			 }//xi
+         }//ProjInd
+         }//  if ((s1<PN)||(s2>0))
+	 } //zi
+     //////end of the main code
+    free(w);
+ }

gecatsim/reconstruction/src/interface_fdk_angle.c

@@ -0,0 +1,162 @@
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define PI 3.14159265358979
+
+typedef struct TestStruct {
+    float    ScanR;
+    float    DecFanAng;
+    float    startangle;
+    int      rotdir; //rotation direction
+    float    DecHeight;
+    int       YL;
+    int       ZL;
+    float    dectorYoffset;
+    float    dectorZoffset;
+    float    XOffSet;
+    float    YOffSet;
+    float    ZOffSet;
+    float    phantomXOffSet;
+    float    phantomYOffSet;
+    float    phantomZOffSet;
+    int       AngleNumber;
+    float    DistD;
+    float    Radius;
+    int       RecSize;
+    float    sliceThickness;
+    int       FOILength;
+    int       FOIWidth;
+    int       FOIHeight;
+    float    ***GF;
+    float    ***RecIm;
+} TestStruct;
+
+extern void fbp(TestStruct *t) {
+
+	float ScanR, DecL,DecHeight,DistD,Radius,sliceThickness,dectorYoffset,dectorZoffset;
+	float DeltaY,DeltaZ,DeltaL,YCtr,ZCtr,DeltaR,RCtr,RadiusSquare,XOffSet,YOffSet,ZOffSet;
+	float centerX,centerY,centerZ,startangle,phantomXOffSet,phantomYOffSet,phantomZOffSet;
+	int YL,ZL,ProjNum,RecSize, rotdir;
+	int FOILength,FOIWidth,FOIHeight;
+
+	ScanR = t->ScanR;        /*source object distance*/
+	DecL = t->DecFanAng;     /*Project Angle*/
+	YL = t->YL;              /*Detection Number */
+	ProjNum = t->AngleNumber;/*Projection Number */
+	Radius = t->Radius;      /*Radius of the field of view*/
+	RecSize = t->RecSize;  /*reconstruction size x*/
+    sliceThickness = t->sliceThickness;
+    DistD = t->DistD;
+    DecHeight = t->DecHeight;
+    ZL = t->ZL;
+    dectorYoffset = t->dectorYoffset;
+    dectorZoffset = t->dectorZoffset;
+    phantomXOffSet = t->phantomXOffSet;
+    phantomYOffSet = t->phantomYOffSet;
+    phantomZOffSet = t->phantomZOffSet;
+
+    startangle = t->startangle;
+    rotdir = t->rotdir;
+    FOILength = t->FOILength;
+    FOIWidth = t->FOIWidth;
+    FOIHeight = t->FOIHeight;
+    XOffSet = t->XOffSet;
+    YOffSet = t->YOffSet;
+    ZOffSet = t->ZOffSet;
+    centerX = (FOILength-1)*0.5;
+    centerY = (FOIWidth-1)*0.5;
+    centerZ = (FOIHeight-1)*0.5;
+	DeltaY  = DecL/YL;       /*Each move Angle of projection*/
+	DeltaZ  = DecHeight/(ZL);       /*Each move Angle of projection*/
+	YCtr    = (YL-1)*0.5+dectorYoffset;
+	ZCtr    = (ZL-1)*0.5+dectorZoffset;
+	DeltaR  = 2*Radius/RecSize;
+    RCtr    = (RecSize-1)*0.5;
+	RadiusSquare= Radius*Radius;
+	DeltaL = 2*PI/ProjNum;
+
+	float  *VectorS, *VectorE,*xCor,*yCor,*zCor;
+    int  loop;
+	float temp;
+
+	VectorS  = (float*)malloc(sizeof(float)*2*ProjNum);
+	VectorE  = (float*)malloc(sizeof(float)*2*ProjNum);
+	xCor     = (float*)malloc(sizeof(float)*RecSize);
+	yCor     = (float*)malloc(sizeof(float)*RecSize);
+	zCor     = (float*)malloc(sizeof(float)*RecSize);
+
+	for(loop=0;loop<ProjNum;loop++)
+	{
+		temp = (rotdir*loop+startangle)*DeltaL;
+		VectorS[loop*2  ] = ScanR*cos(temp);
+		VectorS[loop*2+1] = ScanR*sin(temp);
+		VectorE[loop*2  ]= cos(temp);
+		VectorE[loop*2+1]= sin(temp);
+	}
+
+	for(loop=0;loop<RecSize;loop++) {
+		xCor[loop] = (loop-centerX)*DeltaR-XOffSet-phantomXOffSet;}
+	for(loop=0;loop<RecSize;loop++) {
+		yCor[loop] = (loop-centerY)*DeltaR-YOffSet-phantomYOffSet;}
+    for(loop=0;loop<RecSize;loop++) {
+        zCor[loop] = (loop-centerZ)*sliceThickness-ZOffSet-phantomZOffSet;}
+
+	/* argument about object:  ObjR RecMX RecMY RecMZ*/
+
+	int i,j,k,ProjIndex,UU,UL,VV,VL;//,IR;
+	float dis,Dlocal, DSX[2],UCor,VCor,alfa,beta;
+
+    //IR = (int)(RecSize/10);
+
+#pragma omp parallel for collapse(3) private(i,j,k,ProjIndex, DSX, Dlocal, dis, UCor, VCor, UL, VL, UU, VV, alfa, beta)
+	for (i=0;i<FOILength;i++)
+		{
+            //if ((i%IR)==0)
+            //printf("Reconstruction process:  %d %% \n", 10*i/IR);
+			for (j=0;j<FOIWidth;j++)
+			{
+                for (k=0;k<FOIHeight;k++)
+
+                {
+//				if( (xCor[i]*xCor[i] + yCor[j]*yCor[j])< 2*RadiusSquare)
+//			    	{
+					t->RecIm[i][j][k] = 0;
+                        for(ProjIndex=0;ProjIndex<ProjNum;ProjIndex++)
+                        {
+                            DSX[0]= xCor[i]-VectorS[ProjIndex*2];
+                            DSX[1]= yCor[j]-VectorS[ProjIndex*2+1];
+                            Dlocal = sqrt(DSX[0]*DSX[0]+DSX[1]*DSX[1]+zCor[k]*zCor[k]);
+                            dis   = fabs(xCor[i]*VectorE[ProjIndex*2]+yCor[j]*VectorE[ProjIndex*2+1]-ScanR);
+                            UCor  = atan((DSX[0]*VectorE[ProjIndex*2+1]-DSX[1]*VectorE[ProjIndex*2])/dis);
+                            VCor  = (zCor[k]*DistD)/dis;
+                            VCor  = VCor/DeltaZ+ZCtr;
+                            UCor  = UCor/DeltaY+YCtr;
+                            UL    = (floor)(UCor);
+                            VL    = (floor)(VCor);
+                            UU    = UL+1;
+                            VV    = VL+1;
+                            alfa  = UU-UCor;
+                            beta  = VV-VCor;
+                            if((UL>=0)&(UU<YL)&(VL>=0)&(VV<ZL))
+                            {
+                             t->RecIm[i][j][k] = (t->GF[UU][VL][ProjIndex]*(1-alfa)*beta+
+                                                  t->GF[UU][VV][ProjIndex]*(1-alfa)*(1-beta)+
+                                                  t->GF[UL][VL][ProjIndex]*alfa*beta+
+                                                  t->GF[UL][VV][ProjIndex]*alfa*(1-beta)
+                                                  )/(Dlocal*Dlocal)+t->RecIm[i][j][k];
+                            }
+                        }//for(projindex=0;Projindex<ProjNum;Projindex++)
+					t->RecIm[i][j][k] = -ScanR*PI*t->RecIm[i][j][k]/(ProjNum);
+
+//				}
+            }//for (j=0;j<RecSize;j++)
+        }//for (i=0;i<RecSize;i++)
+    }//for (k=0;i<RecSize;k++)
+    free(VectorS);
+	free(VectorE);
+	free(xCor);
+	free(yCor);
+	free(zCor);
+ }

gecatsim/spectrum/XCISTspectrum.m

@@ -0,0 +1,262 @@
+function [newE,newI] = XCISTspectrum(kVp, angle, dE)
+
+  % ------------------------------------------------------------------------------
+  % Created: B. De Man, August 27, 2020, 2020 - GE Research, Niskayuna, NY 12065, USA
+  % Last modified: B. De Man, August 27, 2020, 2020 - GE Research, Niskayuna, NY 12065, USA
+  % modified by Jiayong Zhang at June 2023: added the correct scaling factor for spectrum
+  %
+  % Copyright 2024, GE Precision HealthCare
+  % Code Developed Using US Government Funding via National Cancer Institute Grant 1U01CA231860-01A1 (ITCR)
+  % All rights reserved. See https://github.com/xcist/main/tree/master/license
+  %
+  % Purpose
+  %    Function to generate normalized, unfiltered X-ray CT spectrum for tungsten anode for tube voltages between
+  %    80 kVp and 140 kVp and for target angles between 5 and 9 degrees.
+  %    Spectra were initialized based using SpekPY (physics-based tool) and iteratively updated based on empirical
+  %    CT data and gradient-ascent minimization of the attenuation least squares error (post-log).
+  %    The spectra are compactly parametrized using a 17 parameter vector. The average RMS
+  %    attenuation errors were 0.026, 0.011, 0.007 and 0.006 at 80, 100, 120 and 140 kVp respectively.
+  %    A detailed description of the spectrum estimation methodology is reported in :
+  %        "Spectrum estimation for X-ray computed tomography"
+  %        Paul FitzGerald, Stephen Araujo, Mingye Wu, Bruno De Man
+  %        Submitted to Medical Physics
+  %
+  % Inputs
+  %    kVp: X-ray tube voltage
+  %    angle: X-ray tube target angle (or takeoff angle of the x-ray beam relative to the target surface)
+  %    dE: desire spectrum sampling density (in keV)
+  %
+  % Outputs
+  %    newE: array of all keV values at which the spectrum is defined
+  %    newI: array of all normalized photon count values of the spectrum
+  %       (note that I scales inversely proportional with dE to preserve total counts)
+  %
+  % Example usage
+  %    [E,I]=XCISTspectrum(120);
+  %    figure; plot(E,I); grid on;
+  %
+  % Limitations
+  %    Only valid for Tungsten targets
+  %    Input parameter space is limited to 80-140 kVp and 5-9 degrees
+  %    Does not include any inherent tube filtration.
+  % ------------------------------------------------------------------------------
+
+  %-------------------------------------------------------------------
+  % validate inputs
+  %-------------------------------------------------------------------
+  if kVp < 80 | kVp > 140
+    error('Tube voltage has to be between 80 and 140 kVp !')
+  end
+  if nargin < 2
+    angle=7.0;
+  end
+  if angle < 5 | angle > 9
+    error('Angle has to be between 5 and 9 degrees !')
+  end
+  if nargin < 3
+    dE=1.0;
+  end
+  if dE < 0.5 | dE > 20
+    error('Sampling density angle has to be between 0.5 and 20 keV !')
+  end
+
+  %-------------------------------------------------------------------
+  % spectrum parameters
+  %-------------------------------------------------------------------
+  allparams=zeros(19,3,4);
+
+  allparams(:,:,1)=...
+  [      0         0         0
+         0         0         0
+	 9.2280    9.0751    8.4031
+	 62.1915   64.5380   69.3968
+	 109.3572  110.8911  116.9230
+	 120.2025  119.3448  121.0521
+	 84.8994   83.3843   80.0781
+	 47.5492   46.5216   43.1936
+	 31.1946   31.4719   30.0455
+	 20.2388   19.9671   19.4418
+	 -20.2388  -19.9671  -19.4418
+	 -60.7163  -59.9014  -58.3255
+	 -121.4327 -119.8027 -116.6511
+	 -202.3878 -199.6712 -194.4185
+         0         0         0
+	 38.4669   41.5628   42.7531
+	 67.8298   73.3348   74.9963
+	 18.4094   20.5120   19.9288
+         0         0         0];
+
+  allparams(:,:,2)=...
+  [ 0         0         0
+    1.4528    1.4060    2.1868
+    16.0157   16.4726   21.1581
+    42.3437   43.5510   49.8557
+    63.3678   64.3889   68.6747
+    73.3139   73.2596   73.9680
+    65.9847   64.7651   63.1847
+    50.6813   49.0172   47.0623
+    34.3827   35.3012   35.0264
+    29.7647   30.1220   29.5544
+    19.1145   18.9863   18.1651
+    7.3835    7.2983    6.7053
+    -14.7670  -14.5966  -13.4106
+    -44.3011  -43.7897  -40.2317
+    0         0         0
+    109.8538  117.4195  122.2282
+    197.4694  210.8765  219.0544
+    73.0435   77.4888   79.7090
+    15.6381   16.5770   17.0522];
+
+  allparams(:,:,3)=...
+  [0         0         0
+   0.8564    0.8994    1.4183
+   9.8912   10.5994   14.0769
+   27.7893   29.1783   34.4463
+   44.0825   45.1210   49.2789
+   54.6745   54.4745   55.8673
+   53.4040   52.0372   51.2659
+   44.9039   43.1173   41.7155
+   28.7341   30.0178   30.4752
+   26.6774   27.4320   27.5315
+   21.3651   21.4246   21.0232
+   15.5955   15.4494   14.7377
+   6.8805    6.8382    6.0445
+   -6.8805   -6.8382   -6.0445
+   0         0         0
+   142.3841  150.0002  156.9327
+   256.7763  270.3153  282.1586
+   97.3396  101.9380  105.2753
+   22.1465   23.1369   23.7903];
+
+  allparams(:,:,4)=...
+  [0         0         0
+   0.6769    0.7496    1.1367
+   7.5893    8.3309   11.1569
+   21.3809   22.7056   27.4418
+   34.4374   35.3683   39.6081
+   43.8696   43.5788   45.6035
+   44.5953   43.1870   43.0696
+   39.3997   37.5810   36.5738
+   23.4315   24.8254   25.6625
+   22.6010   23.5537   24.0224
+   19.8653   20.1196   20.0579
+   16.4030   16.3043   15.9226
+   11.0143   10.8408   10.1404
+   4.0105    4.0080    3.3360
+   0         0         0
+   157.5624  163.9847  172.8835
+   284.6359  296.0568  311.1753
+   109.3829  113.3104  117.3900
+   25.3486   26.1938   26.9541];
+
+  %-------------------------------------------------------------------
+  % Interpolate in angle
+  %-------------------------------------------------------------------
+  angleparams=zeros(19,4);
+  for i=1:19
+    for j=1:4
+      pp=polyfit([5,7,9],[allparams(i,:,j)],2);
+      angleparams(i,j)=(polyval(pp,angle));
+    end
+  end
+  % interpolate between angle and kVp
+  group_ang = 8.73:-0.495:5.26;
+  rescale = 0.01.*[ %0.01 is due to the spectrum unit used in testing was cm^2
+  11681 11135   10812   11722   11672   10199   10152   10263
+  22428 21704   21307   22676   22581   19954   19581   19226
+  36252 35615   34373   36867   36385   32570   31924   31214
+  51002 49395   48234   51116   50536   45081   44094   41995];
+  % http://www.ece.northwestern.edu/local-apps/matlabhelp/techdoc/ref/interp2.html
+  allkVp = 80:20:140;
+  allangle = group_ang;
+  valid_idx = [1 2 3 6 7 8]; % note the center two 8-row groups are not used because abnormal photons/mA
+  thisrescale = interp2(allangle(valid_idx), allkVp, rescale(:, valid_idx), angle, kVp, 'spline');
+  
+  %-------------------------------------------------------------------
+  % Interpolate in tube voltage
+  %-------------------------------------------------------------------
+  params=zeros(19,1);
+  for i=1:19
+    params(i)=max(spline([80,100,120,140],angleparams(i,:),kVp),0);
+  end
+
+  %-------------------------------------------------------------------
+  % Define spline left and right of K-edge and characteristic peaks
+  %-------------------------------------------------------------------
+  % Define spline left of K-edge
+  ee=[15,20,26,32,38,46,56,66]; % spline knot energies below K-edge
+  ii=params(1:8);
+
+  % Define spline right of K-edge
+  ee2=[70.25,75,85,95,110,130]; % spline knot energies above K-edge
+  index=find(ee2<(kVp-10));
+  if ~isempty(index)
+    ee2=[ee2(index),kVp];
+  else
+    ee2=[69.75,kVp];
+  end
+  ii2=[params(9:9+length(ee2)-2);0];
+
+  % Define characteristic peaks
+  eek=[57.982,59.318,67.244,69.100]; % 4 characteristic peaks (drop the fifth one at 69.517)
+  iik=params(16:19);
+
+  %-------------------------------------------------------------------
+  % Generate new spectrum with sampling distance dE
+  %-------------------------------------------------------------------
+  % Interpolate from knots left of K-edge
+  newE=dE:dE:kVp; %define the new energy coordinates
+  indexl=find(newE<=69.5); %indices where we want to interpolate from left size of K-edge
+  xx=newE(indexl);
+  yy=spline([ee],[ii],xx)*dE/0.5; %re-scale to correct absolute count depending on keV sampling density
+  yy(find(xx<ee(1)))=0; % set to zero left of first knot
+
+  % Eliminate oscillations below 30 keV
+  therefix=find(xx<30);
+  f1=0.98^(dE/0.5);
+  f2=0.8^(dE/0.5);
+  for i=1:length(therefix)
+    i2=therefix(end-i+1);
+    if yy(i2)>f1*yy(i2+1)
+      yy(i2)=f2*yy(i2+1);
+    end
+  end
+
+  % Interpolate right side of K-edge
+  indexr=find(newE>69.5); %indices where we want to interpolate from right size of K-edge
+  xx2=newE(indexr); %re-scale to correct absolute count depending on keV sampling density
+  yy2=spline(ee2,ii2,xx2)*dE/0.5;
+  yy2(find(xx2>kVp))=0; % set to zero right of last knot
+
+  % Stack left and right sides together
+  newI=max([yy,yy2],0);
+  
+
+  % Add counts for characteristic peak #1
+  index=find(newE>eek(1));indexh=index(1); indexl=indexh-1; %find coords that straddle the peak
+  dxx=newE(indexh)-newE(indexl);
+  newI(indexl)=newI(indexl)+iik(1)*(newE(indexh)-eek(1))/dxx; %spread counts across two nearest energies
+  newI(indexh)=newI(indexh)+iik(1)*(eek(1)-newE(indexl))/dxx;
+
+  % Add counts for characteristic peak #2
+  index=find(newE>eek(2));indexh=index(1); indexl=indexh-1;
+  dxx=newE(indexh)-newE(indexl);
+  newI(indexl)=newI(indexl)+iik(2)*(newE(indexh)-eek(2))/dxx;
+  newI(indexh)=newI(indexh)+iik(2)*(eek(2)-newE(indexl))/dxx;
+
+  % Add counts for characteristic peak #3
+  index=find(newE>eek(3));indexh=index(1); indexl=indexh-1;
+  dxx=newE(indexh)-newE(indexl);
+  newI(indexl)=newI(indexl)+iik(3)*(newE(indexh)-eek(3))/dxx;
+  newI(indexh)=newI(indexh)+iik(3)*(eek(3)-newE(indexl))/dxx;
+
+  % Add counts for characteristic peak #4
+  index=find(newE>eek(4));indexh=index(1); indexl=indexh-1;
+  dxx=newE(indexh)-newE(indexl);
+  newI(indexl)=newI(indexl)+iik(4)*(newE(indexh)-eek(4))/dxx;
+  newI(indexh)=newI(indexh)+iik(4)*(eek(4)-newE(indexl))/dxx;
+  newI = newI.*thisrescale;
+
+  %outvar = [newE, newI];
+  outname = strcat('xcist_kVp', num2str(kVp), '_tar', num2str(angle), '_bin', num2str(dE), '.mat');
+  save(outname,'newE','newI');

gecatsim/spectrum/convert.py

@@ -0,0 +1,21 @@
+import numpy as np
+import re
+from scipy.io import loadmat
+from glob import glob
+import matplotlib.pyplot as plt
+
+allpath =  glob("*mat")
+for inppath in allpath:
+    inp = loadmat(inppath)
+    Eng = inp['newE'][0]
+    spec = inp['newI'][0]
+    plt.plot(Eng, spec);plt.show()
+    
+    with open(inppath.replace('mat','dat'), 'w') as f:
+        f.write('\n')
+        f.write('%d\n'%len(Eng))
+        for i in range(len(Eng)):
+            f.write("%e,%e\n"%(Eng[i], spec[i]))
+        # write angle
+        ang = float(re.findall("\d+\.*\d*", inppath.split('_')[2])[0])
+        f.write("%e"%ang)

gecatsim/spectrum/readme.md

@@ -0,0 +1,17 @@
+# xcist_kVp{kVp}_tar{targe angle}_bin1.dat
+## How to generate a customized spectrum
+1. use `XCISTspectrum.m` to generate spectrum at a user specified kVp/angle/energybin size. Note we will have a `.mat` file that is not readable to XCIST
+2. modify the spectrum filename in `convert.py` and run it to obtain a spectrum file ending in `.dat` that can be read by XCIST
+
+Note that the generated spectrum here is in unit of photons/mA/mm^2/s at 1m, i.e., we should specify the following in `cfg` file:\
+`protocol.spectrumUnit_mm=1` \
+`protocol.spectrumUnit_mA=1`
+
+The spectrum generated is already filtered by tube window.
+
+# tungsten_tar{targe angle}_{kVp}_filt.dat
+They were generated by Xspectand filtered by tube window, and the unit is photons/mA/cm^2/s at 1m.
+The settings should be:
+`protocol.spectrumUnit_mm=0` \
+`protocol.spectrumUnit_mA=1`
+