catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/clib_build/src/xybowtie.c

@@ -0,0 +1,76 @@
+// Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+/*
+ *
+ * Routine to calculate pathlengths through a closed object defined by a set of (x,y) points
+ * that is assumed to have an even number of intersections with any ray omitted from
+ * the origin.
+ *
+ */
+
+int flt_compare(const void *a, const void *b) {
+  const float *A, *B;
+  A = (const float *) a;
+  B = (const float *) b;
+  if ((*A) < (*B)) return -1;
+  if ((*A) > (*B)) return 1;
+  return 0;
+}
+
+#ifdef WIN32
+__declspec(dllexport)
+#endif
+void xybowtie(int npoints, float *xvec, float *yvec, float source_x, float source_y, int nfanangles, float *fanangles, float *pathlengths) {
+  int i;
+  int j;
+  float rhsx, rhsy;
+  float m00, m01, m10, m11;
+  float fan;
+  float deltax, deltay;
+  float *intersections;
+  int nintersections;
+  float beta, alpha;
+
+  intersections = (float*) malloc(npoints+1);
+  for (i=0;i<nfanangles;i++) {
+    /* retrieve the fan angle */
+    fan = fanangles[i];
+    /* expand into a direction vector, fa=0 --> -y unit vector */
+    deltax = sin(fan);
+    deltay = -cos(fan);
+    m00 = deltax;
+    m10 = deltay;
+    nintersections = 0;
+    for (j=0;j<npoints;j++) {
+      float dx, dy;
+      dx = xvec[(j+1) % npoints] - xvec[j];
+      dy = yvec[(j+1) % npoints] - yvec[j];
+      m01 = dx;
+      m11 = dy;
+      rhsx = source_x - xvec[j];
+      rhsy = source_y - yvec[j];
+      /* Solve for alpha */
+      alpha = (m00*rhsy - m10*rhsx)/(m00*m11-m10*m01);
+      if ((alpha >=0) && (alpha < 1)) {
+	beta = (m11*rhsx - m01*rhsy)/(m00*m11-m10*m01);
+	intersections[nintersections++] = beta;
+      }
+    }
+    /* sort the intersection times */
+    if (nintersections & 1) {
+      fprintf(stderr,"Warning!  Odd number of intersections encountered!\n");
+      nintersections--;
+    }
+    qsort(intersections,nintersections,sizeof(float),flt_compare);
+    pathlengths[i] = 0;
+    for (j=0;j<nintersections/2;j++)
+      pathlengths[i] += (intersections[2*j+1] - intersections[2*j]);
+  }
+  free(intersections);
+}
+
+

gecatsim/dose/examples/dose_doserecon.cfg

@@ -0,0 +1,16 @@
+# dose recon
+dose.imageFileName = 'out_512x512x4.raw'            # name of recon image
+dose.doseFileName = 'dose'                          # name of output
+dose.nVoxel = 256                                   # size of the volume for dose recon
+dose.xoffset = 0                                    # patient x offset from iso-center
+dose.yoffset = 0                                    # patient x offset from iso-center
+dose.zoffset = 0                                    # patient x offset from iso-center
+dose.muWater = 0.2                                  # effective Mu according to spectral cal
+dose.muBone = 0.5530                                # effective Mu according to spectral cal
+dose.doConvol = 1                                   # do convolution or not (1/0)
+dose.method = 4
+dose.convertTomGy = 1
+#dose.doserecon_phantom_material = 'polyethylene';    # if phantom material is known ...
+dose.waterThreshold = 0.25
+dose.airThreshold = 0.04
+dose.outerAirThreshold = 0.04

gecatsim/dose/examples/dose_phantom.cfg

@@ -0,0 +1,6 @@
+# Phantom
+phantom.callback = "Phantom_Analytic"              # name of function that reads and models phantom
+phantom.projectorCallback = "C_Projector_Analytic" # name of function that performs projection through phantom
+phantom.filename = 'FB_thorax.ppm'                 # phantom filename
+phantom.scale = 10.0                               # re-scale the size of phantom
+phantom.projectorNumThreads = 12

