rapidtide 3.0.7__py3-none-any.whl → 3.0.8__py3-none-any.whl

rapidtide/workflows/rapidtide_parser.py

@@ -72,7 +72,6 @@ DEFAULT_REFINE_PRENORM = "var"
 DEFAULT_REFINE_WEIGHTING = "None"
 DEFAULT_REFINE_PCACOMPONENTS = 0.8
 DEFAULT_REGRESSIONFILTDERIVS = 0
-DEFAULT_REFINEREGRESSDERIVS = 1
 
 DEFAULT_DENOISING_LAGMIN = -10.0
 DEFAULT_DENOISING_LAGMAX = 10.0
@@ -1444,16 +1443,11 @@ def _get_parser():
         "Experimental options (not fully tested, or not tested at all, may not work).  Beware!"
     )
     experimental.add_argument(
-        "--refineregressderivs",
-        dest="refineregressderivs",
-        action="store",
-        type=lambda x: pf.is_int(parser, x, minval=1),
-        metavar="NDERIVS",
-        help=(
-            f"When doing regression fit for delay refinement, include derivatives up to NDERIVS order. Must be 1 or more.  "
-            f"Default is {DEFAULT_REFINEREGRESSDERIVS}"
-        ),
-        default=DEFAULT_REFINEREGRESSDERIVS,
+        "--refinedelayeachpass",
+        dest="refinedelayeachpass",
+        action="store_true",
+        help=("Do delay refinement in each pass."),
+        default=False,
     )
     experimental.add_argument(
         "--dofinalrefine",
@@ -1463,10 +1457,10 @@ def _get_parser():
         default=False,
     )
     experimental.add_argument(
-        "--nosLFOfiltmask",
-        dest="nosLFOfiltmask",
+        "--sLFOfiltmask",
+        dest="sLFOfiltmask",
         action="store_true",
-        help=("Don't spatially limit sLFO filter to fit voxels."),
+        help=("Limit sLFO filter to fit voxels."),
         default=False,
     )
     experimental.add_argument(
@@ -1483,13 +1477,6 @@ def _get_parser():
         ),
         default=None,
     )
-    experimental.add_argument(
-        "--psdfilter",
-        dest="psdfilter",
-        action="store_true",
-        help=("Apply a PSD weighted Wiener filter to shifted timecourses prior to refinement."),
-        default=False,
-    )
     experimental.add_argument(
         "--wiener",
         dest="dodeconv",
@@ -1497,26 +1484,6 @@ def _get_parser():
         help=("Do Wiener deconvolution to find voxel transfer function."),
         default=False,
     )
