catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/pyfiles/Phantom_CAD_to_Polygonal.py

@@ -0,0 +1,82 @@
+
+import numpy as np
+from stl import mesh
+
+def Phantom_CAD_to_Polygonal(cadFilename, phantomFilename=None, materialName='water',
+                             materialId=1, mesReductionRatio=-1, sizeScale=0,
+                             offcenter=(0, 0, 0), drawCAD=True):
+
+    if phantomFilename is None:
+        dotId = cadFilename.rfind('.')
+        phantomFilename = cadFilename[:dotId] + '.ppm'
+
+    if mesReductionRatio > 0:
+        # Load the STL CAD file
+        meshStl = mesh.Mesh.from_file(cadFilename)
+        
+        # Reduce facet number
+        numReducedFaces = int(meshStl.vectors.shape[0] * mesReductionRatio)
+        meshStl.reduce(numReducedFaces)
+
+        # Get the vertices and faces
+        v = np.array(meshStl.vectors.reshape(-1, 3), dtype=np.float32)
+        f = np.arange(v.shape[0]).reshape(-1, 3)
+
+    else:
+        # Load the STL CAD file without reduction
+        v, f, _, _ = mesh.read_surface(cadFilename)
+
+    # Off-center
+    if any(offcenter):
+        v += np.array(offcenter, dtype=np.float32)
+
+    # Rescale
+    if sizeScale != 0:
+        v *= sizeScale
+
+    # Show CAD
+    if drawCAD:
+        from mpl_toolkits import mplot3d
+        import matplotlib.pyplot as plt
+
+        fig = plt.figure()
+        ax = mplot3d.Axes3D(fig)
+        ax.add_collection3d(mplot3d.art3d.Poly3DCollection(v[f], facecolors=(0.7, 0.7, 0.75), edgecolors='k', linewidths=0.2))
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        ax.view_init(elev=20, azim=30)
+        plt.show()
+
+    # Save polygon phantom
+    materialList = ['water', 'plexi', 'al', 'ti', 'fe', 'cu', 'graphite']
+    materialList[materialId] = materialName
+
+    with open(phantomFilename, 'w') as fid:
+        fid.write('%% Mesh Phantom for polygonal projector\n')
+        fid.write('%% Author: Mingye Wu, GE GRC\n\n')
+        fid.write('obj=[];object=[];                                             %% DO NOT EDIT THIS LINE\n')
+        fid.write('update = ''[obj,object]=AddObject(obj,object,materialList);'';  %% DO NOT EDIT THIS LINE\n\n')
+
+        fid.write('materialList = { ')
+        for mat in materialList:
+            fid.write("'%s' " % mat)
+        fid.write('};\n\n')
+
+        fid.write('obj.density = 1;\n')
+        fid.write('obj.material = %d;\n' % materialId)
+
+        fid.write('obj.vertices = [')
+        for vert in v:
+            fid.write('%f %f %f;' % tuple(vert))
+        fid.write('];\n')
+
+        fid.write('obj.tri_inds = [')
+        for face in f:
+            fid.write('%d %d %d;' % tuple(face))
+        fid.write('];\n')
+
+        fid.write('eval(update);\n')
+
+    return phantomFilename
+

gecatsim/pyfiles/Phantom_NCAT.py