gecatsim/dose/examples/dose_physics.cfg

@@ -0,0 +1,18 @@
+# Geometric and energy sampling
+physics.energyCount = 12                    # number of energy bins
+
+physics.colSampleCount = 1                  # number of samples of detector cells in lateral direction
+physics.rowSampleCount = 1                  # number of samples of detector cells in longitudinal direction
+physics.srcXSampleCount = 1                 # number of samples of focal spot in lateral direction
+physics.srcYSampleCount = 1                 # number of samples of focal spot cells in longitudinal direction
+physics.viewSampleCount = 1                 # number of samples of each view angle range in rotational direction
+
+# Noise on/off settings
+physics.enableQuantumNoise = 0
+physics.enableElectronicNoise = 0
+
+physics.callback_post_log = 'Prep_BHC_Accurate'
+physics.EffectiveMu = 0.2
+physics.BHC_poly_order = 5
+physics.BHC_max_length_mm = 400
+physics.BHC_length_step_mm = 10

gecatsim/dose/examples/dose_protocol.cfg

@@ -0,0 +1,15 @@
+# Table and gantry
+protocol.scanTypes = [1, 1, 1, 1]           # flags for airscan, offset scan, phantom scan, prep
+protocol.viewsPerRotation = 980             # total numbers of view per rotation
+protocol.viewCount = 980                    # total number of views in scan
+protocol.startViewId = 0                    # index of the first view in the scan
+protocol.stopViewId = protocol.startViewId+protocol.viewCount-1 # index of the last view in the scan
+
+# X-ray tube technique and filtration
+protocol.mA = 300                           # tube current (in mA)
+protocol.spectrumCallback = "Spectrum"      # name of function that reads and models the X-ray spectrum
+protocol.spectrumFilename = "tungsten_tar7.0_120_filt.dat" # name of the spectrum file
+protocol.spectrumScaling = 1                # scaling factor, works for both mono- and poly-chromatic spectra
+protocol.spectrumUnit_mm = 0                # Is the spectrum file in units of photons/sec/mm^2/<current>?
+protocol.spectrumUnit_mA = 1                # Is the spectrum file in units of photons/sec/<area>/mA?          # scaling factor such that spectrum is in photons / mA / s / mm^2 at 1000 mm
+protocol.flatFilter = ['Al',3.0]            # additional filtration - materials and thicknesses (in mm)

gecatsim/dose/examples/dose_recon.cfg

@@ -0,0 +1,9 @@
+# Reconstruction
+recon.fov = 400.0           # diameter of the reconstruction field-of-view (in mm)
+recon.imageSize = 512       # number of columns and rows to be reconstructed (square)
+recon.sliceCount = 4        # number of slices to reconstruct
+
+# note that in recon max complete range in z is 1.57 mm, so we use smaller thickness
+recon.sliceThickness = 0.3  # reconstruction inter-slice interval (in mm)
+
+recon.centerOffset = [0.0,0.0,0.0] # reconstruction offset relative to center of rotation (in mm)

gecatsim/dose/examples/dose_scanner.cfg

