rapidtide 3.0.11__py3-none-any.whl → 3.1.1__py3-none-any.whl

rapidtide/workflows/rapidtide.py

@@ -23,8 +23,10 @@ import platform
 import sys
 import warnings
 from pathlib import Path
+from typing import Any, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from scipy.stats import rankdata
 
 import rapidtide.calccoherence as tide_calccoherence
@@ -65,8 +67,40 @@ LGR = logging.getLogger("GENERAL")
 ErrorLGR = logging.getLogger("ERROR")
 TimingLGR = logging.getLogger("TIMING")
 
-
-def checkforzeromean(thedataset):
+global rt_floattype
+rt_floattype: np.dtype = np.float64
+
+
+def checkforzeromean(thedataset: Any) -> bool:
+    """
+    Check if the mean of dataset is zero.
+
+    Parameters
+    ----------
+    thedataset : array-like
+        Input dataset to check for zero mean. Should be array-like structure
+        that can be processed by numpy mean and std functions.
+
+    Returns
+    -------
+    bool
+        True if the mean of standard deviations is greater than the mean of means,
+        False otherwise.
+
+    Notes
+    -----
+    This function calculates the mean and standard deviation along axis 1,
+    then compares the means of these two arrays. The function name suggests
+    checking for zero mean, but the implementation actually compares means
+    and standard deviations rather than directly checking if mean equals zero.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> data = np.array([[1, 2, 3], [4, 5, 6]])
+    >>> checkforzeromean(data)
+    False
+    """
     themean = np.mean(thedataset, axis=1)
     thestd = np.std(thedataset, axis=1)
     if np.mean(thestd) > np.mean(themean):
@@ -75,7 +109,59 @@ def checkforzeromean(thedataset):
         return False
 
 