-    experimental.add_argument(
-        "--corrbaselinespatialsigma",
-        dest="corrbaselinespatialsigma",
-        action="store",
-        type=float,
-        metavar="SIGMA",
-        help=("Spatial lowpass kernel, in mm, for filtering the correlation function baseline. "),
-        default=0.0,
-    )
-    experimental.add_argument(
-        "--corrbaselinetemphpfcutoff",
-        dest="corrbaselinetemphpfcutoff",
-        action="store",
-        type=float,
-        metavar="FREQ",
-        help=(
-            "Temporal highpass cutoff, in Hz, for filtering the correlation function baseline. "
-        ),
-        default=0.0,
-    )
     experimental.add_argument(
         "--echocancel",
         dest="echocancel",

rapidtide/workflows/refineDelayMap.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2016-2025 Blaise Frederick
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+import numpy as np
+
+import rapidtide.refinedelay as tide_refinedelay
+import rapidtide.stats as tide_stats
+
+
+def 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="normal",
+    gausssigma=-1,
+    patchthresh=3.0,
+    mindelay=-5.0,
+    maxdelay=5.0,
+    numpoints=501,
+    histlen=101,
+    rt_floatset=np.float64,
+    rt_floattype="float64",
+    debug=False,
+):
+    # do the calibration
+    TimingLGR.info("Refinement calibration start")
+    regressderivratios, regressrvalues = tide_refinedelay.getderivratios(
+        fmri_data_valid,
+        validvoxels,
+        initial_fmri_x,
+        lagtimes,
+        sLFOfiltmask,
+        genlagtc,
+        "glm",
+        outputname,
+        oversamptr,
+        sLFOfitmean,
+        rvalue,
+        r2value,
+        fitNorm[:, :2],
+        fitcoeff[:, :2],
+        None,
+        lagtc,
+        None,
+        LGR,
+        TimingLGR,
+        optiondict,
+        regressderivs=1,
+        debug=debug,
+    )
+
+    medfiltregressderivratios, filteredregressderivratios, delayoffsetMAD = (
+        tide_refinedelay.filterderivratios(
+            regressderivratios,
+            nativespaceshape,
+            validvoxels,
+            (xdim, ydim, slicethickness),
+            gausssigma=gausssigma,
+            patchthresh=patchthresh,
+            filetype=theinputdata.filetype,
+            rt_floattype=rt_floattype,
+            debug=debug,
+        )
+    )
+
+    # find the mapping of derivative ratios to delays
+    tide_refinedelay.trainratiotooffset(
+        genlagtc,
+        initial_fmri_x,
+        outputname,
+        outputlevel,
+        mindelay=mindelay,
+        maxdelay=maxdelay,
+        numpoints=numpoints,
+        debug=debug,
+    )
+
+    # now calculate the delay offsets
+    delayoffset = np.zeros_like(filteredregressderivratios)
+    if debug:
+        print(f"calculating delayoffsets for {filteredregressderivratios.shape[0]} voxels")
+    for i in range(filteredregressderivratios.shape[0]):
+        delayoffset[i], closestoffset = tide_refinedelay.ratiotodelay(
+            filteredregressderivratios[i]
+        )
+
+    namesuffix = "_desc-delayoffset_hist"
+    tide_stats.makeandsavehistogram(
+        delayoffset[np.where(sLFOfiltmask > 0)],
+        histlen,
+        1,
+        outputname + namesuffix,
+        displaytitle="Histogram of delay offsets calculated from regression coefficients",
+        dictvarname="delayoffsethist",
+        thedict=optiondict,
+    )
+
+    return (
+        delayoffset,
+        regressderivratios,
+        medfiltregressderivratios,
+        filteredregressderivratios,
+        delayoffsetMAD,
+    )

rapidtide/{RegressorRefiner.py → workflows/refineRegressor.py}

@@ -16,10 +16,7 @@
 #   limitations under the License.
 #
 #
-"""
-A class to impmement regressor refinement
-"""
-import copy
+import sys
 
 import numpy as np
 
@@ -32,6 +29,10 @@ import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
 from rapidtide.tests.utils import mse
 
+"""
+A class to implement regressor refinement
+"""
+
 
 class RegressorRefiner:
 
@@ -137,33 +138,33 @@ class RegressorRefiner:
         self.excludemask = excludemask
 
     def _allocatemem(self, pid):
+        self.shiftedtcs, self.shiftedtcs_shm = tide_util.allocarray(
+            self.internalvalidfmrishape,
+            self.rt_floattype,
+            shared=self.sharedmem,
+            name=f"shiftedtcs_{pid}",
+        )
+        self.weights, self.weights_shm = tide_util.allocarray(
+            self.internalvalidfmrishape,
+            self.rt_floattype,
+            shared=self.sharedmem,
+            name=f"weights_{pid}",
+        )
+        self.paddedshiftedtcs, self.paddedshiftedtcs_shm = tide_util.allocarray(
+            self.internalvalidpaddedfmrishape,
+            self.rt_floattype,
+            shared=self.sharedmem,
+            name=f"paddedshiftedtcs_{pid}",
+        )
+        self.paddedweights, self.paddedweights_shm = tide_util.allocarray(
+            self.internalvalidpaddedfmrishape,
+            self.rt_floattype,
+            shared=self.sharedmem,
+            name=f"paddedweights_{pid}",
+        )
         if self.sharedmem:
-            self.shiftedtcs, self.shiftedtcs_shm = tide_util.allocshared(
-                self.internalvalidfmrishape, self.rt_floatset, name=f"shiftedtcs_{pid}"
-            )
-            self.weights, self.weights_shm = tide_util.allocshared(
-                self.internalvalidfmrishape, self.rt_floatset, name=f"weights_{pid}"
-            )
-            self.paddedshiftedtcs, self.paddedshiftedtcs_shm = tide_util.allocshared(
-                self.internalvalidpaddedfmrishape,
-                self.rt_floatset,
-                name=f"paddedshiftedtcs_{pid}",
-            )
-            self.paddedweights, self.paddedweights_shm = tide_util.allocshared(
-                self.internalvalidpaddedfmrishape,
-                self.rt_floatset,
-                name=f"paddedweights_{pid}",
-            )
             ramlocation = "in shared memory"
         else:
-            self.shiftedtcs = np.zeros(self.internalvalidfmrishape, dtype=self.rt_floattype)
-            self.weights = np.zeros(self.internalvalidfmrishape, dtype=self.rt_floattype)
-            self.paddedshiftedtcs = np.zeros(
-                self.internalvalidpaddedfmrishape, dtype=self.rt_floattype
-            )
-            self.paddedweights = np.zeros(
-                self.internalvalidpaddedfmrishape, dtype=self.rt_floattype
-            )
             ramlocation = "locally"
         totalrefinementbytes = (
             self.shiftedtcs.nbytes
@@ -462,3 +463,174 @@ class RegressorRefiner:
             refinestopreason,
             genlagtc,
         )
+
+
+def refineRegressor(
+    LGR,
+    TimingLGR,
+    thepass,
+    optiondict,
+    fitmask,
+    internaloffsetincludemask_valid,
+    internaloffsetexcludemask_valid,
+    internalrefineincludemask_valid,
+    internalrefineexcludemask_valid,
+    internaldespeckleincludemask,
+    validvoxels,
+    theRegressorRefiner,
+    lagtimes,
+    lagstrengths,
+    lagsigma,
+    fmri_data_valid,
+    fmritr,
+    R2,
+    theprefilter,
+    previousnormoutputdata,
+    theinputdata,
+    numpadtrs,
+    outputname,
+    nativefmrishape,
+    bidsbasedict,
+    rt_floatset=np.float64,
+    rt_floattype="float64",
+):
+    LGR.info(f"\n\nRegressor refinement, pass {thepass}")
+    TimingLGR.info(f"Regressor refinement start, pass {thepass}")
+    if optiondict["refineoffset"]:
+        # check that we won't end up excluding all voxels from offset calculation before accepting mask
+        offsetmask = np.uint16(fitmask)
+        if internaloffsetincludemask_valid is not None:
+            offsetmask[np.where(internaloffsetincludemask_valid == 0)] = 0
+        if internaloffsetexcludemask_valid is not None:
+            offsetmask[np.where(internaloffsetexcludemask_valid != 0.0)] = 0
+        if tide_stats.getmasksize(offsetmask) == 0:
+            LGR.warning(
+                "NB: cannot exclude voxels from offset calculation mask - including for this pass"
+            )
+            offsetmask = fitmask + 0
+
+        peaklag, dummy, dummy = tide_stats.gethistprops(
+            lagtimes[np.where(offsetmask > 0)],
+            optiondict["histlen"],
+            pickleft=optiondict["pickleft"],
+            peakthresh=optiondict["pickleftthresh"],
+        )
+        optiondict["offsettime"] = peaklag
+        optiondict["offsettime_total"] += peaklag
+        optiondict[f"offsettime_pass{thepass}"] = optiondict["offsettime"]
+        optiondict[f"offsettime_total_pass{thepass}"] = optiondict["offsettime_total"]
+        LGR.info(
+            f"offset time set to {optiondict['offsettime']:.3f}, "
+            f"total is {optiondict['offsettime_total']:.3f}"
+        )
+
+    if optiondict["refinedespeckled"] or (optiondict["despeckle_passes"] == 0):
+        # if refinedespeckled is true, or there is no despeckling, masks are unaffected
+        thisinternalrefineexcludemask_valid = internalrefineexcludemask_valid
+    else:
+        # if refinedespeckled is false and there is despeckling, need to make a proper mask
+        if internalrefineexcludemask_valid is None:
+            # if there is currently no exclude mask, set exclude mask = despeckle mask
+            thisinternalrefineexcludemask_valid = np.where(
+                internaldespeckleincludemask[validvoxels] == 0.0, 0, 1
+            )
+        else:
+            # if there is a current exclude mask, add any voxels that are being despeckled
+            thisinternalrefineexcludemask_valid = np.where(
+                internalrefineexcludemask_valid > 0, 1, 0
+            )
+            thisinternalrefineexcludemask_valid[
+                np.where(internaldespeckleincludemask[validvoxels] != 0.0)
+            ] = 1
+
+        # now check that we won't end up excluding all voxels from refinement before accepting mask
+        overallmask = np.uint16(fitmask)
+        if internalrefineincludemask_valid is not None:
+            overallmask[np.where(internalrefineincludemask_valid == 0)] = 0
+        if thisinternalrefineexcludemask_valid is not None:
+            overallmask[np.where(thisinternalrefineexcludemask_valid != 0.0)] = 0
+        if tide_stats.getmasksize(overallmask) == 0:
+            LGR.warning(
+                "NB: cannot exclude despeckled voxels from refinement - including for this pass"
+            )
+            thisinternalrefineexcludemask_valid = internalrefineexcludemask_valid
+    theRegressorRefiner.setmasks(
+        internalrefineincludemask_valid, thisinternalrefineexcludemask_valid
+    )
+
+    # regenerate regressor for next pass
+    # create the refinement mask
+    LGR.info("making refine mask")
+    createdmask = theRegressorRefiner.makemask(lagstrengths, lagtimes, lagsigma, fitmask)
+    print(f"Refine mask has {theRegressorRefiner.refinemaskvoxels} voxels")
+    if not createdmask:
+        print("no voxels qualify for refinement - exiting")
+        sys.exit()
+
+    # align timecourses to prepare for refinement
+    LGR.info("aligning timecourses")
+    tide_util.disablemkl(optiondict["nprocs_refine"], debug=optiondict["threaddebug"])
+    voxelsprocessed_rra = theRegressorRefiner.alignvoxels(fmri_data_valid, fmritr, lagtimes)
+    tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
+    LGR.info(f"align complete: {voxelsprocessed_rra=}")
+
+    # prenormalize
+    LGR.info("prenormalizing timecourses")
+    theRegressorRefiner.prenormalize(lagtimes, lagstrengths, R2)
+
+    # now doing the refinement
+    (
+        voxelsprocessed_rr,
+        outputdict,
+        previousnormoutputdata,
+        resampref_y,
+        resampnonosref_y,
+        stoprefining,
+        refinestopreason,
+        genlagtc,
+    ) = theRegressorRefiner.refine(
+        theprefilter,
+        fmritr,
+        thepass,
+        lagstrengths,
+        lagtimes,
+        previousnormoutputdata,
+        optiondict["corrmasksize"],
+    )
+    TimingLGR.info(
+        f"Regressor refinement end, pass {thepass}",
+        {
+            "message2": voxelsprocessed_rr,
+            "message3": "voxels",
+        },
+    )
+    for key, value in outputdict.items():
+        optiondict[key] = value
+
+    # Save shifted timecourses for César
+    if optiondict["saveintermediatemaps"] and optiondict["savelagregressors"]:
+        theheader = theinputdata.copyheader()
+        bidspasssuffix = f"_intermediatedata-pass{thepass}"
+        maplist = [
+            (
+                (theRegressorRefiner.getpaddedshiftedtcs())[:, numpadtrs:-numpadtrs],
+                "shiftedtcs",
+                "bold",
+                None,
+                "The filtered input fMRI data, in voxels used for refinement, time shifted by the negated delay in every voxel so that the moving blood component is aligned.",
+            ),
+        ]
+        tide_io.savemaplist(
+            f"{outputname}{bidspasssuffix}",
+            maplist,
+            validvoxels,
+            nativefmrishape,
+            theheader,
+            bidsbasedict,
+            filetype=theinputdata.filetype,
+            rt_floattype=rt_floattype,
+            cifti_hdr=theinputdata.cifti_hdr,
+            debug=True,
+        )
+
+    return resampref_y, resampnonosref_y, stoprefining, refinestopreason, genlagtc