@@ -0,0 +1,96 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+from ctypes import *
+from numpy.ctypeslib import ndpointer
+from gecatsim.pyfiles.GetMu import GetMu
+from gecatsim.pyfiles.CommonTools import *
+
+
+def Phantom_NCAT(cfg):
+    ###----------- pass material Mu and volume to C
+    nMat = set_material(cfg)
+    ###----------- pass volume info to C
+    set_volume(cfg, nMat)
+    return cfg
+
+
+def set_material(cfg):
+    materialList = [
+        'ncat_water',
+        'ncat_muscle',
+        'ncat_lung',
+        'ncat_dry_spine',
+        'ncat_dry_rib',
+        'ncat_adipose',
+        'ncat_blood',
+        'ncat_heart',
+        'ncat_kidney',
+        'ncat_liver',
+        'ncat_lymph',
+        'ncat_pancreas',
+        'ncat_intestine',
+        'ncat_skull',
+        'ncat_cartilage',
+        'ncat_brain',
+        'ncat_spleen',
+        'ncat_iodine_blood',
+        'ncat_iron',
+        'ncat_pmma',
+        'ncat_aluminum',
+        'ncat_titanium',
+        'ncat_air',
+        'ncat_graphite',
+        'ncat_lead',
+        'ncat_breast_mammary',
+        'ncat_skin',
+        'ncat_iodine',
+        'ncat_eye_lens',
+        'ncat_ovary',
+        'ncat_red_marrow',
+        'ncat_yellow_marrow',
+        'ncat_testis',
+        'ncat_thyroid',
+        'ncat_bladder']
+    
+    Evec = cfg.spec.Evec
+    nMat = len(materialList)
+    Mus = np.zeros([Evec.size, nMat], dtype=np.double)
+    for i in range(nMat):
+        Mus[:, i] = GetMu(materialList[i], Evec)/10 # cm^-1 --> mm^-1
+
+    # in nCAT_main.c: void set_material_info_NCAT(int materialCount, int eBinCount, double *muTable)
+    # the C func wants data order: materialIndex -> Ebin, so the dim is [Ebin, materialIndex]
+    fun = cfg.clib.set_material_info_NCAT
+    fun.argtypes = [c_int, c_int, ndpointer(c_double)]
+    fun.restype = None
+    fun(nMat, Evec.size, Mus)
+    
+    return nMat
+
+
+def set_volume(cfg, nMat):
+    ###----------- set tolerance, defauts: t1 = 0.001, t2 = 0.0001, pd = 0.02
+    # in nCAT_main.c: void set_tolerance_info_NCAT(double t1, double t2, double pd)
+    fun_t = cfg.clib.set_tolerance_info_NCAT
+    fun_t.argtypes = [c_double, c_double, c_double]
+    fun_t.restype = None
+    t1 = 0.001
+    t2 = 0.0001
+    pd = 0.02
+    fun_t(t1, t2, pd)
+    
+    ###----------- set volume
+    # phantom file (*.nrb)
+    cfg.phantom.filename = my_path.find("phantom", cfg.phantom.filename, '')
+
+    # in nCAT_main.c: void Parse_Phantom(char *filename, int *materials, float *coord_origin_offset, float scale)
+    fun = cfg.clib.Parse_Phantom
+    fun.argtypes = [POINTER(c_char), ndpointer(c_int), POINTER(c_float), c_float]
+    fun.restype = None
+    
+    phantom_filename = c_char_p(bytes(cfg.phantom.filename, 'utf-8'))
+    material_flags = np.ones((1,nMat),dtype=np.int32)
+    offsets = (c_float*3)(*cfg.phantom.centerOffset)
+    scale = cfg.phantom.scale
+    fun(phantom_filename, material_flags, offsets, scale)
+ 

gecatsim/pyfiles/Phantom_Polygonal.py