@@ -0,0 +1,29 @@
+# Scanner geometry
+scanner.detectorCallback = "Detector_ThirdgenCurved" # name of function that defines the detector shape and model
+scanner.sid = 540.0                         # source-to-iso distance (in mm)
+scanner.sdd = 950.0                         # source-to-detector distance (in mm)
+scanner.detectorColsPerMod = 1              # number of detector columns per module
+scanner.detectorRowsPerMod = 4              # number of detector rows per module
+scanner.detectorColOffset = 0.25            # detector column offset relative to centered position (in detector columns)
+scanner.detectorRowOffset = 0.0             # detector row offset relative to centered position (in detector rows)
+scanner.detectorColSize = 1.0               # detector column pitch or size (in mm)
+scanner.detectorRowSize = 1.0               # detector row pitch or size (in mm)
+scanner.detectorColCount = 900              # total number of detector columns
+scanner.detectorRowCount = scanner.detectorRowsPerMod     # total number of detector rows
+scanner.detectorPrefilter = ['graphite', 1.0]  # detector filter
+
+# X-ray tube
+scanner.focalspotCallback = "SetFocalspot"  # name of function that defines the focal spot shape and model
+scanner.focalspotShape = "Uniform"          # Parameterize the model
+scanner.targetAngle = 7.0                   # target angle relative to scanner XY-plane (in degrees)
+scanner.focalspotWidth = 1.0
+scanner.focalspotLength = 1.0
+
+# Detector
+scanner.detectorMaterial = "Lumex"          # detector sensor material
+scanner.detectorDepth = 3.0                 # detector sensor depth (in mm)
+scanner.detectionCallback = "Detection_EI"  # name of function that defines the detection process (conversion from X-rays to detector signal)
+scanner.detectionGain = 15.0                # factor to convert energy to electrons (electrons / keV)
+scanner.detectorColFillFraction = 0.9       # active fraction of each detector cell in the column direction
+scanner.detectorRowFillFraction = 0.9       # active fraction of each detector cell in the row direction
+scanner.eNoise = 5000.0                     # standard deviation of Gaussian electronic noise (in electrons)

gecatsim/dose/examples/run.py

@@ -0,0 +1,37 @@
+import sys, os
+import gecatsim as xc
+import gecatsim.reconstruction.pyfiles.recon as recon
+from gecatsim.dose.pyfiles.catdoserecon import catdoserecon
+
+
+doSim = True
+doRecon = True
+doDose = True
+
+ct = xc.CatSim("dose_physics", "dose_phantom", "dose_recon", "dose_scanner", "dose_protocol", "dose_doserecon")  # initialization
+
+# add any additional search directories
+my_path = xc.pyfiles.CommonTools.my_path
+my_path.add_search_path("my_data")
+
+ct.resultsName = "out" # for sim and recon
+
+if doSim:
+    ct.run_all()  # run the scans defined by protocol.scanTypes
+
+if doRecon:
+    ct.do_Recon = 1
+    recon.recon(ct)
+
+if doDose:
+    ct.dose.imageFileName = 'out_512x512x4.raw'    # name of recon image
+    ct.dose.doseFileName = 'dose'                  # for doserecon
+    cfg = ct.get_current_cfg()
+    dosevol = catdoserecon(cfg=cfg)
+
+## check results
+import matplotlib.pyplot as plt
+doseVolFname = "%s.mGy" %(ct.dose.doseFileName)
+img = xc.rawread(doseVolFname, [ct.recon.sliceCount, ct.dose.nVoxel, ct.dose.nVoxel], 'float')
+plt.imshow(img[0,:,:])
+plt.show()

gecatsim/dose/pyfiles/C_DD3Dose.py