rapidtide/workflows/regressfrommaps.py

@@ -53,20 +53,21 @@ def regressfrommaps(
     showprogressbar=True,
     alwaysmultiproc=False,
     saveEVsandquit=False,
+    ratiosonly=False,
     debug=False,
 ):
     if debug:
         print("regressfrommaps: Starting")
-        print(f"{nprocs_makelaggedtcs=}")
-        print(f"{nprocs_regressionfilt=}")
-        print(f"{regressderivs=}")
-        print(f"{mp_chunksize=}")
-        print(f"{showprogressbar=}")
-        print(f"{alwaysmultiproc=}")
-        print(f"{mode=}")
-        print(f"{outputname=}")
-        print(f"{oversamptr=}")
-        print(f"{regressfiltthreshval=}")
+        print(f"\t{nprocs_makelaggedtcs=}")
+        print(f"\t{nprocs_regressionfilt=}")
+        print(f"\t{regressderivs=}")
+        print(f"\t{mp_chunksize=}")
+        print(f"\t{showprogressbar=}")
+        print(f"\t{alwaysmultiproc=}")
+        print(f"\t{mode=}")
+        print(f"\t{outputname=}")
+        print(f"\t{oversamptr=}")
+        print(f"\t{regressfiltthreshval=}")
     rt_floatset = np.float64
     rt_floattype = "float64"
     numvalidspatiallocs = np.shape(validvoxels)[0]
