rapidtide 3.0.6__py3-none-any.whl → 3.0.7.1__py3-none-any.whl

rapidtide/resample.py

@@ -124,7 +124,17 @@ congridyvals["kernel"] = "kaiser"
 congridyvals["width"] = 3.0
 
 
-def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
+def congrid(
+    xaxis,
+    loc,
+    val,
+    width,
+    kernel="kaiser",
+    cache=True,
+    cyclic=True,
+    debug=False,
+    onlykeynotices=True,
+):
     """
     Perform a convolution gridding operation with a Kaiser-Bessel or Gaussian kernel of width 'width'.  Grid
     parameters are cached for performance.
@@ -164,10 +174,10 @@ def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
 
     if (congridyvals["kernel"] != kernel) or (congridyvals["width"] != width):
         if congridyvals["kernel"] != kernel:
-            if debug:
+            if debug and not onlykeynotices:
                 print(congridyvals["kernel"], "!=", kernel)
         if congridyvals["width"] != width:
-            if debug:
+            if debug and not onlykeynotices:
                 print(congridyvals["width"], "!=", width)
         if debug:
             print("(re)initializing congridyvals")
@@ -191,7 +201,7 @@ def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
 
     # find the closest grid point to the target location, calculate relative offsets from this point
     center = tide_util.valtoindex(xaxis, loc)
-    offset = np.fmod(np.round((loc - xaxis[center]) / xstep, 3), 1.0)  # will vary from -0.5 to 0.5
+    offset = np.fmod(np.round((loc - xaxis[center]) / xstep, 4), 1.0)  # will vary from -0.5 to 0.5
     if cyclic:
         if center == len(xaxis) - 1 and offset > 0.5:
             center = 0
@@ -224,12 +234,13 @@ def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
                 )
                 + offset
             )
-            congridyvals[offsetkey] = tide_fit.gauss_eval(xvals, np.array([1.0, 0.0, width]))
-            yvals = congridyvals[offsetkey]
+            yvals = tide_fit.gauss_eval(xvals, np.array([1.0, 0.0, width]))
+            if cache:
+                congridyvals[offsetkey] = 1.0 * yvals
         startpt = int(center - widthinpts // 2)
         indices = range(startpt, startpt + widthinpts)
         indices = np.remainder(indices, len(xaxis))
-        if debug:
+        if debug and not onlykeynotices:
             print("center, offset, indices, yvals", center, offset, indices, yvals)
         return val * yvals, yvals, indices
     else:
@@ -245,19 +256,18 @@ def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
             xvals = indices - center + offset
             if kernel == "gauss":
                 sigma = optsigma[kernelindex]
-                congridyvals[offsetkey] = tide_fit.gauss_eval(xvals, np.array([1.0, 0.0, sigma]))
+                yvals = tide_fit.gauss_eval(xvals, np.array([1.0, 0.0, sigma]))
             elif kernel == "kaiser":
                 beta = optbeta[kernelindex]
-                congridyvals[offsetkey] = tide_fit.kaiserbessel_eval(
-                    xvals, np.array([beta, width / 2.0])
-                )
+                yvals = tide_fit.kaiserbessel_eval(xvals, np.array([beta, width / 2.0]))
             else:
                 print("illegal kernel value in congrid - exiting")
                 sys.exit()
-            yvals = congridyvals[offsetkey]
-            if debug:
+            if cache:
+                congridyvals[offsetkey] = 1.0 * yvals
+            if debug and not onlykeynotices:
                 print("xvals, yvals", xvals, yvals)
-        if debug:
+        if debug and not onlykeynotices:
             print("center, offset, indices, yvals", center, offset, indices, yvals)
         return val * yvals, yvals, indices
 

rapidtide/tests/test_congrid.py

@@ -21,6 +21,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 from rapidtide.resample import congrid
+from rapidtide.happy_supportfuncs import preloadcongrid
 from rapidtide.tests.utils import mse
 
 
@@ -74,86 +75,74 @@ def test_congrid(debug=False, displayplots=False):
         weights = np.zeros((gridlen), dtype=float)
         griddeddata = np.zeros((gridlen), dtype=float)
 
-        for gridkernel in kernellist:
-            for congridbins in binslist:
-                print("about to grid")
-
-                # reinitialize grid outputs
-                weights *= 0.0
-                griddeddata *= 0.0
-
-                for i in range(numsamples):
-                    thevals, theweights, theindices = congrid(
-                        gridaxis,
-                        testvals[i],
-                        funcvalue2(testvals[i], frequency=cycles),
-                        congridbins,
-                        kernel=gridkernel,
-                        debug=False,
-                    )
-                    for i in range(len(theindices)):
-                        weights[theindices[i]] += theweights[i]
-                        griddeddata[theindices[i]] += thevals[i]
-
-                griddeddata = np.where(weights > 0.0, griddeddata / weights, 0.0)
-
-                target = np.float64(gridaxis * 0.0)
-                for i in range(len(gridaxis)):
-                    target[i] = funcvalue2(gridaxis[i], frequency=cycles)
-
-                print("gridding done")
-                print("debug:", debug)
-
-                # plot if we are doing that
-                if displayplots:
-                    offset = 0.0
-                    legend = []
-                    plt.plot(sourceaxis, timecoursein)
-                    legend.append("Original")
-                    # offset += 1.0
-                    plt.plot(gridaxis, target + offset)
-                    legend.append("Target")
-                    # offset += 1.0
-                    plt.plot(gridaxis, griddeddata + offset)
-                    legend.append("Gridded")
-                    plt.plot(gridaxis, weights)
-                    legend.append("Weights")
-                    plt.legend(legend)
-                    plt.show()
-
-                # do the tests
-                msethresh = 6.0e-2
-                themse = mse(target, griddeddata)
-                if debug:
-                    if themse >= msethresh:
-                        extra = "FAIL"
-                    else:
-                        extra = ""
-                    print(
-                        "mse for",
-                        cycles,
-                        "cycles:",
-                        gridkernel,
-                        str(congridbins),
-                        ":",
-                        themse,
-                        extra,
-                    )
-                    outputlines.append(
-                        " ".join(
-                            [
-                                "mse for",
-                                str(cycles),
-                                "cycles:",
-                                gridkernel,
-                                str(congridbins),
-                                ":",
-                                str(themse),
-                            ]
+        for prefill in [True, False]:
+            for gridkernel in kernellist:
+                for congridbins in binslist:
+                    print("about to grid")
+
+                    # reinitialize grid outputs
+                    weights *= 0.0
+                    griddeddata *= 0.0
+
+                    if prefill:
+                        preloadcongrid(
+                            gridaxis, congridbins, gridkernel=gridkernel, cyclic=True, debug=False
+                        )
+                    for i in range(numsamples):
+                        thevals, theweights, theindices = congrid(
+                            gridaxis,
+                            testvals[i],
+                            funcvalue2(testvals[i], frequency=cycles),
+                            congridbins,
+                            kernel=gridkernel,
+                            debug=False,
+                        )
+                        for i in range(len(theindices)):
+                            weights[theindices[i]] += theweights[i]
+                            griddeddata[theindices[i]] += thevals[i]
+
+                    griddeddata = np.where(weights > 0.0, griddeddata / weights, 0.0)
+
+                    target = np.float64(gridaxis * 0.0)
+                    for i in range(len(gridaxis)):
+                        target[i] = funcvalue2(gridaxis[i], frequency=cycles)
+
+                    print("gridding done")
+                    print("debug:", debug)
+
+                    # plot if we are doing that
+                    if displayplots:
+                        offset = 0.0
+                        legend = []
+                        plt.plot(sourceaxis, timecoursein)
+                        legend.append("Original")
+                        # offset += 1.0
+                        plt.plot(gridaxis, target + offset)
+                        legend.append("Target")
+                        # offset += 1.0
+                        plt.plot(gridaxis, griddeddata + offset)
+                        legend.append("Gridded")
+                        plt.plot(gridaxis, weights)
+                        legend.append("Weights")
+                        plt.legend(legend)
+                        plt.show()
+
+                    # do the tests
+                    msethresh = 6.0e-2
+                    themse = mse(target, griddeddata)
+                    if debug:
+                        if themse >= msethresh:
+                            extra = "FAIL"
+                        else:
+                            extra = ""
+                        print(
+                            f"mse for {cycles} cycles: {prefill=}, {gridkernel} {congridbins}: {themse} {extra}"
+                        )
+                        outputlines.append(
+                            f"mse for {cycles} cycles: {prefill=}, {gridkernel} {congridbins}: {themse}"
                         )
-                    )
-                if not debug:
-                    assert themse < msethresh
+                    if not debug:
+                        assert themse < msethresh
     if debug:
         for theline in outputlines:
             print(theline)

rapidtide/voxelData.py

@@ -100,6 +100,7 @@ class VoxelData:
     ysize = None
     numslices = None
     timepoints = None
+    dimensions = None
     realtimepoints = None
     xdim = None
     ydim = None
@@ -160,6 +161,10 @@ class VoxelData:
                 self.xsize, self.ysize, self.numslices, self.timepoints = tide_io.parseniftidims(
                     self.thedims
                 )
+                if self.timepoints == 1:
+                    self.dimensions = 3
+                else:
+                    self.dimensions = 4
                 self.numslicelocs = int(self.xsize) * int(self.ysize)
                 self.numspatiallocs = int(self.xsize) * int(self.ysize) * int(self.numslices)
                 self.cifti_hdr = None
@@ -283,15 +288,24 @@ class VoxelData:
         if not self.resident:
             self.load()
         if self.filetype == "nifti":
-            return self.nim_data[:, :, :, self.validstart : self.validend + 1]
+            if self.dimensions == 4 or self.filetype == "cifti" or self.filetype == "text":
+                return self.nim_data[:, :, :, self.validstart : self.validend + 1]
+            else:
+                return self.nim_data[:, :, :]
         else:
             return self.nim_data[:, self.validstart : self.validend + 1]
 
     def byvoxel(self):
-        return self.byvoltrimmed().reshape(self.numspatiallocs, -1)
+        if self.dimensions == 4 or self.filetype == "cifti" or self.filetype == "text":
+            return self.byvoltrimmed().reshape(self.numspatiallocs, -1)
+        else:
+            return self.byvoltrimmed().reshape(self.numspatiallocs)
 
     def byslice(self):
-        return self.byvoltrimmed().reshape(self.numslicelocs, self.numslices, -1)
+        if self.dimensions == 4 or self.filetype == "cifti" or self.filetype == "text":
+            return self.byvoltrimmed().reshape(self.numslicelocs, self.numslices, -1)
+        else:
+            return self.byvoltrimmed().reshape(self.numslicelocs, self.numslices)
 
     def validdata(self):
         if self.validvoxels is None:

rapidtide/workflows/cleanregressor.py

@@ -103,8 +103,9 @@ def cleanregressor(
         theCorrelator.setlimits(acmininpts, acmaxinpts)
         # theCorrelator.setlimits(lagmininpts, lagmaxinpts)
         print("check_autocorrelation:", acmininpts, acmaxinpts, lagmininpts, lagmaxinpts)
-        thexcorr, accheckcorrscale, dummy = theCorrelator.run(
-            resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1]
+        thexcorr, accheckcorrscale, theglobalmax = theCorrelator.run(
+            resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1],
+            trim=False,
         )
         theFitter.setcorrtimeaxis(accheckcorrscale)
         (

rapidtide/workflows/happy.py

@@ -24,7 +24,7 @@ import warnings
 from pathlib import Path
 
 import numpy as np
-from tqdm import tqdm
+from scipy.stats import pearsonr
 
 import rapidtide.correlate as tide_corr
 import rapidtide.filter as tide_filt
@@ -315,8 +315,10 @@ def happy_main(argparsingfunc):
         time,
         timings,
         LGR=None,
+        mpcode=args.mpdetrend,
         nprocs=args.nprocs,
         showprogressbar=args.showprogressbar,
+        debug=args.debug,
     )
     normdata_byslice = normdata.reshape((xsize * ysize, numslices, timepoints))
 
@@ -1243,7 +1245,9 @@ def happy_main(argparsingfunc):
         demeandata_byslice = demeandata.reshape((xsize * ysize, numslices, timepoints))
         means_byslice = means.reshape((xsize * ysize, numslices))
 
-        timings.append(["Phase projection to image started" + passstring, time.time(), None, None])
+        timings.append(
+            ["Phase projection to image prep 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(
@@ -1257,6 +1261,14 @@ def happy_main(argparsingfunc):
             proctrs = np.where(censortrs < 1)[0]
             procpoints = np.where(censorpoints < 1)[0]
 
+        # preload congrid
+        if args.preloadcongrid:
+            print("Preloading congrid values...")
+            happy_support.preloadcongrid(
+                outphases, args.congridbins, gridkernel=args.gridkernel, cyclic=True, debug=False
+            )
+            print("done")
+
         # do phase averaging
         app_bypoint, weights_bypoint = happy_support.cardiaccycleaverage(
             instantaneous_cardiacphase,
@@ -1266,6 +1278,7 @@ def happy_main(argparsingfunc):
             args.congridbins,
             args.gridkernel,
             args.centric,
+            cache=args.congridcache,
             cyclic=True,
         )
         if thispass == numpasses - 1:
@@ -1358,9 +1371,53 @@ def happy_main(argparsingfunc):
                 debug=args.debug,
             )
 
+        timings.append(
+            ["Phase projection to image prep ended" + passstring, time.time(), None, None]
+        )
         if not args.verbose:
             print("Setting up for phase projection...")
 
+        # make a vessel map using Wright's method
+        if args.wrightiterations > 0:
+            timings.append(
+                [
+                    "Wright mask generation started" + passstring,
+                    time.time(),
+                    None,
+                    None,
+                ]
+            )
+            wrightcorrs = happy_support.wrightmap(
+                input_data,
+                demeandata_byslice,
+                rawapp_byslice,
+                projmask_byslice,
+                outphases,
+                cardphasevals,
+                proctrs,
+                args.congridbins,
+                args.gridkernel,
+                args.destpoints,
+                iterations=args.wrightiterations,
+                nprocs=args.nprocs,
+                verbose=False,
+                debug=args.debug,
+            )
+
+            theheader = input_data.copyheader(numtimepoints=1)
+            wrightfilename = f"{outputroot}_desc-wrightcorrspass{thispass + 1}_map"
+            tide_io.writedicttojson(bidsbasedict, wrightfilename + ".json")
+            tide_io.savetonifti(wrightcorrs, theheader, wrightfilename)
+            timings.append(
+                [
+                    "Wright mask generation completed" + passstring,
+                    time.time(),
+                    None,
+                    None,
+                ]
+            )
+
+        timings.append(["Phase projection to image started" + passstring, time.time(), None, None])
         # 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

rapidtide/workflows/happy_parser.py

@@ -593,6 +593,14 @@ def _get_parser():
         help="Will disable showing progress bars (helpful if stdout is going to a file). ",
         default=True,
     )
+    misc_opts.add_argument(
+        "--wrightiterations",
+        dest="wrightiterations",
+        action="store",
+        type=lambda x: pf.is_int(parser, x),
+        help="Number of iterations for calculating Wright map. Set to 0 to disable.",
+        default=0,
+    )
     pf.addtagopts(
         misc_opts,
         helptext="Additional key, value pairs to add to the info json file (useful for tracking analyses).",
@@ -692,6 +700,34 @@ def _get_parser():
         help="Decrease the number of intermediate output files. ",
         default=0,
     )
+    debug_opts.add_argument(
+        "--nompdetrend",
+        dest="mpdetrend",
+        action="store_false",
+        help="Disable multiproc detrending.",
+        default=True,
+    )
+    debug_opts.add_argument(
+        "--nompphaseproject",
+        dest="mpphaseproject",
+        action="store_false",
+        help="Disable multiproc phase projection.",
+        default=True,
+    )
+    debug_opts.add_argument(
+        "--noprefillcongrid",
+        dest="preloadcongrid",
+        action="store_false",
+        help="Don't prefill the congrid value cache.",
+        default=True,
+    )
+    debug_opts.add_argument(
+        "--nocongridcache",
+        dest="congridcache",
+        action="store_false",
+        help="Disable the congrid value cache completely.",
+        default=True,
+    )
 
     return parser
 

rapidtide/workflows/rapidtide.py

@@ -28,7 +28,6 @@ import numpy as np
 from scipy import ndimage
 from scipy.stats import rankdata
 
-
 import rapidtide.calccoherence as tide_calccoherence
 import rapidtide.calcnullsimfunc as tide_nullsimfunc
 import rapidtide.calcsimfunc as tide_calcsimfunc
@@ -392,6 +391,11 @@ def rapidtide_main(argparsingfunc):
     csfmask = anatomicmasks[3]
 
     # do spatial filtering if requested
+    if theinputdata.filetype == "nifti":
+        unfiltmeanvalue = np.mean(
+            theinputdata.byvoxel(),
+            axis=1,
+        )
     optiondict["gausssigma"] = theinputdata.smooth(
         optiondict["gausssigma"],
         brainmask=brainmask,
@@ -625,7 +629,6 @@ def rapidtide_main(argparsingfunc):
         )
     else:
         internaloffsetexcludemask_valid = None
-
     tide_util.logmem("after selecting valid voxels")
 
     # move fmri_data_valid into shared memory
@@ -738,7 +741,7 @@ def rapidtide_main(argparsingfunc):
                 theheader["dim"][4] = 1
                 theheader["pixdim"][4] = 1.0
         maplist = [
-            (confoundr2, "confoundfilterR2", "map", None, "R2 of the motion/confound regression")
+            (confoundr2, "confoundfilterR2", "map", None, "R2 of the motion/confound regression"),
         ]
         tide_io.savemaplist(
             outputname,
@@ -2652,6 +2655,10 @@ def rapidtide_main(argparsingfunc):
     optiondict["currentstage"] = "presLFOfit"
     tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
     if optiondict["dolinfitfilt"] or optiondict["docvrmap"] or optiondict["refinedelay"]:
+        if optiondict["sLFOfiltmask"]:
+            sLFOfiltmask = fitmask + 0.0
+        else:
+            sLFOfiltmask = fitmask * 0.0 + 1.0
         if optiondict["dolinfitfilt"]:
             if optiondict["refinedelay"]:
                 TimingLGR.info("Setting up for delay refinement and sLFO filtering")
@@ -2831,7 +2838,7 @@ def rapidtide_main(argparsingfunc):
                 validvoxels,
                 initial_fmri_x,
                 lagtimes,
-                fitmask,
+                sLFOfiltmask,
                 genlagtc,
                 mode,
                 outputname,
@@ -2927,7 +2934,7 @@ def rapidtide_main(argparsingfunc):
             namesuffix = "_desc-delayoffset_hist"
             if optiondict["dolinfitfilt"]:
                 tide_stats.makeandsavehistogram(
-                    delayoffset[np.where(fitmask > 0)],
+                    delayoffset[np.where(sLFOfiltmask > 0)],
                     optiondict["histlen"],
                     1,
                     outputname + namesuffix,
@@ -2965,7 +2972,7 @@ def rapidtide_main(argparsingfunc):
                     validvoxels,
                     initial_fmri_x,
                     lagstouse,
-                    fitmask,
+                    sLFOfiltmask,
                     genlagtc,
                     mode,
                     outputname,
@@ -3471,7 +3478,7 @@ def rapidtide_main(argparsingfunc):
                 validvoxels,
                 initial_fmri_x,
                 lagstouse,
-                fitmask,
+                sLFOfiltmask,
                 genlagtc,
                 mode,
                 outputname,
@@ -3539,7 +3546,16 @@ def rapidtide_main(argparsingfunc):
             tide_util.cleanup_shm(fitNorm_shm)
 
     # write the 3D maps that don't need to be remapped
+    if theinputdata.filetype != "nifti":
+        unfiltmeanvalue = meanvalue
     maplist = [
+        (
+            unfiltmeanvalue,
+            "unfiltmean",
+            "map",
+            None,
+            "Voxelwise mean of fmri data before smoothing",
+        ),
         (meanvalue, "mean", "map", None, "Voxelwise mean of fmri data"),
         (stddevvalue, "std", "map", None, "Voxelwise standard deviation of fmri data"),
         (covvalue, "CoV", "map", None, "Voxelwise coefficient of variation of fmri data"),
@@ -3564,6 +3580,7 @@ def rapidtide_main(argparsingfunc):
         cifti_hdr=theinputdata.cifti_hdr,
     )
     del meanvalue
+    del unfiltmeanvalue
 
     if optiondict["numestreps"] > 0:
         masklist = []

rapidtide/workflows/rapidtide_parser.py

@@ -1462,6 +1462,13 @@ def _get_parser():
         help=("Do regressor refinement on the final pass."),
         default=False,
     )
+    experimental.add_argument(
+        "--sLFOfiltmask",
+        dest="sLFOfiltmask",
+        action="store_true",
+        help=("Limit sLFO filter to fit voxels."),
+        default=False,
+    )
     experimental.add_argument(
         "--territorymap",
         dest="territorymap",

rapidtide/workflows/retroregress.py

@@ -219,6 +219,13 @@ def _get_parser():
         help=("Output lots of helpful information on a limited subset of operations."),
         default=False,
     )
+    parser.add_argument(
+        "--sLFOfiltmask",
+        dest="sLFOfiltmask",
+        action="store_true",
+        help=("Limit sLFO filter to fit voxels."),
+        default=False,
+    )
     experimental = parser.add_argument_group(
         "Experimental options (not fully tested, or not tested at all, may not work).  Beware!"
     )
@@ -515,6 +522,10 @@ def retroregress(args):
     lagtimes_valid = lagtimes_spacebytime[validvoxels]
     corrmask_valid = corrmask_spacebytime[validvoxels]
     procmask_valid = procmask_spacebytime[validvoxels]
+    if args.sLFOfiltmask:
+        sLFOfiltmask_valid = corrmask_spacebytime[validvoxels] + 0.0
+    else:
+        sLFOfiltmask_valid = corrmask_spacebytime[validvoxels] * 0.0 + 1.0
     if args.debug:
         print(f"{fmri_data_valid.shape=}")
 
@@ -638,7 +649,7 @@ def retroregress(args):
             validvoxels,
             initial_fmri_x,
             lagtimes_valid,
-            corrmask_valid,
+            sLFOfiltmask_valid,
             genlagtc,
             mode,
             outputname,
@@ -770,7 +781,7 @@ def retroregress(args):
         validvoxels,
         initial_fmri_x,
         lagstouse_valid,
-        corrmask_valid,
+        sLFOfiltmask_valid,
         genlagtc,
         mode,
         outputname,
@@ -1032,6 +1043,13 @@ def retroregress(args):
                     "corrfitREAD",
                     "mask",
                     None,
+                    "Correlation mask read for calculation",
+                ),
+                (
+                    sLFOfiltmask_valid,
+                    "corrfitUSED",
+                    "mask",
+                    None,
                     "Correlation mask used for calculation",
                 ),
                 (
@@ -1255,7 +1273,7 @@ def retroregress(args):
                     validvoxels,
                     initial_fmri_x,
                     lagstouse_valid,
-                    corrmask_valid,
+                    sLFOfiltmask_valid,
                     genlagtc,
                     mode,
                     outputname,