rapidtide 3.0.7.1__tar.gz → 3.0.8__tar.gz

{rapidtide-3.0.7.1 → rapidtide-3.0.8}/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Release history
 
+## Version 3.0.8 (6/26/25)
+* (rapidtide) Fix https://github.com/bbfrederick/rapidtide/issues/213 (thanks to https://github.com/tomosumi for reporting the bug).
+* (rapidtide) Split coarse delay estimation and fitting out into a separate workflow.
+* (rapidtide) Split delay refinement out into a separate workflow.
+* (rapidtide) Split regressor refinement out into a separate workflow.
+* (rapidtide) All this is in preparation for a new, modular workflow with more flexible control of the fitting process.  It's not done yet, butthis is getting all internal code blocks ready for it.  I want to pause here to make sure I haven't broken anything (all the automated tests pass, but I want to be careful).
+* (docs) Some improvement to the tidepool section.
+* (package) Made a more streamlined and rational interface for allocating shared memory.
+* (package) Resolved incompatibility of statsmodels and scipy>1.15.3.
+* (package) Accepted several dependabot PRs.
+
 ## Version 3.0.7.1 (6/16/25)
 * (rapidtide) Disabled sLFO filtering by default.  Use ``sLFOfiltmask`` to turn it on.
 * (retroregress) Synced with sLFO filtering changes to rapidtide.

{rapidtide-3.0.7.1/rapidtide.egg-info → rapidtide-3.0.8}/PKG-INFO

@@ -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