@@ -0,0 +1,122 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+import numpy as np
+import os
+from ctypes import *
+from numpy.ctypeslib import ndpointer
+from gecatsim.pyfiles.GetMu import GetMu
+from gecatsim.pyfiles.CommonTools import *
+from gecatsim.pyfiles.Phantom_Polygonal_ReadPolygon import extract_polygonal_objects
+
+def Phantom_Polygonal(cfg):
+    ###----------- pass material Mu to C
+    set_material(cfg)
+    ###----------- pass volume info to C
+    set_volume(cfg)
+    return cfg
+
+
+def set_volume(cfg):
+    # print('Starting to pass POLYGONAL phantom to C...')
+
+    cfg.phantom.filename = my_path.find('phantom', cfg.phantom.filename, '')
+    # if os.path.exists(cfg.phantom.filename):
+    #    exec(open(cfg.phantom.filename).read())
+
+    object = extract_polygonal_objects(cfg.phantom.filename)
+
+    numPoly = len(object['type'])
+    C_Phantom_Polygonal_Clear(cfg, numPoly)
+
+    for index in range(numPoly):
+        # rotate around y-axis
+        if hasattr(cfg.phantom, "phantomRotationY") and cfg.phantom.phantomRotationY != 0:
+            ang = cfg['phantom_rotation_y']
+            sina = np.sin(-ang / 180 * np.pi)
+            cosa = np.cos(-ang / 180 * np.pi)
+            transmat = np.array([[cosa, 0, sina], [0, 1, 0], [-sina, 0, cosa]])
+            object['vertices'][index] = np.dot(object['vertices'][index], transmat)
+
+        # Scale and position
+        object['vertices'][index] = object['vertices'][index]*cfg.phantom.scale + np.tile(cfg.phantom.centerOffset,(object['vertices'][index].shape[0], 1)).astype(np.float32)
+
+        # # Move objects to the center, for testing puprpose ONLY.
+        # for kk in [2]:
+            # object['vertices'][index][:,kk] -= np.mean(object['vertices'][index][:,kk])
+            
+        # Pass volumes to C
+        C_Phantom_Polygonal_SetPolygon(cfg, object['vertices'][index], object['num_triangles'][index], object['density'][index], object['materialId'][index])
+
+    # print('... done with phantom.')
+    return cfg
+
+def C_Phantom_Polygonal_Clear(cfg, num_polygons = None):
+    # print('Clearing the POLYGONAL phantom in C global variables.')
+    func = cfg.clib.clear_polygonalized_phantom
+    num_polygons = np.int32(num_polygons)
+    func.argtypes = [c_int]
+    func.restype = None
+    func(num_polygons)
+
+def C_Phantom_Polygonal_SetPolygon(cfg, vertices = None, numTriangles = None, density = None, ID = None):
+    # print(f'Setting a polygon in C global variables; density = {density}; ID = {ID}.')
+    # In nCAT_main.c: void pass_polygon_to_c(float *vertices, int num_triangles, float density, int ID)
+    func = cfg.clib.pass_polygon_to_c
+    func.argtypes = [ndpointer(c_float), c_int, c_float, c_int]
+    func.restype = None
+    func(vertices, numTriangles, density, ID)
+
+
+def set_material(cfg):
+    materialList = [
+        'ncat_water',
+        'ncat_muscle',
+        'ncat_lung',
+        'ncat_dry_spine',
+        'ncat_dry_rib',
+        'ncat_adipose',
+        'ncat_blood',
+        'ncat_heart',
+        'ncat_kidney',
+        'ncat_liver',
+        'ncat_lymph',
+        'ncat_pancreas',
+        'ncat_intestine',
+        'ncat_skull',
+        'ncat_cartilage',
+        'ncat_brain',
+        'ncat_spleen',
+        'ncat_iodine_blood',
+        'ncat_iron',
+        'ncat_pmma',
+        'ncat_aluminum',
+        'ncat_titanium',
+        'ncat_air',
+        'ncat_graphite',
+        'ncat_lead',
+        'ncat_breast_mammary',
+        'ncat_skin',
+        'ncat_iodine',
+        'ncat_eye_lens',
+        'ncat_ovary',
+        'ncat_red_marrow',
+        'ncat_yellow_marrow',
+        'ncat_testis',
+        'ncat_thyroid',
+        'ncat_bladder']
+    
+    Evec = cfg.spec.Evec
+    nMat = len(materialList)
+    Mus = np.zeros([Evec.size, nMat], dtype=np.double)
+    for i in range(nMat):
+        Mus[:, i] = GetMu(materialList[i], Evec)/10    # cm^-1 --> mm^-1
+
+    # in nCAT_main.c: void set_material_info_polygon(int materialCount, int eBinCount, double *muTable)
+    # the C func wants data order: materialIndex -> Ebin, so the dim is [Ebin, materialIndex]
+    fun = cfg.clib.set_material_info_polygon
+    fun.argtypes = [c_int, c_int, ndpointer(c_double)]
+    fun.restype = None
+    fun(nMat, Evec.size, Mus)
+    
+    return nMat, materialList
+