-def echocancel(thetimecourse, echooffset, thetimestep, outputname, padtimepoints):
+def echocancel(
+    thetimecourse: Any, echooffset: Any, thetimestep: Any, outputname: Any, padtimepoints: Any
+) -> Tuple[NDArray, NDArray, float]:
+    """
+    Perform echo cancellation on a timecourse using linear regression.
+
+    This function applies echo cancellation to a given timecourse by modeling the echo signal
+    and subtracting its contribution from the original signal. The echo is shifted in time
+    according to `echooffset` and then fitted using maximum likelihood regression. The
+    resulting filtered timecourse is saved along with the original and echo components.
+
+    Parameters
+    ----------
+    thetimecourse : array-like
+        The input timecourse data to be processed.
+    echooffset : float
+        The time offset (in seconds) of the echo signal relative to the input timecourse.
+    thetimestep : float
+        The time step (in seconds) of the input timecourse.
+    outputname : str
+        Base name for output files; used to construct filenames for saved results.
+    padtimepoints : int
+        Number of timepoints to pad during resampling of the echo signal.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - `outputtimecourse`: The timecourse after echo cancellation.
+        - `echofit`: The regression coefficients from fitting the echo signal.
+        - `echoR2`: The R-squared value of the echo fit.
+
+    Notes
+    -----
+    - The function writes three separate TSV files:
+        1. Original timecourse.
+        2. Echo signal.
+        3. Filtered (echo-cancelled) timecourse.
+    - The echo signal is shifted in time using `tide_resample.timeshift`.
+    - The echo is zeroed out at the beginning up to the computed shift.
+    - The function uses `tide_fit.mlregress` for linear regression fitting.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> timecourse = np.random.rand(100)
+    >>> echo_offset = 2.0
+    >>> time_step = 1.0
+    >>> output_name = "test_output"
+    >>> pad_points = 10
+    >>> result = echocancel(timecourse, echo_offset, time_step, output_name, pad_points)
+    >>> filtered_tc, fit_coeffs, r2 = result
+    """
     tide_io.writebidstsv(
         f"{outputname}_desc-echocancellation_timeseries",
         thetimecourse,
@@ -114,12 +200,84 @@ def echocancel(thetimecourse, echooffset, thetimestep, outputname, padtimepoints
     )
     return outputtimecourse, echofit, echoR2
 
-def setpassoptions(passdict, optiondict):
+
+def setpassoptions(passdict: Any, optiondict: Any) -> None:
+    """
+    Copy key-value pairs from passdict to optiondict.
+
+    This function updates the optiondict with key-value pairs from passdict,
+    effectively passing options from one dictionary to another.
+
+    Parameters
+    ----------
+    passdict : Any
+        Dictionary containing options to be passed
+    optiondict : Any
+        Dictionary that will receive the options from passdict
+
+    Returns
+    -------
+    None
+        This function modifies optiondict in-place and returns None
+
+    Notes
+    -----
+    This function performs an in-place update of optiondict. Any existing keys
+    in optiondict that are also present in passdict will be overwritten with
+    the values from passdict.
+
+    Examples
+    --------
+    >>> options = {'verbose': True, 'timeout': 30}
+    >>> new_options = {'debug': False}
+    >>> setpassoptions(options, new_options)
+    >>> print(new_options)
+    {'debug': False, 'verbose': True, 'timeout': 30}
+    """
     for key, value in passdict.items():
         optiondict[key] = value
 
 
-def rapidtide_main(argparsingfunc):
+def rapidtide_main(argparsingfunc: Any) -> None:
+    """
+    Process fMRI data to perform spatially localized signal-to-noise ratio (sLFO) analysis.
+
+    This function performs a comprehensive analysis of fMRI data including correlation
+    analysis, signal filtering, and various statistical computations to identify and
+    remove spatially localized noise components.
+
+    Parameters
+    ----------
+    None
+
+    Returns
+    -------
+    None
+        The function performs in-place processing and saves results to files.
+
+    Notes
+    -----
+    This function is designed to be called as part of a larger pipeline for fMRI
+    preprocessing and analysis. It handles multiple stages including:
+
+    1. Data initialization and validation
+    2. Correlation analysis across spatial locations
+    3. Signal filtering and noise removal
+    4. Statistical computations and result saving
+    5. Timing and logging management
+
+    Examples
+    --------
+    >>> process_fmri_data()
+    # Processes fMRI data and saves results to output files
+
+    See Also
+    --------
+    tide_regressfrommaps : Performs regression analysis on fMRI data
+    tide_io : Handles input/output operations for fMRI data
+    tide_util : Utility functions for processing fMRI data
+
+    """
     optiondict, theprefilter = argparsingfunc
     optiondict["threaddebug"] = False
 
@@ -179,7 +337,7 @@ def rapidtide_main(argparsingfunc):
         logger_filename=f"{outputname}_log.txt",
         timing_filename=f"{outputname}_runtimings.tsv",
         memory_filename=f"{outputname}_memusage.tsv",
-        verbose=optiondict["verbose"],
+        isverbose=optiondict["verbose"],
         debug=optiondict["debug"],
     )
     TimingLGR.info("Start")
@@ -211,25 +369,21 @@ def rapidtide_main(argparsingfunc):
         tide_util.disablenumba()
 
     # set the internal precision
-    global rt_floatset, rt_floattype
+    global rt_floattype
     if optiondict["internalprecision"] == "double":
         LGR.debug("setting internal precision to double")
-        rt_floattype = "float64"
-        rt_floatset = np.float64
+        rt_floattype = np.float64
     else:
         LGR.debug("setting internal precision to single")
-        rt_floattype = "float32"
-        rt_floatset = np.float32
+        rt_floattype = np.float32
 
     # set the output precision
     if optiondict["outputprecision"] == "double":
         LGR.debug("setting output precision to double")
-        rt_outfloattype = "float64"
-        rt_outfloatset = np.float64
+        rt_outfloattype = np.float64
     else:
         LGR.debug("setting output precision to single")
-        rt_outfloattype = "float32"
-        rt_outfloatset = np.float32
+        rt_outfloattype = np.float32
 
     # set the number of worker processes if multiprocessing
     if optiondict["nprocs"] < 1:
@@ -306,6 +460,7 @@ def rapidtide_main(argparsingfunc):
     if optiondict["oversampfactor"] < 0:
         optiondict["oversampfactor"] = int(np.max([np.ceil(fmritr / 0.5), 1]))
         LGR.debug(f"oversample factor set to {optiondict['oversampfactor']}")
+    # optiondict["prewhitenlags"] *= optiondict["oversampfactor"]
 
     oversamptr = fmritr / optiondict["oversampfactor"]
     LGR.verbose(f"fmri data: {timepoints} timepoints, tr = {fmritr}, oversamptr = {oversamptr}")
