rapidtide 3.0.2__py3-none-any.whl → 3.0.4__py3-none-any.whl

rapidtide/workflows/rapidtide.py

@@ -71,75 +71,6 @@ ErrorLGR = logging.getLogger("ERROR")
 TimingLGR = logging.getLogger("TIMING")
 
 
-def getglobalsignal(
-    indata, optiondict, includemask=None, excludemask=None, pcacomponents=0.8, debug=False
-):
-    # Start with all voxels
-    themask = indata[:, 0] * 0 + 1
-
-    # modify the mask if needed
-    if includemask is not None:
-        themask = themask * includemask
-    if excludemask is not None:
-        themask = themask * (1 - excludemask)
-
-    # combine all the voxels using one of the three methods
-    global rt_floatset, rt_floattype
-    globalmean = rt_floatset(indata[0, :])
-    thesize = np.shape(themask)
-    numvoxelsused = int(np.sum(np.where(themask > 0.0, 1, 0)))
-    selectedvoxels = indata[np.where(themask > 0.0), :][0]
-    if debug:
-        print(f"getglobalsignal: {selectedvoxels.shape=}")
-    LGR.info(f"constructing global mean signal using {optiondict['globalsignalmethod']}")
-    if optiondict["globalsignalmethod"] == "sum":
-        globalmean = np.mean(selectedvoxels, axis=0)
-        globalmean -= np.mean(globalmean)
-    elif optiondict["globalsignalmethod"] == "meanscale":
-        themean = np.mean(indata, axis=1)
-        for vox in range(0, thesize[0]):
-            if themask[vox] > 0.0:
-                if themean[vox] != 0.0:
-                    globalmean += indata[vox, :] / themean[vox] - 1.0
-    elif optiondict["globalsignalmethod"] == "pca":
-        themean = np.mean(indata, axis=1)
-        thevar = np.var(indata, axis=1)
-        scaledvoxels = selectedvoxels * 0.0
-        for vox in range(0, selectedvoxels.shape[0]):
-            scaledvoxels[vox, :] = selectedvoxels[vox, :] - themean[vox]
-            if thevar[vox] > 0.0:
-                scaledvoxels[vox, :] = selectedvoxels[vox, :] / thevar[vox]
-        try:
-            thefit = PCA(n_components=pcacomponents).fit(np.transpose(scaledvoxels))
-        except ValueError:
-            if pcacomponents == "mle":
-                LGR.warning("mle estimation failed - falling back to pcacomponents=0.8")
-                thefit = PCA(n_components=0.8).fit(np.transpose(scaledvoxels))
-            else:
-                raise ValueError("unhandled math exception in PCA refinement - exiting")
-
-        varex = 100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]
-        thetransform = thefit.transform(np.transpose(scaledvoxels))
-        if debug:
-            print(f"getglobalsignal: {thetransform.shape=}")
-        globalmean = np.mean(thetransform, axis=0)
-        globalmean -= np.mean(globalmean)
-        if debug:
-            print(f"getglobalsignal: {varex=}")
-        LGR.info(
-            f"Using {len(thefit.components_)} component(s), accounting for "
-            f"{varex:.2f}% of the variance"
-        )
-    elif optiondict["globalsignalmethod"] == "random":
-        globalmean = np.random.standard_normal(size=len(globalmean))
-    else:
-        raise ValueError(f"illegal globalsignalmethod: {optiondict['globalsignalmethod']}")
-    LGR.info(f"used {numvoxelsused} voxels to calculate global mean signal")
-    if debug:
-        print(f"getglobalsignal: {globalmean=}")
-    return tide_math.stdnormalize(globalmean), themask
-
-
 def checkforzeromean(thedataset):
     themean = np.mean(thedataset, axis=1)
     thestd = np.std(thedataset, axis=1)
@@ -437,6 +368,7 @@ def rapidtide_main(argparsingfunc):
         ["brainmaskincludename", "brainmaskincludevals", "brainmask"],
         ["graymatterincludename", "graymatterincludevals", "graymattermask"],
         ["whitematterincludename", "whitematterincludevals", "whitemattermask"],
+        ["csfincludename", "csfincludevals", "csfmask"],
     ]
     anatomicmasks = []
     for thisanatomic in anatomiclist:
@@ -450,6 +382,7 @@ def rapidtide_main(argparsingfunc):
                     valslist=optiondict[thisanatomic[1]],
                     maskname=thisanatomic[2],
                     tolerance=optiondict["spatialtolerance"],