@@ -0,0 +1,84 @@
+# Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/main/blob/master/license/LICENSE
+
+import numpy as np
+import os
+from ctypes import *
+from numpy.ctypeslib import ndpointer
+    
+def C_DD3Dose(cfg,x0 = None,y0 = None,z0 = None,nrdetcols = None,nrdetrows = None,xds = None,yds = None,zds = None,xoffset = None,yoffset = None,zoffset = None,viewangles = None,zshifts = None,nrviews = None,sino = None,nrcols = None,nrrows = None,nrplanes = None,vol = None,dosevol = None,vox_xy_size = None,vox_z_size = None, debug=True): 
+    # was [nrcols, nrrows, nrplanes]
+    # convert to [nrplanes, nrrows, nrcols]
+    #vol_cp = np.copy(np.transpose(vol, (2,1,0)), order='F')
+    vol_cp = np.copy(vol, order='C')
+    dosevol_cp = np.copy(dosevol, order='C')
+    #dosevol_cp = np.copy(np.transpose(dosevol, (2,1,0)), order='F')
+    sinosize = sino.shape
+    volsize = dosevol_cp.shape
+    xds = np.copy(xds, order='C')
+    yds = np.copy(yds, order='C')
+    zds = np.copy(zds, order='C')
+    #xds = xds[:,None]
+    #yds = yds[:,None]
+    #zds = zds[None,:]
+    #zshifts = zshifts[None,:]
+    #viewangles = viewangles[None,:]
+    
+    ###------- C function and interface
+    fun = cfg.dose.doselib.DD3Dose
+
+    fun.argtypes = [c_float, c_float, c_float,
+        c_int, c_int,
+        ndpointer(c_float), ndpointer(c_float), ndpointer(c_float),
+        c_float, c_float, c_float,
+        ndpointer(c_float),
+        ndpointer(c_float),
+        c_int,
+        ndpointer(c_float),  # sinogram
+        c_int, c_int, c_int,
+        ndpointer(c_float),
+        ndpointer(c_float),
+        c_float, c_float]
+    fun.restype = None
+    
+    ###------- run the function
+    sinogram = np.copy(sino.T, order='C')
+    #sinogram = np.copy(sino)
+   
+    fun(x0, y0, z0, 
+        nrdetcols, nrdetrows, 
+        xds, yds, zds, 
+        xoffset, yoffset, zoffset, 
+        viewangles, 
+        zshifts, 
+        nrviews, 
+        sinogram, 
+        nrcols, nrrows, nrplanes, 
+        vol_cp, dosevol_cp, vox_xy_size, vox_z_size);
+
+    dosevol_cp = np.reshape(dosevol_cp, volsize)
+    sinogram = np.reshape(sinogram, sinosize)
+    # convert to [nrcols, nrrows, nrplanes]
+    #dosevol_cp = np.transpose(dosevol_cp,(2,1,0))
+    #breakpoint()
+    return dosevol_cp, sinogram
+    
+if __name__ == '__main__':
+    from scipy import io as sio
+    from gecatsim.pyfiles.CommonTools import *
+    from gecatsim.dose.pyfiles.catdoserecon import load_C_lib
+
+    cfg = CFG()
+    cfg.dose.doselib = load_C_lib()
+    
+    mat_in = sio.loadmat("unittest/dd3dose_in.mat")
+
+    pydosevol, pysino = C_DD3Dose(cfg,mat_in['x0'][0,0], mat_in['y0'][0,0], mat_in['z0'][0,0], mat_in['nrdetcols'][0,0], mat_in['nrdetrows'][0,0], mat_in['xds'], mat_in['yds'], mat_in['zds'],
+        mat_in['xoffset'][0,0], mat_in['yoffset'][0,0], mat_in['zoffset'][0,0], mat_in['viewangles'], mat_in['zshifts'], mat_in['nrviews'][0,0], mat_in['sino'], mat_in['nrcols'][0,0], mat_in['nrrows'][0,0], mat_in['nrplanes'][0,0],
+        mat_in['vol'], mat_in['dosevol'], mat_in['vox_xy_size'][0,0], mat_in['vox_z_size'][0,0], debug=True)
+
+    mat_out = sio.loadmat("unittest/dd3dose_out.mat")
+
+    try:
+        assert np.allclose(pydosevol, mat_out['dosevol'], atol=1.E-8), 'dosevol'
+    except AssertionError as err:
+        print(err)

gecatsim/dose/pyfiles/Combine_Spectrum_Bowtie_FlatFilter.py