@@ -350,6 +505,13 @@ def rapidtide_main(argparsingfunc):
     optiondict["osvalidsimcalcend"] = osvalidsimcalcend
     optiondict["simcalcoffset"] = -validsimcalcstart * fmritr
 
+    ####################################################
+    # Calculate initial stats
+    ####################################################
+    init_min, init_max, init_mean, init_std, init_median, init_MAD, init_skew, init_kurtosis = (
+        tide_stats.fmristats(theinputdata.byvoxel())
+    )
+
     ####################################################
     #  Prepare data
     ####################################################
@@ -372,13 +534,13 @@ def rapidtide_main(argparsingfunc):
                     valslist=optiondict[thisanatomic[1]],
                     maskname=thisanatomic[2],
                     tolerance=optiondict["spatialtolerance"],
-                    debug=optiondict["focaldebug"],
+                    debug=optiondict["debug"],
                 )
             )
             anatomicmasks[-1] = np.uint16(np.where(anatomicmasks[-1] > 0.1, 1, 0))
         else:
-            anatomicmasks.append(None)
-            # anatomicmasks[-1] = np.uint16(np.ones(nativespaceshape, dtype=np.uint16))
+            anatomicmasks.append(np.uint16(np.ones(nativespaceshape, dtype=np.uint16)))
+
     brainmask = anatomicmasks[0]
     graymask = anatomicmasks[1]
     whitemask = anatomicmasks[2]
@@ -443,7 +605,7 @@ def rapidtide_main(argparsingfunc):
             numspatiallocs,
             istext=(theinputdata.filetype == "text"),
             tolerance=optiondict["spatialtolerance"],
-            debug=optiondict["focaldebug"],
+            debug=optiondict["debug"],
         )
     )
     if internalinvbrainmask is not None:
@@ -462,7 +624,7 @@ def rapidtide_main(argparsingfunc):
         numspatiallocs,
         istext=(theinputdata.filetype == "text"),
         tolerance=optiondict["spatialtolerance"],
-        debug=optiondict["focaldebug"],
+        debug=optiondict["debug"],
     )
     if internalinvbrainmask is not None:
         if internalrefineexcludemask is not None:
@@ -480,7 +642,7 @@ def rapidtide_main(argparsingfunc):
         numspatiallocs,
         istext=(theinputdata.filetype == "text"),
         tolerance=optiondict["spatialtolerance"],
-        debug=optiondict["focaldebug"],
+        debug=optiondict["debug"],
     )
     if internalinvbrainmask is not None:
         if internaloffsetexcludemask is not None:
@@ -502,7 +664,7 @@ def rapidtide_main(argparsingfunc):
             valslist=optiondict["corrmaskincludevals"],
             maskname="correlation",
             tolerance=optiondict["spatialtolerance"],
-            debug=optiondict["focaldebug"],
+            debug=optiondict["debug"],
         )
 
         corrmask = np.uint16(np.where(thecorrmask > 0, 1, 0).reshape(numspatiallocs))
@@ -630,7 +792,7 @@ def rapidtide_main(argparsingfunc):
         LGR.info("moving fmri data to shared memory")
         TimingLGR.verbose("Start moving fmri_data to shared memory")
         fmri_data_valid, fmri_data_valid_shm = tide_util.numpy2shared(
-            fmri_data_valid, rt_floatset, name=f"fmri_data_valid_{optiondict['pid']}"
+            fmri_data_valid, rt_floattype, name=f"fmri_data_valid_{optiondict['pid']}"
         )
         TimingLGR.verbose("End moving fmri_data to shared memory")
 
@@ -1100,7 +1262,7 @@ def rapidtide_main(argparsingfunc):
             padlen=int(inputfreq * optiondict["padseconds"]),
             debug=optiondict["debug"],
         )
-        reference_y = rt_floatset(reference_y_filt.real)
+        reference_y = (reference_y_filt.real).astype(rt_floattype)
 
     warnings.filterwarnings("ignore", "Casting*")
 
@@ -1161,11 +1323,11 @@ def rapidtide_main(argparsingfunc):
     # save the factor used to normalize the input regressor
     optiondict["initialmovingregressornormfac"] = np.std(resampnonosref_y)
 
