rapidtide 3.0a12__py3-none-any.whl → 3.0a13__py3-none-any.whl

rapidtide/fit.py

@@ -23,6 +23,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import scipy as sp
 import scipy.special as sps
+import statsmodels.api as sm
 import tqdm
 from numpy.polynomial import Polynomial
 from scipy.optimize import curve_fit
@@ -1105,6 +1106,37 @@ def mlproject(thefit, theevs, intercept):
     return thedest
 
 
+def olsregress(X, y, intercept=True, debug=False):
+    """
+
+    Parameters
+    ----------
+    X
+    y
+    intercept
+
+    Returns
+    -------
+
+    """
+    """Return the coefficients from a multiple linear regression, along with R, the coefficient of determination.
+
+    X: The independent variables (nxp).
+    y: The dependent variable (1xn or nx1).
+    intercept: Specifies whether or not the slope intercept should be considered.
+
+    The routine computes the coefficients (b_0, b_1, ..., b_p) from the data (x,y) under
+    the assumption that y = b0 + b_1 * x_1 + b_2 * x_2 + ... + b_p * x_p.
+
+    If intercept is False, the routine assumes that b0 = 0 and returns (b_1, b_2, ..., b_p).
+    """
+    if intercept:
+        X = sm.add_constant(X, prepend=True)
+    model = sm.OLS(y, exog=X)
+    thefit = model.fit()
+    return thefit.params, np.sqrt(thefit.rsquared)
+
+
 def mlregress(X, y, intercept=True, debug=False):
     """
 
@@ -1223,9 +1255,9 @@ def calcexpandedregressors(
     return outputregressors, outlabels
 
 
-def derivativeglmfilt(thedata, theevs, nderivs=1, debug=False):
+def derivativelinfitfilt(thedata, theevs, nderivs=1, debug=False):
     r"""First perform multicomponent expansion on theevs (each ev replaced by itself,
-    its square, its cube, etc.).  Then perform a glm fit of thedata using the vectors
+    its square, its cube, etc.).  Then perform a linear fit of thedata using the vectors
     in thenewevs and return the result.
 
     Parameters
@@ -1269,16 +1301,16 @@ def derivativeglmfilt(thedata, theevs, nderivs=1, debug=False):
     if debug:
         print(f"{nderivs=}")
         print(f"{thenewevs.shape=}")
-    filtered, datatoremove, R, coffs = glmfilt(thedata, thenewevs, debug=debug)
+    filtered, datatoremove, R, coffs = linfitfilt(thedata, thenewevs, debug=debug)
     if debug:
         print(f"{R=}")
 
     return filtered, thenewevs, datatoremove, R, coffs
 
 