@@ -0,0 +1,15 @@
+import numpy as np
+import numpy.matlib
+import matplotlib.pyplot as plt
+    
+def Combine_Spectrum_Bowtie_FlatFilter(cfg): 
+    print('Combining spectrum with bowtie transmission and flat filter transmission...')
+    # The spectrum is in units of photons/view/mm^2 per energy bin at 1m.
+    if cfg.spec.Ivec.shape == cfg.src.filterTrans.shape:
+        cfg.spec.netIvec = np.multiply(cfg.spec.Ivec, cfg.src.filterTrans)
+    else:
+        raise Exception('spec.Ivec, bowtie.transVec and FiltrationTransVec(flat filter) should have the same dimension')
+    
+    print('... done combining spectrum with bowtie transmission and flat filter transmission.')
+    
+    return cfg

gecatsim/dose/pyfiles/DoseConv.py

@@ -0,0 +1,87 @@
+# Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/main/blob/master/license/LICENSE
+
+import numpy as np
+from scipy import interpolate,io
+import gecatsim as xc
+from gecatsim.pyfiles.CommonTools import *
+from gecatsim.dose.pyfiles.GetMuByProcess import GetMuByProcess
+from gecatsim.dose.pyfiles.get_voxel_stopping_power import get_voxel_stopping_power
+from gecatsim.dose.pyfiles.doseconvol import doseconvol
+
+def DoseConv(cfg = None, mydc=None, ee = None,dosevol_int = None,mu_vol = None,voxel_xy_size = None,mask_highZ = None): 
+    mask_lowZ = 1 - mask_highZ
+    
+    if mydc.data_Compt_dE_frac is None or mydc.data_E_scatter is None or mydc.dosereconkernel is None:
+        # Geant4 results: 'Compton_ELoss_factor',ee=10:10:160
+        scat_dir = my_path.find("dose_data", 'scatter_E_loss_fraction.mat', '')
+        scat_data = io.loadmat(scat_dir)
+        mydc.data_Compt_dE_frac = np.squeeze(np.vstack(([[0]],scat_data['Compton_ELoss_factor'])))
+        mydc.ee_CdE = np.array([0]+list(np.arange(10,160+10,10)))
+        # mean scatter energy of monos, weighted by scatter spectrum, of multi-material
+        # mean_E, mspr, Geant4 results,ee=10:10:160
+        # load weighted_scatter_energy_by_spec.mat;
+        tmp_dir2 = my_path.find("dose_data", 'weighted_scatter_energy_by_spec.mat', '')
+        tmpdata2 = io.loadmat(tmp_dir2)
+        mydc.data_E_scatter = np.vstack(([0], np.mean(tmpdata2['mean_E'],1,keepdims=True)))
+        mydc.ee_mE = np.array([0]+list(np.arange(10,160+10,10)))
+        # convolution kernel
+        #load dosereconkernel_mthd4.mat; # dosereconkernel
+
+        tmp_dir3 = my_path.find("dose_data", 'dosereconkernel_mthd4.mat', '')
+        tmpdata3 = io.loadmat(tmp_dir3)
+        mydc.dosereconkernel = tmpdata3['dosereconkernel']
+    
+    ## calc scattered energy
+    # fraction of scattered energy to interaction energy
+    f_interp = interpolate.interp1d(mydc.ee_CdE, mydc.data_Compt_dE_frac)
+    Compt_dE_frac = f_interp(ee)
+    frac_water = (xc.GetMu('water',ee) - GetMuByProcess(cfg,'water',ee,'PE') - GetMuByProcess(cfg,'water',ee,'C') * Compt_dE_frac) / xc.GetMu('water',ee)
+    frac_bone = (xc.GetMu('bone',ee) - GetMuByProcess(cfg,'bone',ee,'PE') - GetMuByProcess(cfg,'bone',ee,'C') *Compt_dE_frac) / xc.GetMu('bone',ee)
+    frac_vol = frac_water * mask_lowZ + frac_bone * mask_highZ
+    # apply mu_frac to dosevol (interaction energy volume)
+    dosevol_scatter = np.multiply(dosevol_int,frac_vol)
+    dosevol_1st_abs = dosevol_int - dosevol_scatter
+    ## convolution on dosevol_scatter
+    # stopping power to scatters
+    f_interp = interpolate.interp1d(mydc.ee_mE, np.squeeze(mydc.data_E_scatter))
+    E_scatter = f_interp(ee)
+    stp_water = get_voxel_stopping_power(cfg,'water',E_scatter,voxel_xy_size,1)
+    stp_bone = get_voxel_stopping_power(cfg, 'bone',E_scatter,voxel_xy_size,1)
+    # absorbing vol is determined by material stopping power and density
+    dens_vol = mu_vol / (mask_lowZ * xc.GetMu('water',ee) + mask_highZ * xc.GetMu('bone',ee))
+    abs_vol = np.multiply(dens_vol,(mask_lowZ * stp_water + mask_highZ * stp_bone))
+    # convolution
+    x = mydc.dosereconkernel[np.int32(np.ceil(ee))-1]
+    x = x[0,0]
+    #breakpoint()
+    dosevol_2nd_abs = doseconvol(cfg,dosevol_scatter,abs_vol,stp_water,voxel_xy_size,x)
+    ## final absorption
+    dosevol_final = dosevol_1st_abs + dosevol_2nd_abs
+    return dosevol_final
+
+if __name__ == '__main__':
+    # for persisten variables in 
+    class myDC():
+        def __init__(self):
+            self.data_Compt_dE_frac = None 
+            self.data_E_scatter = None 
+            self.dosereconkernel = None
+            self.ee_CdE = None
+            self.ee_mE = None
+    from scipy import io as sio
+    import matplotlib.pyplot as plt
+    from gecatsim.pyfiles.CommonTools import *
+    
+    matin = sio.loadmat("unittest/doseconpar_in.mat")
+    cfg = CFG()
+    mydc = myDC()
+    
+    pyout = DoseConv(cfg, mydc, matin['ee'][0], matin['dosevol_int'], matin['mu_vol'], matin['voxel_xy_size'][0,0], matin['mask_highZ'])
+
+    matout = sio.loadmat("unittest/doseconpar_out.mat")
+    matout = matout['dosevol_final']
+
+    try:
+        assert np.allclose(pyout, matout, atol=1.E-8), 'dosevol'
+    except AssertionError as err:
+        print(err)