-    # prepare the temporal mask
+    # prepare the temporal masks
     if optiondict["tincludemaskname"] is not None:
         print("creating temporal include mask")
         includetmask_y = tide_mask.maketmask(
-            optiondict["tincludemaskname"], reference_x, rt_floatset(reference_y) + 0.0
+            optiondict["tincludemaskname"], reference_x, reference_y.astype(rt_floattype) + 0.0
         )
     else:
         includetmask_y = (reference_x * 0.0) + 1.0
@@ -1174,7 +1336,7 @@ def rapidtide_main(argparsingfunc):
         excludetmask_y = (
             -1.0
             * tide_mask.maketmask(
-                optiondict["texcludemaskname"], reference_x, rt_floatset(reference_y) + 0.0
+                optiondict["texcludemaskname"], reference_x, reference_y.astype(rt_floattype) + 0.0
             )
             + 1.0
         )
@@ -1210,6 +1372,9 @@ def rapidtide_main(argparsingfunc):
     else:
         tmaskos_y = None
 
+    # construct refine temporal masks here
+    optiondict["windowedrefinemasks"] = None
+
     (
         optiondict["kurtosis_reference_pass1"],
         optiondict["kurtosisz_reference_pass1"],
@@ -1260,7 +1425,7 @@ def rapidtide_main(argparsingfunc):
         corrpadding=optiondict["corrpadding"],
         debug=optiondict["debug"],
     )
-    if optiondict["focaldebug"]:
+    if optiondict["debug"]:
         print(
             f"calling setreftc during initialization with length {optiondict['oversampfactor'] * validtimepoints}"
         )
@@ -1384,7 +1549,7 @@ def rapidtide_main(argparsingfunc):
     fitmask = np.zeros(internalvalidspaceshape, dtype="uint16")
     failreason = np.zeros(internalvalidspaceshape, dtype="uint32")
     R2 = np.zeros(internalvalidspaceshape, dtype=rt_floattype)
-    outmaparray = np.zeros(internalspaceshape, dtype=rt_floattype)
+    outmaparray = np.zeros((internalspaceshape), dtype=rt_floattype)
     tide_util.logmem("after main array allocation")
 
     if optiondict["similaritymetric"] == "riptide":
@@ -1400,7 +1565,6 @@ def rapidtide_main(argparsingfunc):
             chunksize=optiondict["mp_chunksize"],
             nprocs=optiondict["nprocs"],
             alwaysmultiproc=optiondict["alwaysmultiproc"],
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
             debug=optiondict["debug"],
         )
@@ -1426,25 +1590,25 @@ def rapidtide_main(argparsingfunc):
 
     corrout, corrout_shm = tide_util.allocarray(
         internalvalidcorrshape,
-        rt_floatset,
+        rt_floattype,
         shared=optiondict["sharedmem"],
         name=f"corrout_{optiondict['pid']}",
     )
     gaussout, gaussout_shm = tide_util.allocarray(
         internalvalidcorrshape,
-        rt_floatset,
+        rt_floattype,
         shared=optiondict["sharedmem"],
         name=f"gaussout_{optiondict['pid']}",
     )
     windowout, windowout_shm = tide_util.allocarray(
         internalvalidcorrshape,
-        rt_floatset,
+        rt_floattype,
         shared=optiondict["sharedmem"],
         name=f"windowout_{optiondict['pid']}",
     )
     outcorrarray, outcorrarray_shm = tide_util.allocarray(
         internalcorrshape,
-        rt_floatset,
+        rt_floattype,
         shared=optiondict["sharedmem"],
         name=f"outcorrarray_{optiondict['pid']}",
     )
@@ -1613,6 +1777,8 @@ def rapidtide_main(argparsingfunc):
             tmask_y=tmask_y,
             tmaskos_y=tmaskos_y,
             fastresamplerpadtime=optiondict["fastresamplerpadtime"],
+            prewhitenregressor=False,
+            prewhitenlags=optiondict["prewhitenlags"],
             debug=optiondict["debug"],
         )
 
@@ -1674,7 +1840,6 @@ def rapidtide_main(argparsingfunc):
             interptype=optiondict["interptype"],
             showprogressbar=optiondict["showprogressbar"],
             chunksize=optiondict["mp_chunksize"],
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
         tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
@@ -1713,6 +1878,32 @@ def rapidtide_main(argparsingfunc):
                 "message3": "voxels",
             },
         )
