rapidtide 3.0.1__py3-none-any.whl → 3.0.3__py3-none-any.whl

rapidtide/tests/test_io.py

@@ -25,9 +25,17 @@ import rapidtide.io as tide_io
 from rapidtide.tests.utils import create_dir, get_examples_path, get_test_temp_path, mse
 
 
-def test_io(debug=True, displayplots=False):
+def test_io(debug=True, local=False, displayplots=False):
+    # set input and output directories
+    if local:
+        exampleroot = "../data/examples/src"
+        testtemproot = "./tmp"
+    else:
+        exampleroot = get_examples_path()
+        testtemproot = get_test_temp_path()
+
     # create outputdir if it doesn't exist
-    create_dir(get_test_temp_path())
+    create_dir(testtemproot)
 
     # test checkifnifti
     assert tide_io.checkifnifti("test.nii") == True
@@ -88,12 +96,12 @@ def test_io(debug=True, displayplots=False):
     # test fmritimeinfo
     fmritimeinfothresh = 1e-2
     tr, timepoints = tide_io.fmritimeinfo(
-        os.path.join(get_examples_path(), "sub-HAPPYTEST.nii.gz")
+        os.path.join(exampleroot, "sub-HAPPYTEST.nii.gz")
     )
     assert np.fabs(tr - 1.16) < fmritimeinfothresh
     assert timepoints == 110
     tr, timepoints = tide_io.fmritimeinfo(
-        os.path.join(get_examples_path(), "sub-RAPIDTIDETEST.nii.gz")
+        os.path.join(exampleroot, "sub-RAPIDTIDETEST.nii.gz")
     )
     assert np.fabs(tr - 1.5) < fmritimeinfothresh
     assert timepoints == 260
@@ -101,10 +109,10 @@ def test_io(debug=True, displayplots=False):
     # test niftifile reading
     sizethresh = 1e-3
     happy_img, happy_data, happy_hdr, happydims, happysizes = tide_io.readfromnifti(
-        os.path.join(get_examples_path(), "sub-HAPPYTEST.nii.gz")
+        os.path.join(exampleroot, "sub-HAPPYTEST.nii.gz")
     )
     fmri_img, fmri_data, fmri_hdr, fmridims, fmrisizes = tide_io.readfromnifti(
-        os.path.join(get_examples_path(), "sub-RAPIDTIDETEST.nii.gz")
+        os.path.join(exampleroot, "sub-RAPIDTIDETEST.nii.gz")
     )
     targetdims = [4, 65, 89, 64, 110, 1, 1, 1]
     targetsizes = [-1.00, 2.39583, 2.395830, 2.4, 1.16, 0.00, 0.00, 0.00]
@@ -120,7 +128,7 @@ def test_io(debug=True, displayplots=False):
     # test file writing
     datathresh = 2e-3  # relaxed threshold because sub-RAPIDTIDETEST has been converted to INT16
     tide_io.savetonifti(
-        fmri_data, fmri_hdr, os.path.join(get_test_temp_path(), "sub-RAPIDTIDETEST_copy.nii.gz")
+        fmri_data, fmri_hdr, os.path.join(testtemproot, "sub-RAPIDTIDETEST_copy.nii.gz")
     )
     (
         fmricopy_img,
@@ -128,7 +136,7 @@ def test_io(debug=True, displayplots=False):
         fmricopy_hdr,
         fmricopydims,
         fmricopysizes,
-    ) = tide_io.readfromnifti(os.path.join(get_test_temp_path(), "sub-RAPIDTIDETEST_copy.nii.gz"))
+    ) = tide_io.readfromnifti(os.path.join(testtemproot, "sub-RAPIDTIDETEST_copy.nii.gz"))
     assert tide_io.checkspacematch(fmri_hdr, fmricopy_hdr)
     assert tide_io.checktimematch(fmridims, fmridims)
     assert mse(fmri_data, fmricopy_data) < datathresh
@@ -141,10 +149,10 @@ def test_io(debug=True, displayplots=False):
 
     # test writing and reading text files
     debug = False