gecatsim/dose/pyfiles/GetMuByProcess.py

@@ -0,0 +1,57 @@
+# Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/main/blob/master/license/LICENSE
+
+import numpy as np
+from ctypes import *
+import numpy.matlib
+import gecatsim as xc
+from gecatsim.pyfiles.CommonTools import *
+from gecatsim.pyfiles.ReadMaterialFile import ReadMaterialFile
+    
+def GetMuByProcess(cfg,MaterialName = None,Evec = None,ProcessName = None,PairProductionFlag = None): 
+    
+    #print('Setting mu for for material %s...'%MaterialName)
+    # It seems that for over 1024 kVp (1MV), the pair production flag is set.
+    if PairProductionFlag is None:
+        PairProductionFlag = np.max(Evec) > 1024
+    
+    # find the right directory TODO
+    #if (MaterialDirectory is None) or len(MaterialDirectory)==0:
+        #FIXME
+        #SetupDirs
+     #   pass
+    MaterialDirectory = my_path.paths["material"] + "/"
+    c_MaterialDirectory = c_char_p(bytes(MaterialDirectory, 'utf-8'))
+    
+    if MaterialName == 'unit':
+        Mu = np.single(1.0)
+    else:
+        # Read the material file
+        MaterialFile = my_path.find("material", MaterialName, '')
+        Number, Density,AtomicNumbers,NormalizedMassFractions = ReadMaterialFile(MaterialFile)
+        feval('C_Materials_CrossSectionDB_Initialize',cfg, c_MaterialDirectory, PairProductionFlag)
+        # Get the normalized mass attenuation coefficients for each element in the material.
+        #MAC = np.zeros((Evec.shape,Evec.shape))
+        #MAC = np.matlib.repmat(MAC,4,1)
+        MAC = feval('C_Materials_CrossSectionMAC_ByProc_Get',cfg, AtomicNumbers,NormalizedMassFractions,Evec)
+        # Because the mass fractions passed are normalized by Materials_ElementalComposition_Get,
+        # units are cm^2/g of material (not per gram of element).
+        # Convert MAC to mu for each element in the material.
+        Mu = MAC * Density
+        # Units are cm^-1 (cm^2/g * g/cm^3)
+        numE = int(np.asarray(Mu).size/ 4)# in matlab
+        ProcessName = ProcessName.lower()
+        if ProcessName == 'rayleigh' or ProcessName == 'r':
+            ind = np.arange(numE)
+        elif ProcessName == 'compton' or ProcessName =='c':
+            ind = np.arange(numE,numE * 2)
+        elif ProcessName == 'photoelectric' or ProcessName == 'pe':
+            ind = np.arange(numE * 2,numE * 3)
+        elif ProcessName == 'pairproduction' or ProcessName =='pp':
+            ind = np.arange(numE * 3,numE * 4)
+        else:
+            ind = np.arange(numE * 2,numE * 3)
+        Mu = Mu[ind]
+        Mu = np.reshape(Mu, np.array(Evec).shape, order="F")
+    
+    #print('... done setting mu for for %s...'%MaterialName)
+    return Mu