@@ -90,12 +91,13 @@ def regressfrommaps(
         chunksize=mp_chunksize,
         rt_floatset=rt_floatset,
         rt_floattype=rt_floattype,
+        debug=debug,
     )
     if debug:
-        print(f"{lagtimes.shape=}")
+        print(f"\t{lagtimes.shape=}")
         threshmask = np.where(fitmask > 0, 1, 0)
-        print(f"{np.sum(threshmask)} nonzero mask voxels")
-        print(f"after makelaggedtcs: shifted {voxelsprocessed_makelagged} timecourses")
+        print(f"\t{np.sum(threshmask)} nonzero mask voxels")
+        print(f"\tafter makelaggedtcs: shifted {voxelsprocessed_makelagged} timecourses")
     if LGR is not None:
         LGR.info("End lagged timecourse creation")
     if TimingLGR is not None:
@@ -144,6 +146,7 @@ def regressfrommaps(
         fitNorm,
         movingsignal,
         filtereddata,
+        ratiosonly=ratiosonly,
         nprocs=nprocs_regressionfilt,
         alwaysmultiproc=alwaysmultiproc,
         showprogressbar=showprogressbar,
@@ -151,6 +154,7 @@ def regressfrommaps(
         mp_chunksize=mp_chunksize,
         rt_floatset=rt_floatset,
         rt_floattype=rt_floattype,
+        debug=debug,
     )
 
     if mode == "cvrmap":
@@ -158,19 +162,23 @@ def regressfrommaps(
         fitcoeff *= 100.0
 
     # determine what was removed
-    removeddata = fmri_data_valid - filtereddata
-    noiseremoved = np.var(removeddata, axis=0)
-    if saveminimumsLFOfiltfiles:
-        tide_io.writebidstsv(
-            f"{outputname}_desc-lfofilterNoiseRemoved_timeseries",
-            noiseremoved,
-            1.0 / oversamptr,
-            starttime=0.0,
-            columns=[f"removedbyglm"],
-            extraheaderinfo={
-                "Description": "Variance over space of data removed by the sLFO filter at each timepoint"
-            },
-            append=False,
-        )
+    if not ratiosonly:
+        removeddata = fmri_data_valid - filtereddata
+        noiseremoved = np.var(removeddata, axis=0)
+        if saveminimumsLFOfiltfiles:
+            tide_io.writebidstsv(
+                f"{outputname}_desc-lfofilterNoiseRemoved_timeseries",
+                noiseremoved,
+                1.0 / oversamptr,
+                starttime=0.0,
+                columns=[f"removedbyglm"],
+                extraheaderinfo={
+                    "Description": "Variance over space of data removed by the sLFO filter at each timepoint"
+                },
+                append=False,
+            )
+
+    if debug:
+        print("regressfrommaps: End\n\n")
 
     return voxelsprocessed_regressionfilt, regressorset, evset

rapidtide/workflows/retrolagtcs.py

@@ -226,15 +226,14 @@ def retrolagtcs(args):
     if usesharedmem:
         if args.debug:
             print("allocating shared memory")
-        fitNorm, fitNorm_shm = tide_util.allocshared(internalvalidspaceshapederivs, rt_outfloatset)
-        fitcoeff, fitcoeff_shm = tide_util.allocshared(
-            internalvalidspaceshapederivs, rt_outfloatset
-        )
-        lagtc, lagtc_shm = tide_util.allocshared(internalvalidfmrishape, rt_floatset)
     else:
         if args.debug:
             print("allocating memory")
-        lagtc = np.zeros(internalvalidfmrishape, dtype=rt_floattype)
+    fitNorm, fitNorm_shm = tide_util.allocarray(internalvalidspaceshapederivs, rt_outfloattype, shared=usesharedmem)
+    fitcoeff, fitcoeff_shm = tide_util.allocarray(
+        internalvalidspaceshapederivs, rt_outfloattype, shared=usesharedmem
+    )
+    lagtc, lagtc_shm = tide_util.allocarray(internalvalidfmrishape, rt_floattype, shared=usesharedmem)
 
     outputpath = os.path.dirname(args.outputroot)
     rawsources = [