-    DESTDIR = get_test_temp_path()
-    SOURCEDIR = get_examples_path()
+    DESTDIR = testtemproot
+    SOURCEDIR = exampleroot
     EPSILON = 1e-5
-    numpoints = 10
+    numpoints = 100
     the2darray = np.zeros((6, numpoints), dtype=float)
     the2darray[0, :] = np.linspace(0, 1.0, numpoints, endpoint=False)
     the2darray[1, :] = np.sin(the2darray[0, :] * 2.0 * np.pi)
@@ -174,7 +182,7 @@ def test_io(debug=True, displayplots=False):
         ["plaintsv", True, ".tsv.gz"],
     ]
 
-    print("writing files")
+    print("writing files as a unit")
     for thistest in thetests:
         thetype = thistest[0]
         compressed = thistest[1]
@@ -218,6 +226,43 @@ def test_io(debug=True, displayplots=False):
             debug=debug,
         )
 
+    theappendtests = [
+        ["bidscontinuous", False, ".tsv"],
+        ["bidscontinuous", True, ".tsv.gz"],
+    ]
+
+    print("writing files with append")
+    for thistest in theappendtests:
+        thetype = thistest[0]
+        compressed = thistest[1]
+        if compressed:
+            compname = "compressed"
+        else:
+            compname = "uncompressed"
+
+        print(f"{the2darray.shape=}")
+        thefileroot = os.path.join(DESTDIR, f"testout_withcol_{thetype}_{compname}")
+        print(f"\t writing: {thefileroot}")
+        tide_io.writebidstsv(
+            thefileroot + "_append",
+            the2darray[:5, :],
+            inputsamplerate,
+            starttime=inputstarttime,
+            columns=thecols[:5],
+            compressed=compressed,
+            debug=debug,
+        )
+        tide_io.writebidstsv(
+            thefileroot + "_append",
+            the2darray[5, :],
+            inputsamplerate,
+            starttime=inputstarttime,
+            columns=[thecols[5]],
+            compressed=compressed,
+            append=True,
+            debug=debug,
+        )
+
     print("reading complete files")
     for thistest in thetests:
         thetype = thistest[0]
@@ -456,4 +501,4 @@ def test_io(debug=True, displayplots=False):
 
 
 if __name__ == "__main__":
-    test_io(debug=True, displayplots=True)
+    test_io(debug=True, local=True, displayplots=True)

rapidtide/tests/test_refinedelay.py