+        tide_io.writebidstsv(
+            f"{outputname}_desc-oversampledmovingregressor_timeseries",
+            tide_math.stdnormalize(resampref_y),
+            oversampfreq,
+            columns=["pass1_echocancel"],
+            extraheaderinfo={
+                "Description": "The probe regressor used in each pass, at the time resolution used for calculating the similarity function"
+            },
+            append=True,
+        )
+
+    # Preprocessing - prewhitening
+    if optiondict["prewhitenregressor"]:
+        resampref_y = tide_fit.prewhiten(
+            resampref_y, optiondict["prewhitenlags"], debug=optiondict["debug"]
+        )
+        tide_io.writebidstsv(
+            f"{outputname}_desc-oversampledmovingregressor_timeseries",
+            tide_math.stdnormalize(resampref_y),
+            oversampfreq,
+            columns=["pass1_prewhiten"],
+            extraheaderinfo={
+                "Description": "The probe regressor used in each pass, at the time resolution used for calculating the similarity function"
+            },
+            append=True,
+        )
 
     # --------------------- Main pass loop ---------------------
     # loop over all passes
@@ -1801,9 +1992,8 @@ def rapidtide_main(argparsingfunc):
             respdelete=optiondict["respdelete"],
             debug=optiondict["debug"],
             rt_floattype=rt_floattype,
-            rt_floatset=rt_floatset,
         )
-        if optiondict["focaldebug"]:
+        if optiondict["debug"]:
             print(
                 f"after cleanregressor: {len(referencetc)=}, {len(cleaned_referencetc)=}, {osvalidsimcalcstart=}, {osvalidsimcalcend=}, {lagmininpts=}, {lagmaxinpts=}"
             )
@@ -1827,7 +2017,7 @@ def rapidtide_main(argparsingfunc):
                     f"{outputname}_options_pregetnull_pass" + str(thepass) + ".json",
                 )
             theCorrelator.setlimits(lagmininpts, lagmaxinpts)
-            if optiondict["focaldebug"]:
+            if optiondict["debug"]:
                 print(
                     f"calling setreftc prior to significance estimation with length {len(cleaned_resampref_y)}"
                 )
@@ -1854,8 +2044,7 @@ def rapidtide_main(argparsingfunc):
                 showprogressbar=optiondict["showprogressbar"],
                 chunksize=optiondict["mp_chunksize"],
                 permutationmethod=optiondict["permutationmethod"],
-                rt_floatset=np.float64,
-                rt_floattype="float64",
+                rt_floattype=np.float64,
             )
             tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
 
@@ -1999,10 +2188,9 @@ def rapidtide_main(argparsingfunc):
             interptype=optiondict["interptype"],
             showprogressbar=optiondict["showprogressbar"],
             chunksize=optiondict["mp_chunksize"],
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
             threaddebug=optiondict["threaddebug"],
-            debug=optiondict["focaldebug"],
+            debug=optiondict["debug"],
         )
         if optiondict["similaritymetric"] == "riptide":
             optiondict["despeckle_passes"] = 0
@@ -2069,8 +2257,7 @@ def rapidtide_main(argparsingfunc):
             LGR,
             TimingLGR,
             simplefit=(optiondict["similaritymetric"] == "riptide"),
-            rt_floatset=np.float64,
-            rt_floattype="float64",
+            rt_floattype=np.float64,
         )
 
         # Step 2b - refine delay (optional)
@@ -2122,7 +2309,6 @@ def rapidtide_main(argparsingfunc):
                 maxdelay=optiondict["maxdelay"],
                 numpoints=optiondict["numpoints"],
                 histlen=optiondict["histlen"],
-                rt_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
                 debug=optiondict["debug"],
             )
@@ -2147,7 +2333,7 @@ def rapidtide_main(argparsingfunc):
                     cifti_hdr=theinputdata.cifti_hdr,
                 )
 
-        # Step 2b - make a rank order map
+        # Step 2c - make a rank order map
         timepercentile = (
             100.0 * (rankdata(lagtimes, method="dense") - 1) / (numvalidspatiallocs - 1)
         )
@@ -2189,7 +2375,7 @@ def rapidtide_main(argparsingfunc):
             or optiondict["initregressorpreselect"]
             or optiondict["dofinalrefine"]
         ):
