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

rapidtide/DerivativeDelay.py

@@ -135,8 +135,6 @@ class DerivativeDelay:
                     (xdim, ydim, slicedim),
                     gausssigma=args.delayoffsetgausssigma,
                     patchthresh=args.delaypatchthresh,
-                    fileiscifti=False,
-                    textio=False,
                     rt_floattype=rt_floattype,
                     debug=args.debug,
                 )
@@ -181,8 +179,6 @@ class DerivativeDelay:
                     (xdim, ydim, slicedim),
                     gausssigma=args.delayoffsetgausssigma,
                     patchthresh=args.delaypatchthresh,
-                    fileiscifti=False,
-                    textio=False,
                     rt_floattype=rt_floattype,
                     debug=args.debug,
                 )

rapidtide/data/examples/src/testretro

@@ -1,25 +1,21 @@
 #!/bin/bash
 
-#rapidtide \
-#    --nprocs -1 \
-#    --passes 3 \
-#    --refinetype unweighted_average \
-#    --numnull 0 \
-#    --outputlevel max \
-#    --regressderivs 1 \
-#    sub-RAPIDTIDETEST.nii.gz \
-#    ../dst/sub-RAPIDTIDETEST
+rapidtide \
+    --nprocs -1 \
+    --passes 3 \
+    --outputlevel max \
+    --regressderivs 1 \
+    sub-RAPIDTIDETEST.nii.gz \
+    ../dst/sub-RAPIDTIDETEST
 
 ##retroregress sub-RAPIDTIDETEST.nii.gz ../dst/sub-RAPIDTIDETEST --alternateoutput ../dst/0deriv --nprocs -1 
 
 retroregress \
     sub-RAPIDTIDETEST.nii.gz \
     ../dst/sub-RAPIDTIDETEST \
-    --alternateoutput ../dst/wintest \
+    --alternateoutput ../dst/specialtest \
     --nprocs -1 \
-    --outputlevel max \
-    --focaldebug \
-    --delayoffsetspatialfilt -1 
+    --outputlevel onlyregressors
 
 #retroregress sub-RAPIDTIDETEST.nii.gz ../dst/sub-RAPIDTIDETEST --alternateoutput ../dst/0deriv_refined --nprocs -1 --regressderivs 0 --makepseudofile --outputlevel max --refinedelay --nofilterwithrefineddelay
 #retroregress sub-RAPIDTIDETEST.nii.gz ../dst/sub-RAPIDTIDETEST --alternateoutput ../dst/0deriv_refinedfit --nprocs -1 --regressderivs 0 --makepseudofile --outputlevel max --refinedelay

rapidtide/happy_supportfuncs.py

@@ -999,211 +999,42 @@ def circularderivs(timecourse):
 
 
 def phaseproject(
-    datatoproject,
-    means,
-    destpoints,
-    numsteps,
-    timings,
-    cardfromfmri_sliceres,
-    instantaneous_cardiacphase,
+    input_data,
+    demeandata_byslice,
+    means_byslice,
+    rawapp_byslice,
+    app_byslice,
+    normapp_byslice,
+    weights_byslice,
+    cine_byslice,
+    projmask_byslice,
+    derivatives_byslice,
+    proctrs,
     thispass,
-    numpasses,
     args,
-    outputroot,
-    slicesamplerate,
-    pleth_sliceres,
-    mrsamplerate,
-    projmask_byslice,
+    sliceoffsets,
     cardphasevals,
-    thetimes,
-    centric=True,
-    passstring="",
-    badpointlist=None,
-    congridbins=3.0,
-    gridkernel="kaiser",
+    outphases,
+    appsmoothingfilter,
+    phaseFs,
+    thecorrfunc_byslice,
+    waveamp_byslice,
+    wavedelay_byslice,
+    wavedelayCOM_byslice,
+    corrected_rawapp_byslice,
+    corrstartloc,
+    correndloc,
+    thealiasedcorrx,
+    theAliasedCorrelator,
 ):