+                    debug=optiondict["focaldebug"],
                 )
             )
             anatomicmasks[-1] = np.uint16(np.where(anatomicmasks[-1] > 0.1, 1, 0))
@@ -459,6 +392,7 @@ def rapidtide_main(argparsingfunc):
     brainmask = anatomicmasks[0]
     graymask = anatomicmasks[1]
     whitemask = anatomicmasks[2]
+    csfmask = anatomicmasks[3]
 
     # do spatial filtering if requested
     optiondict["gausssigma"] = theinputdata.smooth(
@@ -489,7 +423,7 @@ def rapidtide_main(argparsingfunc):
         )
         optiondict["refineprenorm"] = "None"
 
-    # reformat the brain mask, if it exists
+    # reformat the anatomic masks, if they exist
     if brainmask is None:
         invbrainmask = None
 
@@ -503,22 +437,25 @@ def rapidtide_main(argparsingfunc):
     # read in the optional masks
     tide_util.logmem("before setting masks")
 
-    internalglobalmeanincludemask, internalglobalmeanexcludemask, dummy = tide_mask.getmaskset(
-        "global mean",
-        optiondict["globalmeanincludename"],
-        optiondict["globalmeanincludevals"],
-        optiondict["globalmeanexcludename"],
-        optiondict["globalmeanexcludevals"],
-        theinputdata.nim_hdr,
-        numspatiallocs,
-        istext=(theinputdata.filetype == "text"),
-        tolerance=optiondict["spatialtolerance"],
+    internalinitregressorincludemask, internalinitregressorexcludemask, dummy = (
+        tide_mask.getmaskset(
+            "global mean",
+            optiondict["initregressorincludename"],
+            optiondict["initregressorincludevals"],
+            optiondict["initregressorexcludename"],
+            optiondict["initregressorexcludevals"],
+            theinputdata.nim_hdr,
+            numspatiallocs,
+            istext=(theinputdata.filetype == "text"),
+            tolerance=optiondict["spatialtolerance"],
+            debug=optiondict["focaldebug"],
+        )
     )
     if internalinvbrainmask is not None:
-        if internalglobalmeanexcludemask is not None:
-            internalglobalmeanexcludemask *= internalinvbrainmask
+        if internalinitregressorexcludemask is not None:
+            internalinitregressorexcludemask *= internalinvbrainmask
         else:
-            internalglobalmeanexcludemask = internalinvbrainmask
+            internalinitregressorexcludemask = internalinvbrainmask
 
     internalrefineincludemask, internalrefineexcludemask, dummy = tide_mask.getmaskset(
         "refine",
@@ -530,6 +467,7 @@ def rapidtide_main(argparsingfunc):
         numspatiallocs,
         istext=(theinputdata.filetype == "text"),
         tolerance=optiondict["spatialtolerance"],
+        debug=optiondict["focaldebug"],
     )
     if internalinvbrainmask is not None:
         if internalrefineexcludemask is not None:
@@ -547,6 +485,7 @@ def rapidtide_main(argparsingfunc):
         numspatiallocs,
         istext=(theinputdata.filetype == "text"),
         tolerance=optiondict["spatialtolerance"],
+        debug=optiondict["focaldebug"],
     )
     if internalinvbrainmask is not None:
         if internaloffsetexcludemask is not None:
@@ -568,6 +507,7 @@ def rapidtide_main(argparsingfunc):
             valslist=optiondict["corrmaskincludevals"],
             maskname="correlation",
             tolerance=optiondict["spatialtolerance"],
+            debug=optiondict["focaldebug"],
         )
 
         corrmask = np.uint16(np.where(thecorrmask > 0, 1, 0).reshape(numspatiallocs))
@@ -604,8 +544,8 @@ def rapidtide_main(argparsingfunc):
                         np.std(fmri_data, axis=1), threshpct=optiondict["corrmaskthreshpct"]
                     )
                 )
-    if internalbrainmask is not None:
-        corrmask = internalbrainmask
+        if internalbrainmask is not None:
+            corrmask = internalbrainmask
     if tide_stats.getmasksize(corrmask) == 0:
         raise ValueError("ERROR: there are no voxels in the correlation mask - exiting")
 
@@ -710,7 +650,7 @@ def rapidtide_main(argparsingfunc):
             ),
             labels=["xtrans", "ytrans", "ztrans", "xrot", "yrot", "zrot"],
             deriv=optiondict["mot_deriv"],