-            (resampref_y, resampnonosref_y, stoprefining, refinestopreason, genlagtc) = (
+            resampref_y, resampnonosref_y, stoprefining, refinestopreason, genlagtc = (
                 tide_refineRegressor.refineRegressor(
                     LGR,
                     TimingLGR,
@@ -2216,8 +2402,7 @@ def rapidtide_main(argparsingfunc):
                     outputname,
                     nativefmrishape,
                     bidsbasedict,
-                    rt_floatset=np.float64,
-                    rt_floattype="float64",
+                    rt_floattype=np.float64,
                 )
             )
         # End of main pass loop
@@ -2284,19 +2469,19 @@ def rapidtide_main(argparsingfunc):
         # now allocate the arrays needed for the coherence calculation
         coherencefunc, coherencefunc_shm = tide_util.allocarray(
             internalvalidcoherenceshape,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"coherencefunc_{optiondict['pid']}",
         )
         coherencepeakval, coherencepeakval_shm = tide_util.allocarray(
             numvalidspatiallocs,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"coherencepeakval_{optiondict['pid']}",
         )
         coherencepeakfreq, coherencepeakfreq_shm = tide_util.allocarray(
             numvalidspatiallocs,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"coherencepeakfreq_{optiondict['pid']}",
         )
@@ -2360,13 +2545,13 @@ def rapidtide_main(argparsingfunc):
         # now allocate the arrays needed for Wiener deconvolution
         wienerdeconv, wienerdeconv_shm = tide_util.allocarray(
             internalvalidspaceshape,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"wienerdeconv_{optiondict['pid']}",
         )
         wpeak, wpeak_shm = tide_util.allocarray(
             internalvalidspaceshape,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"wpeak_{optiondict['pid']}",
         )
@@ -2387,7 +2572,6 @@ def rapidtide_main(argparsingfunc):
             wienerdeconv,
             wpeak,
             resampref_y,
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
         TimingLGR.info(
@@ -2450,7 +2634,7 @@ def rapidtide_main(argparsingfunc):
 
             if optiondict["docvrmap"]:
                 # percent normalize the fmri data
-                LGR.info("normalzing data for CVR map")
+                LGR.info("normalizing data for CVR map")
                 themean = np.mean(fmri_data_valid, axis=1)
                 fmri_data_valid /= themean[:, None]
 
@@ -2471,7 +2655,7 @@ def rapidtide_main(argparsingfunc):
                 TimingLGR.info("Start moving fmri_data to shared memory")
                 fmri_data_valid, fmri_data_valid_shm = tide_util.numpy2shared(
                     fmri_data_valid,
-                    rt_floatset,
+                    rt_floattype,
                     name=f"fmri_data_valid_regressionfilt_{optiondict['pid']}",
                 )
                 TimingLGR.info("End moving fmri_data to shared memory")
@@ -2587,11 +2771,56 @@ def rapidtide_main(argparsingfunc):
                 maxdelay=optiondict["maxdelay"],
                 numpoints=optiondict["numpoints"],
                 histlen=optiondict["histlen"],
-                rt_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
                 debug=optiondict["debug"],
             )
             lagtimesrefined = lagtimes + delayoffset
+
+            if optiondict["windowedrefinemasks"] is not None:
+                windoweddelayoffsets = []
+                for thetimemask in optiondict["windowedrefinemasks"]:
+                    (
+                        windoweddelayoffset,
+                        dummy,
+                        dummy,
+                        dummy,
+                        dummy,
+                    ) = tide_refineDelayMap.refineDelay(
+                        fmri_data_valid,
+                        initial_fmri_x,
+                        xdim,
+                        ydim,
+                        slicethickness,
+                        sLFOfiltmask,
+                        genlagtc,
+                        oversamptr,
+                        sLFOfitmean,
+                        rvalue,
+                        r2value,
+                        fitNorm,
+                        fitcoeff,
+                        lagtc,
+                        outputname,
+                        validvoxels,
+                        nativespaceshape,
+                        theinputdata,
+                        lagtimes,
+                        optiondict,
+                        LGR,
+                        TimingLGR,
+                        outputlevel=optiondict["outputlevel"],
+                        gausssigma=optiondict["delayoffsetgausssigma"],
+                        patchthresh=optiondict["delaypatchthresh"],
+                        timemask=thetimemask,
+                        mindelay=optiondict["mindelay"],
+                        maxdelay=optiondict["maxdelay"],
+                        numpoints=optiondict["numpoints"],
+                        histlen=optiondict["histlen"],
+                        rt_floattype=rt_floattype,
+                        debug=optiondict["debug"],
+                    )
+                    windoweddelayoffsets.append(windoweddelayoffset)
+
             ####################################################
             #  Delay refinement end
             ####################################################
@@ -2669,6 +2898,12 @@ def rapidtide_main(argparsingfunc):
             varchange = initialvariance * 0.0
             varchange[divlocs] = 100.0 * (finalvariance[divlocs] / initialvariance[divlocs] - 1.0)
 
+            # calculate the voxelwise mean of the filtered data
+            lfofilteredmeanvalue = np.mean(
+                filtereddata,
+                axis=1,
+            )
+
             LGR.info("End filtering operation")
             TimingLGR.info(
                 "sLFO filtering end",
@@ -2978,6 +3213,13 @@ def rapidtide_main(argparsingfunc):
                     "percent",
                     "Change in inband variance after filtering, in percent",
                 ),
+                # (
+                #    lfofilteredmeanvalue,
+                #    "lfofilterMean",
+                #    "map",
+                #    None,
+                #    "Voxelwise mean of the sLFO filtered data",
+                # ),
             ]
             if optiondict["saveminimumsLFOfiltfiles"]:
                 maplist += [
@@ -3039,6 +3281,59 @@ def rapidtide_main(argparsingfunc):
                             "Normalized fit coefficient",
                         ),
                     ]
