catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/reconstruction/pyfiles/helical_equiAngle.py

@@ -0,0 +1,284 @@
+import ctypes as ct
+import numpy as np
+import math
+from gecatsim.reconstruction.pyfiles.createHSP import createHSP
+import scipy.io as scio
+import matplotlib.pyplot as plt
+from gecatsim.reconstruction.pyfiles.mapConfigVariablesToHelical import mapConfigVariablesToHelical
+import os
+
+# Init ctypes types
+FLOAT = ct.c_float
+PtrFLOAT = ct.POINTER(FLOAT)
+PtrPtrFLOAT = ct.POINTER(PtrFLOAT)
+PtrPtrPtrFLOAT = ct.POINTER(PtrPtrFLOAT)
+PI =3.14159265358979
+
+class TestStruct(ct.Structure):
+    _fields_ = [
+                ("ScanR", ct.c_float),
+                ("DistD", ct.c_float),
+                ("YL", ct.c_int),
+                ("ZL", ct.c_int),
+                ("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(mm)
+                ("YOffSet", ct.c_float),  # recon offset along the y axis(mm)
+                ("ZOffSet", ct.c_float),  # recon offset along the z axis(mm)
+                ("phantomXOffSet", ct.c_float),  # phantom offset along the x axis(mm)
+                ("phantomYOffSet", ct.c_float),  # phantom offset along the y axis(mm)
+                ("phantomZOffSet", ct.c_float),  # phantom offset along the z axis(mm)
+                ("DecFanAng", ct.c_float),
+                ("DecHeight", ct.c_float),
+                ("DecWidth", ct.c_float),
+                ("dx", ct.c_float),
+                ("dy", ct.c_float),
+                ("dz", ct.c_float),
+                ("h", ct.c_float),
+                ("BetaS", ct.c_float),
+                ("BetaE", ct.c_float),
+                ("AngleNumber", ct.c_int),
+                ("N_2pi", ct.c_int),
+                ("Radius", ct.c_float),
+                ("RecSize", ct.c_int),
+                ("RecSizeZ", ct.c_int),
+                ("delta", ct.c_float),
+                ("HSCoef", ct.c_float),
+                ("k1", ct.c_float),
+                ("GF", PtrPtrPtrFLOAT),
+                ("RecIm", PtrPtrPtrFLOAT)
+                ]
+
+
+def double3darray2pointer(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 double3dpointer2array(ptr, n, m, o):
+    # Converts ctypes 3D array into a 3D numpy array.
+    arr = np.zeros(shape=(n, m, o))
+
+    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 = "helicalrecon.dll"
+    else:
+        lib_file = "helicalrecon.so"
+    clib = ll(os.path.join(recon_lib, lib_file))
+
+    return clib
+
+
+def helical_equiAngle(cfg, prep):
+    prep = prep[:,:,::-1]
+
+    if cfg.protocol.rotationDirection == -1:	
+        prep = prep[::-1,:,:]
+    Proj = prep.transpose(0,2,1)
+
+    # scanner & recon geometry
+    SO, DD, YL, ZL, ViewN, N_Turn, N_2pi, h, startAngle, dectorYoffset, dectorZoffset, \
+    k1, delta, HSCoef, rowSize, ColSize, imageSize, sliceCount, sliceThickness, centerOffset, ObjR,kernelType \
+        = mapConfigVariablesToHelical(cfg)
+
+    # print(SO, DD, YL, ZL, ViewN, N_Turn, N_2pi, h, dectorYoffset, dectorZoffset, imageSize, sliceCount, ObjR, ColSize)
+    
+    DecAngle = math.atan(ColSize/2/DD)*2*YL
+    HSCoef = (DecAngle/PI+0.52)
+    DecHeight = rowSize * ZL
+    h = h/DecHeight
+    dx = 2*ObjR/imageSize
+    dy = 2*ObjR/imageSize
+    dz = sliceThickness
+
+    YLCW = (YL-1)*0.5
+    YLC= (YL-1)*0.5 - dectorYoffset  # Detector center along the horizontal direction of detector array
+    ZLC= (ZL-1)*0.5 - dectorZoffset # Detector center along the vertical direction of detector array
+    
+    BetaS = -N_Turn*PI  + PI*startAngle/180
+    BetaE =  N_Turn*PI  + PI*startAngle/180
+
+    DecWidth = math.tan(DecAngle*0.5)*(SO)*2
+    dYL   =  DecWidth/YL
+    dZL   =  DecHeight/ZL
+    DeltaFai= (BetaE-BetaS)/(ViewN-1)
+    DeltaTheta = DeltaFai
+    DeltaT     = dYL  
+    dYA = DecAngle/YL
+    PProj    = np.zeros((ViewN,YL,ZL))
+
+    ## rebinning the projection
+    print("* Rebinning the projection...")
+    for i in range(ViewN):
+        Theta=(i)*DeltaTheta                   # the view for the parallel projection
+        for j in range(YL):
+            t      = (j-YLCW)*DeltaT     # the distance from origin to ray for parallel beam
+            Beta   = math.asin(t/(SO))            # the fan_angle for cone_beam projection
+            Fai    = Theta+Beta              # the view for cone_beam projecton
+            a      = Beta  # the position of this ray on the flat detector
+            FaiIndex        =  (Fai/DeltaFai)
+            UIndex          =  (a/dYA)+YLC
+            FI              =  math.ceil(FaiIndex)
+            UI              =  math.ceil(UIndex)
+            coeXB           =  FI-FaiIndex
+            coeXU           =  1-coeXB
+            coeYB           =  UI-UIndex
+            coeYU           =  1-coeYB
+            if (FI<=0):
+                IndexXU = 0
+                IndexXB = 0
+            elif(FI > ViewN-1):
+                IndexXU = ViewN-1
+                IndexXB = ViewN-1
+            else:
+                IndexXU = FI
+                IndexXB = FI-1
+
+            if (UI<=0):
+                IndexYU = 0
+                IndexYB = 0
+            elif(UI>YL-1):
+                IndexYU = YL-1
+                IndexYB = YL-1
+            else:
+                IndexYU=UI
+                IndexYB=UI-1
+            PProj[i,j,:]=coeXB*coeYB*Proj[IndexXB,IndexYB,:]+coeXU*coeYB*Proj[IndexXU,IndexYB,:]+coeXB*coeYU*Proj[IndexXB,IndexYU,:]+coeXU*coeYU*Proj[IndexXU,IndexYU,:]
+
+    # https://github.com/xcist/main/issues/122
+    Projflip = np.flip(PProj, axis=2)
+    Proj = Projflip.transpose(1, 2, 0)
+
+    #scio.savemat('testrebin.mat', {'rebin': PProj})
+
+    #Perform Ramp filtering
+    print("* Applying the filter...")
+    Dg=Proj
+    nn = int(math.pow(2, (math.ceil(math.log2(abs(YL))) + 1)))
+    nn2 = nn*2
+    FFT_F = createHSP(nn, kernelType)
+
+    GF = Proj
+    
+    for ProjIndex in range(0, ViewN):
+        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/dYL
+
+    #Backproject the filtered data into the 3D space
+    # 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 = SO
+    t.DistD = DD
+    t.YL = YL
+    t.ZL = ZL
+    t.DecFanAng = DecAngle
+    t.DecHeight = DecHeight
+    t.DecWidth = DecWidth
+    t.dx = dx
+    t.dy = dy 
+    t.dz = dz
+    t.h = h
+    t.BetaS = BetaS
+    t.BetaE = BetaE
+    t.dectorYoffset = dectorYoffset
+    t.dectorZoffset = dectorZoffset
+    t.AngleNumber = ViewN
+    t.N_2pi = N_2pi
+    t.Radius = ObjR
+    t.RecSize = imageSize
+    t.RecSizeZ = sliceCount
+    t.delta = delta
+    t.HSCoef = HSCoef
+    t.k1 = k1
+
+    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 X offset: {} mm".format(t.XOffSet))
+        print("* Recon Y offset: {} mm".format(t.YOffSet))
+        print("* Recon Z offset: {} mm".format(t.ZOffSet))
+    # Generate a 3D ctypes array from numpy array
+    print("* Converting projection data from a numpy array to a C array...")
+    GF_ptr = double3darray2pointer(GF)
+    t.GF = GF_ptr
+
+    # RecIm = np.zeros(shape=(t.RecSize, t.RecSize, t.RecSize))
+    print("* Allocating a C array for the recon results...")
+    RecIm = np.zeros(shape=(t.RecSize, t.RecSize, t.RecSizeZ))
+    RecIm_ptr = double3darray2pointer(RecIm)
+    t.RecIm = RecIm_ptr
+
+    # interface with C function
+    print("* In C...")
+    recon.fbp(ct.byref(t))
+
+    # Convert ctypes 3D arrays to numpy arrays
+    print("* Converting the recon results from a C array to a numpy array...")
+    rec = double3dpointer2array(RecIm_ptr, *RecIm.shape)
+    rec = rec.transpose(1,0,2).astype(np.float32)
+    rec = rec[::-1,::-1]
+
+    return rec

gecatsim/reconstruction/pyfiles/mapConfigVariablesToFDK.py

@@ -0,0 +1,38 @@
+from math import ceil
+from copy import deepcopy
+
+def mapConfigVariablesToFDK(cfg):
+
+    sid = cfg.scanner.sid
+    sdd = cfg.scanner.sdd
+    nMod = ceil(cfg.scanner.detectorColCount/cfg.scanner.detectorColsPerMod)
+    rowSize = cfg.scanner.detectorRowSize
+    modWidth = cfg.scanner.detectorColsPerMod*cfg.scanner.detectorColSize
+    dectorYoffset = -cfg.scanner.detectorColOffset
+    dectorZoffset = cfg.scanner.detectorRowOffset
+
+    fov = cfg.recon.fov
+    imageSize = cfg.recon.imageSize
+    sliceCount = cfg.recon.sliceCount
+    sliceThickness = cfg.recon.sliceThickness
+    centerOffset = deepcopy(cfg.recon.centerOffset)
+    # Pass desired X as Y
+    centerOffset[1] = deepcopy(cfg.recon.centerOffset[0])
+    # Pass desired Y as X; this minus sign is needed to get correct offset
+    centerOffset[0] = -deepcopy(cfg.recon.centerOffset[1])
+
+    # The FDK recon seems to be using a "start view" rather than a "start angele".
+    # This is a hack until that gets fixed.
+    startView_at_view_angle_equals_0 = cfg.protocol.viewCount/2
+    if cfg.recon.startAngle <= 180:
+        startView = startView_at_view_angle_equals_0 + int(cfg.protocol.viewCount*cfg.recon.startAngle/360)
+    elif cfg.recon.startAngle > 180:
+        startView = startView_at_view_angle_equals_0 - int(cfg.protocol.viewCount*cfg.recon.startAngle/360)
+    else:
+        raise Exception("******** Error! Invalid start angle = {} specified. ********".format(cfg.recon.startAngle))
+
+    rotdir = cfg.protocol.rotationDirection
+    kernelType = cfg.recon.kernelType
+
+    return sid, sdd, nMod, rowSize, modWidth, dectorYoffset, dectorZoffset, \
+           fov, imageSize, sliceCount, sliceThickness, centerOffset, startView, rotdir, kernelType

gecatsim/reconstruction/pyfiles/mapConfigVariablesToHelical.py

@@ -0,0 +1,50 @@
+from math import ceil
+from copy import deepcopy
+
+
+def mapConfigVariablesToHelical(cfg):
+
+    
+    sid = cfg.scanner.sid # source to isocenter distance, in mm
+    sdd = cfg.scanner.sdd # source to detector distance, in mm
+    YL = int(cfg.scanner.detectorColCount)
+    ZL = int(cfg.scanner.detectorRowCount) #
+    N_2pi =  cfg.protocol.viewsPerRotation #
+    ViewN = cfg.protocol.viewCount
+    N_Turn = (cfg.protocol.viewCount-1)/cfg.protocol.viewsPerRotation
+    h = cfg.protocol.tableSpeed*cfg.protocol.rotationTime # in xcist, in unit of mm/s
+    startAngle = cfg.protocol.startAngle
+    dectorYoffset = -cfg.scanner.detectorColOffset   # coloffset is in unit of cols, could be float
+    dectorZoffset = cfg.scanner.detectorRowOffset
+
+    # The following lines are used to define the reconstruction paramters
+    k1 = 5  # The order to define the 3D weighting function
+    delta = 60  # The range to define smoothness of 2D weigthing function
+    HSCoef = 0.6  # This is used to define the half-scan range
+
+    # nMod = ceil(cfg.scanner.detectorColCount/cfg.scanner.detectorColsPerMod)
+    rowSize = cfg.scanner.detectorRowSize  # size of 1 detector row in unit of mm, float
+    ColSize = cfg.scanner.detectorColSize  # size of 1 detector col in unit of mm, float
+
+    imageSize = cfg.recon.imageSize # how many pixels, currently a single int, has to be square
+    sliceCount = cfg.recon.sliceCount # how many slices in recon for 3d recon
+    sliceThickness = cfg.recon.sliceThickness # float in mm
+    objR =0.5* cfg.recon.fov #FOV in mm
+
+    kernelType = cfg.recon.kernelType
+    centerOffset = deepcopy(cfg.recon.centerOffset)
+    # Pass desired X as Y
+    centerOffset[1] = deepcopy(cfg.recon.centerOffset[0])
+    # Pass desired Y as X
+    centerOffset[0] = -deepcopy(cfg.recon.centerOffset[1])
+    # kernelType = cfg.recon.kernelType
+    # centerOffset = deepcopy(cfg.recon.centerOffset)
+    # # Pass desired X as Y
+    # centerOffset[1] = deepcopy(cfg.recon.centerOffset[0])
+    # # Pass desired Y as -X
+    # centerOffset[0] = -deepcopy(cfg.recon.centerOffset[1])
+
+    return  sid, sdd, YL, ZL, ViewN, N_Turn, N_2pi, h, startAngle, dectorYoffset, dectorZoffset, \
+            k1, delta, HSCoef, rowSize, ColSize, imageSize,sliceCount, sliceThickness, centerOffset, objR, kernelType
+
+

gecatsim/reconstruction/pyfiles/recon.py

@@ -0,0 +1,172 @@
+# Copyright 2020, General Electric Company. All rights reserved. See https://github.com/xcist/code/blob/master/LICENSE
+
+import gecatsim as xc
+from gecatsim.pyfiles.CommonTools import *
+import matplotlib.pyplot as plt
+import numpy as np
+# Need to import new recons as they are added
+
+def recon_direct(cfg):
+    prep = load_prep(cfg)
+    # cfg.recon.reconType is the recon function's name
+    imageVolume3D = feval("gecatsim.reconstruction.pyfiles." + cfg.recon.reconType, cfg, prep)
+    imageVolume3D = scaleReconData(cfg, imageVolume3D)
+    return imageVolume3D
+
+def recon(cfg):
+    # If doing the recon, load the projection data, do the recon, and save the resulting image volume.
+    if cfg.do_Recon:
+        imageVolume3D = recon_direct(cfg)
+        if cfg.recon.saveImageVolume:
+            saveImageVolume(cfg, imageVolume3D)
+
+    # If not doing the recon, load the previously-saved recon image volume.
+    else:
+        imageVolume3D = loadImageVolume(cfg)
+
+    # In either case, save the results as individual images and display results at the specified window/level.
+    if cfg.recon.saveSingleImages:
+        saveSingleImages(cfg, imageVolume3D)
+            
+    if cfg.recon.displayImagePictures:
+        cfg = displayImagePictures(cfg, imageVolume3D)
+
+    if cfg.recon.saveImagePictureFiles:
+        cfg = saveImagePictureFiles(cfg, imageVolume3D)
+
+    return cfg
+
+     
+def load_prep(cfg):
+
+    print("* Loading the projection data...")
+    prep = xc.rawread(cfg.resultsName + ".prep",
+                  [cfg.protocol.viewCount, cfg.scanner.detectorRowCount, cfg.scanner.detectorColCount],
+                  'float')
+                  
+    return prep
+
+
+def scaleReconData(cfg, imageVolume3D):
+
+    print('* Scaling recon data...')
+    if cfg.recon.unit =='HU':
+        imageVolume3D = imageVolume3D*(1000/(cfg.recon.mu)) + cfg.recon.huOffset
+    elif cfg.recon.unit == '/mm':
+        pass
+    elif cfg.recon.unit == '/cm':
+        imageVolume3D = imageVolume3D*10
+    else:
+        raise Exception('******** Error! An unsupported recon unit was specified: {:s}. ********'.format(cfg.recon.unit))
+
+    return imageVolume3D
+
+
+def saveImageVolume(cfg, imageVolume3D):
+
+    print('* Writing the recon results to one big file...')
+
+    imageVolume3D_size_string = str(cfg.recon.imageSize) + 'x' + str(cfg.recon.imageSize) + 'x' + str(cfg.recon.sliceCount)
+    fname = cfg.resultsName + '_' + imageVolume3D_size_string + '.raw'
+    imageVolume3D = imageVolume3D.transpose(2, 0, 1)
+    imageVolume3D = imageVolume3D.copy(order='C')
+    xc.rawwrite(fname, imageVolume3D)
+
+
+def loadImageVolume(cfg):
+
+    print('* Reading the recon results from one big file...')
+
+    imageVolume3D_size_string = str(cfg.recon.imageSize) + 'x' + str(cfg.recon.imageSize) + 'x' + str(cfg.recon.sliceCount)
+    fname = cfg.resultsName + '_' + imageVolume3D_size_string + '.raw'
+    imageVolume3D = xc.rawread(fname,
+                    [cfg.recon.sliceCount, cfg.recon.imageSize, cfg.recon.imageSize],
+                    'float')
+    imageVolume3D = imageVolume3D.copy(order='C')
+    imageVolume3D = imageVolume3D.transpose(1, 2, 0)
+
+    return imageVolume3D
+
+
+def saveSingleImages(cfg, imageVolume3D):
+
+    print('* Writing the recon results to individual files...')
+
+    sliceIndicesToSave = range(0, cfg.recon.sliceCount)
+    for sliceIndexToSave in sliceIndicesToSave:
+        imageVolume3D_size_string = str(cfg.recon.imageSize) + 'x' + str(cfg.recon.imageSize) + 'x1'
+        sliceNumberString = 'slice' + str(sliceIndexToSave+1).zfill(3) + 'of' + str(cfg.recon.sliceCount).zfill(3)
+        fileName = cfg.resultsName + '_' + sliceNumberString + '_' + imageVolume3D_size_string + '.raw'
+        sliceToSave = imageVolume3D[:, :, sliceIndexToSave]
+        sliceToSave = sliceToSave.copy(order='C')
+        xc.rawwrite(fileName, sliceToSave)
+
+
+def displayImagePictures(cfg, imageVolume3D):
+
+    cfg = drawImages('screen', cfg, imageVolume3D)
+    
+    return cfg
+
+
+def saveImagePictureFiles(cfg, imageVolume3D):
+
+    print('* Saving the recon results to individual .png files...')
+
+    cfg = drawImages('file', cfg, imageVolume3D)
+    
+    return cfg
+
+
+def drawImages(drawTo, cfg, imageVolume3D):
+
+    # Draw all images.
+    # Future improvement: allow caller to specifiy a list of images to draw.
+    sliceIndicesToDraw = range(0, cfg.recon.sliceCount)
+
+    # If displayWindowMin and displayWindowMax were not passed in,
+    # get them from the image data, so all images are displayed using the same W/L.
+    if not hasattr(cfg.recon, 'displayWindowMin'):
+        cfg.recon.displayWindowMin = np.min(imageVolume3D)
+    if not hasattr(cfg.recon, 'displayWindowMax'):
+        cfg.recon.displayWindowMax = np.max(imageVolume3D)
+
+    for sliceIndexToDraw in sliceIndicesToDraw:
+        sliceToDraw = imageVolume3D[:, :, sliceIndexToDraw]
+        sliceToDraw = sliceToDraw.copy(order='C')
+        sliceNumberString = 'slice' + str(sliceIndexToDraw+1).zfill(3) + 'of' + str(cfg.recon.sliceCount).zfill(3)
+        fileName = cfg.resultsName + '_' + sliceNumberString + '.png'
+        plt.figure(int(sliceIndexToDraw+1))
+        plt.imshow(sliceToDraw, cmap='gray', vmin=cfg.recon.displayWindowMin, vmax=cfg.recon.displayWindowMax)
+        if not cfg.recon.displayImagePictureAxes:
+            plt.axis('off')
+
+        if cfg.recon.displayImagePictureTitles:
+            sliceString = "slice " + str(sliceIndexToDraw+1) + " of " + str(cfg.recon.sliceCount)
+            if hasattr(cfg, 'reconImageTitle'):
+                # If a plot title is specified, use it, and add the slice info if specified.
+                if hasattr(cfg, 'addSliceInfoToReconImageTitle') \
+                and cfg.addSliceInfoToReconImageTitle:
+                    titleString = cfg.reconImageTitle + "\n" + sliceString
+                else:
+                    titleString = cfg.reconImageTitle
+            else:
+                # Otherwise, title the plot with the slice info.
+                titleString = sliceString
+            plt.title(titleString, fontsize=10)
+
+        if drawTo == 'file':
+            plt.savefig(fileName, bbox_inches='tight')
+            plt.close()
+        elif drawTo == 'screen':
+            plt.draw()
+            
+    if drawTo == 'screen':
+        plt.pause(1)
+        if cfg.waitForKeypress:
+            print('********************************************')
+            print('* Press Enter to close images and continue *')
+            input('********************************************')
+        plt.close('all')
+
+    return cfg