gecatsim/dose/pyfiles/brconvol_matlab.py

@@ -0,0 +1,67 @@
+# Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/main/blob/master/license/LICENSE
+
+import numpy as np
+from scipy.signal import convolve, convolve2d
+    
+def brconvol_matlab(data = None,sigma = None,dim = None): 
+    data = np.copy(data)
+    if sigma != 0:
+        # determine convolution directions
+        if dim is None: dim = -1
+        do_row = (dim == -1 or dim==255 or dim == 0)
+        do_col = (dim == -1 or dim==255 or dim == 1)
+        do_plane = (dim == -1 or dim==255 or dim == 2)
+        kernelsize = np.max(data.shape) * 2 + 1
+        kernel = np.exp(- (np.arange(kernelsize) - np.max(data.shape)) ** 2 / (2 * sigma ** 2))
+        kernel = kernel.flatten()
+        kernel /= np.sum(kernel)
+        mid = np.max(data.shape)
+        # convolve in row direction
+        if (do_row):
+            half = data.shape[1-1]
+            k0 = kernel[np.arange(mid - half,mid + half+1)]
+            #k0 = k0 / np.sum(k0)
+            #for i in range(data.shape[2]):
+            #    for j in range(data.shape[0]):
+            #        data[j,:,i] = convolve(data[j,:,i], k0,'same')
+            data = convolve(data, k0[None,:,None],'same')
+        # convolve in col direction
+        if (do_col):
+            half = data.shape[2-1]
+            k0 = kernel[np.arange(mid - half,mid + half+1)]
+            #k0 = k0 / np.sum(k0)
+            #data = np.convolve(data,np.transpose(k0),'same')
+            #for i in range(data.shape[2]):
+            #    for j in range(data.shape[1]):
+                    #TODO: check this is the col ops
+            #        data[:,j,i] = convolve(data[:,j,i], k0,'same')
+            data = convolve(data, k0[:,None,None],'same')
+        # convolve in plane direction
+        if (do_plane):
+            half = data.shape[3-1]
+            k0 = kernel[np.arange(mid - half,mid + half+1)]
+            #k0 = k0 / np.sum(k0)
+            #data = np.convolve(data,permute(k0,np.array([1,2,0])),'same')
+            if data.shape[2]==1:
+                # k0 *= 5  # dose.method==1
+                k0 *= 2  # DoseRecon 2.0
+            #for i in range(data.shape[0]):
+            #    for j in range(data.shape[1]):
+            #        data[i,j,:] = convolve(data[i,j,:], k0, 'same')
+            data = convolve(data, k0[None, None, :], 'same')
+    
+    return data
+
+if __name__ == '__main__':
+    from scipy import io as sio
+    mat_in = sio.loadmat("unittest/brconv_in.mat")
+
+    py_out = brconvol_matlab(mat_in['data'], mat_in['sigma'], mat_in['dim']-1)
+
+    mat_out = sio.loadmat("unittest/brconv_out.mat")
+    mat_out = mat_out['data']
+
+    try:
+        assert np.allclose(py_out, mat_out, atol=1.E-8), 'dosevol'
+    except AssertionError as err:
+        print(err)