-    xsize, ysize, numslices, timepoints = datatoproject.shape
-    # construct the destination arrays
-    tide_util.logmem("before making destination arrays")
-    app = np.zeros((xsize, ysize, numslices, destpoints), dtype=np.float64)
-    app_byslice = app.reshape((xsize * ysize, numslices, destpoints))
-    cine = np.zeros((xsize, ysize, numslices, destpoints), dtype=np.float64)
-    cine_byslice = cine.reshape((xsize * ysize, numslices, destpoints))
-    rawapp = np.zeros((xsize, ysize, numslices, destpoints), dtype=np.float64)
-    rawapp_byslice = rawapp.reshape((xsize * ysize, numslices, destpoints))
-    corrected_rawapp = np.zeros((xsize, ysize, numslices, destpoints), dtype=np.float64)
-    corrected_rawapp_byslice = rawapp.reshape((xsize * ysize, numslices, destpoints))
-    normapp = np.zeros((xsize, ysize, numslices, destpoints), dtype=np.float64)
-    normapp_byslice = normapp.reshape((xsize * ysize, numslices, destpoints))
-    weights = np.zeros((xsize, ysize, numslices, destpoints), dtype=np.float64)
-    weight_byslice = weights.reshape((xsize * ysize, numslices, destpoints))
-    derivatives = np.zeros((xsize, ysize, numslices, 4), dtype=np.float64)
-    derivatives_byslice = derivatives.reshape((xsize * ysize, numslices, 4))
-
-    timings.append(["Output arrays allocated" + passstring, time.time(), None, None])
-
-    if centric:
-        outphases = np.linspace(-np.pi, np.pi, num=destpoints, endpoint=False)
-    else:
-        outphases = np.linspace(0.0, 2.0 * np.pi, num=destpoints, endpoint=False)
-    phasestep = outphases[1] - outphases[0]
-
-    #######################################################################################################
-    #
-    # now do the phase projection
-    #
-    #
-    datatoproject_byslice = datatoproject.reshape((xsize * ysize, numslices, timepoints))
-    means_byslice = means.reshape((xsize * ysize, numslices))
-
-    timings.append(["Phase projection to image started" + passstring, time.time(), None, None])
-    print("Starting phase projection")
-    proctrs = range(timepoints)  # proctrs is the list of all fmri trs to be projected
-    procpoints = range(
-        timepoints * numsteps
-    )  # procpoints is the list of all sliceres datapoints to be projected
-    if badpointlist is not None:
-        censortrs = np.zeros(timepoints, dtype="int")
-        censorpoints = np.zeros(timepoints * numsteps, dtype="int")
-        censortrs[np.where(badpointlist > 0.0)[0] // numsteps] = 1
-        censorpoints[np.where(badpointlist > 0.0)[0]] = 1
-        proctrs = np.where(censortrs < 1)[0]
-        procpoints = np.where(censorpoints < 1)[0]
-
-    # do phase averaging
-    app_bypoint = cardiaccycleaverage(
-        instantaneous_cardiacphase,
-        outphases,
-        cardfromfmri_sliceres,
-        procpoints,
-        congridbins,
-        gridkernel,
-        centric,
-        cyclic=True,
-    )
-    if thispass == numpasses - 1:
-        tide_io.writebidstsv(
-            outputroot + "_desc-cardiaccyclefromfmri_timeseries",
-            app_bypoint,
-            1.0 / (outphases[1] - outphases[0]),
-            starttime=outphases[0],
-            columns=["cardiaccyclefromfmri"],
-            append=False,
-            debug=args.debug,
-        )
-
-    # now do time averaging
-    lookaheadval = int(slicesamplerate / 4.0)
-    print("lookaheadval = ", lookaheadval)
-    wrappedcardiacphase = tide_math.phasemod(instantaneous_cardiacphase, centric=centric)
-    max_peaks, min_peaks = tide_fit.peakdetect(wrappedcardiacphase, lookahead=lookaheadval)
-    # start on a maximum
-    if max_peaks[0][0] > min_peaks[0][0]:
-        min_peaks = min_peaks[1:]
-    # work only with pairs
-    if len(max_peaks) > len(min_peaks):
-        max_peaks = max_peaks[:-1]
-
-    zerophaselocs = []
-    for idx, peak in enumerate(max_peaks):
-        minloc = min_peaks[idx][0]
-        maxloc = max_peaks[idx][0]
-        minval = min_peaks[idx][1]
-        maxval = max_peaks[idx][1]
-        if minloc > 0:
-            if wrappedcardiacphase[minloc - 1] < wrappedcardiacphase[minloc]:
-                minloc -= 1
-                minval = wrappedcardiacphase[minloc]
-        phasediff = minval - (maxval - 2.0 * np.pi)
-        timediff = minloc - maxloc
-        zerophaselocs.append(1.0 * minloc - (minval - outphases[0]) * timediff / phasediff)
-        # print(idx, [maxloc, maxval], [minloc, minval], phasediff, timediff, zerophaselocs[-1])
-    instantaneous_cardiactime = instantaneous_cardiacphase * 0.0
-
-    whichpeak = 0
-    for t in procpoints:
-        if whichpeak < len(zerophaselocs) - 1:
-            if t > zerophaselocs[whichpeak + 1]:
-                whichpeak += 1
-        if t > zerophaselocs[whichpeak]:
-            instantaneous_cardiactime[t] = (t - zerophaselocs[whichpeak]) / slicesamplerate
-        # print(t, whichpeak, zerophaselocs[whichpeak], instantaneous_cardiactime[t])
-    maxtime = (
-        np.ceil(
-            int(
-                1.02
-                * tide_stats.getfracval(instantaneous_cardiactime, 0.98)
-                // args.pulsereconstepsize
-            )
-        )
-        * args.pulsereconstepsize
-    )
-    outtimes = np.linspace(
-        0.0, maxtime, num=int(maxtime / args.pulsereconstepsize), endpoint=False
-    )
-    atp_bypoint = cardiaccycleaverage(
-        instantaneous_cardiactime,
-        outtimes,
-        cardfromfmri_sliceres,
-        procpoints,
-        congridbins,
-        gridkernel,
-        False,
-        cyclic=True,
-    )
-    if thispass == numpasses - 1:
-        tide_io.writebidstsv(
-            outputroot + "_desc-cardpulsefromfmri_timeseries",
-            atp_bypoint,
-            1.0 / (outtimes[1] - outtimes[0]),
-            starttime=outtimes[0],
-            columns=["pulsefromfmri"],
-            append=False,
-            debug=args.debug,
-        )
-
-    if not args.verbose:
-        print("Phase projecting...")
-
-    # make a lowpass filter for the projected data. Limit frequency to 3 cycles per 2pi (1/6th Fs)
-    phaseFs = 1.0 / phasestep
-    phaseFc = phaseFs / 6.0
-    appsmoothingfilter = tide_filt.NoncausalFilter("arb", cyclic=True, padtime=0.0)
-    appsmoothingfilter.setfreqs(0.0, 0.0, phaseFc, phaseFc)
-
-    # setup for aliased correlation if we're going to do it
-    if args.doaliasedcorrelation and (thispass == numpasses - 1):
-        if args.cardiacfilename:
-            signal_sliceres = pleth_sliceres
-            # signal_stdres = pleth_stdres
-        else:
-            signal_sliceres = cardfromfmri_sliceres
-            # signal_stdres = dlfilteredcard_stdres
-        corrsearchvals = (
-            np.linspace(0.0, args.aliasedcorrelationwidth, num=args.aliasedcorrelationpts)
-            - args.aliasedcorrelationwidth / 2.0
-        )
-        theAliasedCorrelator = tide_corr.AliasedCorrelator(
-            signal_sliceres,
-            slicesamplerate,
-            numsteps,
-        )
-        thecorrfunc = np.zeros(
-            (xsize, ysize, numslices, args.aliasedcorrelationpts), dtype=np.float64
-        )
-        thecorrfunc_byslice = thecorrfunc.reshape(
-            (xsize * ysize, numslices, args.aliasedcorrelationpts)
-        )
-        wavedelay = np.zeros((xsize, ysize, numslices), dtype=np.float64)
-        wavedelay_byslice = wavedelay.reshape((xsize * ysize, numslices))
-        waveamp = np.zeros((xsize, ysize, numslices), dtype=np.float64)
-        waveamp_byslice = waveamp.reshape((xsize * ysize, numslices))
+    xsize, ysize, numslices, timepoints = input_data.getdims()
+    fmri_data_byslice = input_data.byslice()
 
-    # now project the data
     for theslice in tqdm(
         range(numslices),
         desc="Slice",
         unit="slices",
+        disable=(not args.showprogressbar),
     ):
         if args.verbose:
             print("Phase projecting for slice", theslice)
@@ -1211,33 +1042,31 @@ def phaseproject(
         # indexlist = range(0, len(cardphasevals[theslice, :]))
         if len(validlocs) > 0:
             for t in proctrs:
-                filteredmr = -datatoproject_byslice[validlocs, theslice, t]
-                cinemr = (
-                    datatoproject_byslice[validlocs, theslice, t]
-                    + means_byslice[validlocs, theslice, t]
-                )
+                filteredmr = -demeandata_byslice[validlocs, theslice, t]
+                cinemr = fmri_data_byslice[validlocs, theslice, t]
                 thevals, theweights, theindices = tide_resample.congrid(
                     outphases,
                     cardphasevals[theslice, t],
                     1.0,
-                    congridbins,
-                    kernel=gridkernel,
+                    args.congridbins,
+                    kernel=args.gridkernel,
                     cyclic=True,
                 )
                 for i in range(len(theindices)):
-                    weight_byslice[validlocs, theslice, theindices[i]] += theweights[i]
-                    rawapp_byslice[validlocs, theslice, theindices[i]] += (
-                        theweights[i] * filteredmr
-                    )
+                    weights_byslice[validlocs, theslice, theindices[i]] += theweights[i]
+                    # rawapp_byslice[validlocs, theslice, theindices[i]] += (
+                    #    theweights[i] * filteredmr
+                    # )
+                    rawapp_byslice[validlocs, theslice, theindices[i]] += filteredmr
                     cine_byslice[validlocs, theslice, theindices[i]] += theweights[i] * cinemr
-            for d in range(destpoints):
-                if weight_byslice[validlocs[0], theslice, d] == 0.0:
-                    weight_byslice[validlocs, theslice, d] = 1.0
+            for d in range(args.destpoints):
+                if weights_byslice[validlocs[0], theslice, d] == 0.0:
+                    weights_byslice[validlocs, theslice, d] = 1.0
             rawapp_byslice[validlocs, theslice, :] = np.nan_to_num(
-                rawapp_byslice[validlocs, theslice, :] / weight_byslice[validlocs, theslice, :]
+                rawapp_byslice[validlocs, theslice, :] / weights_byslice[validlocs, theslice, :]
             )
             cine_byslice[validlocs, theslice, :] = np.nan_to_num(
-                cine_byslice[validlocs, theslice, :] / weight_byslice[validlocs, theslice, :]
+                cine_byslice[validlocs, theslice, :] / weights_byslice[validlocs, theslice, :]
             )
         else:
             rawapp_byslice[:, theslice, :] = 0.0
@@ -1260,33 +1089,41 @@ def phaseproject(
             corrected_rawapp_byslice[validlocs, theslice, :] = (
                 rawapp_byslice[validlocs, theslice, :] - timecoursemean
             ) * appflips_byslice[validlocs, theslice, None] + timecoursemean
-            if args.doaliasedcorrelation and (thispass == numpasses - 1):
+            if args.doaliasedcorrelation and (thispass > 0):
                 for theloc in validlocs:
                     thecorrfunc_byslice[theloc, theslice, :] = theAliasedCorrelator.apply(
                         -appflips_byslice[theloc, theslice]
-                        * datatoproject_byslice[theloc, theslice, :],
-                        -thetimes[theslice][0],
-                    )
+                        * demeandata_byslice[theloc, theslice, :],
+                        int(sliceoffsets[theslice]),
+                    )[corrstartloc : correndloc + 1]
                     maxloc = np.argmax(thecorrfunc_byslice[theloc, theslice, :])
-                    wavedelay_byslice[theloc, theslice] = corrsearchvals[maxloc]
-                    waveamp_byslice[theloc, theslice] = thecorrfunc_byslice[
-                        theloc, theslice, maxloc
-                    ]
+                    wavedelay_byslice[theloc, theslice] = (
+                        thealiasedcorrx[corrstartloc : correndloc + 1]
+                    )[maxloc]
+                    waveamp_byslice[theloc, theslice] = np.fabs(
+                        thecorrfunc_byslice[theloc, theslice, maxloc]
+                    )
+                    wavedelayCOM_byslice[theloc, theslice] = theCOM(
+                        thealiasedcorrx[corrstartloc : correndloc + 1],
+                        np.fabs(thecorrfunc_byslice[theloc, theslice, :]),
+                    )
         else:
             corrected_rawapp_byslice[validlocs, theslice, :] = rawapp_byslice[
                 validlocs, theslice, :
             ]
-            if args.doaliasedcorrelation and (thispass == numpasses - 1):
+            if args.doaliasedcorrelation and (thispass > 0):
                 for theloc in validlocs:
                     thecorrfunc_byslice[theloc, theslice, :] = theAliasedCorrelator.apply(
-                        -datatoproject_byslice[theloc, theslice, :],
-                        -thetimes[theslice][0],
-                    )
+                        -demeandata_byslice[theloc, theslice, :],
+                        int(sliceoffsets[theslice]),
+                    )[corrstartloc : correndloc + 1]
                     maxloc = np.argmax(np.abs(thecorrfunc_byslice[theloc, theslice, :]))
-                    wavedelay_byslice[theloc, theslice] = corrsearchvals[maxloc]
-                    waveamp_byslice[theloc, theslice] = thecorrfunc_byslice[
-                        theloc, theslice, maxloc
-                    ]
+                    wavedelay_byslice[theloc, theslice] = (
+                        thealiasedcorrx[corrstartloc : correndloc + 1]
+                    )[maxloc]
+                    waveamp_byslice[theloc, theslice] = np.fabs(
+                        thecorrfunc_byslice[theloc, theslice, maxloc]
+                    )
         timecoursemin = np.min(corrected_rawapp_byslice[validlocs, theslice, :], axis=1).reshape(
             (-1, 1)
         )
@@ -1296,10 +1133,10 @@ def phaseproject(
         normapp_byslice[validlocs, theslice, :] = np.nan_to_num(
             app_byslice[validlocs, theslice, :] / means_byslice[validlocs, theslice, None]
         )
-    return app, rawapp, corrected_rawapp, normapp, weights, cine, derivatives
+    return appflips_byslice
 
 
-def upsampleimage(input_data, input_hdr, numsteps, sliceoffsets, slicesamplerate, outputroot):
+def upsampleimage(input_data, numsteps, sliceoffsets, slicesamplerate, outputroot):
     fmri_data = input_data.byvol()
     timepoints = input_data.timepoints
     xsize = input_data.xsize
@@ -1309,7 +1146,6 @@ def upsampleimage(input_data, input_hdr, numsteps, sliceoffsets, slicesamplerate
     # allocate the image
     print(f"upsampling fmri data by a factor of {numsteps}")
     upsampleimage = np.zeros((xsize, ysize, numslices, numsteps * timepoints), dtype=float)
-    upsampleimage_byslice = upsampleimage.reshape(xsize * ysize, numslices, numsteps * timepoints)
 
     # demean the raw data
     meanfmri = fmri_data.mean(axis=1)
@@ -1339,8 +1175,8 @@ def upsampleimage(input_data, input_hdr, numsteps, sliceoffsets, slicesamplerate
             )
             upsampleimage_byslice[thexyvoxel, :, thetimepoint] = 1.0 * theinterps
 
-    theheader = copy.deepcopy(input_hdr)
-    theheader["dim"][4] = timepoints * numsteps
-    theheader["pixdim"][4] = 1.0 / slicesamplerate
+    theheader = input_data.copyheader(
+        numtimepoints=(timepoints * numsteps), tr=(1.0 / slicesamplerate)
+    )
     tide_io.savetonifti(upsampleimage, theheader, outputroot + "_upsampled")
     print("upsampling complete")

rapidtide/io.py

@@ -139,7 +139,7 @@ def parseniftidims(thedims):
     nx, ny, nz, nt : int
         Number of points along each dimension
     """
-    return thedims[1], thedims[2], thedims[3], thedims[4]
+    return int(thedims[1]), int(thedims[2]), int(thedims[3]), int(thedims[4])
 
 
 # sizes are the mapping between voxels and physical coordinates
@@ -263,32 +263,30 @@ def niftihdrfromarray(data):
 
 def makedestarray(
     destshape,
-    textio=False,
-    fileiscifti=False,
+    filetype="nifti",
     rt_floattype="float64",
 ):
-    if textio:
+    if filetype == "text":
         try:
             internalspaceshape = destshape[0]
             timedim = destshape[1]
         except TypeError:
             internalspaceshape = destshape
             timedim = None
+    elif filetype == "cifti":
+        spaceindex = len(destshape) - 1
+        timeindex = spaceindex - 1
+        internalspaceshape = destshape[spaceindex]
+        if destshape[timeindex] > 1:
+            timedim = destshape[timeindex]
+        else:
+            timedim = None
     else:
-        if fileiscifti:
-            spaceindex = len(destshape) - 1
-            timeindex = spaceindex - 1
-            internalspaceshape = destshape[spaceindex]
-            if destshape[timeindex] > 1:
-                timedim = destshape[timeindex]
-            else:
-                timedim = None
+        internalspaceshape = int(destshape[0]) * int(destshape[1]) * int(destshape[2])
+        if len(destshape) == 3:
+            timedim = None
         else:
-            internalspaceshape = int(destshape[0]) * int(destshape[1]) * int(destshape[2])
-            if len(destshape) == 3:
-                timedim = None
-            else:
-                timedim = destshape[3]
+            timedim = destshape[3]
     if timedim is None:
         outmaparray = np.zeros(internalspaceshape, dtype=rt_floattype)
     else:
@@ -329,8 +327,7 @@ def savemaplist(
     destshape,
     theheader,
     bidsbasedict,
-    textio=False,
-    fileiscifti=False,
+    filetype="nifti",
     rt_floattype="float64",
     cifti_hdr=None,
     savejson=True,
@@ -338,8 +335,7 @@ def savemaplist(
 ):
     outmaparray, internalspaceshape = makedestarray(
         destshape,
-        textio=textio,
-        fileiscifti=fileiscifti,
+        filetype=filetype,
         rt_floattype=rt_floattype,
     )
     for themap, mapsuffix, maptype, theunit, thedescription in maplist:
@@ -365,7 +361,7 @@ def savemaplist(
             bidsdict["Units"] = theunit
         if thedescription is not None:
             bidsdict["Description"] = thedescription
-        if textio:
+        if filetype == "text":
             writenpvecs(
                 outmaparray.reshape(destshape),
                 f"{outputname}_{mapsuffix}.txt",
@@ -374,7 +370,7 @@ def savemaplist(
             savename = f"{outputname}_desc-{mapsuffix}_{maptype}"
             if savejson:
                 writedicttojson(bidsdict, savename + ".json")
-            if not fileiscifti:
+            if filetype == "nifti":
                 savetonifti(outmaparray.reshape(destshape), theheader, savename)
             else:
                 isseries = len(outmaparray.shape) != 1

rapidtide/refinedelay.py

@@ -110,7 +110,6 @@ def trainratiotooffset(
         "alwaysmultiproc": False,
         "focaldebug": debug,
         "fmrifreq": 1.0 / sampletime,
-        "textio": False,
     }
 
     if trainlagmax - trainlagmin > 0.0:
@@ -233,7 +232,7 @@ def trainratiotooffset(
         funcoffsets.append(trainoffsets[whichoffset] + 0.0)
     maplimits = (xaxis[0], xaxis[-1])
 
-    if outputlevel != "min":
+    if outputlevel != "min" and outputlevel != "onlyregressors":
         resampaxis = np.linspace(xaxis[0], xaxis[-1], num=len(xaxis), endpoint=True)
         outputfuncs = np.zeros((resampaxis.size, numoffsets), dtype=float)
         colnames = []
@@ -429,8 +428,7 @@ def filterderivratios(
     thedims,
     patchthresh=3.0,
     gausssigma=0,
-    fileiscifti=False,
-    textio=False,
+    filetype="nifti",
     rt_floattype="float64",
     verbose=True,
     debug=False,
@@ -448,8 +446,7 @@ def filterderivratios(
         print(f"MAD of regression fit derivative ratios = {themad}")
     outmaparray, internalspaceshape = tide_io.makedestarray(
         nativespaceshape,
-        textio=textio,
-        fileiscifti=fileiscifti,
+        filetype=filetype,
         rt_floattype=rt_floattype,
     )
     mappedregressderivratios = tide_io.populatemap(
@@ -459,7 +456,7 @@ def filterderivratios(
         outmaparray,
         debug=debug,
     )
-    if textio or fileiscifti:
+    if filetype != "nifti":
         medfilt = regressderivratios
         filteredarray = regressderivratios
     else:

rapidtide/tests/cleanposttest

@@ -17,5 +17,4 @@
 #
 
 rm tmp/*
-#rm testdata/*
 rm .coveragerc.*

rapidtide/tests/test_fullrunrapidtide_v3.py

@@ -23,6 +23,7 @@ import matplotlib as mpl
 import rapidtide.workflows.rapidtide as rapidtide_workflow
 import rapidtide.workflows.rapidtide_parser as rapidtide_parser
 from rapidtide.tests.utils import get_examples_path, get_test_temp_path
+import rapidtide.workflows.retroregress as rapidtide_retroregress
 
 
 def test_fullrunrapidtide_v3(debug=False, local=False, displayplots=False):
@@ -76,6 +77,15 @@ def test_fullrunrapidtide_v3(debug=False, local=False, displayplots=False):
     #    "--cleanrefined",
     rapidtide_workflow.rapidtide_main(rapidtide_parser.process_args(inputargs=inputargs))
 
+    inputargs = [
+        os.path.join(exampleroot, "sub-RAPIDTIDETEST.nii.gz"),
+        os.path.join(testtemproot, "sub-RAPIDTIDETEST3"),
+        "--alternateoutput",
+        os.path.join(testtemproot, "onlyregressors"),
+        "--outputlevel",
+        "onlyregressors",
+    ]
+    rapidtide_retroregress.retroregress(rapidtide_retroregress.process_args(inputargs=inputargs))
 
 if __name__ == "__main__":
     mpl.use("TkAgg")

rapidtide/tests/test_fullrunrapidtide_v6.py

@@ -17,7 +17,6 @@
 #
 #
 import os
-import subprocess
 
 import matplotlib as mpl
 

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,
     )