-def expandedglmfilt(thedata, theevs, ncomps=1, debug=False):
+def expandedlinfitfilt(thedata, theevs, ncomps=1, debug=False):
     r"""First perform multicomponent expansion on theevs (each ev replaced by itself,
-    its square, its cube, etc.).  Then perform a glm fit of thedata using the vectors
+    its square, its cube, etc.).  Then perform a multiple regression fit of thedata using the vectors
     in thenewevs and return the result.
 
     Parameters
@@ -1322,15 +1354,15 @@ def expandedglmfilt(thedata, theevs, ncomps=1, debug=False):
     if debug:
         print(f"{ncomps=}")
         print(f"{thenewevs.shape=}")
-    filtered, datatoremove, R, coffs = glmfilt(thedata, thenewevs, debug=debug)
+    filtered, datatoremove, R, coffs = linfitfilt(thedata, thenewevs, debug=debug)
     if debug:
         print(f"{R=}")
 
     return filtered, thenewevs, datatoremove, R, coffs
 
 
-def glmfilt(thedata, theevs, returnintercept=False, debug=False):
-    r"""Performs a glm fit of thedata using the vectors in theevs
+def linfitfilt(thedata, theevs, returnintercept=False, debug=False):
+    r"""Performs a multiple regression fit of thedata using the vectors in theevs
     and returns the result.
 
     Parameters
@@ -1383,7 +1415,7 @@ def glmfilt(thedata, theevs, returnintercept=False, debug=False):
         return filtered, datatoremove, R2, retcoffs
 
 
-def confoundglm(
+def confoundregress(
     data,
     regressors,
     debug=False,

rapidtide/happy_supportfuncs.py

@@ -290,6 +290,11 @@ def cardiacfromimage(
     )
 
 
+def theCOM(X, data):
+    # return the center of mass
+    return np.sum(X * data) / np.sum(data)
+
+
 def savgolsmooth(data, smoothlen=101, polyorder=3):
     return savgol_filter(data, smoothlen, polyorder)
 

rapidtide/io.py

@@ -1426,6 +1426,8 @@ def writebidstsv(
     extraheaderinfo=None,
     compressed=True,
     columns=None,
+    xaxislabel="time",
+    yaxislabel="arbitrary value",
     starttime=0.0,
     append=False,
     colsinjson=True,
@@ -1447,6 +1449,8 @@ def writebidstsv(
     :param samplerate:
     :param compressed:
     :param columns:
+    :param xaxislabel:
+    :param yaxislabel:
     :param starttime:
     :param append:
     :param colsinjson:
@@ -1462,6 +1466,8 @@ def writebidstsv(
         print("\tsamplerate:", samplerate)
         print("\tcompressed:", compressed)
         print("\tcolumns:", columns)
+        print("\txaxislabel:", xaxislabel)
+        print("\tyaxislabel:", yaxislabel)
         print("\tstarttime:", starttime)
         print("\tappend:", append)
     if len(data.shape) == 1:
@@ -1538,6 +1544,8 @@ def writebidstsv(
     headerdict = {}
     headerdict["SamplingFrequency"] = float(samplerate)
     headerdict["StartTime"] = float(starttime)
+    headerdict["XAxisLabel"] = xaxislabel
+    headerdict["YAxisLabel"] = yaxislabel
     if colsinjson:
         if startcol == 0:
             headerdict["Columns"] = columns
@@ -1991,8 +1999,11 @@ def colspectolist(colspec, debug=False):
         ("APARC_SUBCORTGRAY", "8-13,17-20,26-28,47-56,58-60,96,97"),
         ("APARC_CORTGRAY", "1000-1035,2000-2035"),
         ("APARC_GRAY", "8-13,17-20,26-28,47-56,58-60,96,97,1000-1035,2000-2035"),
-        ("APARC_WHITE", "2,7,41,46,177,219"),
-        ("APARC_ALLBUTCSF", "2,7-13,17-20,26-28,41,46-56,58-60,96,97,177,219,1000-1035,2000-2035"),
+        ("APARC_WHITE", "2,7,41,46,177,219,3000-3035,4000-4035,5001,5002"),
+        (
+            "APARC_ALLBUTCSF",
+            "2,7-13,17-20,26-28,41,46-56,58-60,96,97,177,219,1000-1035,2000-2035,3000-3035,4000-4035,5001,5002",
+        ),
         ("SSEG_GRAY", "3,8,10-13,16-18,26,42,47,49-54,58"),
         ("SSEG_WHITE", "2,7,41,46"),
     )

rapidtide/{glmpass.py → linfitfiltpass.py}

@@ -26,7 +26,9 @@ import rapidtide.miscmath as tide_math
 import rapidtide.multiproc as tide_multiproc
 
 
-def _procOneGLMItem(vox, theevs, thedata, rt_floatset=np.float64, rt_floattype="float64"):
+def _procOneRegressionFitItem(
+    vox, theevs, thedata, rt_floatset=np.float64, rt_floattype="float64"
+):
     # NOTE: if theevs is 2D, dimension 0 is number of points, dimension 1 is number of evs
     thefit, R2 = tide_fit.mlregress(theevs, thedata)
     if theevs.ndim > 1:
@@ -75,7 +77,7 @@ def _procOneGLMItem(vox, theevs, thedata, rt_floatset=np.float64, rt_floattype="
         )
 
 
-def glmpass(
+def linfitfiltpass(
     numprocitems,
     fmri_data,
     threshval,
@@ -89,7 +91,7 @@ def glmpass(
     filtereddata,
     nprocs=1,
     alwaysmultiproc=False,
-    confoundglm=False,
+    confoundregress=False,
     procbyvoxel=True,
     showprogressbar=True,
     mp_chunksize=1000,
@@ -132,9 +134,9 @@ def glmpass(
 
                     # process and send the data
                     if procbyvoxel:
-                        if confoundglm:
+                        if confoundregress:
                             outQ.put(
-                                _procOneGLMItem(
+                                _procOneRegressionFitItem(
                                     val,
                                     theevs,
                                     fmri_data[val, :],
@@ -144,7 +146,7 @@ def glmpass(
                             )
                         else:
                             outQ.put(
-                                _procOneGLMItem(
+                                _procOneRegressionFitItem(
                                     val,
                                     theevs[val, :],
                                     fmri_data[val, :],
@@ -153,9 +155,9 @@ def glmpass(
                                 )
                             )
                     else:
-                        if confoundglm:
+                        if confoundregress:
                             outQ.put(
-                                _procOneGLMItem(
+                                _procOneRegressionFitItem(
                                     val,
                                     theevs,
                                     fmri_data[:, val],
@@ -165,7 +167,7 @@ def glmpass(
                             )
                         else:
                             outQ.put(
-                                _procOneGLMItem(
+                                _procOneRegressionFitItem(
                                     val,
                                     theevs[:, val],
                                     fmri_data[:, val],
@@ -191,7 +193,7 @@ def glmpass(
         # unpack the data
         itemstotal = 0
         if procbyvoxel:
-            if confoundglm:
+            if confoundregress:
                 for voxel in data_out:
                     r2value[voxel[0]] = voxel[3]
                     filtereddata[voxel[0], :] = voxel[7]
@@ -211,7 +213,7 @@ def glmpass(
                     filtereddata[voxel[0], :] = voxel[7]
                     itemstotal += 1
         else:
-            if confoundglm:
+            if confoundregress:
                 for timepoint in data_out:
                     r2value[timepoint[0]] = timepoint[3]
                     filtereddata[:, timepoint[0]] = timepoint[7]
@@ -243,7 +245,7 @@ def glmpass(
             ):
                 thedata = fmri_data[vox, :].copy()
                 if (themask is None) or (themask[vox] > 0):
-                    if confoundglm:
+                    if confoundregress:
                         (
                             dummy,
                             dummy,
@@ -253,7 +255,7 @@ def glmpass(
                             dummy,
                             dummy,
                             filtereddata[vox, :],
-                        ) = _procOneGLMItem(
+                        ) = _procOneRegressionFitItem(
                             vox,
                             theevs,
                             thedata,
@@ -270,7 +272,7 @@ def glmpass(
                             fitNorm[vox],
                             datatoremove[vox, :],
                             filtereddata[vox, :],
-                        ) = _procOneGLMItem(
+                        ) = _procOneRegressionFitItem(
                             vox,
                             theevs[vox, :],
                             thedata,
@@ -287,7 +289,7 @@ def glmpass(
             ):
                 thedata = fmri_data[:, timepoint].copy()
                 if (themask is None) or (themask[timepoint] > 0):
-                    if confoundglm:
+                    if confoundregress:
                         (
                             dummy,
                             dummy,
@@ -297,7 +299,7 @@ def glmpass(
                             dummy,
                             dummy,
                             filtereddata[:, timepoint],
-                        ) = _procOneGLMItem(
+                        ) = _procOneRegressionFitItem(
                             timepoint,
                             theevs,
                             thedata,
@@ -314,7 +316,7 @@ def glmpass(
                             fitNorm[timepoint],
                             datatoremove[:, timepoint],
                             filtereddata[:, timepoint],
-                        ) = _procOneGLMItem(
+                        ) = _procOneRegressionFitItem(
                             timepoint,
                             theevs[:, timepoint],
                             thedata,
@@ -425,7 +427,7 @@ def confoundregress(
     numprocitems = thedataarray.shape[0]
     filtereddata = thedataarray * 0.0
     r2value = np.zeros(numprocitems)
-    numfiltered = glmpass(
+    numfiltered = linfitfiltpass(
         numprocitems,
         thedataarray,
         None,
@@ -437,7 +439,7 @@ def confoundregress(
         None,
         None,
         filtereddata,
-        confoundglm=True,
+        confoundregress=True,
         nprocs=nprocs,
         showprogressbar=showprogressbar,
         procbyvoxel=True,

rapidtide/refinedelay.py

@@ -24,7 +24,7 @@ from statsmodels.robust import mad
 
 import rapidtide.filter as tide_filt
 import rapidtide.io as tide_io
-import rapidtide.workflows.glmfrommaps as tide_glmfrommaps
+import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 
 global ratiotooffsetfunc, maplimits
 
@@ -40,12 +40,14 @@ def trainratiotooffset(
     timeaxis,
     outputname,
     outputlevel,
+    trainwidth=0.0,
+    trainstep=0.5,
     mindelay=-3.0,
     maxdelay=3.0,
     numpoints=501,
     smoothpts=3,
     edgepad=5,
-    glmderivs=1,
+    regressderivs=1,
     debug=False,
 ):
     global ratiotooffsetfunc, maplimits
@@ -55,11 +57,13 @@ def trainratiotooffset(
         lagtcgenerator.info(prefix="\t")
         print("\ttimeaxis:", timeaxis)
         print("\toutputname:", outputname)
+        print("\ttrainwidth:", trainwidth)
+        print("\ttrainstep:", trainstep)
         print("\tmindelay:", mindelay)
         print("\tmaxdelay:", maxdelay)
         print("\tsmoothpts:", smoothpts)
         print("\tedgepad:", edgepad)
-        print("\tglmderivs:", glmderivs)
+        print("\tregressderivs:", regressderivs)
         print("\tlagtcgenerator:", lagtcgenerator)
     # make a delay map
     delaystep = (maxdelay - mindelay) / (numpoints - 1)
@@ -78,16 +82,13 @@ def trainratiotooffset(
         print(f"{maxdelay=}")
         print("lagtimes=", lagtimes)
 
-    # now make synthetic fMRI data
+    # set up for getratioderivs call
+    rt_floattype = "float64"
     internalvalidfmrishape = (numpoints + 2 * edgepad, timeaxis.shape[0])
     fmridata = np.zeros(internalvalidfmrishape, dtype=float)
     fmrimask = np.ones(numpoints + 2 * edgepad, dtype=float)
     validvoxels = np.where(fmrimask > 0)[0]
-    for i in range(numpoints + 2 * edgepad):
-        fmridata[i, :] = lagtcgenerator.yfromx(timeaxis - lagtimes[i])
-
-    rt_floattype = "float64"
-    glmmean = np.zeros(numpoints + 2 * edgepad, dtype=rt_floattype)
+    sLFOfitmean = np.zeros(numpoints + 2 * edgepad, dtype=rt_floattype)
     rvalue = np.zeros(numpoints + 2 * edgepad, dtype=rt_floattype)
     r2value = np.zeros(numpoints + 2 * edgepad, dtype=rt_floattype)
     fitNorm = np.zeros((numpoints + 2 * edgepad, 2), dtype=rt_floattype)
@@ -97,10 +98,10 @@ def trainratiotooffset(
     filtereddata = np.zeros(internalvalidfmrishape, dtype=rt_floattype)
     sampletime = timeaxis[1] - timeaxis[0]
     optiondict = {
-        "glmthreshval": 0.0,
-        "saveminimumglmfiles": False,
+        "regressfiltthreshval": 0.0,
+        "saveminimumsLFOfiltfiles": False,
         "nprocs_makelaggedtcs": 1,
-        "nprocs_glm": 1,
+        "nprocs_regressionfilt": 1,
         "mp_chunksize": 1000,
         "showprogressbar": False,
         "alwaysmultiproc": False,
@@ -110,7 +111,27 @@ def trainratiotooffset(
         "textio": False,
     }
 
-    glmderivratios = getderivratios(
+    if trainwidth > 0.0:
+        numsteps = int(trainwidth / trainstep)
+        numsteps += 1 - numsteps % 2  # force numsteps to be odd
+        numsteps = np.max((numsteps, 3))  # ensure at least 1 positive and 1 negative step
+        trainoffsets = (
+            np.linspace(0, numsteps * trainstep, numsteps, endpoint=True)
+            - (numsteps // 2) * trainstep
+        )
+    else:
+        trainoffsets = np.array([0.0], dtype=float)
+    if debug:
+        print("trainoffsets:", trainoffsets)
+
+    for i in range(len(trainoffsets)):
+        pass
+
+    # now make synthetic fMRI data
+    for i in range(numpoints + 2 * edgepad):
+        fmridata[i, :] = lagtcgenerator.yfromx(timeaxis - lagtimes[i])
+
+    regressderivratios, regressrvalues = getderivratios(
         fmridata,
         validvoxels,
         timeaxis,
@@ -120,7 +141,7 @@ def trainratiotooffset(
         "glm",
         "refinedelaytest",
         sampletime,
-        glmmean,
+        sLFOfitmean,
         rvalue,
         r2value,
         fitNorm[:, :2],
@@ -131,41 +152,41 @@ def trainratiotooffset(
         None,
         None,
         optiondict,
-        glmderivs=glmderivs,
+        regressderivs=regressderivs,
         debug=debug,
     )
     if debug:
         print("before trimming")
-        print(f"{glmderivratios.shape=}")
+        print(f"{regressderivratios.shape=}")
         print(f"{lagtimes.shape=}")
-    if glmderivs == 1:
-        smoothglmderivratios = tide_filt.unpadvec(
-            smooth(tide_filt.padvec(glmderivratios, padlen=20, padtype="constant"), smoothpts),
+    if regressderivs == 1:
+        smoothregressderivratios = tide_filt.unpadvec(
+            smooth(tide_filt.padvec(regressderivratios, padlen=20, padtype="constant"), smoothpts),
             padlen=20,
         )
-        glmderivratios = glmderivratios[edgepad:-edgepad]
-        smoothglmderivratios = smoothglmderivratios[edgepad:-edgepad]
+        regressderivratios = regressderivratios[edgepad:-edgepad]
+        smoothregressderivratios = smoothregressderivratios[edgepad:-edgepad]
     else:
-        smoothglmderivratios = np.zeros_like(glmderivratios)
-        for i in range(glmderivs):
-            smoothglmderivratios[i, :] = tide_filt.unpadvec(
+        smoothregressderivratios = np.zeros_like(regressderivratios)
+        for i in range(regressderivs):
+            smoothregressderivratios[i, :] = tide_filt.unpadvec(
                 smooth(
-                    tide_filt.padvec(glmderivratios[i, :], padlen=20, padtype="constant"),
+                    tide_filt.padvec(regressderivratios[i, :], padlen=20, padtype="constant"),
                     smoothpts,
                 ),
                 padlen=20,
             )
-        glmderivratios = glmderivratios[:, edgepad:-edgepad]
-        smoothglmderivratios = smoothglmderivratios[:, edgepad:-edgepad]
+        regressderivratios = regressderivratios[:, edgepad:-edgepad]
+        smoothregressderivratios = smoothregressderivratios[:, edgepad:-edgepad]
     lagtimes = lagtimes[edgepad:-edgepad]
     if debug:
         print("after trimming")
-        print(f"{glmderivratios.shape=}")
-        print(f"{smoothglmderivratios.shape=}")
+        print(f"{regressderivratios.shape=}")
+        print(f"{smoothregressderivratios.shape=}")
         print(f"{lagtimes.shape=}")
 
     # make sure the mapping function is legal
-    xaxis = smoothglmderivratios[::-1]
+    xaxis = smoothregressderivratios[::-1]
     yaxis = lagtimes[::-1]
     midpoint = int(len(xaxis) // 2)
     lowerlim = midpoint + 0
@@ -187,7 +208,13 @@ def trainratiotooffset(
             1.0 / (resampaxis[1] - resampaxis[0]),
             starttime=resampaxis[0],
             columns=["delay"],
-            extraheaderinfo={"Description": "The function mapping derivative ratio to delay"},
+            extraheaderinfo={
+                "Description": "The function mapping derivative ratio to delay",
+                "minratio": f"{resampaxis[0]}",
+                "maxratio": f"{resampaxis[-1]}",
+            },
+            xaxislabel="coefficientratio",
+            yaxislabel="time",
             append=False,
         )
 
@@ -240,7 +267,7 @@ def getderivratios(
     mode,
     outputname,
     oversamptr,
-    glmmean,
+    sLFOfitmean,
     rvalue,
     r2value,
     fitNorm,
@@ -251,25 +278,34 @@ def getderivratios(
     LGR,
     TimingLGR,
     optiondict,
-    glmderivs=1,
+    regressderivs=1,
+    starttr=None,
+    endtr=None,
     debug=False,
 ):
+    if starttr is None:
+        starttr = 0
+    if endtr is None:
+        endtr = fmri_data_valid.shape[1]
     if debug:
         print("getderivratios")
         print(f"{fitNorm.shape=}")
         print(f"{fitcoeff.shape=}")
-        print(f"{glmderivs=}")
-    voxelsprocessed_glm, regressorset, evset = tide_glmfrommaps.glmfrommaps(
-        fmri_data_valid,
+        print(f"{regressderivs=}")
+        print(f"{starttr=}")
+        print(f"{endtr=}")
+
+    voxelsprocessed_regressionfilt, regressorset, evset = tide_regressfrommaps.regressfrommaps(
+        fmri_data_valid[:, starttr:endtr],
         validvoxels,
-        initial_fmri_x,
+        initial_fmri_x[starttr:endtr],
         lagtimes,
         fitmask,
         genlagtc,
         mode,
         outputname,
         oversamptr,
-        glmmean,
+        sLFOfitmean,
         rvalue,
         r2value,
         fitNorm,
@@ -279,11 +315,11 @@ def getderivratios(
         filtereddata,
         LGR,
         TimingLGR,
-        optiondict["glmthreshval"],
-        optiondict["saveminimumglmfiles"],
+        optiondict["regressfiltthreshval"],
+        optiondict["saveminimumsLFOfiltfiles"],
         nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
-        nprocs_glm=optiondict["nprocs_glm"],
-        glmderivs=glmderivs,
+        nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
+        regressderivs=regressderivs,
         mp_chunksize=optiondict["mp_chunksize"],
         showprogressbar=optiondict["showprogressbar"],
         alwaysmultiproc=optiondict["alwaysmultiproc"],
@@ -292,19 +328,19 @@ def getderivratios(
     )
 
     # calculate the ratio of the first derivative to the main regressor
-    if glmderivs == 1:
-        glmderivratios = np.nan_to_num(fitcoeff[:, 1] / fitcoeff[:, 0])
+    if regressderivs == 1:
+        regressderivratios = np.nan_to_num(fitcoeff[:, 1] / fitcoeff[:, 0])
     else:
         numvoxels = fitcoeff.shape[0]
-        glmderivratios = np.zeros((glmderivs, numvoxels), dtype=np.float64)
-        for i in range(glmderivs):
-            glmderivratios[i, :] = np.nan_to_num(fitcoeff[:, i + 1] / fitcoeff[:, 0])
+        regressderivratios = np.zeros((regressderivs, numvoxels), dtype=np.float64)
+        for i in range(regressderivs):
+            regressderivratios[i, :] = np.nan_to_num(fitcoeff[:, i + 1] / fitcoeff[:, 0])
 
-    return glmderivratios
+    return regressderivratios, rvalue
 
 
 def filterderivratios(
-    glmderivratios,
+    regressderivratios,
     nativespaceshape,
     validvoxels,
     thedims,
@@ -323,32 +359,34 @@ def filterderivratios(
         print(f"\t{nativespaceshape=}")
 
     # filter the ratio to find weird values
-    themad = mad(glmderivratios).astype(np.float64)
-    print(f"MAD of GLM derivative ratios = {themad}")
+    themad = mad(regressderivratios).astype(np.float64)
+    print(f"MAD of regression fit derivative ratios = {themad}")
     outmaparray, internalspaceshape = tide_io.makedestarray(
         nativespaceshape,
         textio=textio,
         fileiscifti=fileiscifti,
         rt_floattype=rt_floattype,
     )
-    mappedglmderivratios = tide_io.populatemap(
-        glmderivratios,
+    mappedregressderivratios = tide_io.populatemap(
+        regressderivratios,
         internalspaceshape,
         validvoxels,
         outmaparray,
         debug=debug,
     )
     if textio or fileiscifti:
-        medfilt = glmderivratios
-        filteredarray = glmderivratios
+        medfilt = regressderivratios
+        filteredarray = regressderivratios
     else:
         if debug:
-            print(f"{glmderivratios.shape=}, {mappedglmderivratios.shape=}")
+            print(f"{regressderivratios.shape=}, {mappedregressderivratios.shape=}")
         medfilt = median_filter(
-            mappedglmderivratios.reshape(nativespaceshape), size=(3, 3, 3)
+            mappedregressderivratios.reshape(nativespaceshape), size=(3, 3, 3)
         ).reshape(internalspaceshape)[validvoxels]
         filteredarray = np.where(
-            np.fabs(glmderivratios - medfilt) > patchthresh * themad, medfilt, glmderivratios
+            np.fabs(regressderivratios - medfilt) > patchthresh * themad,
+            medfilt,
+            regressderivratios,
         )
         if gausssigma > 0:
             mappedfilteredarray = tide_io.populatemap(

rapidtide/resample.py

@@ -328,6 +328,9 @@ class FastResampler:
             pl.legend(("input", "hires"))
             pl.show()
 
+    def getdata(self):
+        return self.timeaxis, self.timecourse, self.hires_x, self.hires_y, 1.0 / self.initstep
+
     def info(self, prefix=""):
         print(f"{prefix}{self.timeaxis=}")
         print(f"{prefix}{self.timecourse=}")

rapidtide/scripts/{retroglm.py → delayvar.py}

@@ -17,11 +17,11 @@
 #
 #
 import rapidtide.workflows.parser_funcs as pf
-import rapidtide.workflows.retroglm as theworkflow
+import rapidtide.workflows.delayvar as theworkflow
 
 
 def entrypoint():
-    pf.generic_init(theworkflow._get_parser, theworkflow.retroglm)
+    pf.generic_init(theworkflow._get_parser, theworkflow.delayvar)
 
 
 if __name__ == "__main__":

rapidtide/scripts/{glmfilt.py → linfitfilt.py}

@@ -16,11 +16,11 @@
 #   limitations under the License.
 #
 #
-import rapidtide.workflows.glmfilt as glmfilt_workflow
+import rapidtide.workflows.linfitfilt as linfitfilt_workflow
 
 
 def entrypoint():
-    glmfilt_workflow.main()
+    linfitfilt_workflow.main()
 
 
 if __name__ == "__main__":