{rapidtide-3.0.7.1 → rapidtide-3.0.8}/pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
 requires-python = '>=3.9'
 dependencies = [
   'numpy',
-  'scipy',
+  'scipy<=1.15.3',
   'pandas',
   'pyarrow',
   'scikit-image',

{rapidtide-3.0.7.1 → rapidtide-3.0.8}/rapidtide/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-06-16T15:12:43-0400",
+ "date": "2025-06-26T14:50:59-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "6dead8e554dd0464bdfc65de24889374508f920d",
- "version": "3.0.7.1"
+ "full-revisionid": "d9a8fd9ab24057e4a74e43dccdc1117e3c6875a2",
+ "version": "3.0.8"
 }
 '''  # END VERSION_JSON
 

{rapidtide-3.0.7.1 → rapidtide-3.0.8}/rapidtide/calcnullsimfunc.py

@@ -18,13 +18,11 @@
 #
 import sys
 
-
 import numpy as np
 
-
 import rapidtide.filter as tide_filt
-import rapidtide.miscmath as tide_math
 import rapidtide.genericmultiproc as tide_genericmultiproc
+import rapidtide.miscmath as tide_math
 
 
 # note: rawtimecourse has been filtered, but NOT windowed

{rapidtide-3.0.7.1 → rapidtide-3.0.8}/rapidtide/data/examples/src/test_findmaxlag.py

@@ -24,8 +24,8 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 import rapidtide.fit as tide_fit
-import rapidtide.helper_classes as tide_classes
 import rapidtide.io as tide_io
+import rapidtide.simFuncClasses as tide_classes
 from rapidtide.tests.utils import get_examples_path
 
 

rapidtide-3.0.8/rapidtide/data/examples/src/testfmri

@@ -0,0 +1,36 @@
+#!/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 \
+    --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 \
+    --refinedelayeachpass \
+    --similaritymetric correlation \
+    sub-RAPIDTIDETEST.nii.gz \
+    ../dst/sub-RAPIDTIDETEST_passrefine
+
+tidepool --uistyle big --dataset ../dst/sub-RAPIDTIDETEST_ ../dst/sub-RAPIDTIDETEST_passrefine_

{rapidtide-3.0.7.1 → rapidtide-3.0.8}/rapidtide/data/examples/src/testnewrefine

@@ -6,28 +6,15 @@ rapidtide \
     --searchrange -5 20 \
     --simcalcrange 50 -1 \
     --outputlevel max \
-    --refineregressderivs 1 \
     sub-RAPIDTIDETEST.nii.gz \
     ../dst/sub-RAPIDTIDETEST_1deriv
 
-rapidtide \
-    --spatialfilt -1 \
-    --nprocs -1 \
-    --searchrange -5 20 \
-    --simcalcrange 50 -1 \
-    --outputlevel max \
-    --refineregressderivs 2 \
-    sub-RAPIDTIDETEST.nii.gz \
-    ../dst/sub-RAPIDTIDETEST_2deriv
-
-
 retroregress \
     sub-RAPIDTIDETEST.nii.gz \
     ../dst/sub-RAPIDTIDETEST_1deriv \
     --alternateoutput ../dst/retrotest_1to1 \
     --nprocs -1 \
     --regressderivs 0 \
-    --refineregressderivs 1 \
     --outputlevel max
 
 retroregress \
@@ -36,14 +23,4 @@ retroregress \
     --alternateoutput ../dst/retrotest_2to1 \
     --nprocs -1 \
     --regressderivs 0 \
-    --refineregressderivs 1 \
-    --outputlevel max
-
-retroregress \
-    sub-RAPIDTIDETEST.nii.gz \
-    ../dst/sub-RAPIDTIDETEST_1deriv \
-    --alternateoutput ../dst/retrotest_1to2 \
-    --nprocs -1 \
-    --regressderivs 0 \
-    --refineregressderivs 2 \
     --outputlevel max

{rapidtide-3.0.7.1 → rapidtide-3.0.8}/rapidtide/fMRIData_class.py

@@ -16,21 +16,9 @@
 #   limitations under the License.
 #
 #
-import sys
-import warnings
-
-import matplotlib.pyplot as plt
 import numpy as np
-import scipy as sp
-from numpy.polynomial import Polynomial
-from scipy.optimize import curve_fit
-from statsmodels.robust import mad
 
-import rapidtide.correlate as tide_corr
-import rapidtide.filter as tide_filt
-import rapidtide.fit as tide_fit
-import rapidtide.miscmath as tide_math
-import rapidtide.util as tide_util
+import rapidtide.io as tide_io
 
 
 class fMRIData:
@@ -42,9 +30,7 @@ class fMRIData:
     mask = None
     validvoxels = None
     filename = None
-    textio = False
-    fileiscifti = False
-    fileisnifti = False
+    filetype = None
 
     def __init__(
         self,
@@ -110,53 +96,44 @@ class fMRIData:
         ####################################################
         #  Read data
         ####################################################
-        # open the fmri datafil
+        # open the fmri datafile
         if tide_io.checkiftext(self.filename):
-            self.textio = True
-        else:
-            self.textio = False
-
-        if self.textio:
+            self.filetype = "text"
             self.data = tide_io.readvecs(self.filename)
             self.header = None
             theshape = np.shape(nim_data)
             self.xsize = theshape[0]
             self.ysize = 1
             self.numslices = 1
-            self.fileiscifti = False
             self.timepoints = theshape[1]
             self.thesizes = [0, int(self.xsize), 1, 1, int(self.timepoints)]
             self.numspatiallocs = int(self.xsize)
             self.nativespaceshape = self.xsize
             self.cifti_hdr = None
+        elif tide_io.checkifcifti(self.filename):
+            self.filetype = "cifti"
+            (
+                cifti,
+                cifti_hdr,
+                self.data,
+                self.header,
+                thedims,
+                thesizes,
+                dummy,
+            ) = tide_io.readfromcifti(self.filename)
+            self.isgrayordinate = True
+            self.timepoints = nim_data.shape[1]
+            numspatiallocs = nim_data.shape[0]
+            LGR.debug(f"cifti file has {timepoints} timepoints, {numspatiallocs} numspatiallocs")
+            slicesize = numspatiallocs
+            nativespaceshape = (1, 1, 1, 1, numspatiallocs)
         else:
-            self.fileiscifti = tide_io.checkifcifti(self.filename)
-            if self.fileiscifti:
-                (
-                    cifti,
-                    cifti_hdr,
-                    self.data,
-                    self.header,
-                    thedims,
-                    thesizes,
-                    dummy,
-                ) = tide_io.readfromcifti(self.filename)
-                self.isgrayordinate = True
-                self.timepoints = nim_data.shape[1]
-                numspatiallocs = nim_data.shape[0]
-                LGR.debug(
-                    f"cifti file has {timepoints} timepoints, {numspatiallocs} numspatiallocs"
-                )
-                slicesize = numspatiallocs
-                nativespaceshape = (1, 1, 1, 1, numspatiallocs)
-            else:
-                LGR.debug("input file is NIFTI")
-                nim, self.data, self.header, thedims, thesizes = tide_io.readfromnifti(
-                    fmrifilename
-                )
-                optiondict["isgrayordinate"] = False
-                xsize, ysize, numslices, timepoints = tide_io.parseniftidims(thedims)
-                numspatiallocs = int(xsize) * int(ysize) * int(numslices)
-                cifti_hdr = None
-                nativespaceshape = (xsize, ysize, numslices)
+            self.filetype = "nifti"
+            LGR.debug("input file is NIFTI")
+            nim, self.data, self.header, thedims, thesizes = tide_io.readfromnifti(fmrifilename)
+            optiondict["isgrayordinate"] = False
+            xsize, ysize, numslices, timepoints = tide_io.parseniftidims(thedims)
+            numspatiallocs = int(xsize) * int(ysize) * int(numslices)
+            cifti_hdr = None
+            nativespaceshape = (xsize, ysize, numslices)
             xdim, ydim, slicethickness, tr = tide_io.parseniftisizes(thesizes)

{rapidtide-3.0.7.1 → rapidtide-3.0.8}/rapidtide/fit.py

@@ -1469,11 +1469,11 @@ def getpeaks(xvals, yvals, xrange=None, bipolar=False, displayplots=False):
         peaks = np.concatenate((peaks, negpeaks))
     procpeaks = []
     if xrange is None:
-        lagmin = xvals[0]
-        lagmax = xvals[-1]
+        lagmin = xvals[0] + 0.0
+        lagmax = xvals[-1] + 0.0
     else:
-        lagmin = xrange[0]
-        lagmax = xrange[1]
+        lagmin = xrange[0] + 0.0
+        lagmax = xrange[1] + 0.0
     originloc = tide_util.valtoindex(xvals, 0.0, discrete=False)
     for thepeak in peaks:
         if lagmin <= xvals[thepeak] <= lagmax:

{rapidtide-3.0.7.1 → rapidtide-3.0.8}/rapidtide/happy_supportfuncs.py

@@ -22,7 +22,7 @@ import warnings
 
 import numpy as np
 from scipy.signal import savgol_filter, welch
-from scipy.stats import kurtosis, skew, pearsonr
+from scipy.stats import kurtosis, pearsonr, skew
 from statsmodels.robust import mad
 from tqdm import tqdm
 

rapidtide-3.0.8/rapidtide/helper_classes.py

@@ -0,0 +1,330 @@
+#!/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 warnings
+
+import matplotlib.pyplot as plt
+import numpy as np
+import scipy as sp
+from numpy.polynomial import Polynomial
+from scipy.optimize import curve_fit
+from statsmodels.robust import mad
+
+import rapidtide.correlate as tide_corr
+import rapidtide.filter as tide_filt
+import rapidtide.fit as tide_fit
+import rapidtide.miscmath as tide_math
+import rapidtide.util as tide_util
+
+
+class fMRIDataset:
+    thedata = None
+    theshape = None
+    xsize = None
+    ysize = None
+    numslices = None
+    realtimepoints = None
+    timepoints = None
+    slicesize = None
+    numvox = None
+    numskip = 0
+    validvoxels = None
+
+    def __init__(self, thedata, zerodata=False, copydata=False, numskip=0):
+        if zerodata:
+            self.thedata = thedata * 0.0
+        else:
+            if copydata:
+                self.thedata = thedata + 0.0
+            else:
+                self.thedata = thedata
+        self.getsizes()
+        self.setnumskip(numskip)
+
+    def getsizes(self):
+        self.theshape = self.thedata.shape
+        self.xsize = self.theshape[0]
+        self.ysize = self.theshape[1]
+        self.numslices = self.theshape[2]
+        try:
+            self.realtimepoints = self.theshape[3]
+        except KeyError:
+            self.realtimepoints = 1
+        self.slicesize = self.xsize * self.ysize
+        self.numvox = self.slicesize * self.numslices
+
+    def setnumskip(self, numskip):
+        self.numskip = numskip
+        self.timepoints = self.realtimepoints - self.numskip
+
+    def setvalid(self, validvoxels):
+        self.validvoxels = validvoxels
+
+    def byslice(self):
+        return self.thedata[:, :, :, self.numskip :].reshape(
+            (self.slicesize, self.numslices, self.timepoints)
+        )
+
+    def byvol(self):
+        return self.thedata[:, :, :, self.numskip :].reshape((self.numvox, self.timepoints))
+
+    def byvox(self):
+        return self.thedata[:, :, :, self.numskip :]
+
+
+class ProbeRegressor:
+    inputtimeaxis = None
+    inputvec = None
+    inputfreq = None
+    inputstart = 0.0
+    inputoffset = 0.0
+    targettimeaxis = None
+    targetvec = None
+    targetfreq = None
+    targetstart = 0.0
+    targetoffset = 0.0
+
+    def __init__(
+        self,
+        inputvec,
+        inputfreq,
+        targetperiod,
+        targetpoints,
+        targetstartpoint,
+        targetoversample=1,
+        inputstart=0.0,
+        inputoffset=0.0,
+        targetstart=0.0,
+        targetoffset=0.0,
+    ):
+        self.inputoffset = inputoffset
+        self.setinputvec(inputvec, inputfreq, inputstart=inputstart)
+        self.targetperiod = targetperiod
+        self.makeinputtimeaxis()
+        self.targetoversample = targetoversample
+        self.targetpoints = targetpoints
+        self.targetstartpoint = targetstartpoint
+
+    def setinputvec(self, inputvec, inputfreq, inputstart=0.0):
+        self.inputvec = inputvec
+        self.inputfreq = inputfreq
+        self.inputstart = inputstart
+
+    def makeinputtimeaxis(self):
+        self.inputtimeaxis = np.linspace(0.0, len(self.inputvec)) / self.inputfreq - (
+            self.inputstarttime + self.inputoffset
+        )
+
+    def maketargettimeaxis(self):
+        self.targettimeaxis = np.linspace(
+            self.targetperiod * self.targetstartpoint,
+            self.targetperiod * self.targetstartpoint + self.targetperiod * self.targetpoints,
+            num=self.targetpoints,
+            endpoint=True,
+        )
+
+
+class Coherer:
+    reftc = None
+    prepreftc = None
+    testtc = None
+    preptesttc = None
+    freqaxis = None
+    similarityfunclen = 0
+    datavalid = False
+    freqaxisvalid = False
+    similarityfuncorigin = 0
+    freqmin = None
+    freqmax = None
+
+    def __init__(
+        self,
+        Fs=0.0,
+        freqmin=None,
+        freqmax=None,
+        ncprefilter=None,
+        reftc=None,
+        detrendorder=1,
+        windowfunc="hamming",
+        debug=False,
+    ):
+        self.Fs = Fs
+        self.ncprefilter = ncprefilter
+        self.reftc = reftc
+        self.windowfunc = windowfunc
+        self.detrendorder = detrendorder
+        self.debug = debug
+        if freqmin is not None:
+            self.freqmin = freqmin
+        if freqmax is not None:
+            self.freqmax = freqmax
+        if self.reftc is not None:
+            self.setreftc(self.reftc)
+        if self.debug:
+            print("Coherer init:")
+            print("\tFs:", self.Fs)
+            print("\twindowfunc:", self.windowfunc)
+            print("\tdetrendorder:", self.detrendorder)
+            print("\tfreqmin:", self.freqmin)
+            print("\tfreqmax:", self.freqmax)
+
+    def preptc(self, thetc):
+        # prepare timecourse by filtering, normalizing, detrending, and applying a window function
+        return tide_math.corrnormalize(
+            self.ncprefilter.apply(self.Fs, thetc),
+            detrendorder=self.detrendorder,
+            windowfunc="None",
+        )
+
+    def setlimits(self, freqmin, freqmax):
+        self.freqmin = freqmin
+        self.freqmax = freqmax
+        if self.freqaxisvalid:
+            self.freqmininpts = np.max([0, tide_util.valtoindex(self.freqaxis, self.freqmin)])
+            self.freqmaxinpts = np.min(
+                [
+                    tide_util.valtoindex(self.freqaxis, self.freqmax),
+                    len(self.freqaxis) - 1,
+                ]
+            )
+        if self.debug:
+            print("setlimits:")
+            print("\tfreqmin,freqmax:", self.freqmin, self.freqmax)
+            print("\tfreqmininpts,freqmaxinpts:", self.freqmininpts, self.freqmaxinpts)
+
+    def getaxisinfo(self):
+        return (
+            self.freqaxis[self.freqmininpts],
+            self.freqaxis[self.freqmaxinpts],
+            self.freqaxis[1] - self.freqaxis[0],
+            self.freqmaxinpts - self.freqmininpts,
+        )
+
+    def setreftc(self, reftc):
+        self.reftc = reftc + 0.0
+        self.prepreftc = self.preptc(self.reftc)
+
+        # get frequency axis, etc
+        self.freqaxis, self.thecoherence = sp.signal.coherence(
+            self.prepreftc, self.prepreftc, fs=self.Fs
+        )
+        #                                                       window=self.windowfunc)'''
+        self.similarityfunclen = len(self.thecoherence)
+        self.similarityfuncorigin = 0
+        self.freqaxisvalid = True
+        self.datavalid = False
+        if self.freqmin is None or self.freqmax is None:
+            self.setlimits(self.freqaxis[0], self.freqaxis[-1])
+        self.freqmininpts = tide_util.valtoindex(
+            self.freqaxis, self.freqmin, discretization="floor", debug=self.debug
+        )
+        self.freqmaxinpts = tide_util.valtoindex(
+            self.freqaxis, self.freqmax, discretization="ceiling", debug=self.debug
+        )
+
+    def trim(self, vector):
+        return vector[self.freqmininpts : self.freqmaxinpts]
+
+    def run(self, thetc, trim=True, alt=False):
+        if len(thetc) != len(self.reftc):
+            print(
+                "Coherer: timecourses are of different sizes:",
+                len(thetc),
+                "!=",
+                len(self.reftc),
+                "- exiting",
+            )
+            sys.exit()
+
+        self.testtc = thetc + 0.0
+        self.preptesttc = self.preptc(self.testtc)
+
+        # now actually do the coherence
+        if self.debug:
+            fig = plt.figure()
+            ax = fig.add_subplot(111)
+            plt.plot(self.prepreftc, "r")
+            plt.plot(self.preptesttc, "b")
+            plt.legend(["reference", "test timecourse"])
+            plt.show()
+
+        if not alt:
+            self.freqaxis, self.thecoherence = sp.signal.coherence(
+                self.prepreftc, self.preptesttc, fs=self.Fs
+            )
+        else:
+            self.freqaxis, self.thecsdxy = sp.signal.csd(
+                10000.0 * self.prepreftc,
+                10000.0 * self.preptesttc,
+                fs=self.Fs,
+                scaling="spectrum",
+            )
+            self.freqaxis, self.thecsdxx = sp.signal.csd(
+                10000.0 * self.prepreftc,
+                10000.0 * self.prepreftc,
+                fs=self.Fs,
+                scaling="spectrum",
+            )
+            self.freqaxis, self.thecsdyy = sp.signal.csd(
+                10000.0 * self.preptesttc,
+                10000.0 * self.preptesttc,
+                fs=self.Fs,
+                scaling="spectrum",
+            )
+            self.thecoherence = np.nan_to_num(
+                abs(self.thecsdxy) ** 2 / (abs(self.thecsdxx) * abs(self.thecsdyy))
+            )
+
+        self.similarityfunclen = len(self.thecoherence)
+        self.similarityfuncorigin = 0
+        self.datavalid = True
+
+        if trim:
+            if alt:
+                self.themax = np.argmax(self.thecoherence[self.freqmininpts : self.freqmaxinpts])
+                return (
+                    self.trim(self.thecoherence),
+                    self.trim(self.freqaxis),
+                    self.themax,
+                    self.trim(self.thecsdxx),
+                    self.trim(self.thecsdyy),
+                    self.trim(self.thecsdxy),
+                )
+            else:
+                self.themax = np.argmax(self.thecoherence[self.freqmininpts : self.freqmaxinpts])
+                return (
+                    self.trim(self.thecoherence),
+                    self.trim(self.freqaxis),
+                    self.themax,
+                )
+        else:
+            if alt:
+                self.themax = np.argmax(self.thecoherence)
+                return (
+                    self.thecoherence,
+                    self.freqaxis,
+                    self.themax,
+                    self.thecsdxx,
+                    self.thecsdyy,
+                    self.thecsdxy,
+                )
+
+            else:
+                self.themax = np.argmax(self.thecoherence)
+                return self.thecoherence, self.freqaxis, self.themax