rapidtide 3.0.6__py3-none-any.whl → 3.0.7__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,
@@ -2652,6 +2656,9 @@ 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"]:
+        sLFOfiltmask = fitmask + 0.0
+        if optiondict["nosLFOfiltmask"]:
+            sLFOfiltmask = sLFOfiltmask * 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,10 @@ 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 +3574,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(
+        "--nosLFOfiltmask",
+        dest="nosLFOfiltmask",
+        action="store_true",
+        help=("Don't spatially limit sLFO filter to fit voxels."),
+        default=False,
+    )
     experimental.add_argument(
         "--territorymap",
         dest="territorymap",

rapidtide/workflows/showarbcorr.py

@@ -297,6 +297,8 @@ def showarbcorr(args):
         sys.exit()
     if starttime1 == None:
         starttime1 = 0.0
+    endtime1 = starttime1 + len(inputdata1) / Fs1
+    print(f"inputdata1 goes from {starttime1} to {endtime1}")
 
     if args.samplerate2 is not None:
         Fs2 = args.samplerate2
@@ -305,9 +307,19 @@ def showarbcorr(args):
         sys.exit()
     if starttime2 == None:
         starttime2 = 0.0
+    endtime2 = starttime2 + len(inputdata2) / Fs2
+    print(f"inputdata2 goes from {starttime2} to {endtime2}")
 
-    trimdata1 = inputdata1
-    trimdata2 = inputdata2
+    matchedinput1, matchedinput2, commonFs = tide_corr.matchsamplerates(
+        inputdata1,
+        Fs1,
+        inputdata2,
+        Fs2,
+        method="univariate",
+        debug=args.debug,
+    )
+    trimdata1 = matchedinput1
+    trimdata2 = matchedinput2
 
     if args.trimdata:
         minlen = np.min([len(trimdata1), len(trimdata2)])
@@ -324,12 +336,12 @@ def showarbcorr(args):
         if args.verbose:
             print("filtering to ", theprefilter.gettype(), " band")
     filtereddata1 = tide_math.corrnormalize(
-        theprefilter.apply(Fs1, trimdata1),
+        theprefilter.apply(commonFs, trimdata1),
         detrendorder=args.detrendorder,
         windowfunc=args.windowfunc,
     )
     filtereddata2 = tide_math.corrnormalize(
-        theprefilter.apply(Fs2, trimdata2),
+        theprefilter.apply(commonFs, trimdata2),
         detrendorder=args.detrendorder,
         windowfunc=args.windowfunc,
     )
@@ -341,9 +353,9 @@ def showarbcorr(args):
         print(f"{Fs1=}, {Fs2=}, {starttime1=}, {starttime2=}, {args.windowfunc=}")
     xcorr_x, thexcorr, corrFs, zeroloc = tide_corr.arbcorr(
         filtereddata1,
-        Fs1,
+        commonFs,
         filtereddata2,
-        Fs2,
+        commonFs,
         start1=starttime1,
         start2=starttime2,
         windowfunc=args.windowfunc,
@@ -375,6 +387,7 @@ def showarbcorr(args):
     thexcorr_trim = thexcorr[lowerlim:upperlim]
     print("trimmed Correlator lengths (x, y):", len(xcorr_x_trim), len(thexcorr_trim))
 
+    print(f"{len(filtereddata1)=}, {len(filtereddata2)=}")
     thepxcorr = pearsonr(filtereddata1, filtereddata2)
 
     # initialize the correlation fitter