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

rapidtide/RapidtideDataset.py

@@ -408,7 +408,7 @@ class Overlay:
 
     def maskData(self):
         self.mask = self.geommask * self.funcmask
-        maskhash = hash(self.mask.tostring())
+        maskhash = hash(self.mask.tobytes())
         # these operations are expensive, so only do them if the mask is changed
         if (maskhash == self.maskhash) and (self.verbose > 1):
             print("mask has not changed")

rapidtide/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-06-26T14:50:59-0400",
+ "date": "2025-07-03T10:21:49-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "d9a8fd9ab24057e4a74e43dccdc1117e3c6875a2",
- "version": "3.0.8"
+ "full-revisionid": "292e93bbd0a9c13e2d62a00746e14522b0783156",
+ "version": "3.0.9"
 }
 '''  # END VERSION_JSON
 

rapidtide/data/examples/src/testfmri

@@ -1,25 +1,9 @@
 #!/bin/bash
 
-#rapidtide \
-#    --spatialfilt -1 \
-#    --nprocs -1 \
-#    --searchrange -5 20 \
-#    --simcalcrange 50 -1 \
-#    --outputlevel more \
-#    --graymattermask sub-RAPIDTIDETEST_synthseg.nii.gz:SSEG_GRAY \
-#    --brainmask sub-RAPIDTIDETEST_brainmask.nii.gz \
-#    --whitemattermask sub-RAPIDTIDETEST_synthseg.nii.gz:SSEG_WHITE \
-#    --csfmask sub-RAPIDTIDETEST_synthseg.nii.gz:SSEG_CSF \
-#    --cleanrefined \
-#    --nofitfilt \
-#    --similaritymetric correlation \
-#    sub-RAPIDTIDETEST.nii.gz \
-#    ../dst/sub-RAPIDTIDETEST
-
 rapidtide \
-    --spatialfilt 3 \
+    --spatialfilt 2.5 \
     --nprocs -1 \
-    --searchrange -5 20 \
+    --searchrange -7.5 30 \
     --simcalcrange 50 -1 \
     --outputlevel more \
     --graymattermask sub-RAPIDTIDETEST_synthseg.nii.gz:SSEG_GRAY \
@@ -31,6 +15,28 @@ rapidtide \
     --refinedelayeachpass \
     --similaritymetric correlation \
     sub-RAPIDTIDETEST.nii.gz \
-    ../dst/sub-RAPIDTIDETEST_passrefine
+    ../dst/sub-RAPIDTIDETEST_simfunc
+
+rapidtide \
+    --spatialfilt 2.5 \
+    --nprocs -1 \
+    --searchrange -7.5 30 \
+    --simcalcrange 50 -1 \
+    --outputlevel more \
+    --graymattermask sub-RAPIDTIDETEST_synthseg.nii.gz:SSEG_GRAY \
+    --brainmask sub-RAPIDTIDETEST_brainmask.nii.gz \
+    --whitemattermask sub-RAPIDTIDETEST_synthseg.nii.gz:SSEG_WHITE \
+    --csfmask sub-RAPIDTIDETEST_synthseg.nii.gz:SSEG_CSF \
+    --cleanrefined \
+    --nofitfilt \
+    --refinedelayeachpass \
+    --similaritymetric riptide \
+    --riptidestep 1.5 \
+    --ampthresh 0.0 \
+    --numnull 0 \
+    sub-RAPIDTIDETEST.nii.gz \
+    ../dst/sub-RAPIDTIDETEST_riptide
 
-tidepool --uistyle big --dataset ../dst/sub-RAPIDTIDETEST_ ../dst/sub-RAPIDTIDETEST_passrefine_
+tidepool --uistyle big --dataset \
+    ../dst/sub-RAPIDTIDETEST_simfunc_ \
+    ../dst/sub-RAPIDTIDETEST_riptide_ &

rapidtide/linfitfiltpass.py

@@ -91,11 +91,12 @@ def linfitfiltpass(
     filtereddata,
     nprocs=1,
     alwaysmultiproc=False,
+    voxelspecific=True,
     confoundregress=False,
-    ratiosonly=False,
+    coefficientsonly=False,
     procbyvoxel=True,
     showprogressbar=True,
-    mp_chunksize=1000,
+    chunksize=1000,
     rt_floatset=np.float64,
     rt_floattype="float64",
     verbose=True,
@@ -142,7 +143,7 @@ def linfitfiltpass(
 
                     # process and send the data
                     if procbyvoxel:
-                        if confoundregress:
+                        if confoundregress or (not voxelspecific):
                             outQ.put(
                                 _procOneRegressionFitItem(
                                     val,
@@ -163,7 +164,7 @@ def linfitfiltpass(
                                 )
                             )
                     else:
-                        if confoundregress:
+                        if confoundregress or (not voxelspecific):
                             outQ.put(
                                 _procOneRegressionFitItem(
                                     val,
@@ -197,7 +198,7 @@ def linfitfiltpass(
             indexaxis=indexaxis,
             procunit=procunit,
             showprogressbar=showprogressbar,
-            chunksize=mp_chunksize,
+            chunksize=chunksize,
         )
 
         # unpack the data
@@ -208,7 +209,7 @@ def linfitfiltpass(
                     r2value[voxel[0]] = voxel[3]
                     filtereddata[voxel[0], :] = voxel[7]
                     itemstotal += 1
-            elif ratiosonly:
+            elif coefficientsonly:
                 for voxel in data_out:
                     meanvalue[voxel[0]] = voxel[1]
                     rvalue[voxel[0]] = voxel[2]
@@ -240,7 +241,7 @@ def linfitfiltpass(
                     r2value[timepoint[0]] = timepoint[3]
                     filtereddata[:, timepoint[0]] = timepoint[7]
                     itemstotal += 1
-            elif ratiosonly:
+            elif coefficientsonly:
                 for timepoint in data_out:
                     meanvalue[timepoint[0]] = timepoint[1]
                     rvalue[timepoint[0]] = timepoint[2]
@@ -296,23 +297,41 @@ def linfitfiltpass(
                             rt_floatset=rt_floatset,
                             rt_floattype=rt_floattype,
                         )
-                    elif ratiosonly:
-                        (
-                            dummy,
-                            meanvalue[vox],
-                            rvalue[vox],
-                            r2value[vox],
-                            fitcoeff[vox],
-                            fitNorm[vox],
-                            dummy,
-                            dummy,
-                        ) = _procOneRegressionFitItem(
-                            vox,
-                            theevs[vox, :],
-                            thedata,
-                            rt_floatset=rt_floatset,
-                            rt_floattype=rt_floattype,
-                        )
+                    elif coefficientsonly:
+                        if voxelspecific:
+                            (
+                                dummy,
+                                meanvalue[vox],
+                                rvalue[vox],
+                                r2value[vox],
+                                fitcoeff[vox],
+                                fitNorm[vox],
+                                dummy,
+                                dummy,
+                            ) = _procOneRegressionFitItem(
+                                vox,
+                                theevs[vox, :],
+                                thedata,
+                                rt_floatset=rt_floatset,
+                                rt_floattype=rt_floattype,
+                            )
+                        else:
+                            (
+                                dummy,
+                                meanvalue[vox],
+                                rvalue[vox],
+                                r2value[vox],
+                                fitcoeff[vox],
+                                fitNorm[vox],
+                                dummy,
+                                dummy,
+                            ) = _procOneRegressionFitItem(
+                                vox,
+                                theevs,
+                                thedata,
+                                rt_floatset=rt_floatset,
+                                rt_floattype=rt_floattype,
+                            )
                     else:
                         (
                             dummy,
@@ -357,7 +376,7 @@ def linfitfiltpass(
                             rt_floatset=rt_floatset,
                             rt_floattype=rt_floattype,
                         )
-                    elif ratiosonly:
+                    elif coefficientsonly:
                         (
                             dummy,
                             meanvalue[timepoint],

rapidtide/refinedelay.py

@@ -391,10 +391,10 @@ def getderivratios(
         nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
         nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
         regressderivs=regressderivs,
-        mp_chunksize=optiondict["mp_chunksize"],
+        chunksize=optiondict["mp_chunksize"],
         showprogressbar=optiondict["showprogressbar"],
         alwaysmultiproc=optiondict["alwaysmultiproc"],
-        ratiosonly=True,
+        coefficientsonly=True,
         debug=debug,
     )
 

rapidtide/refineregressor.py

@@ -590,7 +590,7 @@ def dorefine(
                 sys.exit()
         LGR.info(
             f"Using {len(thefit.components_)} component(s), accounting for "
-            + f"{100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]}% of the variance"
+            + f"{100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]:.2f}% of the variance"
         )
         reduceddata = thefit.inverse_transform(thefit.transform(refinevoxels))
         if debug:

rapidtide/resample.py

@@ -597,7 +597,7 @@ def arbresample(
         return resampled
 
 
-def upsample(inputdata, Fs_init, Fs_higher, method="univariate", intfac=False, debug=False):
+def upsample(inputdata, Fs_init, Fs_higher, method="univariate", intfac=False, dofilt=True, debug=False):
     starttime = time.time()
     if Fs_higher <= Fs_init:
         print("upsample: target frequency must be higher than initial frequency")
@@ -607,19 +607,19 @@ def upsample(inputdata, Fs_init, Fs_higher, method="univariate", intfac=False, d
     orig_x = np.linspace(0.0, (1.0 / Fs_init) * len(inputdata), num=len(inputdata), endpoint=False)
     endpoint = orig_x[-1] - orig_x[0]
     ts_higher = 1.0 / Fs_higher
-    numresamppts = int(endpoint // ts_higher + 1)
     if intfac:
         numresamppts = int(Fs_higher // Fs_init) * len(inputdata)
     else:
         numresamppts = int(endpoint // ts_higher + 1)
     upsampled_x = np.arange(0.0, ts_higher * numresamppts, ts_higher)
     upsampled_y = doresample(orig_x, inputdata, upsampled_x, method=method)
-    initfilter = tide_filt.NoncausalFilter(
-        filtertype="arb", transferfunc="trapezoidal", debug=debug
-    )
-    stopfreq = np.min([1.1 * Fs_init / 2.0, Fs_higher / 2.0])
-    initfilter.setfreqs(0.0, 0.0, Fs_init / 2.0, stopfreq)
-    upsampled_y = initfilter.apply(Fs_higher, upsampled_y)
+    if dofilt:
+        initfilter = tide_filt.NoncausalFilter(
+            filtertype="arb", transferfunc="trapezoidal", debug=debug
+        )
+        stopfreq = np.min([1.1 * Fs_init / 2.0, Fs_higher / 2.0])
+        initfilter.setfreqs(0.0, 0.0, Fs_init / 2.0, stopfreq)
+        upsampled_y = initfilter.apply(Fs_higher, upsampled_y)
     if debug:
         print("upsampling took", time.time() - starttime, "seconds")
     return upsampled_y

rapidtide/tests/test_delayestimation.py

@@ -350,7 +350,7 @@ def test_delayestimation(displayplots=False, debug=False):
             nprocs=nprocs,
             alwaysmultiproc=False,
             showprogressbar=False,
-            mp_chunksize=chunksize,
+            chunksize=chunksize,
         )
 
         if nprocs == 1:

rapidtide/tests/test_fullrunrapidtide_v8.py

@@ -0,0 +1,66 @@
+#!/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 os
+
+import matplotlib as mpl
+
+import rapidtide.qualitycheck as rapidtide_quality
+import rapidtide.workflows.rapidtide as rapidtide_workflow
+import rapidtide.workflows.rapidtide_parser as rapidtide_parser
+from rapidtide.tests.utils import get_examples_path, get_test_temp_path
+
+
+def test_fullrunrapidtide_v8(debug=False, local=False, displayplots=False):
+    # set input and output directories
+    if local:
+        exampleroot = "../data/examples/src"
+        testtemproot = "./tmp"
+    else:
+        exampleroot = get_examples_path()
+        testtemproot = get_test_temp_path()
+
+    # run rapidtide
+    inputargs = [
+        os.path.join(exampleroot, "sub-RAPIDTIDETEST.nii.gz"),
+        os.path.join(testtemproot, "sub-RAPIDTIDETEST8"),
+        "--spatialfilt",
+        "2",
+        "--simcalcrange",
+        "4",
+        "-1",
+        "--searchrange",
+        "-5",
+        "10",
+        "--nprocs",
+        "-1",
+        "--passes",
+        "1",
+        "--despecklepasses",
+        "3",
+        "--similaritymetric",
+        "riptide",
+        "--riptidestep",
+        "1.5",
+    ]
+    rapidtide_workflow.rapidtide_main(rapidtide_parser.process_args(inputargs=inputargs))
+
+
+if __name__ == "__main__":
+    mpl.use("TkAgg")
+    test_fullrunrapidtide_v8(debug=True, local=True, displayplots=True)

rapidtide/workflows/calcSimFuncMap.py

@@ -0,0 +1,271 @@
+#!/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.calcsimfunc as tide_calcsimfunc
+import rapidtide.io as tide_io
+import rapidtide.linfitfiltpass as tide_linfitfiltpass
+import rapidtide.makelaggedtcs as tide_makelagged
+import rapidtide.stats as tide_stats
+import rapidtide.util as tide_util
+
+
+def makeRIPTiDeRegressors(
+    initial_fmri_x,
+    lagmin,
+    lagmax,
+    lagtcgenerator,
+    LGR,
+    nprocs=1,
+    alwaysmultiproc=False,
+    showprogressbar=True,
+    chunksize=1000,
+    targetstep=2.5,
+    edgepad=0,
+    rt_floatset=np.float64,
+    rt_floattype="float64",
+    debug=False,
+):
+    # make the RIPTiDe evs
+    numdelays = int(np.round((lagmax - lagmin) / targetstep, 0))
+    numregressors = numdelays + 2 * edgepad
+    delaystep = (lagmax - lagmin) / numdelays
+    delaystouse = np.linspace(
+        lagmin - edgepad * delaystep,
+        lagmax + edgepad * delaystep,
+        numdelays + 2 * edgepad,
+        endpoint=True,
+    )
+    if debug:
+        print(f"{lagmin=}")
+        print(f"{lagmax=}")
+        print(f"{numdelays=}")
+        print(f"{edgepad=}")
+        print(f"{numregressors=}")
+        print(f"{delaystep=}")
+        print(f"{delaystouse=}, {len(delaystouse)}")
+        print(f"{len(initial_fmri_x)}")
+
+    regressorset = np.zeros((len(delaystouse), len(initial_fmri_x)), dtype=rt_floatset)
+
+    dummy = tide_makelagged.makelaggedtcs(
+        lagtcgenerator,
+        initial_fmri_x,
+        np.ones_like(delaystouse, dtype=np.float64),
+        delaystouse,
+        regressorset,
+        LGR=LGR,
+        nprocs=nprocs,
+        alwaysmultiproc=alwaysmultiproc,
+        showprogressbar=showprogressbar,
+        chunksize=chunksize,
+        rt_floatset=rt_floatset,
+        rt_floattype=rt_floattype,
+        debug=debug,
+    )
+
+    if debug:
+        print(regressorset)
+
+    return regressorset, delaystouse
+
+
+def calcSimFunc(
+    numvalidspatiallocs,
+    fmri_data_valid,
+    validsimcalcstart,
+    validsimcalcend,
+    osvalidsimcalcstart,
+    osvalidsimcalcend,
+    initial_fmri_x,
+    os_fmri_x,
+    theCorrelator,
+    theMutualInformationator,
+    cleaned_referencetc,
+    corrout,
+    regressorset,
+    delayvals,
+    sLFOfitmean,
+    r2value,
+    fitcoeff,
+    fitNorm,
+    meanval,
+    corrscale,
+    outputname,
+    outcorrarray,
+    validvoxels,
+    nativecorrshape,
+    theinputdata,
+    theheader,
+    lagmininpts,
+    lagmaxinpts,
+    thepass,
+    optiondict,
+    LGR,
+    TimingLGR,
+    similaritymetric="correlation",
+    simcalcoffset=0,
+    echocancel=False,
+    checkpoint=False,
+    nprocs=1,
+    alwaysmultiproc=False,
+    oversampfactor=2,
+    interptype="univariate",
+    showprogressbar=True,
+    chunksize=1000,
+    rt_floatset=np.float64,
+    rt_floattype="float64",
+    mklthreads=1,
+    threaddebug=False,
+    debug=False,
+):
+    # Step 1 - Correlation step
+    if similaritymetric == "mutualinfo":
+        similaritytype = "Mutual information"
+    elif similaritymetric == "correlation":
+        similaritytype = "Correlation"
+    elif similaritymetric == "riptide":
+        similaritytype = "RIPTiDe"
+    else:
+        similaritytype = "MI enhanced correlation"
+    LGR.info(f"\n\n{similaritytype} calculation, pass {thepass}")
+    TimingLGR.info(f"{similaritytype} calculation start, pass {thepass}")
+
+    tide_util.disablemkl(nprocs, debug=threaddebug)
+    if similaritymetric == "mutualinfo":
+        theMutualInformationator.setlimits(lagmininpts, lagmaxinpts)
+        (
+            voxelsprocessed_cp,
+            theglobalmaxlist,
+            trimmedcorrscale,
+        ) = tide_calcsimfunc.correlationpass(
+            fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
+            cleaned_referencetc,
+            theMutualInformationator,
+            initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
+            os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
+            lagmininpts,
+            lagmaxinpts,
+            corrout,
+            meanval,
+            nprocs=nprocs,
+            alwaysmultiproc=alwaysmultiproc,
+            oversampfactor=oversampfactor,
+            interptype=interptype,
+            showprogressbar=showprogressbar,
+            chunksize=chunksize,
+            rt_floatset=rt_floatset,
+            rt_floattype=rt_floattype,
+            debug=debug,
+        )
+    elif (similaritymetric == "correlation") or (similaritymetric == "hybrid"):
+        (
+            voxelsprocessed_cp,
+            theglobalmaxlist,
+            trimmedcorrscale,
+        ) = tide_calcsimfunc.correlationpass(
+            fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
+            cleaned_referencetc,
+            theCorrelator,
+            initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
+            os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
+            lagmininpts,
+            lagmaxinpts,
+            corrout,
+            meanval,
+            nprocs=nprocs,
+            alwaysmultiproc=alwaysmultiproc,
+            oversampfactor=oversampfactor,
+            interptype=interptype,
+            showprogressbar=showprogressbar,
+            chunksize=chunksize,
+            rt_floatset=rt_floatset,
+            rt_floattype=rt_floattype,
+            debug=debug,
+        )
+    elif similaritymetric == "riptide":
+        # do the linear fit to the comb of delayed regressors
+        for thedelay in range(len(delayvals)):
+            print(f"Fitting delay {delayvals[thedelay]:.2f}")
+            voxelsprocessed_cp = tide_linfitfiltpass.linfitfiltpass(
+                numvalidspatiallocs,
+                fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
+                0.0,
+                regressorset[thedelay, validsimcalcstart : validsimcalcend + 1],
+                sLFOfitmean,
+                corrout[:, thedelay],
+                r2value,
+                fitcoeff,
+                fitNorm,
+                None,
+                None,
+                coefficientsonly=True,
+                voxelspecific=False,
+                nprocs=nprocs,
+                alwaysmultiproc=alwaysmultiproc,
+                showprogressbar=showprogressbar,
+                verbose=(LGR is not None),
+                chunksize=chunksize,
+                rt_floatset=rt_floatset,
+                rt_floattype=rt_floattype,
+                debug=debug,
+            )
+    else:
+        print("illegal similarity metric")
+
+    tide_util.enablemkl(mklthreads, debug=threaddebug)
+
+    if similaritymetric != "riptide":
+        for i in range(len(theglobalmaxlist)):
+            theglobalmaxlist[i] = corrscale[theglobalmaxlist[i]] - simcalcoffset
+        namesuffix = "_desc-globallag_hist"
+        tide_stats.makeandsavehistogram(
+            np.asarray(theglobalmaxlist),
+            len(corrscale),
+            0,
+            outputname + namesuffix,
+            displaytitle="Histogram of lag times from global lag calculation",
+            therange=(corrscale[0], corrscale[-1]),
+            refine=False,
+            dictvarname="globallaghist_pass" + str(thepass),
+            append=(echocancel or (thepass > 1)),
+            thedict=optiondict,
+        )
+
+    if checkpoint:
+        outcorrarray[:, :] = 0.0
+        outcorrarray[validvoxels, :] = corrout[:, :]
+        if theinputdata.filetype == "text":
+            tide_io.writenpvecs(
+                outcorrarray.reshape(nativecorrshape),
+                f"{outputname}_corrout_prefit_pass" + str(thepass) + ".txt",
+            )
+        else:
+            savename = f"{outputname}_desc-corroutprefit_pass-" + str(thepass)
+            tide_io.savetonifti(outcorrarray.reshape(nativecorrshape), theheader, savename)
+
+    TimingLGR.info(
+        f"{similaritytype} calculation end, pass {thepass}",
+        {
+            "message2": voxelsprocessed_cp,
+            "message3": "voxels",
+        },
+    )
+
+    return similaritytype

rapidtide/workflows/delayvar.py

@@ -825,7 +825,7 @@ def delayvar(args):
                 sys.exit()
         print(
             f"Using {len(thefit.components_)} component(s), accounting for "
-            + f"{100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]}% of the variance"
+            + f"{100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]:.2f}% of the variance"
         )
         reduceddata = thefit.inverse_transform(thefit.transform(scaledvoxels))
         # unscale the PCA cleaned data