gecatsim/pyfiles/Phantom_Polygonal_ReadPolygon.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+from gecatsim.pyfiles.CommonTools import *
+
+def Phantom_Polygonal_ReadPolygon(Verts):
+    ddir = my_path.find_dir("phantom", "poly_bin")
+    filename = 'poly{}'.format(Verts)
+    with open(os.path.join(ddir, filename),'rb') as fid:
+        data_array = np.fromfile(fid, dtype=np.int32, count=4)
+        nv_sz1, nv_sz2, vx_sz1, vx_sz2 = data_array
+        tmp = np.fromfile(fid, dtype=np.float64)
+        nV = tmp[:nv_sz1*nv_sz2].reshape(nv_sz2,nv_sz1).T
+        Vx = tmp[nv_sz1*nv_sz2:].reshape(vx_sz2,vx_sz1).T
+
+    return Vx,nV
+
+def extract_polygonal_objects(file_path):
+    obj = {}
+    obj['vertices'] ={}
+    obj['type'] = {}
+    obj['materialId'] ={}
+    obj['density'] = {}
+    obj['num_triangles'] = {}
+    
+    with open(file_path, 'r') as file:
+        lines = [line.strip() for line in file.readlines()]
+        index = 0
+        j = 0
+        combined_polygons = []
+        while index < len(lines):
+            if index + 4 >= len(lines):
+                break
+            object_name = lines[index + 1]
+            material_index = int(lines[index + 2])
+            try:
+                num_polygons = int(lines[index + 3])
+            except ValueError:
+                print(f"Error: Number of polygons doesn't match the stated count in line {index + 3}")
+                break
+
+            all_polygon_vertices = []
+            for i in range(num_polygons):
+                read_line_of_coordinates = lines[index + 4 + i]
+                each_polygon_coordinates = [tuple(map(float, point.split(','))) for point in read_line_of_coordinates.split()]
+                all_polygon_vertices.append(each_polygon_coordinates)
+
+            obj['vertices'][j] = np.array(all_polygon_vertices, dtype='float32').reshape((num_polygons*3,3))
+            obj['type'][j] = object_name
+            obj['materialId'][j] = material_index
+            obj['density'][j] = 1
+            obj['num_triangles'][j]= num_polygons
+
+            j = j + 1
+
+            # move to next objects
+            index += 4 + num_polygons
+
+    return obj

gecatsim/pyfiles/Phantom_Voxelized.py