-            order=1,
+            order=optiondict["mot_power"],
         )
         domotion = True
     else:
@@ -753,7 +693,7 @@ def rapidtide_main(argparsingfunc):
             append=False,
         )
 
-        if optiondict["focaldebug"]:
+        if optiondict["debug"]:
             print(f"{mergedregressors.shape=}")
             print(f"{mergedregressorlabels}")
             print(f"{fmri_data_valid.shape=}")
@@ -880,15 +820,86 @@ def rapidtide_main(argparsingfunc):
     meanfreq = 1.0 / fmritr
     meanperiod = 1.0 * fmritr
     meanstarttime = 0.0
-    meanvec, meanmask = getglobalsignal(
+    meanvec, meanmask = tide_mask.saveregionaltimeseries(
+        "initial regressor",
+        "startregressormask",
         fmri_data,
-        optiondict,
-        includemask=internalglobalmeanincludemask,
-        excludemask=internalglobalmeanexcludemask,
-        pcacomponents=optiondict["globalpcacomponents"],
-        debug=False,
+        internalinitregressorincludemask,
+        meanfreq,
+        outputname,
+        initfile=True,
+        signalgenmethod=optiondict["initregressorsignalmethod"],
+        pcacomponents=optiondict["initregressorpcacomponents"],
+        excludemask=internalinitregressorexcludemask,
+        filedesc="regionalprefilter",
+        suffix="",
+        debug=optiondict["debug"],
     )
 
+    if brainmask is not None:
+        brainvec, dummy = tide_mask.saveregionaltimeseries(
+            "whole brain",
+            "brain",
+            fmri_data,
+            internalbrainmask,
+            meanfreq,
+            outputname,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
+    if graymask is None:
+        internalgraymask = None
+    else:
+        internalgraymask = graymask.reshape((numspatiallocs))
+        grayvec, dummy = tide_mask.saveregionaltimeseries(
+            "gray matter",
+            "GM",
+            fmri_data,
+            internalgraymask,
+            meanfreq,
+            outputname,
+            excludemask=internalinvbrainmask,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
+    if whitemask is None:
+        internalwhitemask = None
+    else:
+        internalwhitemask = whitemask.reshape((numspatiallocs))
+        whitevec, dummy = tide_mask.saveregionaltimeseries(
+            "white matter",
+            "WM",
+            fmri_data,
+            internalwhitemask,
+            meanfreq,
+            outputname,
+            excludemask=internalinvbrainmask,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
+    if csfmask is None:
+        internalcsfmask = None
+    else:
+        internalcsfmask = csfmask.reshape((numspatiallocs))
+        csfvec, dummy = tide_mask.saveregionaltimeseries(
+            "CSF",
+            "CSF",
+            fmri_data,
+            internalcsfmask,
+            meanfreq,
+            outputname,
+            excludemask=internalinvbrainmask,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
     # get rid of more memory we aren't using
     theinputdata.unload()
     uncollected = gc.collect()
@@ -903,12 +914,12 @@ def rapidtide_main(argparsingfunc):
     TimingLGR.info("Start of reference prep")
     if regressorfilename is None:
         LGR.info("no regressor file specified - will use the global mean regressor")
-        optiondict["useglobalref"] = True
+        optiondict["useinitregressorref"] = True
     else:
-        optiondict["useglobalref"] = False
+        optiondict["useinitregressorref"] = False
 
     # now set the regressor that we'll use
-    if optiondict["useglobalref"]:
+    if optiondict["useinitregressorref"]:
         LGR.verbose("using global mean as probe regressor")
         inputfreq = meanfreq
         inputperiod = meanperiod
@@ -917,7 +928,9 @@ def rapidtide_main(argparsingfunc):
 
         # save the meanmask
         theheader = theinputdata.copyheader(numtimepoints=1)
-        masklist = [(meanmask, "globalmean", "mask", None, "Voxels used to calculate global mean")]
+        masklist = [
+            (meanmask, "initregressor", "mask", None, "Voxels used to calculate initial regressor")
+        ]
         tide_io.savemaplist(
             outputname,
             masklist,
@@ -968,7 +981,7 @@ def rapidtide_main(argparsingfunc):
     LGR.verbose(f"input freq: {inputfreq}")
     LGR.verbose(f"input start time: {inputstarttime:.3f}")
 
-    if not optiondict["useglobalref"]:
+    if not optiondict["useinitregressorref"]:
         globalcorrx, globalcorry, dummy, dummy = tide_corr.arbcorr(
             meanvec, meanfreq, inputvec, inputfreq, start2=(inputstarttime)
         )
@@ -1253,6 +1266,10 @@ def rapidtide_main(argparsingfunc):
         corrpadding=optiondict["corrpadding"],
         debug=optiondict["debug"],
     )
+    if optiondict["focaldebug"]:
+        print(
+            f"calling setreftc during initialization with length {optiondict['oversampfactor'] * validtimepoints}"
+        )
     theCorrelator.setreftc(
         np.zeros((optiondict["oversampfactor"] * validtimepoints), dtype=np.float64)
     )
@@ -1452,7 +1469,7 @@ def rapidtide_main(argparsingfunc):
     # prepare for regressor refinement, if we're doing it
     if (
         optiondict["passes"] > 1
-        or optiondict["globalpreselect"]
+        or optiondict["initregressorpreselect"]
         or optiondict["dofinalrefine"]
         or optiondict["convergencethresh"] is not None
     ):
@@ -1667,6 +1684,10 @@ def rapidtide_main(argparsingfunc):
             rt_floattype=rt_floattype,
             rt_floatset=rt_floatset,
         )
+        if optiondict["focaldebug"]:
+            print(
+                f"after cleanregressor: {len(referencetc)=}, {len(cleaned_referencetc)=}, {osvalidsimcalcstart=}, {osvalidsimcalcend=}, {lagmininpts=}, {lagmaxinpts=}"
+            )
 
         # Step 0 - estimate significance
         if optiondict["numestreps"] > 0:
@@ -1694,6 +1715,10 @@ def rapidtide_main(argparsingfunc):
                     f"{outputname}_options_pregetnull_pass" + str(thepass) + ".json",
                 )
             theCorrelator.setlimits(lagmininpts, lagmaxinpts)
+            if optiondict["focaldebug"]:
+                print(
+                    f"calling setreftc prior to significance estimation with length {len(cleaned_resampref_y)}"
+                )
             theCorrelator.setreftc(cleaned_resampref_y)
             theMutualInformationator.setlimits(lagmininpts, lagmaxinpts)
             theMutualInformationator.setreftc(cleaned_resampref_y)
@@ -1861,6 +1886,7 @@ def rapidtide_main(argparsingfunc):
                 chunksize=optiondict["mp_chunksize"],
                 rt_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
+                debug=optiondict["focaldebug"],
             )
         else:
             (
@@ -1885,6 +1911,7 @@ def rapidtide_main(argparsingfunc):
                 chunksize=optiondict["mp_chunksize"],
                 rt_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
+                debug=optiondict["focaldebug"],
             )
         tide_util.enablemkl(optiondict["mklthreads"], debug=threaddebug)
 
@@ -2303,7 +2330,7 @@ def rapidtide_main(argparsingfunc):
         if (
             thepass < optiondict["passes"]
             or optiondict["convergencethresh"] is not None
-            or optiondict["globalpreselect"]
+            or optiondict["initregressorpreselect"]
             or optiondict["dofinalrefine"]
         ):
             LGR.info(f"\n\nRegressor refinement, pass {thepass}")
@@ -2319,7 +2346,7 @@ def rapidtide_main(argparsingfunc):
                     LGR.warning(
                         "NB: cannot exclude voxels from offset calculation mask - including for this pass"
                     )
-                    offsetmask = fitmask
+                    offsetmask = fitmask + 0
 
                 peaklag, dummy, dummy = tide_stats.gethistprops(
                     lagtimes[np.where(offsetmask > 0)],
@@ -2420,7 +2447,34 @@ def rapidtide_main(argparsingfunc):
             )
             for key, value in outputdict.items():
                 optiondict[key] = value
-        # We are done with refinement.
+
+            # 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,
+                )
+            # We are done with refinement.
+        # End of main pass loop
 
     if optiondict["convergencethresh"] is None:
         optiondict["actual_passes"] = optiondict["passes"]
@@ -2974,6 +3028,79 @@ def rapidtide_main(argparsingfunc):
                     "message3": "voxels",
                 },
             )
