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

rapidtide/workflows/retroregress.py

@@ -32,12 +32,12 @@ import rapidtide.io as tide_io
 import rapidtide.maskutil as tide_mask
 import rapidtide.miscmath as tide_math
 import rapidtide.multiproc as tide_multiproc
-import rapidtide.refinedelay as tide_refinedelay
 import rapidtide.resample as tide_resample
 import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
 import rapidtide.voxelData as tide_voxelData
 import rapidtide.workflows.parser_funcs as pf
+import rapidtide.workflows.refineDelayMap as tide_refineDelayMap
 import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 
 from .rapidtide_parser import DEFAULT_REGRESSIONFILTDERIVS
@@ -61,7 +61,6 @@ DEFAULT_REFINEDELAYMINDELAY = -5.0
 DEFAULT_REFINEDELAYMAXDELAY = 5.0
 DEFAULT_REFINEDELAYNUMPOINTS = 501
 DEFAULT_DELAYOFFSETSPATIALFILT = -1
-DEFAULT_REFINEREGRESSDERIVS = 1
 
 
 def _get_parser():
@@ -229,18 +228,6 @@ def _get_parser():
     experimental = parser.add_argument_group(
         "Experimental options (not fully tested, or not tested at all, may not work).  Beware!"
     )
-    experimental.add_argument(
-        "--refineregressderivs",
-        dest="refineregressderivs",
-        action="store",
-        type=lambda x: pf.is_int(parser, x, minval=1),
-        metavar="NDERIVS",
-        help=(
-            f"When doing GLM for delay refinement, include derivatives up to NDERIVS order. Must be 1 or more.  "
-            f"Default is {DEFAULT_REFINEREGRESSDERIVS}"
-        ),
-        default=DEFAULT_REFINEREGRESSDERIVS,
-    )
 
     return parser
 
@@ -504,7 +491,7 @@ def retroregress(args):
         print(f"{numvalidspatiallocs=}")
     internalvalidspaceshape = numvalidspatiallocs
     if args.refinedelay:
-        derivaxissize = np.max([args.refineregressderivs + 1, args.regressderivs + 1])
+        derivaxissize = np.max([2, args.regressderivs + 1])
     else:
         derivaxissize = args.regressderivs + 1
     internalvalidspaceshapederivs = (
@@ -529,37 +516,29 @@ def retroregress(args):
     if args.debug:
         print(f"{fmri_data_valid.shape=}")
 
+    sLFOfitmean, sLFOfitmean_shm = tide_util.allocarray(
+        internalvalidspaceshape, rt_outfloattype, shared=usesharedmem
+    )
+    rvalue, rvalue_shm = tide_util.allocarray(internalvalidspaceshape, rt_outfloattype, shared=usesharedmem)
+    r2value, r2value_shm = tide_util.allocarray(internalvalidspaceshape, rt_outfloattype, shared=usesharedmem)
+    fitNorm, fitNorm_shm = tide_util.allocarray(internalvalidspaceshapederivs, rt_outfloattype, shared=usesharedmem)
+    fitcoeff, fitcoeff_shm = tide_util.allocarray(
+        internalvalidspaceshapederivs, rt_outfloattype, shared=usesharedmem
+    )
+    movingsignal, movingsignal_shm = tide_util.allocarray(
+        internalvalidfmrishape, rt_outfloattype, shared=usesharedmem
+    )
+    lagtc, lagtc_shm = tide_util.allocarray(internalvalidfmrishape, rt_floattype, shared=usesharedmem)
+    filtereddata, filtereddata_shm = tide_util.allocarray(
+        internalvalidfmrishape, rt_outfloattype, shared=usesharedmem
+    )
     if usesharedmem:
         if args.debug:
             print("allocating shared memory")
-        sLFOfitmean, sLFOfitmean_shm = tide_util.allocshared(
-            internalvalidspaceshape, rt_outfloatset
-        )
-        rvalue, rvalue_shm = tide_util.allocshared(internalvalidspaceshape, rt_outfloatset)
-        r2value, r2value_shm = tide_util.allocshared(internalvalidspaceshape, rt_outfloatset)
-        fitNorm, fitNorm_shm = tide_util.allocshared(internalvalidspaceshapederivs, rt_outfloatset)
-        fitcoeff, fitcoeff_shm = tide_util.allocshared(
-            internalvalidspaceshapederivs, rt_outfloatset
-        )
-        movingsignal, movingsignal_shm = tide_util.allocshared(
-            internalvalidfmrishape, rt_outfloatset
-        )
-        lagtc, lagtc_shm = tide_util.allocshared(internalvalidfmrishape, rt_floatset)
-        filtereddata, filtereddata_shm = tide_util.allocshared(
-            internalvalidfmrishape, rt_outfloatset
-        )
         ramlocation = "in shared memory"
     else:
         if args.debug:
             print("allocating memory")
-        sLFOfitmean = np.zeros(internalvalidspaceshape, dtype=rt_outfloattype)
-        rvalue = np.zeros(internalvalidspaceshape, dtype=rt_outfloattype)
-        r2value = np.zeros(internalvalidspaceshape, dtype=rt_outfloattype)
-        fitNorm = np.zeros(internalvalidspaceshapederivs, dtype=rt_outfloattype)
-        fitcoeff = np.zeros(internalvalidspaceshapederivs, dtype=rt_outfloattype)
-        movingsignal = np.zeros(internalvalidfmrishape, dtype=rt_outfloattype)
-        lagtc = np.zeros(internalvalidfmrishape, dtype=rt_floattype)
-        filtereddata = np.zeros(internalvalidfmrishape, dtype=rt_outfloattype)
         ramlocation = "locally"
 
     totalbytes = (
@@ -643,118 +622,49 @@ def retroregress(args):
             # set gausssigma automatically
             args.delayoffsetgausssigma = np.mean([xdim, ydim, slicethickness]) / 2.0
 
-        TimingLGR.info("Refinement calibration start")
-        regressderivratios, regressrvalues = tide_refinedelay.getderivratios(
-            fmri_data_valid,
-            validvoxels,
-            initial_fmri_x,
-            lagtimes_valid,
-            sLFOfiltmask_valid,
-            genlagtc,
-            mode,
-            outputname,
-            oversamptr,
-            sLFOfitmean,
-            rvalue,
-            r2value,
-            fitNorm[:, : (args.refineregressderivs + 1)],
-            fitcoeff[:, : (args.refineregressderivs + 1)],
-            movingsignal,
-            lagtc,
-            filtereddata,
-            LGR,
-            TimingLGR,
-            therunoptions,
-            regressderivs=args.refineregressderivs,
-            debug=args.debug,
-        )
-
-        if args.refineregressderivs == 1:
-            medfiltregressderivratios, filteredregressderivratios, delayoffsetMAD = (
-                tide_refinedelay.filterderivratios(
-                    regressderivratios,
-                    (xsize, ysize, numslices),
-                    validvoxels,
-                    (xdim, ydim, slicethickness),
-                    gausssigma=args.delayoffsetgausssigma,
-                    patchthresh=args.delaypatchthresh,
-                    rt_floattype=rt_floattype,
-                    debug=args.debug,
-                )
-            )
-
-            # find the mapping of glm ratios to delays
-            tide_refinedelay.trainratiotooffset(
-                genlagtc,
+            (
+                delayoffset,
+                regressderivratios,
+                medfiltregressderivratios,
+                filteredregressderivratios,
+                delayoffsetMAD,
+            ) = tide_refineDelayMap.refineDelay(
+                fmri_data_valid,
                 initial_fmri_x,
+                xdim,
+                ydim,
+                slicethickness,
+                sLFOfiltmask_valid,
+                genlagtc,
+                oversamptr,
+                sLFOfitmean,
+                rvalue,
+                r2value,
+                fitNorm,
+                fitcoeff,
+                lagtc,
                 outputname,
-                args.outputlevel,
+                validvoxels,
+                theinputdata.nativespaceshape,
+                theinputdata,
+                lagtimes_valid,
+                therunoptions,
+                LGR,
+                TimingLGR,
+                outputlevel=args.outputlevel,
+                gausssigma=args.delayoffsetgausssigma,
+                patchthresh=args.delaypatchthresh,
                 mindelay=args.mindelay,
                 maxdelay=args.maxdelay,
                 numpoints=args.numpoints,
+                histlen=therunoptions["histlen"],
+                rt_floatset=rt_floatset,
+                rt_floattype=rt_floattype,
                 debug=args.debug,
             )
-            TimingLGR.info("Refinement calibration end")
-
-            # now calculate the delay offsets
-            TimingLGR.info("Calculating delay offsets")
-            delayoffset = np.zeros_like(filteredregressderivratios)
-            if args.debug:
-                print(f"calculating delayoffsets for {filteredregressderivratios.shape[0]} voxels")
-            for i in range(filteredregressderivratios.shape[0]):
-                delayoffset[i], closestoffset = tide_refinedelay.ratiotodelay(
-                    filteredregressderivratios[i]
-                )
-                """delayoffset[i] = tide_refinedelay.coffstodelay(
-                    np.asarray([filteredregressderivratios[i]]),
-                    mindelay=args.mindelay,
-                    maxdelay=args.maxdelay,
-                )"""
 
-            refinedvoxelstoreport = filteredregressderivratios.shape[0]
-        else:
-            medfiltregressderivratios = np.zeros_like(regressderivratios)
-            filteredregressderivratios = np.zeros_like(regressderivratios)
-            delayoffsetMAD = np.zeros(args.refineregressderivs, dtype=float)
-            for i in range(args.refineregressderivs):
-                (
-                    medfiltregressderivratios[i, :],
-                    filteredregressderivratios[i, :],
-                    delayoffsetMAD[i],
-                ) = tide_refinedelay.filterderivratios(
-                    regressderivratios[i, :],
-                    (xsize, ysize, numslices),
-                    validvoxels,
-                    (xdim, ydim, slicethickness),
-                    gausssigma=args.delayoffsetgausssigma,
-                    patchthresh=args.delaypatchthresh,
-                    rt_floattype=rt_floattype,
-                    debug=args.debug,
-                )
-
-            # now calculate the delay offsets
-            delayoffset = np.zeros_like(filteredregressderivratios[0, :])
-            if args.debug:
-                print(f"calculating delayoffsets for {filteredregressderivratios.shape[1]} voxels")
-            for i in range(filteredregressderivratios.shape[1]):
-                delayoffset[i] = tide_refinedelay.coffstodelay(
-                    filteredregressderivratios[:, i],
-                    mindelay=args.mindelay,
-                    maxdelay=args.maxdelay,
-                )
-            refinedvoxelstoreport = filteredregressderivratios.shape[1]
+        refinedvoxelstoreport = filteredregressderivratios.shape[0]
 
-        if not args.saveEVsandquit:
-            namesuffix = "_desc-delayoffset_hist"
-            tide_stats.makeandsavehistogram(
-                delayoffset,
-                therunoptions["histlen"],
-                1,
-                outputname + namesuffix,
-                displaytitle="Histogram of delay offsets calculated from GLM",
-                dictvarname="delayoffsethist",
-                thedict=None,
-            )
         lagtimesrefined_valid = lagtimes_valid + delayoffset
 
         TimingLGR.info(
@@ -1090,56 +1000,28 @@ def retroregress(args):
                 ]
 
         if args.refinedelay:
-            if args.refineregressderivs > 1:
-                for i in range(args.refineregressderivs):
-                    maplist += [
-                        (
-                            regressderivratios[i, :],
-                            f"regressderivratios_{i}",
-                            "map",
-                            None,
-                            f"Ratio of derivative {i+1} of delayed sLFO to the delayed sLFO",
-                        ),
-                        (
-                            medfiltregressderivratios[i, :],
-                            f"medfiltregressderivratios_{i}",
-                            "map",
-                            None,
-                            f"Median filtered version of the regressderivratios_{i} map",
-                        ),
-                        (
-                            filteredregressderivratios[i, :],
-                            f"filteredregressderivratios_{i}",
-                            "map",
-                            None,
-                            f"regressderivratios_{i}, with outliers patched using median filtered data",
-                        ),
-                    ]
-            else:
-                maplist += [
-                    (
-                        regressderivratios,
-                        "regressderivratios",
-                        "map",
-                        None,
-                        "Ratio of the first derivative of delayed sLFO to the delayed sLFO",
-                    ),
-                    (
-                        medfiltregressderivratios,
-                        "medfiltregressderivratios",
-                        "map",
-                        None,
-                        "Median filtered version of the regressderivratios map",
-                    ),
-                    (
-                        filteredregressderivratios,
-                        "filteredregressderivratios",
-                        "map",
-                        None,
-                        "regressderivratios, with outliers patched using median filtered data",
-                    ),
-                ]
             maplist += [
+                (
+                    regressderivratios,
+                    "regressderivratios",
+                    "map",
+                    None,
+                    "Ratio of the first derivative of delayed sLFO to the delayed sLFO",
+                ),
+                (
+                    medfiltregressderivratios,
+                    "medfiltregressderivratios",
+                    "map",
+                    None,
+                    "Median filtered version of the regressderivratios map",
+                ),
+                (
+                    filteredregressderivratios,
+                    "filteredregressderivratios",
+                    "map",
+                    None,
+                    "regressderivratios, with outliers patched using median filtered data",
+                ),
                 (
                     delayoffset,
                     "delayoffset",

rapidtide/workflows/showarbcorr.py

@@ -23,9 +23,9 @@ import numpy as np
 from scipy.stats import pearsonr
 
 import rapidtide.correlate as tide_corr
-import rapidtide.helper_classes as tide_classes
 import rapidtide.io as tide_io
 import rapidtide.miscmath as tide_math
+import rapidtide.simFuncClasses as tide_simFuncClasses
 import rapidtide.workflows.parser_funcs as pf
 
 
@@ -391,7 +391,7 @@ def showarbcorr(args):
     thepxcorr = pearsonr(filtereddata1, filtereddata2)
 
     # initialize the correlation fitter
-    thexsimfuncfitter = tide_classes.SimilarityFunctionFitter(
+    thexsimfuncfitter = tide_simFuncClasses.SimilarityFunctionFitter(
         corrtimeaxis=xcorr_x,
         lagmin=args.lagmin,
         lagmax=args.lagmax,

rapidtide/workflows/showxcorrx.py

@@ -28,10 +28,10 @@ from scipy.stats import pearsonr
 import rapidtide.calcnullsimfunc as tide_nullsimfunc
 import rapidtide.correlate as tide_corr
 import rapidtide.fit as tide_fit
-import rapidtide.helper_classes as tide_classes
 import rapidtide.io as tide_io
 import rapidtide.miscmath as tide_math
 import rapidtide.peakeval as tide_peakeval
+import rapidtide.simFuncClasses as tide_simFuncClasses
 import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
 import rapidtide.workflows.parser_funcs as pf
@@ -459,7 +459,7 @@ def showxcorrx(args):
             thefit, R2 = tide_fit.mlregress(regressorvec, filtereddata2)
 
     # initialize the Correlator and MutualInformationator
-    theCorrelator = tide_classes.Correlator(
+    theCorrelator = tide_simFuncClasses.Correlator(
         Fs=args.samplerate,
         ncprefilter=theprefilter,
         detrendorder=args.detrendorder,
@@ -469,7 +469,7 @@ def showxcorrx(args):
         debug=args.debug,
     )
     theCorrelator.setreftc(trimdata2 * flipfac)
-    theMutualInformationator = tide_classes.MutualInformationator(
+    theMutualInformationator = tide_simFuncClasses.MutualInformationator(
         Fs=args.samplerate,
         smoothingtime=args.smoothingtime,
         ncprefilter=theprefilter,
@@ -559,7 +559,7 @@ def showxcorrx(args):
 
     if args.similaritymetric == "mutualinfo":
         # initialize the similarity function fitter
-        themifitter = tide_classes.SimilarityFunctionFitter(
+        themifitter = tide_simFuncClasses.SimilarityFunctionFitter(
             corrtimeaxis=MI_x_trim,
             lagmin=args.lagmin,
             lagmax=args.lagmax,
@@ -574,7 +574,7 @@ def showxcorrx(args):
         maxdelaymi = MI_x_trim[np.argmax(theMI_trim)]
     else:
         # initialize the correlation fitter
-        thexsimfuncfitter = tide_classes.SimilarityFunctionFitter(
+        thexsimfuncfitter = tide_simFuncClasses.SimilarityFunctionFitter(
             corrtimeaxis=xcorr_x,
             lagmin=args.lagmin,
             lagmax=args.lagmax,

rapidtide/workflows/tidepool.py

@@ -33,9 +33,9 @@ from pyqtgraph.Qt import QtCore, QtGui, QtWidgets
 
 import rapidtide.util as tide_util
 from rapidtide.Colortables import *
-from rapidtide.helper_classes import SimilarityFunctionFitter
 from rapidtide.OrthoImageItem import OrthoImageItem
 from rapidtide.RapidtideDataset import RapidtideDataset, check_rt_spatialmatch
+from rapidtide.simFuncClasses import SimilarityFunctionFitter
 from rapidtide.workflows.atlasaverage import summarizevoxels
 
 try:
@@ -2002,7 +2002,7 @@ def tidepool(args):
         },
         "R2": {
             "colormap": gen_thermal_state(),
-            "label": "GLM Fit R2",
+            "label": "sLFO Fit R2",
             "display": extramaps,
             "funcmask": "p_lt_0p050_mask",
         },
@@ -2020,13 +2020,13 @@ def tidepool(args):
         },
         "varBefore": {
             "colormap": gen_thermal_state(),
-            "label": "LFO variance before GLM",
+            "label": "LFO variance before filtering",
             "display": extramaps,
             "funcmask": "p_lt_0p050_mask",
         },
         "varAfter": {
             "colormap": gen_thermal_state(),
-            "label": "LFO variance after GLM",
+            "label": "LFO variance after filtering",
             "display": extramaps,
             "funcmask": "p_lt_0p050_mask",
         },
@@ -2074,7 +2074,7 @@ def tidepool(args):
         },
         "fitcoff": {
             "colormap": gen_thermal_state(),
-            "label": "GLM fit coefficient",
+            "label": "sLFO fit coefficient",
             "display": True,
             "funcmask": "p_lt_0p050_mask",
         },

{rapidtide-3.0.7.1.dist-info → rapidtide-3.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapidtide
-Version: 3.0.7.1
+Version: 3.0.8
 Summary: Tools for performing correlation analysis on fMRI data.
 Author: Taylor Salo, Daniel M. Drucker, Ph.D., Jeffrey N Stout, Yaroslav O. Halchenko, Derek Monroe
 Author-email: "Blaise deB. Frederick" <blaise.frederick@gmail.com>
@@ -24,7 +24,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: numpy
-Requires-Dist: scipy
+Requires-Dist: scipy<=1.15.3
 Requires-Dist: pandas
 Requires-Dist: pyarrow
 Requires-Dist: scikit-image