@@ -0,0 +1,120 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+from ctypes import *
+from numpy.ctypeslib import ndpointer
+from gecatsim.pyfiles.GetMu import GetMu
+from gecatsim.pyfiles.CommonTools import *
+
+def Phantom_Voxelized(cfg):
+    
+    ###----------- phantom file (vp file is json format)
+    cfg.phantom.filename = my_path.find('phantom', cfg.phantom.filename, '')
+    filepath, vpFilename = os.path.split(cfg.phantom.filename)
+    with open(cfg.phantom.filename) as fin:
+        vp = json.load(fin)
+        
+    ###----------- pass material Mu to C
+    materialList = vp['mat_name']
+    numberOfMaterials = vp['n_materials']
+    cfg.phantom.numberOfMaterials = numberOfMaterials
+    set_material(cfg, materialList)
+    
+    ###----------- pass volume info to C
+    # import matplotlib.pyplot as plt # Only needed for plots of phantom (below)
+
+    for i in range(numberOfMaterials):
+        dims = np.array([vp['cols'][i], vp['rows'][i], vp['slices'][i]], dtype=np.int32)
+        offsets = np.array([vp['x_offset'][i], vp['y_offset'][i], vp['z_offset'][i]], dtype=np.single)
+        voxelsize = np.array([vp['x_size'][i], vp['y_size'][i], vp['z_size'][i]], dtype=np.single)*cfg.phantom.scale
+        voxelsizeXY = voxelsize[0]
+        voxelsizeZ  = voxelsize[2]
+        
+        volumePathName = cfg.phantom.filename.replace(vpFilename, vp['volumefractionmap_filename'][i])
+        volumeData = rawread(volumePathName, [], vp['volumefractionmap_datatype'][i])
+        # if density_scale is set
+        if 'density_scale' in vp:
+            volumeData *= vp['density_scale'][i]
+        
+        '''
+        Offsets in .vp file indicate the index coordinate of the scanner origin (isocenter) relative to the edge of the phantom.
+        DD Proj expects an offset (in mm) between the phantom voxel grid center and the scanner isocenter
+        Here we fix the offsets to be what DD Proj expects
+        '''
+        offsets = ((np.single(dims)+1)/2-offsets)*voxelsize + np.array(cfg.phantom.centerOffset, dtype=np.single)
+
+        ###------- prepair data for setting volume in C
+        volumeDims = np.append(dims, np.int32(numberOfMaterials))
+        xyMask = np.ones((dims[1]*2, dims[0]), dtype=np.uint8)
+        
+        # The order of bin data of CatSim phantom file is x -> y -> z
+        # when python reads it, the matrix dim becomes [z, y, x]
+        # And the C func wants data order: z -> x -> y
+        # Note: numpy array starts from the last dim, and when transposed, .ravel is needed, or the order will not change.
+        
+        volumeData = volumeData.reshape(dims[2], dims[1], dims[0])
+        volumeData = np.transpose(volumeData, (1, 2, 0)).ravel()
+        volumeData = volumeData.astype(np.float32)
+
+        # # Plot slice 0 for each material
+        # plt.figure(i)
+        # plt.imshow(volumeData.reshape(dims[2], dims[1], dims[0])[0], cmap='gray')
+        # plt.title(materialList[i])
+
+        materialIndex = i+1        
+        set_voxelized_volume(cfg, volumeData, volumeDims, offsets, voxelsize, xyMask, materialIndex, numberOfMaterials)
+    
+    # plt.pause(1)
+    # print('*******************************************')
+    # print('* Press Enter to close plots and continue *')
+    # input('*******************************************')
+    # plt.close('all')
+
+    return cfg
+
+def set_material(cfg, materialList):
+    Evec = cfg.spec.Evec
+    nMat = len(materialList)
+    Mus = np.zeros([Evec.size, nMat], dtype=np.single)
+    for i in range(nMat):
+        Mus[:, i] = GetMu(materialList[i], Evec)/10 # cm^-1 --> mm^-1
+        
+    # the C func wants data order: materialIndex -> Ebin, so the dim is [Ebin, materialIndex]
+    fun = cfg.clib.set_material_info_vox
+    fun.argtypes = [c_int, c_int, ndpointer(c_float)]
+    fun.restype = None
+    fun(nMat, Evec.size, Mus)
+
+def set_voxelized_volume(cfg, volumeData, volumeDims, offsets, voxelsize, xyMask, materialIndex, numberOfMaterials):
+    if hasattr(cfg.phantom, "useUInt16") and cfg.phantom.useUInt16:
+        fun = cfg.clib.set_phantom_info_vox_uint16
+        fun.argtypes = [POINTER(c_int), ndpointer(c_ushort), ndpointer(c_int), \
+            c_float, c_float, c_float, c_float, c_float, ndpointer(c_ubyte), c_int, c_int]
+
+        # convert data to uint16
+        volumeData = np.ushort(np.round(volumeData*10000))
+    else:
+        fun = cfg.clib.set_phantom_info_vox
+        fun.argtypes = [POINTER(c_int), ndpointer(c_float), ndpointer(c_int), \
+            c_float, c_float, c_float, c_float, c_float, ndpointer(c_ubyte), c_int, c_int]
+    fun.restype = None
+    
+    Status = [0]
+    Status = (c_int*1)(*Status)
+    fun(Status, volumeData, volumeDims, \
+        offsets[0], offsets[1], offsets[2], voxelsize[0], voxelsize[2], xyMask, materialIndex, numberOfMaterials)
+    
+    if Status[0] == -1:
+        print("*** Error %d in set_phantom_info_vox: memory allocation error!" % Status[0])
+    elif Status[0] == -2:
+        print("*** Error %d in set_phantom_info_vox: Not have enough system memory for voxelized phantom!" % Status[0])
+
+
+# if __name__ == "__main__":
+#     cfg = source_cfg("./cfg/default.cfg")
+#     cfg.phantom.filename = 'BIG.json'
+#
+#     cfg = feval(cfg.scanner.detectorCallback, cfg)
+#     cfg = feval(cfg.scanner.focalspotCallback, cfg)
+#     cfg = feval(cfg.protocol.spectrumCallback, cfg)
+#
+#     cfg = Phantom_Voxelized(cfg)

gecatsim/pyfiles/PrepView.py

