catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/pyfiles/Xray_Filter.py

@@ -0,0 +1,93 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+import numpy as np
+from scipy import interpolate
+from gecatsim.pyfiles.GetMu import GetMu
+from gecatsim.pyfiles.CommonTools import *
+
+def Xray_Filter(cfg):
+    '''
+    Calculate the transmittance of flat and bowtie filters
+    return cfg.src.filterTrans, dim [totalNumCells, Ebin]
+    Mingye Wu, GE Research
+    
+    '''
+    cfg.src.filterTrans = np.ones([cfg.det.totalNumCells, cfg.spec.nEbin], dtype=np.single)
+    cfg = flat_filter(cfg)
+    cfg = bowtie_filter(cfg)
+    
+    return cfg
+
+def flat_filter(cfg):
+    '''
+    Apply the transmittance of flat filter at source side, dim: [Ebin, totalNumCells]
+    '''
+    cosineFactors = 1/np.cos(cfg.det.gammas)/np.cos(cfg.det.alphas)
+    
+    Evec = cfg.sim.Evec
+    trans = np.ones([cfg.det.totalNumCells, cfg.spec.nEbin], dtype = np.single)
+    
+    if hasattr(cfg.protocol, "flatFilter"):
+        for ii in range(0, round(len(cfg.protocol.flatFilter)/2)):
+            material = cfg.protocol.flatFilter[2*ii]
+            depth = cfg.protocol.flatFilter[2*ii+1]
+            mu = GetMu(material, Evec)
+            trans *= np.exp(-depth*0.1*cosineFactors @ mu.reshape(1, mu.size))
+    cfg.src.filterTrans *= trans
+    
+    return cfg
+
+def bowtie_filter(cfg):
+    '''
+    Apply the transmittance of bowtie filter, dim: [Ebin, totalNumCells]
+    '''
+    if not cfg.protocol.bowtie:
+        return cfg
+    
+    # find bowtie file
+    bowtieFile = my_path.find("bowtie", cfg.protocol.bowtie, ".txt")
+
+    # read bowtie file
+    data = np.loadtxt(bowtieFile, dtype=np.single, comments=['#', '%'])
+    
+    gammas0 = data[:, 0]
+    t0 = data[:, 1:] # thickness in cm
+    bowtieMaterials = ['Al', 'graphite', 'Cu', 'Ti']
+    
+    Evec = cfg.spec.Evec
+    gammas1 = cfg.det.gammas
+    
+    muT = 0
+    for i in range(len(bowtieMaterials)):
+        mu = GetMu(bowtieMaterials[i], Evec)
+        f = interpolate.interp1d(gammas0, t0[:, i], kind='linear', fill_value='extrapolate')
+        t1 = f(gammas1)/np.cos(cfg.det.alphas)
+        muT += t1 @ mu.reshape(1, mu.size)
+    
+    trans = np.exp(-muT)
+    cfg.src.filterTrans *= trans
+    
+    return cfg
+
+# if __name__ == "__main__":
+#     import matplotlib.pyplot as plt
+#     cfg = source_cfg("./cfg/default.cfg")
+#
+#     cfg = feval(cfg.scanner.detectorCallback, cfg)
+#     cfg = feval(cfg.scanner.focalspotCallback, cfg)
+#     cfg = feval(cfg.physics.rayAngleCallback, cfg)
+#     cfg = feval(cfg.protocol.spectrumCallback, cfg)
+#
+#     cfg.protocol.bowtie = 'medium'
+#     cfg.protocol.flatFilter = ['al', 0.1, 'water', 2]
+#
+#     cfg = Xray_Filter(cfg)
+#     trans = cfg.src.filterTrans.reshape(cfg.scanner.detectorColCount, cfg.scanner.detectorRowCount, cfg.spec.nEbin)
+#     check_value(trans)
+#     plt.plot(trans[:, 7, 8])
+#     plt.show()
+    
+    
+    
+    
+    

gecatsim/pyfiles/catvoxel.py