+            if internalinitregressorincludemask is not None:
+                thisincludemask = internalinitregressorincludemask[validvoxels]
+            else:
+                thisincludemask = None
+            if internalinitregressorexcludemask is not None:
+                thisexcludemask = internalinitregressorexcludemask[validvoxels]
+            else:
+                thisexcludemask = None
+
+            meanvec, meanmask = tide_mask.saveregionaltimeseries(
+                "initial regressor",
+                "startregressormask",
+                filtereddata,
+                thisincludemask,
+                meanfreq,
+                outputname,
+                initfile=True,
+                excludemask=thisexcludemask,
+                filedesc="regionalpostfilter",
+                suffix="",
+                debug=optiondict["debug"],
+            )
+            if brainmask is not None:
+                brainvec, dummy = tide_mask.saveregionaltimeseries(
+                    "whole brain",
+                    "brain",
+                    filtereddata,
+                    internalbrainmask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            if graymask is not None:
+                grayvec, dummy = tide_mask.saveregionaltimeseries(
+                    "gray matter",
+                    "GM",
+                    filtereddata,
+                    internalgraymask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    excludemask=internalinvbrainmask[validvoxels],
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            if whitemask is not None:
+                whitevec, dummy = tide_mask.saveregionaltimeseries(
+                    "white matter",
+                    "WM",
+                    filtereddata,
+                    internalwhitemask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    excludemask=internalinvbrainmask[validvoxels],
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            if csfmask is not None:
+                grayvec, dummy = tide_mask.saveregionaltimeseries(
+                    "CSF",
+                    "CSF",
+                    filtereddata,
+                    internalcsfmask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    excludemask=internalinvbrainmask[validvoxels],
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
             tide_util.logmem("after sLFO filter")
             LGR.info("")
     else:
@@ -3336,7 +3463,7 @@ def rapidtide_main(argparsingfunc):
             cifti_hdr=theinputdata.cifti_hdr,
         )
 
-        if optiondict["refinedelay"] and False:
+        if optiondict["refinedelay"]:
             # filter the fmri data to the lfo band
             print("filtering fmri_data to sLFO band")
             for i in range(fmri_data_valid.shape[0]):
@@ -3377,7 +3504,13 @@ def rapidtide_main(argparsingfunc):
             )
 
             maplist = [
-                (rvalue, "maxcorralt", "map", None, "R value of the inband sLFO fit, with sign"),
+                (
+                    rvalue,
+                    "maxcorrrefined",
+                    "map",
+                    None,
+                    "R value of the inband sLFO fit, with sign",
+                ),
             ]
 
             tide_io.savemaplist(
@@ -3423,6 +3556,8 @@ def rapidtide_main(argparsingfunc):
         maplist.append((graymask, "GM", "mask", None, "Gray matter mask"))
     if whitemask is not None:
         maplist.append((whitemask, "WM", "mask", None, "White matter mask"))
+    if csfmask is not None:
+        maplist.append((csfmask, "CSF", "mask", None, "CSF mask"))
     tide_io.savemaplist(
         outputname,
         maplist,
@@ -3474,15 +3609,15 @@ def rapidtide_main(argparsingfunc):
         )
         del masklist
 
-    if (optiondict["passes"] > 1 or optiondict["globalpreselect"]) and optiondict[
+    if (optiondict["passes"] > 1 or optiondict["initregressorpreselect"]) and optiondict[
         "refinestopreason"
     ] != "emptymask":
         refinemask = theRegressorRefiner.getrefinemask()
-        if optiondict["globalpreselect"]:
+        if optiondict["initregressorpreselect"]:
             masklist = [
                 (
                     refinemask,
-                    "globalmeanpreselect",
+                    "initregressorpreselect",
                     "mask",
                     None,
                     "I really don't know what this file is for",
@@ -3511,7 +3646,11 @@ def rapidtide_main(argparsingfunc):
     del fitmask
 
     # now do the 4D maps of the similarity function and friends
-    theheader = theinputdata.copyheader(numtimepoints=np.shape(outcorrarray)[1], tr=corrtr)
+    theheader = theinputdata.copyheader(
+        numtimepoints=np.shape(outcorrarray)[1],
+        tr=corrtr,
+        toffset=(corrscale[corrorigin - lagmininpts]),
+    )
     if (
         optiondict["savecorrout"]
         or (optiondict["outputlevel"] != "min")

rapidtide/workflows/rapidtide2std.py

@@ -187,8 +187,10 @@ def rapidtide2std(args):
 
     thefmrimaps = [
         "desc-maxtime_map",
+        "desc-maxtimerefined_map",
         "desc-timepercentile_map",
         "desc-maxcorr_map",
+        "desc-maxcorrrefined_map",
         "desc-maxwidth_map",
         "desc-MTT_map",
         "desc-corrfit_mask",