gecatsim/dose/pyfiles/calcDetectorFlux.py

@@ -0,0 +1,54 @@
+# Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/main/blob/master/license/LICENSE
+
+import numpy as np
+from gecatsim.pyfiles.CommonTools import *
+from gecatsim.pyfiles.Gantry_Helical import Gantry_Helical
+
+def calcDetectorFlux(viewId, ViewNumber, cfg):
+    # source
+    if viewId == 0 or cfg.physics.recalcSrc:
+        cfg = feval(cfg.scanner.focalspotCallback, cfg)
+
+    # spectrum
+    # Setup spectra for Variable kVp & mA simulation, Mingye
+    if viewId == 0 and hasattr(cfg,'variable_kV_mA_sim') and cfg.variable_kV_mA_sim == 1:
+        # read spectra for all kVps
+        kVs = np.arange(np.min(cfg.kV_profile),np.max(cfg.kV_profile)+1)
+        spec_all_kV = cell(np.asarray(kVs).size,1)
+        for kV_id in np.arange(np.asarray(kVs).size):
+            cfg.spectrum_filename = sprintf_filepath(cfg.spectrum_base_filename,kVs(kV_id))
+            cfg.number_Ebins = kVs(kV_id) / cfg.Ebin_sampling_factor
+            spec_all_kV[kV_id],cfg_tmp = feval(cfg.callback_spectrum,cfg)
+        # set E-bins and Evec to max kV for all views
+        cfg = cfg_tmp
+        spec = spec_all_kV[end()]
+        # fullfil the high empty Ebins with zeros
+        Ivec_all_kV = cell(np.asarray(kVs).size,1)
+        for kV_id in np.arange(1,np.asarray(kVs).size+1).reshape(-1):
+            dim = spec_all_kV[kV_id].Ivec.shape
+            dim[1] = spec.number_Ebins - dim(1)
+            Ivec_all_kV[kV_id] = np.array([[spec_all_kV[kV_id].Ivec],[np.zeros((dim,dim))]])
+    
+    if viewId == 0 or cfg.physics.recalcSpec:
+        # Variable kVp & mA simulation, Mingye
+        if hasattr(cfg,'variable_kV_mA_sim') and cfg.variable_kV_mA_sim == 1:
+            kV_id = find(kVs == cfg.kV_profile(ViewNumber))
+            #fprintf('kV_id #d ',kV_id);
+            mA_factor = 1
+            if hasattr(cfg,'mA_profile') and np.asarray(cfg.mA_profile).size == cfg.total_n_views:
+                mA_factor = cfg.mA_profile(ViewNumber) / cfg.mA
+            spec.Ivec = Ivec_all_kV[kV_id] * mA_factor
+            cfg.Ivec = spec.Ivec
+        else:
+            # constant kVp simulation
+            cfg = feval(cfg.protocol.spectrumCallback, cfg)
+    
+    # filters (bowtie and flat)
+    if viewId == 0 or cfg.physics.recalcFilt:
+        cfg = feval(cfg.protocol.filterCallback, cfg)
+    
+    # flux
+    if viewId == 0 or cfg.physics.recalcFlux:
+        cfg = feval(cfg.physics.fluxCallback, cfg)
+
+    return  cfg.detFlux