@@ -153,7 +153,6 @@ def eval_refinedelay(
         "alwaysmultiproc": False,
         "focaldebug": debug,
         "fmrifreq": Fs,
-        "textio": False,
     }
 
     regressderivratios, regressrvalues = tide_refinedelay.getderivratios(
@@ -186,8 +185,6 @@ def eval_refinedelay(
         validvoxels,
         (xdim, ydim, slicedim),
         patchthresh=3.0,
-        fileiscifti=False,
-        textio=False,
         rt_floattype="float64",
         debug=debug,
     )

rapidtide/voxelData.py

@@ -16,14 +16,78 @@
 #   limitations under the License.
 #
 #
+import copy
+
 import numpy as np
-from tf_keras.src.layers.preprocessing.benchmarks.index_lookup_forward_benchmark import (
-    get_vocab,
-)
 from tqdm import tqdm
 
 import rapidtide.filter as tide_filt
 import rapidtide.io as tide_io
+import rapidtide.util as tide_util
+
+
+class dataVolume:
+    xsize = None
+    ysize = None
+    numslices = None
+    numspatiallocs = None
+    timepoints = None
+    dtype = None
+    dimensions = None
+    data = None
+    data_shm = None
+    thepid = None
+
+    def __init__(
+        self,
+        shape,
+        shared=False,
+        dtype=np.float64,
+        thepid=0,
+    ):
+        if len(shape) == 3:
+            self.xsize = int(shape[0])
+            self.ysize = int(shape[1])
+            self.numslices = int(shape[2])
+            self.timepoints = 1
+            self.dimensions = 3
+        elif len(shape) == 4:
+            self.xsize = int(shape[0])
+            self.ysize = int(shape[1])
+            self.numslices = int(shape[2])
+            self.timepoints = int(shape[3])
+            self.dimensions = 4
+        else:
+            print(f"illegal shape: {shape}")
+        self.numspatiallocs = self.xsize * self.ysize * self.numslices
+        self.dtype = dtype
+        if not shared:
+            self.data = np.zeros(shape, dtype=dtype)
+        else:
+            self.data, self.data_shm = tide_util.allocshared(
+                shape, self.dtype, name=f"filtereddata_{thepid}"
+            )
+        return self.data
+
+    def byvol(self):
+        return self.data
+
+    def byslice(self):
+        if self.dimensions == 3:
+            return self.data.reshape(self.xsize * self.ysize, -1)
+        else:
+            return self.data.reshape(self.xsize * self.ysize, self.numslices, -1)
+
+    def byvoxel(self):
+        if self.dimensions == 3:
+            return self.data.reshape(self.numspatiallocs)
+        else:
+            return self.data.reshape(self.numspatiallocs, -1)
+
+    def destroy(self):
+        del self.data
+        if self.data_shm is not None:
+            tide_util.cleanup_shm(self.data_shm)
 
 
 class VoxelData:
@@ -36,14 +100,17 @@ class VoxelData:
     ysize = None
     numslices = None
     timepoints = None
+    realtimepoints = None
     xdim = None
     ydim = None
     slicethickness = None
     timestep = None
     thesizes = None
     thedims = None
+    numslicelocs = None
     numspatiallocs = None
     nativespaceshape = None
+    nativefmrishape = None
     validvoxels = None
     cifti_hdr = None
     filetype = None
@@ -61,6 +128,7 @@ class VoxelData:
         self.readdata(timestep, validstart, validend)
 
     def readdata(self, timestep, validstart, validend):
+        # load the data
         self.load()
 
         if tide_io.checkiftext(self.filename):
@@ -71,7 +139,8 @@ class VoxelData:
             self.xsize = self.theshape[0]
             self.ysize = 1
             self.numslices = 1
-            self.timepoints = self.theshape[1]
+            self.numslicelocs = None
+            self.timepoints = int(self.theshape[1])
             self.thesizes = [0, int(self.xsize), 1, 1, int(self.timepoints)]
             self.toffset = 0.0
             self.numspatiallocs = int(self.xsize)
@@ -81,7 +150,8 @@ class VoxelData:
             if tide_io.checkifcifti(self.filename):
                 self.filetype = "cifti"
                 self.nim_affine = None
-                self.timepoints = self.nim_data.shape[1]
+                self.numslicelocs = None
+                self.timepoints = int(self.nim_data.shape[1])
                 self.numspatiallocs = self.nim_data.shape[0]
                 self.nativespaceshape = (1, 1, 1, 1, self.numspatiallocs)
             else:
@@ -90,6 +160,7 @@ class VoxelData:
                 self.xsize, self.ysize, self.numslices, self.timepoints = tide_io.parseniftidims(
                     self.thedims
                 )
+                self.numslicelocs = int(self.xsize) * int(self.ysize)
                 self.numspatiallocs = int(self.xsize) * int(self.ysize) * int(self.numslices)
                 self.cifti_hdr = None
                 self.nativespaceshape = (self.xsize, self.ysize, self.numslices)
@@ -120,6 +191,30 @@ class VoxelData:
         self.setvalidtimes(validstart, validend)
         self.resident = True
 
+    def copyheader(self, numtimepoints=None, tr=None, toffset=None):
+        if self.filetype == "text":
+            return None
+        else:
+            thisheader = copy.deepcopy(self.nim_hdr)
+            if self.filetype == "cifti":
+                timeindex = thisheader["dim"][0] - 1
+                spaceindex = thisheader["dim"][0]
+                thisheader["dim"][timeindex] = numtimepoints
+                thisheader["dim"][spaceindex] = self.numspatiallocs
+            else:
+                if numtimepoints is not None:
+                    thisheader["dim"][4] = numtimepoints
+                    if numtimepoints > 1:
+                        thisheader["dim"][0] = 4
+                    else:
+                        thisheader["dim"][0] = 3
+                        thisheader["pixdim"][4] = 1.0
+                if toffset is not None:
+                    thisheader["toffset"] = toffset
+                if tr is not None:
+                    thisheader["pixdim"][4] = tr
+            return thisheader
+
     def getsizes(self):
         return self.xdim, self.ydim, self.slicethickness, self.timestep
 
@@ -167,32 +262,48 @@ class VoxelData:
             self.validend = self.timepoints - 1
         else:
             self.validend = validend
+        self.realtimepoints = self.validend - self.validstart + 1
+        if self.filetype == "nifti":
+            self.nativefmrishape = (self.xsize, self.ysize, self.numslices, self.realtimepoints)
+        elif self.filetype == "cifti":
+            self.nativefmrishape = (1, 1, 1, self.realtimepoints, self.numspatiallocs)
+        else:
+            self.nativefmrishape = (self.xsize, self.realtimepoints)
 
     def setvalidvoxels(self, validvoxels):
         self.validvoxels = validvoxels
         self.numvalidspatiallocs = np.shape(self.validvoxels)[0]
 
-    def native(self):
+    def byvol(self):
         if not self.resident:
             self.load()
         return self.nim_data
 
-    def nativetrimmed(self):
+    def byvoltrimmed(self):
         if not self.resident:
             self.load()
         if self.filetype == "nifti":
             return self.nim_data[:, :, :, self.validstart : self.validend + 1]
         else:
-            return self.nim_data[:, self.validstart: self.validend + 1]
+            return self.nim_data[:, self.validstart : self.validend + 1]
+
+    def byvoxel(self):
+        return self.byvoltrimmed().reshape(self.numspatiallocs, -1)
 
-    def voxelbytime(self):
-        return self.nativetrimmed().reshape(self.numspatiallocs, -1)
+    def byslice(self):
+        return self.byvoltrimmed().reshape(self.numslicelocs, self.numslices, -1)
 
-    def getvalidvoxels(self):
+    def validdata(self):
         if self.validvoxels is None:
-            return self.voxelbytime()
+            return self.byvoxel()
         else:
-            return self.voxelbytime()[self.validvoxels, :]
+            return self.byvoxel()[self.validvoxels, :]
+
+    # def validdatabyslice(self):
+    #    if self.validvoxels is None:
+    #       return self.byslice()
+    #    else:
+    #        return self.byvoxel()[self.validvoxels, :].reshape(self.numslicelocs, self.numslices, -1)
 
     def smooth(
         self,
@@ -241,7 +352,7 @@ class VoxelData:
                 f"applying gaussian spatial filter to timepoints {self.validstart} "
                 f"to {self.validend} with sigma={gausssigma}"
             )
-            sourcedata = self.native()
+            sourcedata = self.byvol()
             for i in tqdm(
                 range(self.validstart, self.validend + 1),
                 desc="Timepoint",
@@ -271,6 +382,7 @@ class VoxelData:
         print(f"\t{self.timestep=}")
         print(f"\t{self.thesizes=}")
         print(f"\t{self.thedims=}")
+        print(f"\t{self.numslicelocs=}")
         print(f"\t{self.numspatiallocs=}")
         print(f"\t{self.nativespaceshape=}")
         print(f"\t{self.cifti_hdr=}")

rapidtide/workflows/cleanregressor.py

@@ -51,10 +51,32 @@ def cleanregressor(
     detrendorder=3,
     windowfunc="hamming",
     respdelete=False,
+    displayplots=False,
     debug=False,
     rt_floattype="float64",
     rt_floatset=np.float64,
 ):
+    # print debugging info
+    if debug:
+        print("cleanregressor:")
+        print(f"\t{thepass=}")
+        print(f"\t{lagmininpts=}")
+        print(f"\t{lagmaxinpts=}")
+        print(f"\t{lagmin=}")
+        print(f"\t{lagmax=}")
+        print(f"\t{detrendorder=}")
+        print(f"\t{windowfunc=}")
+        print(f"\t{respdelete=}")
+        print(f"\t{check_autocorrelation=}")
+        print(f"\t{fix_autocorrelation=}")
+        print(f"\t{despeckle_thresh=}")
+        print(f"\t{lthreshval=}")
+        print(f"\t{fixdelay=}")
+        print(f"\t{check_autocorrelation=}")
+        print(f"\t{displayplots=}")
+        print(f"\t{rt_floattype=}")
+        print(f"\t{rt_floatset=}")
+
     # check the regressor for periodic components in the passband
     dolagmod = True
     doreferencenotch = True
@@ -121,21 +143,33 @@ def cleanregressor(
                 f"searching for sidelobes with amplitude > {theampthresh} "
                 f"with abs(lag) < {thelagthresh} s"
             )
+        if debug:
+            print(
+                (
+                    f"searching for sidelobes with amplitude > {theampthresh} "
+                    f"with abs(lag) < {thelagthresh} s"
+                )
+            )
         sidelobetime, sidelobeamp = tide_corr.check_autocorrelation(
             accheckcorrscale,
             thexcorr,
             acampthresh=theampthresh,
             aclagthresh=thelagthresh,
             detrendorder=detrendorder,
+            displayplots=displayplots,
+            debug=debug,
         )
+        if debug:
+            print(f"check_autocorrelation returned: {sidelobetime=}, {sidelobeamp=}")
         absmaxsigma = acwidth * 10.0
         passsuffix = "_pass" + str(thepass)
         if sidelobetime is not None:
             despeckle_thresh = np.max([despeckle_thresh, sidelobetime / 2.0])
-            LGR.warning(
-                f"\n\nWARNING: check_autocorrelation found bad sidelobe at {sidelobetime} "
-                f"seconds ({1.0 / sidelobetime} Hz)..."
-            )
+            if LGR is not None:
+                LGR.warning(
+                    f"\n\nWARNING: check_autocorrelation found bad sidelobe at {sidelobetime} "
+                    f"seconds ({1.0 / sidelobetime} Hz)..."
+                )
             # bidsify
             """tide_io.writebidstsv(
                 f"{outputname}_desc-movingregressor_timeseries",
@@ -160,7 +194,7 @@ def cleanregressor(
                         LGR.info("removing spectral component at sidelobe frequency")
                     acstopfreq = 1.0 / sidelobetime
                     acfixfilter = tide_filt.NoncausalFilter(
-                        debug=debug,
+                        debug=False,
                     )
                     acfixfilter.settype("arb_stop")
                     acfixfilter.setfreqs(
@@ -175,7 +209,7 @@ def cleanregressor(
                         detrendorder=detrendorder,
                     )
                     cleaned_referencetc = tide_math.corrnormalize(
-                        cleaned_resampref_y,
+                        cleaned_resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1],
                         detrendorder=detrendorder,
                         windowfunc=windowfunc,
                     )
@@ -222,6 +256,9 @@ def cleanregressor(
             cleaned_referencetc = 1.0 * referencetc
             cleaned_nonosreferencetc = 1.0 * resampnonosref_y
     else:
+        sidelobetime = None
+        sidelobeamp = None
+        lagmod = 1000.0
         acwidth = None
         absmaxsigma = None
         cleaned_resampref_y = 1.0 * tide_math.corrnormalize(

rapidtide/workflows/delayestimation.py

@@ -130,7 +130,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
     if optiondict["checkpoint"]:
         outcorrarray[:, :] = 0.0
         outcorrarray[validvoxels, :] = corrout[:, :]
-        if optiondict["textio"]:
+        if theinputdata.filetype == "text":
             tide_io.writenpvecs(
                 outcorrarray.reshape(nativecorrshape),
                 f"{outputname}_corrout_prefit_pass" + str(thepass) + ".txt",
@@ -320,8 +320,8 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
         if optiondict["savedespecklemasks"] and (optiondict["despeckle_passes"] > 0):
             despecklesavemask = np.where(internaldespeckleincludemask[validvoxels] == 0.0, 0, 1)
             if thepass == optiondict["passes"]:
-                if not optiondict["textio"]:
-                    if fileiscifti:
+                if theinputdata.filetype != "text":
+                    if theinputdata.filetype == "cifti":
                         timeindex = theheader["dim"][0] - 1
                         spaceindex = theheader["dim"][0]
                         theheader["dim"][timeindex] = 1
@@ -346,8 +346,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
                     nativespaceshape,
                     theheader,
                     bidsbasedict,
-                    textio=optiondict["textio"],
-                    fileiscifti=fileiscifti,
+                    filetype=theinputdata.filetype,
                     rt_floattype=rt_floattype,
                     cifti_hdr=cifti_hdr,
                 )
@@ -384,8 +383,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
             cifti_hdr=cifti_hdr,
         )
@@ -417,8 +415,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
                 cifti_hdr=cifti_hdr,
             )
@@ -442,8 +439,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
                 cifti_hdr=cifti_hdr,
             )
@@ -478,8 +474,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
                 cifti_hdr=cifti_hdr,
             )

rapidtide/workflows/delayvar.py

@@ -36,6 +36,7 @@ import rapidtide.refinedelay as tide_refinedelay
 import rapidtide.resample as tide_resample
 import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
+import rapidtide.voxelData as tide_voxelData
 import rapidtide.workflows.parser_funcs as pf
 import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 
@@ -381,19 +382,19 @@ def delayvar(args):
 
     # read the fmri input files
     print("reading fmrifile")
-    fmri_input, fmri_data, fmri_header, fmri_dims, fmri_sizes = tide_io.readfromnifti(
-        args.fmrifile
-    )
+    theinputdata = tide_voxelData.VoxelData(args.fmrifile)
+    xsize, ysize, numslices, timepoints = theinputdata.getdims()
+    xdim, ydim, slicethickness, fmritr = theinputdata.getsizes()
+    fmri_header = theinputdata.copyheader()
+    fmri_data = theinputdata.byvol()
+    numspatiallocs = theinputdata.numspatiallocs
 
     # create the canary file
     Path(f"{outputname}_DELAYVARISRUNNING.txt").touch()
 
     if args.debug:
         print(f"{fmri_data.shape=}")
-    xdim, ydim, slicedim, fmritr = tide_io.parseniftisizes(fmri_sizes)
-    xsize, ysize, numslices, timepoints = tide_io.parseniftidims(fmri_dims)
-    numspatiallocs = int(xsize) * int(ysize) * int(numslices)
-    fmri_data_spacebytime = fmri_data.reshape((numspatiallocs, timepoints))
+    fmri_data_spacebytime = theinputdata.byvoxel()
     if args.debug:
         print(f"{fmri_data_spacebytime.shape=}")
 
@@ -530,7 +531,7 @@ def delayvar(args):
 
     if args.windelayoffsetgausssigma < 0.0:
         # set gausssigma automatically
-        args.windelayoffsetgausssigma = np.mean([xdim, ydim, slicedim]) / 2.0
+        args.windelayoffsetgausssigma = np.mean([xdim, ydim, slicethickness]) / 2.0
 
     wintrs = int(np.round(args.windowsize / fmritr, 0))
     wintrs += wintrs % 2
@@ -590,8 +591,7 @@ def delayvar(args):
                 (xsize, ysize, numslices, validtimepoints),
                 theheader,
                 bidsbasedict,
-                textio=therunoptions["textio"],
-                fileiscifti=False,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
                 cifti_hdr=None,
             )
@@ -737,11 +737,9 @@ def delayvar(args):
             windowedregressderivratios[:, thewin],
             (xsize, ysize, numslices),
             validvoxels,
-            (xdim, ydim, slicedim),
+            (xdim, ydim, slicethickness),
             gausssigma=args.windelayoffsetgausssigma,
             patchthresh=args.delaypatchthresh,
-            fileiscifti=False,
-            textio=False,
             rt_floattype=rt_floattype,
             verbose=args.verbose,
             debug=args.debug,