@@ -0,0 +1,56 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+# This is raw-data prep for EICT or gray-scale CT only. Use other code to prep spectral CT / PCCT.
+
+import numpy.matlib as nm
+from gecatsim.pyfiles.CommonTools import *
+from gecatsim.pyfiles.LowSignalCorr import LowSignalCorr
+
+def prep_view(cfg):
+    
+    ###--------- read scan data
+    if hasattr(cfg.det, "totalNumCells"):
+        totalNumCells = cfg.det.totalNumCells
+    else:
+        totalNumCells = cfg.scanner.detectorColCount*cfg.scanner.detectorRowCount
+    airscan = rawread(cfg.resultsName+'.air', [cfg.protocol.airViewCount, totalNumCells], 'float')
+    offsetScan = rawread(cfg.resultsName+'.offset', [cfg.protocol.offsetViewCount, totalNumCells], 'float')
+    phantomScan = rawread(cfg.resultsName+'.scan', [cfg.protocol.viewCount, totalNumCells], 'float')
+
+    if cfg.protocol.airViewCount==1:
+        airscan = nm.repmat(airscan, cfg.protocol.viewCount, 1)
+    if cfg.protocol.offsetViewCount==1:
+        offsetScan = nm.repmat(offsetScan, cfg.protocol.viewCount, 1)
+        
+    ###--------- pre-log
+    if hasattr(cfg.physics, "callback_pre_log") and cfg.physics.callback_pre_log:
+        airscan, offsetScan, phantomScan = feval(cfg.physics.callback_pre_log, cfg, airscan, offsetScan, phantomScan)
+    
+    
+    ###--------- log
+    prep = (phantomScan-offsetScan)/(airscan-offsetScan)
+    
+    ### simple low-signal correction and -log
+    #smallValue = 1e-12
+    #prep[prep<smallValue] = smallValue
+    #prep = -np.log(prep)
+    
+    ### signal-domain low-signal correction and -log
+    prep = LowSignalCorr(cfg, prep)
+    prep[prep<0] = 0
+    
+    
+    ###--------- post-log
+    # BHC and so furth
+    if hasattr(cfg.physics, "callback_post_log") and cfg.physics.callback_post_log:
+        prep = feval(cfg.physics.callback_post_log, cfg, prep)
+        
+    # a simple p-domain low-signal correction, further limiting mu values if desired
+    if cfg.protocol.maxPrep>0:
+        prep[prep>cfg.protocol.maxPrep] = cfg.protocol.maxPrep
+        
+    ###--------- save prep
+    fname = cfg.resultsName + '.prep'
+    rawwrite(fname, prep)
+
+    return cfg

gecatsim/pyfiles/Prep_BHC_Accurate.py

@@ -0,0 +1,69 @@
+import os
+import copy
+import numpy as np
+from gecatsim.pyfiles.CommonTools import rawread
+
+def Prep_BHC_Accurate(cfg, prep):
+    print("Applying Beam Hardening Correction (ACCURATE BHC)...", end='')
+    
+    if hasattr(cfg.physics, "BHC_vec_fname"):
+        if os.path.isfile(cfg.physics.BHC_vec_fname):
+            poly_coef = np.load(cfg.physics.BHC_vec_fname)
+        else:
+            poly_coef = gen_BHC_vec(cfg)
+    else:
+        poly_coef = gen_BHC_vec(cfg)
+
+    num_poly_coefs = cfg.physics.BHC_poly_order+1
+    for viewId in range(cfg.protocol.viewCount):
+        view_out = poly_coef[:, 0]
+        for i in range(1, num_poly_coefs):
+            view_out = view_out*prep[viewId] + poly_coef[:,i]
+
+        prep[viewId] = view_out
+
+    print("done.\n")
+    return prep
+
+def gen_BHC_vec(cfg):
+
+    from gecatsim.pyfiles.CatSim import CatSim
+    ct = CatSim()
+    ct.cfg_to_self(cfg)
+
+    poly_order = ct.physics.BHC_poly_order
+    num_poly_coefs = poly_order+1
+
+    if not hasattr(ct.physics, "BHC_material") or ct.physics.BHC_material == "":
+        mt = "water"
+    else:
+        mt = ct.physics.BHC_material
+
+    max_length_mm = ct.physics.BHC_max_length_mm
+    length_step_mm = ct.physics.BHC_length_step_mm
+    num_length = int(max_length_mm/length_step_mm)
+
+    ndet = ct.scanner.detectorColCount*ct.scanner.detectorRowCount
+    sig = np.zeros((num_length, ndet))
+
+    mtViews = rawread(ct.resultsName+".air", [ndet], 'float')
+    I0 = mtViews
+
+    orginal_prefilter = copy.copy(ct.scanner.detectorPrefilter)
+    for j in range(num_length):
+        thick = (1+j)*length_step_mm
+
+        ct.scanner.detectorPrefilter = orginal_prefilter + [mt, thick]
+        ct.air_scan(doPrint=False)
+        rawViews = rawread(ct.resultsName+".air", [ndet], 'float')
+        sig[j] = -np.log(rawViews/I0)
+
+    ct.scanner.detectorPrefilter = orginal_prefilter
+    ct.air_scan()
+
+    dessig = ct.physics.EffectiveMu*length_step_mm/10*(1+np.arange(num_length))
+    poly_coef = np.zeros((ndet, num_poly_coefs))
+    for n in range(ndet):
+        poly_coef[n] = np.polyfit(sig[:,n], dessig, poly_order)
+
+    return poly_coef