@@ -0,0 +1,161 @@
+# Copyright 2025, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+"""
+-----------------------------------------------------------------------
+convert analytic, ncat, or polygonal phantoms to voxelized phantom
+
+Authors
+  Mingye Wu (GE Global Research)
+  Jiayong Zhang
+
+-----------------------------------------------------------------------
+"""
+
+import os
+import numpy as np
+import gecatsim as xc
+import json
+from collections import defaultdict
+from gecatsim.pyfiles.GetMu import GetMu
+from gecatsim.pyfiles.CommonTools import *
+
+def dumpjson(filename, jsondict):
+    out_file = open(filename, "w") 
+    json.dump(jsondict, out_file, indent = 4) 
+    out_file.close()
+
+def catvoxel(cfg):
+
+    if not hasattr(cfg, "material_volumes"):
+        cfg.material_volumes = 0
+    if cfg.material_volumes:
+        print('Multiple volumes of material volume fractions will be produced.')
+        if cfg.write_vp:
+            print('Voxelized phantom files will be written.')
+        else:
+            print('Voxelized phantom files will not be written.')
+    else:
+        if hasattr(cfg, "make_img_kv"):
+            cfg.spec.Evec = np.array(cfg.make_img_kv)
+        else:
+            cfg.spec.Evec = np.array([120])
+
+        print(f"A single volume of attenuation coefficients will be produced.\nAttenuation coefficients will be determined at {cfg.make_img_kv} keV.")
+
+    # PHANTOM 
+    cfg = feval(cfg.phantom.callback, cfg)
+    Materials = cfg.phantom.Materials
+    NumberOfMaterials = cfg.phantom.numberOfMaterials
+
+    cfg.Nx = cfg.recon.imageSize
+    cfg.Ny = cfg.recon.imageSize
+    cfg.Nz = cfg.recon.sliceCount
+    cfg.dx = cfg.recon.fov / cfg.recon.imageSize
+    cfg.dy = cfg.recon.fov / cfg.recon.imageSize
+    cfg.dz = cfg.recon.sliceThickness
+    cfg.xoff = -cfg.recon.centerOffset[0] / cfg.dx + (cfg.Nx + 1) / 2
+    cfg.yoff = -cfg.recon.centerOffset[1] / cfg.dy + (cfg.Ny + 1) / 2
+    cfg.zoff = -cfg.recon.centerOffset[2] / cfg.dz + (cfg.Nz + 1) / 2
+    print('Phantom setup updated:')
+    PrintPhantomSetup(cfg)
+
+    print(f'Oversampling = {cfg.vol_os}')
+
+    # VOLUMES
+    if cfg.material_volumes:
+        print(f'Producing volume fraction volumes for {NumberOfMaterials} materials.')
+    else:
+        print('Producing a single volume of attenuation coefficients.')
+        NumberOfMaterials = 1
+
+    Volume = np.zeros((NumberOfMaterials, cfg.Nz, cfg.Ny, cfg.Nx), dtype=np.single)
+    Volume = MakeAllVolumes(Volume, cfg, NumberOfMaterials, cfg.material_volumes)
+    Volume = np.transpose(Volume, axes=[3, 2, 1, 0])
+
+    # Flip the volume top-to-bottom so it will be in the "file" format of decreasing Y value with increasing Y index.
+    Volume_YFlipped = np.flip(Volume, axis=1)
+
+    Directory, PhantomExtension = os.path.splitext(cfg.phantom.filename)
+    FileName = os.path.basename(Directory)
+
+    # to avoid the case when phantom is in python library, the output will be saved there
+    base_phantom_name = os.path.basename(cfg.phantom.filename)
+    if cfg.material_volumes and cfg.write_vp:
+        vp_json = defaultdict(list)
+        nonzero_materials = 0
+        # Write a .vp file and material density volume file(s)
+        VoxelizedPhantomPathname = base_phantom_name.replace(PhantomExtension, '.json')
+        print(f'Writing {VoxelizedPhantomPathname} and material volume fraction file(s)...')
+        # this line needs to be here so that in json file, the position of n_materials is right
+        vp_json['n_materials'] = 0
+        for MaterialIndex in range(NumberOfMaterials):
+
+            # ignore this material if all zero
+            if np.sum(Volume[:,:,:,MaterialIndex]) < 1.E-4: continue
+
+            nonzero_materials += 1
+
+            VolumeExtension = f'VolumeFraction_{Materials[MaterialIndex]}'
+            VolumePathname = VoxelizedPhantomPathname.replace('.json', f'.{VolumeExtension}')
+            Path, Filename = os.path.splitext(VolumePathname)
+            VolumeFilename = Filename + PhantomExtension
+            print(f'    writing material volume fraction file for {VolumeExtension}')
+
+            tmpArr = np.transpose(Volume_YFlipped[:, :, :, MaterialIndex], axes=[2, 1, 0])
+            xc.rawwrite(VolumePathname, np.copy(tmpArr, order='C'))
+
+            print(f'    writing data for {VolumeExtension} to {VoxelizedPhantomPathname}')
+            vp_json['mat_name'].append(f'{Materials[MaterialIndex]}')
+            vp_json['volumefractionmap_filename'].append(VolumePathname)
+            vp_json['volumefractionmap_datatype'].append('float')
+            vp_json['cols'].append(cfg.Nx)
+            vp_json['rows'].append(cfg.Ny)
+            vp_json['slices'].append(cfg.Nz)
+            vp_json['x_size'].append(cfg.dx)
+            vp_json['y_size'].append(cfg.dy)
+            vp_json['z_size'].append(cfg.dz)
+            vp_json['x_offset'].append(cfg.xoff)
+            vp_json['y_offset'].append(cfg.yoff)
+            vp_json['z_offset'].append(cfg.zoff)
+
+        vp_json['n_materials'] = nonzero_materials
+        dumpjson(VoxelizedPhantomPathname, vp_json)
+        print('... done writing files.')
+    else:
+        # Write attenuation coefficient volume to a .vol file
+        VoxelizedPhantomPathname = base_phantom_name.replace(PhantomExtension, '.mu')
+        print(f'Writing attenuation coefficients volume to {VoxelizedPhantomPathname}')
+        with open(VoxelizedPhantomPathname, 'wb') as f:
+            Volume_YFlipped.tofile(f)
+
+
+def MakeAllVolumes(Volume, cfg, NumberOfMaterials, MakeMaterialVolumes):
+    switch_function = {
+        'C_Projector_Analytic': 'C_Volume_Get',
+        'C_Projector_NCAT': 'C_Volume_NCAT_Get',
+        'C_Projector_Polygon': 'C_Volume_Poly_Get'
+    }
+
+    FunctionName = switch_function.get(cfg.phantom.projectorCallback, None)
+    if FunctionName is None:
+        raise ValueError(f"Error: CatVoxel not compatible with the projector_callback {cfg.phantom.projectorCallback}")
+
+    Volume = feval(FunctionName, cfg, 
+        Volume, cfg.Nx, cfg.xoff, cfg.dx,
+        cfg.Ny, cfg.yoff, cfg.dy,
+        cfg.Nz, cfg.zoff, cfg.dz,
+        cfg.vol_os, NumberOfMaterials, MakeMaterialVolumes
+    )
+
+    return Volume
+
+def PrintPhantomSetup(cfg):
+    print(f'Number of X voxels: cfg.Nx   = {cfg.Nx}')
+    print(f'Number of Y voxels: cfg.Ny   = {cfg.Ny}')
+    print(f'Number of Z voxels: cfg.Nz   = {cfg.Nz}')
+    print(f'X voxel size: cfg.dx  = {cfg.dx}')
+    print(f'Y voxel size: cfg.dy  = {cfg.dy}')
+    print(f'Z voxel size: cfg.dz  = {cfg.dz}')
+    print(f'X voxel offset: cfg.xoff = {cfg.xoff}')
+    print(f'Y voxel offset: cfg.yoff = {cfg.yoff}')
+    print(f'Z voxel offset: cfg.zoff = {cfg.zoff}')
+

gecatsim/pyfiles/randpf.py

@@ -0,0 +1,27 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+from numpy.ctypeslib import ndpointer
+from gecatsim.pyfiles.CommonTools import *
+
+#----------------- load C lib
+clib = load_C_lib()
+fun = clib.rndpoi
+fun.argtypes = [ndpointer(ctypes.c_float), ctypes.c_int]
+fun.restype = None
+
+def randpf(arr):
+    # numpy array only
+    arr1 = arr[arr>0]
+    fun(arr1, arr1.size)
+    arr[arr>0] = arr1
+    
+    return arr
+
+# if __name__ == '__main__':
+#     data0 = np.float32(np.random.random([5, 4])*100)
+#     data0[1:4, 1:3] = 0
+#
+#     check_value(data0)
+#     data1 = randpf(data0)
+#     check_value(data0)
+#     check_value(data1)

gecatsim/reconstruction/lib/readme.md

@@ -0,0 +1,20 @@
+
+# How to compile recon lib
+
+# For Linux
+Go to the `reconstruction\src` folder and run following command:
+
+`gcc -fPIC -fopenmp -shared -o fdk_equiAngle.so interface_fdk_angle.c`
+
+This will generate a `fdk_equiAngle.so` file and copy it to your `reconstruction\lib` folder.
+
+# For Mac OS
+Same as for Linux but make sure to use the "gcc" compiler and not the "clang" compiler.
+
+You may need to install gcc manually (e.g., brew install gcc).
+If needed, specify the full path to the gcc compiler when compiling, e.g.:
+
+`/usr/local/bin/gcc-14 -fPIC -fopenmp -shared -o fdk_equiAngle_macos.so interface_fdk_angle.c`
+
+# For Windows
+in cmd, run `xxx\mingw64\bin\gcc.exe -Wall -O -g -fPIC -shared -o fdk_equiAngle.dll .\interface_fdk_angle.c `

gecatsim/reconstruction/pyfiles/createHSP.py

@@ -0,0 +1,81 @@
+# Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+import numpy as np
+import math
+from scipy.interpolate import interp1d
+
+def createHSP(Length, kernelType):
+    HS = np.zeros(Length)
+    Center = int((Length) / 2)
+    PI = 3.14159265358979
+    nn = Length
+    nn2 = nn * 2
+
+    if kernelType == "R-L":
+        HS[0] = 0
+        HS[Center] = 0.25
+        for i in range(1, Center):
+            HS[i] = -np.power((math.sin(PI * (i - Center) / 2)), 2) / (PI * PI * (i - Center) * (i - Center))
+
+        for k in range((Center + 1), Length):
+            HS[k] = -np.power((math.sin(PI * (k - Center) / 2)), 2) / (PI * PI * (k - Center) * (k - Center))
+        k = int(nn / 2)
+        TempF = np.zeros(nn2)
+        TempF[0:k] = HS[k:nn]
+        TempF[k + nn:nn2] = HS[0:k]
+        HS = TempF * complex(0, 1)
+        FFT_F = np.fft.fft(HS)
+
+    elif kernelType == "S-L":
+        for i in range(Length):
+            HS[i] = -2 / (PI * PI * (4 * (i - Center) * (i - Center) - 1))
+        k = int(nn / 2)
+        TempF = np.zeros(nn2)
+        TempF[0:k] = HS[k:nn]
+        TempF[k + nn:nn2] = HS[0:k]
+        HS = TempF * complex(0, 1)
+        FFT_F = np.fft.fft(HS)
+
+    elif kernelType == "soft":
+        x = np.array([0, 0.25, 0.5, 0.75, 1])
+        y = np.array([1, 0.815, 0.4564, 0.1636, 0])
+        # y = np.array([1, 1.0485, 1.17, 1.2202, 0.9201])
+        # y= np.array([1, 0.9338, 0.7441, 0.4425, 0.0531])
+        f = interp1d(x, y, kind='quadratic')
+        FFT_F = np.zeros(nn2)
+        for i in range(nn):
+            FFT_F[i] = f((i)/nn)*0.997 * (i+0.003) / nn2
+            FFT_F[nn2 - i - 1] = f((i)/nn)* 0.997*(i + 1 + 0.003) / nn2
+        FFT_F= FFT_F * complex(0,1)
+
+    elif kernelType == "standard":
+        x = np.array([0, 0.25, 0.5, 0.75, 1])
+        # y = np.array([1, 0.815, 0.4564, 0.1636, 0])
+        # y = np.array([1, 1.0485, 1.17, 1.2202, 0.9201])
+        y = np.array([1, 0.9338, 0.7441, 0.4425, 0.0531])
+        f = interp1d(x, y, kind='quadratic')
+        FFT_F = np.zeros(nn2)
+        for i in range(nn):
+            FFT_F[i] = f((i) / nn) * 0.997 * (i + 0.003) / nn2
+            FFT_F[nn2 - i - 1] = f((i) / nn) * 0.997 * (i + 1 + 0.003) / nn2
+        FFT_F = FFT_F * complex(0, 1)
+
+    elif kernelType == "bone":
+        x = np.array([0, 0.25, 0.5, 0.75, 1])
+        # y = np.array([1, 0.815, 0.4564, 0.1636, 0])
+        y = np.array([1, 1.0485, 1.17, 1.2202, 0.9201])
+        # y = np.array([1, 0.9338, 0.7441, 0.4425, 0.0531])
+        f = interp1d(x, y, kind='quadratic')
+        FFT_F = np.zeros(nn2)
+        for i in range(nn):
+            FFT_F[i] = f((i) / nn) * 0.997 * (i + 0.003) / nn2
+            FFT_F[nn2 - i - 1] = f((i) / nn) * 0.997 * (i + 1 + 0.003) / nn2
+        FFT_F = FFT_F * complex(0, 1)
+
+    elif kernelType == "none":
+        FFT_F = np.ones(nn2) * complex(0, 1)
+
+    else: 
+        raise Exception("******** Error! An unsupported kernel was specified: {:s}. ********".format(kernelType))
+
+    return FFT_F

gecatsim/reconstruction/pyfiles/fdk_equiAngle.py

@@ -0,0 +1,245 @@
+# Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+import ctypes as ct
+import math
+from gecatsim.reconstruction.pyfiles.createHSP import createHSP
+from gecatsim.reconstruction.pyfiles.mapConfigVariablesToFDK import mapConfigVariablesToFDK
+from gecatsim.pyfiles.CommonTools import *
+
+# Init ctypes types
+FLOAT = ct.c_float
+PtrFLOAT = ct.POINTER(FLOAT)
+PtrPtrFLOAT = ct.POINTER(PtrFLOAT)
+PtrPtrPtrFLOAT = ct.POINTER(PtrPtrFLOAT)
+
+
+class TestStruct(ct.Structure):
+    _fields_ = [
+                ("ScanR", ct.c_float),         # Radius of the scanning trajectory of x-ray source
+                ("DecFanAng", ct.c_float),     # Fan angle coverage of the detector element along the horizontal diretion
+                ("startangle", ct.c_float),     # recon startangle
+                ("rotdir", ct.c_int), # //rotation direction
+                ("DecHeight", ct.c_float),      # Physical height of the detector along the vertical direction
+                ("YL", ct.c_int),               # Detector cell number on each row along the horizontal direction
+                ("ZL", ct.c_int),               # Detector cell number on each column along the vertical direction
+                ("dectorYoffset", ct.c_float),               # Detector along the horizontal direction (pixel, e.g. quarter pixel)
+                ("dectorZoffset", ct.c_float),               # Detector offset along the vertical direcion (pixel, e.g. quarter pixel)
+                ("XOffSet", ct.c_float),       # recon offset along the x axis
+                ("YOffSet", ct.c_float),       # recon offset along the y axis
+                ("ZOffSet", ct.c_float),       # recon offset along the z axis
+                ("phantomXOffSet", ct.c_float),  # phantom offset along the x axis
+                ("phantomYOffSet", ct.c_float),  # phantom offset along the y axis
+                ("phantomZOffSet", ct.c_float),  # phantom offset along the z axis
+                ("AngleNumber", ct.c_int),      # Number of view samples on the scanning trajectory
+                ("DistD", ct.c_float),         # Distance between the x-ray source and the detector
+                ("Radius", ct.c_float),        # Radius of the phantom
+                ("RecSize", ct.c_int),          # Reconstructed size
+                ("sliceThickness", ct.c_float),   # Reconstructed thickness
+#                 ("centerX", ct.c_float),          # Reconstructed center on x axis
+#                 ("centerY", ct.c_float),          # Reconstructed center on y axis
+#                 ("centerZ", ct.c_float),          # Reconstructed center on z axis
+                ("FOILength", ct.c_int),        # Reconstructed length on x axis
+                ("FOIWidth", ct.c_int),         # Reconstructed length on y axis
+                ("FOIHeight", ct.c_int),         # Reconstructed length on z axis
+                ("GF", PtrPtrPtrFLOAT),        # Projection data/ Sinogram data
+                ("RecIm", PtrPtrPtrFLOAT)      # Reconstructed 3D image data
+                ]
+
+
+def float3Darray2pointer(arr):
+    # Converts a 3D numpy to ctypes 3D array.
+    arr_dimx = FLOAT * arr.shape[2]
+    arr_dimy = PtrFLOAT * arr.shape[1]
+    arr_dimz = PtrPtrFLOAT * arr.shape[0]
+
+    arr_ptr = arr_dimz()
+
+    for i, row in enumerate(arr):
+        arr_ptr[i] = arr_dimy()
+        for j, col in enumerate(row):
+            arr_ptr[i][j] = arr_dimx()
+            for k, val in enumerate(col):
+                arr_ptr[i][j][k] = val
+    return arr_ptr
+
+
+def float3Dpointer2array(ptr, n, m, o):
+    # Converts ctypes 3D array into a 3D numpy array.
+    arr = np.zeros(shape=(n, m, o), dtype=np.single)
+
+    for i in range(n):
+        for j in range(m):
+            for k in range(o):
+                arr[i, j, k] = ptr[i][j][k]
+
+    return arr
+
+
+def load_C_recon_lib():
+
+    # add recon lib path to environment value "PATH" for depending DLLs
+    # # # # recon_lib = my_path.find_dir("top", os.path.join("reconstruction", "lib"))
+    # # # # my_path.add_dir_to_path(recon_lib)
+    
+    #  my_path.find_dir doesn't have the key "reconstruction", use the temp solution below:
+    recon_lib = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../lib")
+    
+
+    # load C/C++ lib
+    ll = ct.cdll.LoadLibrary
+    if os.name == "nt":
+        lib_file = "fdk_equiAngle.dll"
+    elif os.uname().sysname == 'Darwin':
+        lib_file = "fdk_equiAngle_macos.so"
+    else:
+        lib_file = "fdk_equiAngle.so"
+    clib = ll(os.path.join(recon_lib, lib_file))
+    
+    return clib
+
+
+def fdk_equiAngle(cfg, prep):
+
+    # scanner & recon geometry
+    sid, sdd, nMod, rowSize, modWidth, dectorYoffset, dectorZoffset, \
+    fov, imageSize, sliceCount, sliceThickness, centerOffset, startView, rotdir, kernelType      \
+        = mapConfigVariablesToFDK(cfg)
+
+    # initialize parameters
+    ScanR = sid
+    DistD = sdd
+    Radius = fov/2
+    ProjData = prep.transpose(2,1,0)
+    # ProjData = ProjData[::-1,:,:]
+    ProjScale = cfg.protocol.viewsPerRotation
+    DecFanAng = nMod*2*math.atan(modWidth/2/sdd)
+    Dgy = np.array(ProjData, dtype=np.float32)
+    YL = int(cfg.scanner.detectorColCount)
+    ZL = int(cfg.scanner.detectorRowCount)
+
+    YCtr = (YL - 1) * 0.5
+    ZCtr = (ZL - 1) * 0.5
+    DecHeight = rowSize*ZL
+    
+    DeltaUW = DecFanAng/ YL
+    DeltaZ = DecHeight / ZL
+    
+    
+    ############## pre-weighting for ramp-filter
+
+    print("* Pre-weighting the filter...")
+    for Yindex in range(YL):
+        for zindex in range(ZL):
+            Dgy[Yindex, zindex, :] = (DistD / np.sqrt(DistD ** 2 + ((zindex - ZCtr) * DeltaZ) ** 2)) * ProjData[Yindex,
+                                    zindex,:] * math.cos((Yindex - YCtr) * DeltaUW)
+
+    Dg=Dgy
+
+    ############## filtering
+
+    print("* Applying the filter...")
+    nn = int(math.pow(2, (math.ceil(math.log2(abs(YL))) + 1)))
+    nn2 = nn*2
+    FFT_F = createHSP(nn, kernelType)
+
+    GF = Dg
+
+    for ProjIndex in range(0, ProjScale):
+        for j in range(ZL):
+            TempData = np.ones(YL)
+            for k in range(YL):
+                TempData[k] = Dg[k, j, ProjIndex]
+            FFT_S = np.fft.fft(TempData, nn2)
+            TempData = np.fft.ifft(FFT_S * FFT_F).imag
+            for k in range(YL):
+                GF[k, j, ProjIndex] = -TempData[k]
+    
+    GF = GF/DeltaUW
+    
+    # special case when ZL is 1
+    if ZL == 1:
+        GF = np.append(GF, GF, axis=1)
+        ZL = 2
+
+
+    ############## FBP
+ 
+    print("* Running the reconstruction...")
+    # Load the compiled library
+    recon = load_C_recon_lib()
+
+    # Define arguments of the C function
+    recon.fbp.argtypes = [ct.POINTER(TestStruct)]
+
+    # Define the return type of the C function
+    recon.fbp.restype = None
+    
+    # init the struct
+    t = TestStruct()
+
+    t.ScanR = ScanR
+    t.DistD = DistD
+    t.DecFanAng = DecFanAng
+    t.startangle = startView # Inconsistent C variable name - should be startAngle. Also, this seems to be the start view, not angle.
+    t.rotdir = rotdir
+    t.DecHeight = DecHeight
+    t.YL = YL
+    t.ZL = ZL
+    t.dectorYoffset = dectorYoffset
+    t.dectorZoffset = dectorZoffset
+    t.AngleNumber = ProjScale
+
+    t.Radius = Radius
+    t.RecSize = imageSize
+    t.sliceThickness = sliceThickness
+    t.FOILength = imageSize
+    t.FOIWidth = imageSize
+    t.FOIHeight = sliceCount
+#     t.centerX = (t.RecSize - 1)*0.5
+#     t.centerY = (t.RecSize - 1)*0.5
+#     t.centerZ = (t.FOIHeight - 1)*0.5
+    t.XOffSet = centerOffset[0]
+    t.YOffSet = centerOffset[1]
+    t.ZOffSet = centerOffset[2]
+    t.phantomXOffSet = 0
+    t.phantomYOffSet = 0
+    t.phantomZOffSet = 0
+    
+    if cfg.recon.printReconParameters:
+        print("* Reconstruction parameters:")
+        print("* SID: {} mm".format(t.ScanR))
+        print("* SDD: {} mm".format(t.DistD))
+        print("* Fan angle: {} degrees".format(t.DecFanAng))
+        print("* Start view: {}".format(t.startangle))
+        print("* Number of detector cols: {}".format(t.YL))
+        print("* Number of detector rows: {}".format(t.ZL))
+        print("* Detector height: {} mm".format(t.DecHeight))
+        print("* Detector X offset: {} mm".format(t.dectorYoffset))
+        print("* Detector Z offset: {} mm".format(t.dectorZoffset))
+        print("* Scan number of views: {} ".format(t.AngleNumber))
+        print("* Recon FOV: {} mm".format(2*t.Radius))
+        print("* Recon XY pixel size: {} mm".format(t.RecSize))
+        print("* Recon Slice thickness: {} mm".format(t.sliceThickness))
+        print("* Recon XY: {} pixels".format(t.FOIWidth))
+        print("* Recon Z: {} slices".format(t.FOIHeight))
+        print("* Recon X offset: {} mm".format(t.XOffSet))
+        print("* Recon Y offset: {} mm".format(t.YOffSet))
+        print("* Recon Z offset: {} mm".format(t.ZOffSet))
+
+    print("* Converting projection data from a numpy array to a C array...")
+    GF_ptr = float3Darray2pointer(GF)
+    t.GF = GF_ptr
+
+    print("* Allocating a C array for the recon results...")
+    RecIm = np.zeros(shape=(t.FOILength, t.FOIWidth, t.FOIHeight), dtype=np.single)
+    RecIm_ptr = float3Darray2pointer(RecIm)
+    t.RecIm = RecIm_ptr
+
+    print("* In C...")
+    recon.fbp(ct.byref(t))
+
+    print("* Converting the recon results from a C array to a numpy array...")
+    RecA = float3Dpointer2array(RecIm_ptr, *RecIm.shape)
+    RecA = RecA[:,:,::-1]
+
+    return RecA