+                init_std_valid = init_std[validvoxels] + 0.0
+                init_skew_valid = init_skew[validvoxels] + 0.0
+                init_kurtosis_valid = init_kurtosis[validvoxels] + 0.0
+                maplist += [
+                    (init_std_valid, "initialStd", "map", None, "Std of the raw input data"),
+                    (
+                        init_skew_valid,
+                        "initialSkewness",
+                        "map",
+                        None,
+                        "Skewness of the raw input data",
+                    ),
+                    (
+                        init_kurtosis_valid,
+                        "initialKurtosis",
+                        "map",
+                        None,
+                        "Kurtosis of the raw input data",
+                    ),
+                ]
+                (
+                    final_min_valid,
+                    final_max_valid,
+                    final_mean_valid,
+                    final_std_valid,
+                    final_median_valid,
+                    final_MAD_valid,
+                    final_skew_valid,
+                    final_kurtosis_valid,
+                ) = tide_stats.fmristats(filtereddata)
+                maplist += [
+                    (
+                        final_std_valid,
+                        "lfofilterCleanedStd",
+                        "map",
+                        None,
+                        "Std of the sLFO cleaned data",
+                    ),
+                    (
+                        final_skew_valid,
+                        "lfofilterCleanedSkewness",
+                        "map",
+                        None,
+                        "Skewness of the sLFO cleaned data",
+                    ),
+                    (
+                        final_kurtosis_valid,
+                        "lfofilterCleanedKurtosis",
+                        "map",
+                        None,
+                        "Kurtosis of the sLFO cleaned data",
+                    ),
+                ]
         else:
             maplist = [
                 (
@@ -3062,25 +3357,22 @@ def rapidtide_main(argparsingfunc):
                     None,
                     "Percentage of inband variance attributable to CVR regressor",
                 ),
+                (rvalue, "CVRR", "map", None, "R value of the sLFO fit"),
+                (
+                    r2value,
+                    "CVRR2",
+                    "map",
+                    None,
+                    "Squared R value of the sLFO fit (proportion of variance explained)",
+                ),
+                (
+                    fitcoeff[:, 0],
+                    "CVR",
+                    "map",
+                    "percent",
+                    "Percent signal change due to the CVR regressor",
+                )
             ]
-            if optiondict["savenormalsLFOfiltfiles"]:
-                maplist = [
-                    (rvalue, "CVRR", "map", None, "R value of the sLFO fit"),
-                    (
-                        r2value,
-                        "CVRR2",
-                        "map",
-                        None,
-                        "Squared R value of the sLFO fit (proportion of variance explained)",
-                    ),
-                    (
-                        fitcoeff,
-                        "CVR",
-                        "map",
-                        "percent",
-                        "Percent signal change due to the CVR regressor",
-                    ),
-                ]
 
         tide_io.savemaplist(
             outputname,