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

rapidtide/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-05-06T11:02:28-0400",
+ "date": "2025-05-21T09:46:09-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "c5e5e2f38938a78c3439882e8ad596c483c6adcf",
- "version": "3.0.4"
+ "full-revisionid": "3f58d08c2a84ae41777dc6b9522b0e89da4cdaec",
+ "version": "3.0.6"
 }
 '''  # END VERSION_JSON
 

rapidtide/calccoherence.py

@@ -21,17 +21,28 @@ import logging
 import warnings
 
 import numpy as np
-from tqdm import tqdm
 
-import rapidtide.multiproc as tide_multiproc
+import rapidtide.genericmultiproc as tide_genericmultiproc
 
 warnings.simplefilter(action="ignore", category=FutureWarning)
 LGR = logging.getLogger("GENERAL")
 
 
 def _procOneVoxelCoherence(
-    vox, theCoherer, fmritc, alt=False, rt_floatset=np.float64, rt_floattype="float64"
+    vox,
+    voxelargs,
+    **kwargs,
 ):
+    options = {
+        "alt": False,
+        "debug": False,
+    }
+    options.update(kwargs)
+    alt = options["alt"]
+    debug = options["debug"]
+    (theCoherer, fmritc) = voxelargs
+    if debug:
+        print(f"{alt=}")
     if alt:
         (
             thecoherence_y,
@@ -53,6 +64,19 @@ def _procOneVoxelCoherence(
     )
 
 
+def _packvoxeldata(voxnum, voxelargs):
+    return [
+        voxelargs[0],
+        (voxelargs[1])[voxnum, :],
+    ]
+
+
+def _unpackvoxeldata(retvals, voxelproducts):
+    (voxelproducts[0])[retvals[0]] = retvals[2]
+    (voxelproducts[1])[retvals[0]] = retvals[3]
+    (voxelproducts[2])[retvals[0]] = retvals[4]
+
+
 def coherencepass(
     fmridata,
     theCoherer,
@@ -64,8 +88,7 @@ def coherencepass(
     nprocs=1,
     alwaysmultiproc=False,
     showprogressbar=True,
-    rt_floatset=np.float64,
-    rt_floattype="float64",
+    debug=False,
 ):
     """
 
@@ -88,74 +111,29 @@ def coherencepass(
 
     """
     inputshape = np.shape(fmridata)
-    volumetotal = 0
-    if nprocs > 1 or alwaysmultiproc:
-        # define the consumer function here so it inherits most of the arguments
-        def coherence_consumer(inQ, outQ):
-            while True:
-                try:
-                    # get a new message
-                    val = inQ.get()
-
-                    # this is the 'TERM' signal
-                    if val is None:
-                        break
-
-                    # process and send the data
-                    outQ.put(
-                        _procOneVoxelCoherence(
-                            val,
-                            theCoherer,
-                            fmridata[val, :],
-                            alt=alt,
-                            rt_floatset=rt_floatset,
-                            rt_floattype=rt_floattype,
-                        )
-                    )
-
-                except Exception as e:
-                    print("error!", e)
-                    break
-
-        data_out = tide_multiproc.run_multiproc(
-            coherence_consumer,
-            inputshape,
-            None,
-            nprocs=nprocs,
-            showprogressbar=showprogressbar,
-            chunksize=chunksize,
-        )
-
-        # unpack the data
-        volumetotal = 0
-        for voxel in data_out:
-            coherencefunc[voxel[0], :] = voxel[2] + 0.0
-            coherencepeakval[voxel[0]] = voxel[3] + 0.0
-            coherencepeakfreq[voxel[0]] = voxel[4] + 0.0
-            volumetotal += 1
-        del data_out
-    else:
-        for vox in tqdm(
-            range(0, inputshape[0]),
-            desc="Voxel",
-            unit="voxels",
-            disable=(not showprogressbar),
-        ):
-            (
-                dummy,
-                dummy,
-                coherencefunc[vox],
-                coherencepeakval[vox],
-                coherencepeakfreq[vox],
-            ) = _procOneVoxelCoherence(
-                vox,
-                theCoherer,
-                fmridata[vox, :],
-                alt=alt,
-                rt_floatset=rt_floatset,
-                rt_floattype=rt_floattype,
-            )
-            volumetotal += 1
+    voxelargs = [theCoherer, fmridata]
+    voxelfunc = _procOneVoxelCoherence
+    packfunc = _packvoxeldata
+    unpackfunc = _unpackvoxeldata
+    voxeltargets = [coherencefunc, coherencepeakval, coherencepeakfreq]
+    voxelmask = fmridata[:, 0] * 0.0 + 1
+
+    volumetotal = tide_genericmultiproc.run_multiproc(
+        voxelfunc,
+        packfunc,
+        unpackfunc,
+        voxelargs,
+        voxeltargets,
+        inputshape,
+        voxelmask,
+        LGR,
+        nprocs,
+        alwaysmultiproc,
+        showprogressbar,
+        chunksize,
+        alt=alt,
+        debug=debug,
+    )
     LGR.info(f"\nCoherence performed on {volumetotal} voxels")
 
     # garbage collect

rapidtide/calcnullsimfunc.py

@@ -16,34 +16,41 @@
 #   limitations under the License.
 #
 #
-import os
 import sys
-import time
+
 
 import numpy as np
-from tqdm import tqdm
+
 
 import rapidtide.filter as tide_filt
 import rapidtide.miscmath as tide_math
-import rapidtide.multiproc as tide_multiproc
+import rapidtide.genericmultiproc as tide_genericmultiproc
 
 
 # note: rawtimecourse has been filtered, but NOT windowed
 def _procOneNullCorrelationx(
-    normalizedreftc,
-    rawtcfft_r,
-    rawtcfft_ang,
-    Fs,
-    theCorrelator,
-    thefitter,
-    despeckle_thresh=5.0,
-    fixdelay=False,
-    initialdelayvalue=0.0,
-    permutationmethod="shuffle",
-    disablethresholds=False,
-    rt_floatset=np.float64,
-    rt_floattype="float64",
+    vox,
+    voxelargs,
+    **kwargs,
 ):
+
+    options = {
+        "permutationmethod": "shuffle",
+        "debug": False,
+    }
+    options.update(kwargs)
+    permutationmethod = options["permutationmethod"]
+    debug = options["debug"]
+    if debug:
+        print(f"{permutationmethod=}")
+    (
+        normalizedreftc,
+        rawtcfft_r,
+        rawtcfft_ang,
+        theCorrelator,
+        thefitter,
+    ) = voxelargs
+
     # make a shuffled copy of the regressors
     if permutationmethod == "shuffle":
         permutedtc = np.random.permutation(normalizedreftc)
@@ -71,17 +78,22 @@ def _procOneNullCorrelationx(
         peakend,
     ) = thefitter.fit(thexcorr_y)
 
-    return maxval
+    return vox, maxval
+
+
+def _packvoxeldata(voxnum, voxelargs):
+    return [voxelargs[0], voxelargs[1], voxelargs[2], voxelargs[3], voxelargs[4]]
 
 
-def getNullDistributionDatax(
-    rawtimecourse,
+def _unpackvoxeldata(retvals, voxelproducts):
+    (voxelproducts[0])[retvals[0]] = retvals[1]
+
+
+def getNullDistributionData(
     Fs,
     theCorrelator,
     thefitter,
-    despeckle_thresh=5.0,
-    fixdelay=False,
-    initialdelayvalue=0.0,
+    LGR,
     numestreps=0,
     nprocs=1,
     alwaysmultiproc=False,
@@ -90,12 +102,16 @@ def getNullDistributionDatax(
     permutationmethod="shuffle",
     rt_floatset=np.float64,
     rt_floattype="float64",
+    debug=False,
 ):
     r"""Calculate a set of null correlations to determine the distribution of correlation values.  This can
     be used to find the spurious correlation threshold
 
     Parameters
     ----------
+    Fs: float
+        The sample frequency of rawtimecourse, in Hz
+
     rawtimecourse : 1D numpy array
         The test regressor.  This should be filtered to the desired bandwidth, but NOT windowed.
         :param rawtimecourse:
@@ -106,9 +122,6 @@ def getNullDistributionDatax(
     filterfunc: function
         This is a preconfigured NoncausalFilter function which is used to filter data to the desired bandwidth
 
-    Fs: float
-        The sample frequency of rawtimecourse, in Hz
-
     corrorigin: int
         The bin number in the correlation timescale corresponding to 0.0 seconds delay
 
@@ -129,91 +142,32 @@ def getNullDistributionDatax(
         ),
     )
     rawtcfft_r, rawtcfft_ang = tide_filt.polarfft(normalizedreftc)
-    if nprocs > 1 or alwaysmultiproc:
-        # define the consumer function here so it inherits most of the arguments
-        def nullCorrelation_consumer(inQ, outQ):
-            np.random.seed((os.getpid() * int(time.time())) % 123456789)
-            while True:
-                try:
-                    # get a new message
-                    val = inQ.get()
-
-                    # this is the 'TERM' signal
-                    if val is None:
-                        break
-
-                    # process and send the data
-                    outQ.put(
-                        _procOneNullCorrelationx(
-                            normalizedreftc,
-                            rawtcfft_r,
-                            rawtcfft_ang,
-                            Fs,
-                            theCorrelator,
-                            thefitter,
-                            despeckle_thresh=despeckle_thresh,
-                            fixdelay=fixdelay,
-                            initialdelayvalue=initialdelayvalue,
-                            permutationmethod=permutationmethod,
-                            rt_floatset=rt_floatset,
-                            rt_floattype=rt_floattype,
-                        )
-                    )
-
-                except Exception as e:
-                    print("error!", e)
-                    break
-
-        data_out = tide_multiproc.run_multiproc(
-            nullCorrelation_consumer,
-            inputshape,
-            None,
-            nprocs=nprocs,
-            showprogressbar=showprogressbar,
-            chunksize=chunksize,
-        )
-
-        # unpack the data
-        corrlist = np.asarray(data_out, dtype=rt_floattype)
-    else:
-        corrlist = np.zeros((numestreps), dtype=rt_floattype)
-
-        for i in tqdm(
-            range(0, numestreps),
-            desc="Sham correlation",
-            unit="correlations",
-            disable=(not showprogressbar),
-        ):
-            # make a shuffled copy of the regressors
-            if permutationmethod == "shuffle":
-                permutedtc = np.random.permutation(normalizedreftc)
-            elif permutationmethod == "phaserandom":
-                permutedtc = tide_filt.ifftfrompolar(
-                    rawtcfft_r, np.random.permutation(rawtcfft_ang)
-                )
-            else:
-                print("illegal shuffling method")
-                sys.exit()
-
-            # crosscorrelate with original, fit, and return the maximum value, and add it to the list
-            thexcorr = _procOneNullCorrelationx(
-                normalizedreftc,
-                rawtcfft_r,
-                rawtcfft_ang,
-                Fs,
-                theCorrelator,
-                thefitter,
-                despeckle_thresh=despeckle_thresh,
-                fixdelay=fixdelay,
-                initialdelayvalue=initialdelayvalue,
-                permutationmethod=permutationmethod,
-                rt_floatset=rt_floatset,
-                rt_floattype=rt_floattype,
-            )
-            corrlist[i] = thexcorr
-
-        # jump to line after progress bar
-        print()
+    corrlist = np.zeros((numestreps), dtype=rt_floattype)
+    voxelmask = np.ones((numestreps), dtype=rt_floattype)
+    voxelargs = [normalizedreftc, rawtcfft_r, rawtcfft_ang, theCorrelator, thefitter]
+    voxelfunc = _procOneNullCorrelationx
+    packfunc = _packvoxeldata
+    unpackfunc = _unpackvoxeldata
+    voxeltargets = [
+        corrlist,
+    ]
+
+    volumetotal = tide_genericmultiproc.run_multiproc(
+        voxelfunc,
+        packfunc,
+        unpackfunc,
+        voxelargs,
+        voxeltargets,
+        inputshape,
+        voxelmask,
+        LGR,
+        nprocs,
+        alwaysmultiproc,
+        showprogressbar,
+        chunksize,
+        permutationmethod=permutationmethod,
+        debug=debug,
+    )
 
     # return the distribution data
     numnonzero = len(np.where(corrlist != 0.0)[0])

rapidtide/calcsimfunc.py

@@ -21,9 +21,8 @@ import logging
 import warnings
 
 import numpy as np
-from tqdm import tqdm
 
-import rapidtide.multiproc as tide_multiproc
+import rapidtide.genericmultiproc as tide_genericmultiproc
 import rapidtide.resample as tide_resample
 
 warnings.simplefilter(action="ignore", category=FutureWarning)
@@ -32,23 +31,48 @@ LGR = logging.getLogger("GENERAL")
 
 def _procOneVoxelCorrelation(
     vox,
-    thetc,
-    theCorrelator,
-    fmri_x,
-    fmritc,
-    os_fmri_x,
-    oversampfactor=1,
-    interptype="univariate",
-    rt_floatset=np.float64,
-    rt_floattype="float64",
+    voxelargs,
+    **kwargs,
 ):
+    options = {
+        "oversampfactor": 1,
+        "interptype": "univariate",
+        "debug": False,
+    }
+    options.update(kwargs)
+    oversampfactor = options["oversampfactor"]
+    interptype = options["interptype"]
+    debug = options["debug"]
+    if debug:
+        print(f"{oversampfactor=} {interptype=}")
+    (thetc, theCorrelator, fmri_x, fmritc, os_fmri_x, theglobalmaxlist, thexcorr_y) = voxelargs
     if oversampfactor >= 1:
         thetc[:] = tide_resample.doresample(fmri_x, fmritc, os_fmri_x, method=interptype)
     else:
         thetc[:] = fmritc
     thexcorr_y, thexcorr_x, theglobalmax = theCorrelator.run(thetc)
+    # print(f"_procOneVoxelCorrelation: {thexcorr_x=}")
+
+    return vox, np.mean(thetc), thexcorr_y, thexcorr_x, theglobalmax, theglobalmaxlist
 
-    return vox, np.mean(thetc), thexcorr_y, thexcorr_x, theglobalmax
+
+def _packvoxeldata(voxnum, voxelargs):
+    return [
+        voxelargs[0],
+        voxelargs[1],
+        voxelargs[2],
+        (voxelargs[3])[voxnum, :],
+        voxelargs[4],
+        voxelargs[5],
+        voxelargs[6],
+    ]
+
+
+def _unpackvoxeldata(retvals, voxelproducts):
+    (voxelproducts[0])[retvals[0]] = retvals[1]
+    (voxelproducts[1])[retvals[0], :] = retvals[2]
+    voxelproducts[2] = retvals[3]
+    (voxelproducts[3]).append(retvals[4] + 0)
 
 
 def correlationpass(
@@ -101,87 +125,45 @@ def correlationpass(
         print(f"calling setreftc in calcsimfunc with length {len(referencetc)}")
     theCorrelator.setreftc(referencetc)
     theCorrelator.setlimits(lagmininpts, lagmaxinpts)
-
-    inputshape = np.shape(fmridata)
-    volumetotal = 0
     thetc = np.zeros(np.shape(os_fmri_x), dtype=rt_floattype)
     theglobalmaxlist = []
-    if nprocs > 1 or alwaysmultiproc:
-        # define the consumer function here so it inherits most of the arguments
-        def correlation_consumer(inQ, outQ):
-            while True:
-                try:
-                    # get a new message
-                    val = inQ.get()
-
-                    # this is the 'TERM' signal
-                    if val is None:
-                        break
-
-                    # process and send the data
-                    outQ.put(
-                        _procOneVoxelCorrelation(
-                            val,
-                            thetc,
-                            theCorrelator,
-                            fmri_x,
-                            fmridata[val, :],
-                            os_fmri_x,
-                            oversampfactor=oversampfactor,
-                            interptype=interptype,
-                            rt_floatset=rt_floatset,
-                            rt_floattype=rt_floattype,
-                        )
-                    )
-
-                except Exception as e:
-                    print("error!", e)
-                    break
-
-        data_out = tide_multiproc.run_multiproc(
-            correlation_consumer,
-            inputshape,
-            None,
-            nprocs=nprocs,
-            showprogressbar=showprogressbar,
-            chunksize=chunksize,
-        )
-
-        # unpack the data
-        volumetotal = 0
-        for voxel in data_out:
-            meanval[voxel[0]] = voxel[1]
-            corrout[voxel[0], :] = voxel[2]
-            thecorrscale = voxel[3]
-            theglobalmaxlist.append(voxel[4] + 0)
-            volumetotal += 1
-        del data_out
-    else:
-        for vox in tqdm(
-            range(0, inputshape[0]),
-            desc="Voxel",
-            disable=(not showprogressbar),
-        ):
-            (
-                dummy,
-                meanval[vox],
-                corrout[vox, :],
-                thecorrscale,
-                theglobalmax,
-            ) = _procOneVoxelCorrelation(
-                vox,
-                thetc,
-                theCorrelator,
-                fmri_x,
-                fmridata[vox, :],
-                os_fmri_x,
-                oversampfactor=oversampfactor,
-                interptype=interptype,
-                rt_floatset=rt_floatset,
-                rt_floattype=rt_floattype,
-            )
-            theglobalmaxlist.append(theglobalmax + 0)
-            volumetotal += 1
+
+    # generate a corrscale of the correct length
+    dummy = np.zeros(100, dtype=rt_floattype)
+    dummy, dummy, dummy, thecorrscale, dummy, dummy = _procOneVoxelCorrelation(
+        0,
+        _packvoxeldata(
+            0, [thetc, theCorrelator, fmri_x, fmridata, os_fmri_x, theglobalmaxlist, dummy]
+        ),
+        oversampfactor=oversampfactor,
+        interptype=interptype,
+    )
+
+    inputshape = np.shape(fmridata)
+    voxelargs = [thetc, theCorrelator, fmri_x, fmridata, os_fmri_x, theglobalmaxlist, thecorrscale]
+    voxelfunc = _procOneVoxelCorrelation
+    packfunc = _packvoxeldata
+    unpackfunc = _unpackvoxeldata
+    voxeltargets = [meanval, corrout, thecorrscale, theglobalmaxlist]
+    voxelmask = fmridata[:, 0] * 0.0 + 1
+
+    volumetotal = tide_genericmultiproc.run_multiproc(
+        voxelfunc,
+        packfunc,
+        unpackfunc,
+        voxelargs,
+        voxeltargets,
+        inputshape,
+        voxelmask,
+        LGR,
+        nprocs,
+        alwaysmultiproc,
+        showprogressbar,
+        chunksize,
+        oversampfactor=oversampfactor,
+        interptype=interptype,
+        debug=debug,
+    )
     LGR.info(f"\nSimilarity function calculated on {volumetotal} voxels")
 
     # garbage collect

rapidtide/data/examples/src/testatlasaverage

@@ -21,3 +21,25 @@ atlasaverage \
     --extramask /opt/fsl-latest/data/standard/MNI152_T1_1mm_brain_mask.nii.gz \
     --summarymethod median \
     --headerline
+
+atlasaverage \
+    sub-RAPIDTIDETEST.nii.gz \
+    sub-RAPIDTIDETEST_dseg.nii.gz \
+    ../dst/synthsegaverages \
+    --ignorezeros \
+    --numpercentiles 3 \
+    --includemask sub-RAPIDTIDETEST_brainmask.nii.gz \
+    --regionlabelfile dseglabels.txt \
+    --summarymethod mean 
+
+atlasaverage \
+    sub-RAPIDTIDETEST.nii.gz \
+    sub-RAPIDTIDETEST_dseg.nii.gz \
+    ../dst/synthsegaverages_pctnorm \
+    --normmethod pct \
+    --ignorezeros \
+    --numpercentiles 3 \
+    --includemask sub-RAPIDTIDETEST_brainmask.nii.gz \
+    --regionlabelfile dseglabels.txt \
+    --summarymethod mean 
+

rapidtide/data/examples/src/testfmri

@@ -6,10 +6,10 @@ rapidtide \
     --searchrange -5 20 \
     --simcalcrange 50 -1 \
     --outputlevel more \
-    --dofinalrefine \
     --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 \
     sub-RAPIDTIDETEST.nii.gz \
     ../dst/sub-RAPIDTIDETEST

rapidtide/data/examples/src/testhappy

@@ -65,13 +65,14 @@
 happy \
     sub-HAPPYTEST.nii.gz \
     sub-HAPPYTEST.json \
-    ../dst/happy
+    ../dst/happy \
+    --nprocs -1
 
-happy \
-    sub-HAPPYTEST.nii.gz \
-    sub-HAPPYTEST.json \
-    --model ~/code/rapidtide/rapidtide/data/models/model_cnn_w064_l13_fn20_fl08 \
-    ../dst/happy_newcnn
+#happy \
+    #sub-HAPPYTEST.nii.gz \
+    #sub-HAPPYTEST.json \
+    #--model ~/code/rapidtide/rapidtide/data/models/model_cnn_w064_l13_fn20_fl08 \
+    #../dst/happy_newcnn
 
 #happy \
     #sub-HAPPYTEST.nii.gz \