rapidtide 3.0.5__tar.gz → 3.0.7__tar.gz

{rapidtide-3.0.5 → rapidtide-3.0.7}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Release history
 
+## Version 3.0.7 (6/16/25)
+* (rapidtide) Save the full autocorrelation function of the probe regressor at each pass.
+* (rapidtide) Now save a version of the mean fMRI image prior to filtering
+* (rapidtide) Added the abilty to disable masking of sLFO filter. Use ``--nosLFOfiltmask`` to disable.
+* (happy) Implemented multiprocessing for detrending, phase projection, and phase projection smoothing.
+* (happy) Precache convolution gridding kernel outputs to improve repeatability.
+* (happy) Early implementation of Wright's method for finding vessels.
+* (showarbcorr) Fixed some internal issues.
+* (simdata) Many changes to finetune the simulation and make the output more realistic.  Still in progress.
+* (Docker) Turned on provenance and sbom in Docker builds.
+* (package) Accepted several dependabot PRs.
+
+## Version 3.0.6 (5/21/25)
+* (rapidtide) Made a generic, reusable multiprocessing module and moved many functions over to it.
+* (ccorrica) Samplerate is now set properly if input is a BIDS tsv file.
+* (package) Added several new tests.
+
 ## Version 3.0.5 (5/7/25)
 * (rapidtide) Loosened the sample rate matching when appending timecourses to files, and read NIFTI tr values using modern header features.  This should help address https://github.com/bbfrederick/rapidtide/issues/205 (thank you to https://github.com/phildeming for finding this).
 