gecatsim/pyfiles/ReadMaterialFile.py

@@ -0,0 +1,29 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+def ReadMaterialFile(mtFile):
+    # read material file
+    d0 = []
+    for line in open(mtFile, 'r', encoding='UTF-8'):
+        line = line.strip() # remove the end '\n'
+        if line and line[0].isdigit():
+            d0.append(line)
+
+    numberOfElements = int(d0[0])
+    density = float(d0[1])
+    atomicNumbers = []
+    massFractions = []
+    for ii in range(2, 2+numberOfElements):
+        d1 = d0[ii].split()
+        atomicNumbers.append(int(d1[0]))
+        massFractions.append(float(d1[1]))
+        
+    # normalize mass fraction
+    massSum = sum(massFractions)
+    for ii in range(0, len(massFractions)):
+        massFractions[ii] /= massSum
+
+    return numberOfElements, density, atomicNumbers, massFractions
+
+# if __name__ == '__main__':
+#     (numberOfElements, density, atomicNumbers, massFractions) = ReadMaterialFile('water')
+#     print(numberOfElements, density, atomicNumbers, massFractions)

gecatsim/pyfiles/Scatter_ConvolutionModel.py

@@ -0,0 +1,44 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+from gecatsim.pyfiles.CommonTools import *
+
+
+# This is a simplified kernel based scatter model, will have roughly 15% SPR for 35-cm water phantom, 120 kVp, 40-mm beam width.
+def Scatter_ConvolutionModel(cfg, viewId, subViewId):
+    epsilon = 1.E-10
+    # Get scatter kernel
+    if viewId == cfg.sim.startViewId and subViewId == 0:
+        if cfg.physics.scatterKernelCallback:
+            cfg.scatter_kernel = feval(cfg.physics.scatterKernelCallback, cfg)
+        else:
+            cfg.scatter_kernel = get_scatter_kernel()
+            
+    # Scatter is low frequency signal and computational expensive, we only calculate it at the first subview.
+    if subViewId == 0:
+        _prep = cfg.thisSubView.sum(1)/cfg.detFlux.sum(1)
+        _prep[_prep<epsilon] = epsilon
+        prep = -np.log(_prep)
+        if not hasattr(cfg.physics, "scatterScaleFactor"):
+            cfg.physics.scatterScaleFactor = 1
+        sc_preConv = cfg.thisSubView.sum(1)*prep*0.025*cfg.physics.scatterScaleFactor
+        sc_preConv = sc_preConv.reshape(cfg.scanner.detectorColCount, cfg.scanner.detectorRowCount)
+        sc_conv = conv2(sc_preConv, cfg.scatter_kernel, 'same')
+        
+        sc_conv = sc_conv.reshape(sc_conv.size,1)
+        spec = cfg.thisSubView.mean(0)
+        spec /= spec.sum()
+        spec = spec.reshape(1,spec.size)
+        sc_conv_spec = sc_conv @ spec
+        
+        cfg.scatter_view = sc_conv_spec
+        
+    cfg.thisSubView += cfg.scatter_view
+    
+    return cfg
+
+def get_scatter_kernel():
+    scatterDataFile = my_path.find("scatter", "scatter_kernel.dat", "")
+    h = rawread(scatterDataFile, [49,65], 'float')
+    h = h/np.sum(h)    
+    return h
+