{rapidtide-3.0.5/rapidtide.egg-info → rapidtide-3.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapidtide
-Version: 3.0.5
+Version: 3.0.7
 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>

{rapidtide-3.0.5 → rapidtide-3.0.7}/rapidtide/RapidtideDataset.py

@@ -903,6 +903,23 @@ class RapidtideDataset:
                 print("using ", self.fileroot + "meanvalue.nii.gz", " as background")
             # allloadedmaps.append('anatomic')
             return True
+        elif os.path.isfile(self.fileroot + "desc-unfiltmean_map.nii.gz"):
+            thepath, thebase = os.path.split(self.fileroot)
+            self.overlays["anatomic"] = Overlay(
+                "anatomic",
+                self.fileroot + "desc-unfiltmean_map.nii.gz",
+                thebase,
+                init_LUT=self.init_LUT,
+                verbose=self.verbose,
+            )
+            if self.verbose > 1:
+                print(
+                    "using ",
+                    self.fileroot + "desc-unfiltmean_map.nii.gz",
+                    " as background",
+                )
+            # allloadedmaps.append('anatomic')
+            return True
         elif os.path.isfile(self.fileroot + "desc-mean_map.nii.gz"):
             thepath, thebase = os.path.split(self.fileroot)
             self.overlays["anatomic"] = Overlay(

{rapidtide-3.0.5 → rapidtide-3.0.7}/rapidtide/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-05-07T20:47:14-0400",
+ "date": "2025-06-16T13:13:35-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "ea9d8f413eaa094534d2da7318765380528980fe",
- "version": "3.0.5"
+ "full-revisionid": "9e8ae750c70431c04a50473c749c451e996d490f",
+ "version": "3.0.7"
 }
 '''  # END VERSION_JSON
 

rapidtide-3.0.7/rapidtide/calccoherence.py

@@ -0,0 +1,146 @@
+#!/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 gc
+import logging
+import warnings
+
+import numpy as np
+
+import rapidtide.genericmultiproc as tide_genericmultiproc
+
+warnings.simplefilter(action="ignore", category=FutureWarning)
+LGR = logging.getLogger("GENERAL")
+
+
+def _procOneVoxelCoherence(
+    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,
+            thecoherence_x,
+            globalmaxindex,
+            dummy,
+            dummy,
+            dummy,
+        ) = theCoherer.run(fmritc, trim=True, alt=True)
+    else:
+        thecoherence_y, thecoherence_x, globalmaxindex = theCoherer.run(fmritc, trim=True)
+    maxindex = np.argmax(thecoherence_y)
+    return (
+        vox,
+        thecoherence_x,
+        thecoherence_y,
+        thecoherence_y[maxindex],
+        thecoherence_x[maxindex],
+    )
+
+
+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,
+    coherencefunc,
+    coherencepeakval,
+    coherencepeakfreq,
+    alt=False,
+    chunksize=1000,
+    nprocs=1,
+    alwaysmultiproc=False,
+    showprogressbar=True,
+    debug=False,
+):
+    """
+
+    Parameters
+    ----------
+    fmridata
+    theCoherer
+    coherencefunc
+    coherencepeakval
+    coherencepeakfreq
+    chunksize
+    nprocs
+    alwaysmultiproc
+    showprogressbar
+    rt_floatset
+    rt_floattype
+
+    Returns
+    -------
+
+    """
+    inputshape = np.shape(fmridata)
+    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
+    uncollected = gc.collect()
+    if uncollected != 0:
+        LGR.info(f"garbage collected - unable to collect {uncollected} objects")
+    else:
+        LGR.info("garbage collected")
+
+    return volumetotal

rapidtide-3.0.7/rapidtide/calcnullsimfunc.py

@@ -0,0 +1,179 @@
+#!/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 sys
+
+
+import numpy as np
+
+
+import rapidtide.filter as tide_filt
+import rapidtide.miscmath as tide_math
+import rapidtide.genericmultiproc as tide_genericmultiproc
+
+
+# note: rawtimecourse has been filtered, but NOT windowed
+def _procOneNullCorrelationx(
+    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)
+        # apply the appropriate filter
+        # permutedtc = theCorrelator.ncprefilter.apply(Fs, permutedtc)
+    elif permutationmethod == "phaserandom":
+        permutedtc = tide_filt.ifftfrompolar(rawtcfft_r, np.random.permutation(rawtcfft_ang))
+    else:
+        print("illegal shuffling method")
+        sys.exit()
+
+    # crosscorrelate with original
+    thexcorr_y, thexcorr_x, dummy = theCorrelator.run(permutedtc)
+
+    # fit the correlation
+    thefitter.setcorrtimeaxis(thexcorr_x)
+    (
+        maxindex,
+        maxlag,
+        maxval,
+        maxsigma,
+        maskval,
+        failreason,
+        peakstart,
+        peakend,
+    ) = thefitter.fit(thexcorr_y)
+
+    return vox, maxval
+
+
+def _packvoxeldata(voxnum, voxelargs):
+    return [voxelargs[0], voxelargs[1], voxelargs[2], voxelargs[3], voxelargs[4]]
+
+
+def _unpackvoxeldata(retvals, voxelproducts):
+    (voxelproducts[0])[retvals[0]] = retvals[1]
+
+
+def getNullDistributionData(
+    Fs,
+    theCorrelator,
+    thefitter,
+    LGR,
+    numestreps=0,
+    nprocs=1,
+    alwaysmultiproc=False,
+    showprogressbar=True,
+    chunksize=1000,
+    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:
+
+    corrscale: 1D numpy array
+        The time axis of the cross correlation function.
+
+    filterfunc: function
+        This is a preconfigured NoncausalFilter function which is used to filter data to the desired bandwidth
+
+    corrorigin: int
+        The bin number in the correlation timescale corresponding to 0.0 seconds delay
+
+    negbins: int
+        The lower edge of the search range for correlation peaks, in number of bins below corrorigin
+
+    posbins: int
+        The upper edge of the search range for correlation peaks, in number of bins above corrorigin
+
+    """
+    inputshape = np.asarray([numestreps])
+    normalizedreftc = theCorrelator.ncprefilter.apply(
+        Fs,
+        tide_math.corrnormalize(
+            theCorrelator.reftc,
+            windowfunc="None",
+            detrendorder=theCorrelator.detrendorder,
+        ),
+    )
+    rawtcfft_r, rawtcfft_ang = tide_filt.polarfft(normalizedreftc)
+    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])
+    print(
+        "{:d} non-zero correlations out of {:d} ({:.2f}%)".format(
+            numnonzero, len(corrlist), 100.0 * numnonzero / len(corrlist)
+        )
+    )
+    return corrlist

rapidtide-3.0.7/rapidtide/calcsimfunc.py

@@ -0,0 +1,176 @@
+#!/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 gc
+import logging
+import warnings
+
+import numpy as np
+
+import rapidtide.genericmultiproc as tide_genericmultiproc
+import rapidtide.resample as tide_resample
+
+warnings.simplefilter(action="ignore", category=FutureWarning)
+LGR = logging.getLogger("GENERAL")
+
+
+def _procOneVoxelCorrelation(
+    vox,
+    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
+
+
+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(
+    fmridata,
+    referencetc,
+    theCorrelator,
+    fmri_x,
+    os_fmri_x,
+    lagmininpts,
+    lagmaxinpts,
+    corrout,
+    meanval,
+    nprocs=1,
+    alwaysmultiproc=False,
+    oversampfactor=1,
+    interptype="univariate",
+    showprogressbar=True,
+    chunksize=1000,
+    rt_floatset=np.float64,
+    rt_floattype="float64",
+    debug=False,
+):
+    """
+
+    Parameters
+    ----------
+    fmridata
+    referencetc - the reference regressor, already oversampled
+    theCorrelator
+    fmri_x
+    os_fmri_x
+    tr
+    lagmininpts
+    lagmaxinpts
+    corrout
+    meanval
+    nprocs
+    oversampfactor
+    interptype
+    showprogressbar
+    chunksize
+    rt_floatset
+    rt_floattype
+
+    Returns
+    -------
+
+    """
+    if debug:
+        print(f"calling setreftc in calcsimfunc with length {len(referencetc)}")
+    theCorrelator.setreftc(referencetc)
+    theCorrelator.setlimits(lagmininpts, lagmaxinpts)
+    thetc = np.zeros(np.shape(os_fmri_x), dtype=rt_floattype)
+    theglobalmaxlist = []
+
+    # 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
+    uncollected = gc.collect()
+    if uncollected != 0:
+        LGR.info(f"garbage collected - unable to collect {uncollected} objects")
+    else:
+        LGR.info("garbage collected")
+
+    return volumetotal, theglobalmaxlist, thecorrscale

{rapidtide-3.0.5 → rapidtide-3.0.7}/rapidtide/correlate.py

@@ -761,18 +761,14 @@ class AliasedCorrelator:
         return corrfunc
 
 
-def arbcorr(
+def matchsamplerates(
     input1,
     Fs1,
     input2,
     Fs2,
-    start1=0.0,
-    start2=0.0,
-    windowfunc="hamming",
     method="univariate",
     debug=False,
 ):
-    """Calculate something."""
     if Fs1 > Fs2:
         corrFs = Fs1
         matchedinput1 = input1
@@ -782,9 +778,32 @@ def arbcorr(
         matchedinput1 = tide_resample.upsample(input1, Fs1, corrFs, method=method, debug=debug)
         matchedinput2 = input2
     else:
-        corrFs = Fs1
+        corrFs = Fs2
         matchedinput1 = input1
         matchedinput2 = input2
+    return matchedinput1, matchedinput2, corrFs
+
+
+def arbcorr(
+    input1,
+    Fs1,
+    input2,
+    Fs2,
+    start1=0.0,
+    start2=0.0,
+    windowfunc="hamming",
+    method="univariate",
+    debug=False,
+):
+    # upsample to the higher frequency of the two
+    matchedinput1, matchedinput2, corrFs = matchsamplerates(
+        input1,
+        Fs1,
+        input2,
+        Fs2,
+        method=method,
+        debug=debug,
+    )
     norm1 = tide_math.corrnormalize(matchedinput1, detrendorder=1, windowfunc=windowfunc)
     norm2 = tide_math.corrnormalize(matchedinput2, detrendorder=1, windowfunc=windowfunc)
     thexcorr_y = signal.fftconvolve(norm1, norm2[::-1], mode="full")

{rapidtide-3.0.5 → rapidtide-3.0.7}/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-3.0.7/rapidtide/data/examples/src/testfmri

@@ -0,0 +1,30 @@
+#!/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 \
+    sub-RAPIDTIDETEST.nii.gz \
+    ../dst/sub-RAPIDTIDETEST
+
+rapidtide \
+    --spatialfilt -1 \
+    --nprocs -1 \
+    --searchrange -5 20 \
+    --simcalcrange 50 -1 \
+    --outputlevel more \
+    --nosLFOfiltmask \
+    --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_nosLFOfiltmask