rapidtide 3.1__py3-none-any.whl → 3.1.1__py3-none-any.whl

rapidtide/wiener.py

@@ -28,21 +28,68 @@ def _procOneVoxelWiener(
     vox: int,
     lagtc: NDArray,
     inittc: NDArray,
-    rt_floatset: type = np.float64,
-    rt_floattype: str = "float64",
-) -> tuple[int, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray]:
+    rt_floattype: np.dtype = np.float64,
+) -> tuple[int, float, float, float, float, NDArray, NDArray, NDArray]:
+    """
+    Perform Wiener filter processing on a single voxel time series.
+
+    This function applies a Wiener filter to remove the lagged component from
+    the initial time course, returning both the filtered and unfiltered results
+    along with fitting statistics.
+
+    Parameters
+    ----------
+    vox : int
+        Voxel index identifier
+    lagtc : NDArray
+        Lagged time course data (input signal)
+    inittc : NDArray
+        Initial time course data (target signal)
+    rt_floattype : np.dtype, optional
+        Rapidtide float type for output arrays, default is np.float64
+
+    Returns
+    -------
+    tuple[int, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray]
+        A tuple containing:
+        - vox (int): Input voxel index
+        - intercept (NDArray): Regression intercept term
+        - sqrt_R2 (NDArray): Square root of coefficient of determination
+        - R2 (NDArray): Coefficient of determination
+        - fitcoff (NDArray): Fitting coefficient
+        - ratio (NDArray): Ratio of slope to intercept
+        - datatoremove (NDArray): Data to be removed (filtered signal)
+        - residual (NDArray): Residual signal (unfiltered data)
+
+    Notes
+    -----
+    This function uses maximum likelihood regression to estimate the relationship
+    between lagged and initial time courses, then applies the Wiener filter
+    to remove the lagged component from the initial signal.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lagtc = np.array([1.0, 2.0, 3.0, 4.0])
+    >>> inittc = np.array([2.0, 4.0, 6.0, 8.0])
+    >>> result = _procOneVoxelWiener(0, lagtc, inittc)
+    >>> print(result[0])  # voxel index
+    0
+    >>> print(result[4])  # fitting coefficient
+    2.0
+    """
     thefit, R2 = tide_fit.mlregress(lagtc, inittc)
-    fitcoff = rt_floatset(thefit[0, 1])
-    datatoremove = rt_floatset(fitcoff * lagtc)
+    fitcoff = thefit[0, 1]
+    datatoremove = (fitcoff * lagtc).astype(rt_floattype)
     return (
         vox,
-        rt_floatset(thefit[0, 0]),
-        rt_floatset(np.sqrt(R2)),
-        rt_floatset(R2),
+        thefit[0, 0],
+        np.sqrt(R2),
+        R2,
         fitcoff,
-        rt_floatset(thefit[0, 1] / thefit[0, 0]),
+        thefit[0, 1] / thefit[0, 0],
         datatoremove,
-        rt_floatset(inittc - datatoremove),
+        (inittc - datatoremove).astype(rt_floattype),
     )
 
 
@@ -55,10 +102,71 @@ def wienerpass(
     wienerdeconv: NDArray,
     wpeak: NDArray,
     resampref_y: NDArray,
-    rt_floatset: type = np.float64,
-    rt_floattype: str = "float64",
+    rt_floattype: np.dtype = np.float64,
 ) -> int:
-    rt_floatset = (rt_floatset,)
+    """
+    Perform Wiener deconvolution on fMRI data voxels.
+
+    This function applies Wiener deconvolution to each voxel in the fMRI data
+    based on the provided lagged time course and threshold. It supports both
+    single-threaded and multi-threaded processing depending on the configuration
+    in `optiondict`.
+
+    Parameters
+    ----------
+    numspatiallocs : int
+        Number of spatial locations (voxels) in the fMRI data.
+    fmri_data : NDArray
+        2D array of fMRI data with shape (numspatiallocs, timepoints).
+    threshval : float
+        Threshold value for masking voxels based on mean signal intensity.
+    lagtc : NDArray
+        2D array of lagged time courses with shape (numspatiallocs, timepoints).
+    optiondict : dict
+        Dictionary containing processing options including:
+        - 'nprocs': number of processors to use (default: 1)
+        - 'showprogressbar': whether to show progress bar (default: True)
+        - 'mp_chunksize': chunk size for multiprocessing (default: 10)
+    wienerdeconv : NDArray
+        Wiener deconvolution kernel or filter.
+    wpeak : NDArray
+        Peak values associated with the Wiener deconvolution.
+    resampref_y : NDArray
+        Resampled reference signal for filtering.
+    rt_floattype : np.dtype, optional
+        Data type for floating-point numbers, default is `np.float64`.
+
+    Returns
+    -------
+    int
+        Total number of voxels processed.
+
+    Notes
+    -----
+    - Voxels are masked based on their mean signal intensity exceeding `threshval`.
+    - If `nprocs` > 1, multiprocessing is used to process voxels in parallel.
+    - The function modifies global variables such as `meanvalue`, `rvalue`, etc.,
+      which are assumed to be defined in the outer scope.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> fmri_data = np.random.rand(100, 50)
+    >>> lagtc = np.random.rand(100, 50)
+    >>> optiondict = {'nprocs': 4, 'showprogressbar': True, 'mp_chunksize': 5}
+    >>> result = wienerpass(
+    ...     numspatiallocs=100,
+    ...     fmri_data=fmri_data,
+    ...     threshval=0.1,
+    ...     lagtc=lagtc,
+    ...     optiondict=optiondict,
+    ...     wienerdeconv=np.array([1, 2, 1]),
+    ...     wpeak=np.array([0.5]),
+    ...     resampref_y=np.array([1, 1, 1])
+    ... )
+    >>> print(result)
+    100
+    """
     rt_floattype = rt_floattype
     inputshape = np.shape(fmri_data)
     themask = np.where(np.mean(fmri_data, axis=1) > threshval, 1, 0)
@@ -80,7 +188,6 @@ def wienerpass(
                             val,
                             lagtc[val, :],
                             fmri_data[val, :],
-                            rt_floatset=rt_floatset,
                             rt_floattype=rt_floattype,
                         )
                     )
@@ -132,8 +239,7 @@ def wienerpass(
                     vox,
                     lagtc[vox, :],
                     inittc,
-                    rt_floatset=rt_floatset,
-                    t_floattype=rt_floattype,
+                    rt_floattype=rt_floattype,
                 )
             volumetotal += 1
 

rapidtide/wiener2.py

@@ -153,9 +153,9 @@ def wiener_deconvolution(signal: NDArray, kernel: NDArray, lambd: float) -> NDAr
 
     Parameters
     ----------
-    signal : numpy.ndarray
+    signal : NDArray
         Input signal to be deconvolved, assumed to be 1D.
-    kernel : numpy.ndarray
+    kernel : NDArray
         Convolution kernel (point spread function), assumed to be 1D.
     lambd : float
         Regularization parameter (signal-to-noise ratio). Higher values
@@ -163,7 +163,7 @@ def wiener_deconvolution(signal: NDArray, kernel: NDArray, lambd: float) -> NDAr
 
     Returns
     -------
-    numpy.ndarray
+    NDArray
         Deconvolved signal with same length as input signal.
 
     Notes

rapidtide/workflows/applyppgproc.py

@@ -17,9 +17,11 @@
 #
 #
 import argparse
-from typing import Any
+from typing import Any, Tuple
 
+import matplotlib.pyplot as plt
 import numpy as np
+from numpy.typing import NDArray
 
 import rapidtide.filter as tide_filt
 import rapidtide.ppgproc as tide_ppg
@@ -133,7 +135,23 @@ def _get_parser() -> Any:
     return parser
 
 
-def procppg(args: Any) -> None:
+def procppg(
+    args: Any,
+) -> Tuple[
+    dict,
+    NDArray,
+    NDArray,
+    NDArray,
+    NDArray,
+    NDArray,
+    NDArray,
+    NDArray,
+    NDArray,
+    NDArray,
+    NDArray,
+    NDArray,
+    NDArray,
+]:
     """
     Process PPG (Photoplethysmography) signal using a combination of filtering,
     heart rate extraction, and signal quality assessment techniques.
@@ -171,27 +189,27 @@ def procppg(args: Any) -> None:
         A tuple containing:
         - ppginfo : dict
             Dictionary with various performance metrics and computed features
-        - peak_indices : array_like
+        - peak_indices : NDArray
             Indices of detected peaks in the filtered signal
-        - rri : array_like
+        - rri : NDArray
             Inter-beat intervals (RRIs) derived from peak detection
-        - hr_waveform_from_peaks : array_like
+        - hr_waveform_from_peaks : NDArray
             Heart rate waveform computed from peaks
-        - hr_times : array_like
+        - hr_times : NDArray
             Time points for heart rate estimates
-        - hr_values : array_like
+        - hr_values : NDArray
             Heart rate values (FFT-based)
-        - filtered_ekf : array_like
+        - filtered_ekf : NDArray
             Signal filtered using Extended Kalman Filter
-        - ekf_heart_rates : array_like
+        - ekf_heart_rates : NDArray
             Heart rate estimates from EKF
-        - cardiacfromfmri_qual_times : array_like
+        - cardiacfromfmri_qual_times : NDArray
             Time points for quality scores from raw fMRI signal
-        - cardiacfromfmri_qual_scores : array_like
+        - cardiacfromfmri_qual_scores : NDArray
             Quality scores for raw fMRI signal
-        - dlfiltered_qual_times : array_like
+        - dlfiltered_qual_times : NDArray
             Time points for quality scores from DL-filtered signal
-        - dlfiltered_qual_scores : array_like
+        - dlfiltered_qual_scores : NDArray
             Quality scores for DL-filtered signal
 
     Notes
@@ -348,7 +366,7 @@ def procppg(args: Any) -> None:
         ax6.set_title("Heart Rate Extraction")
         ax6.legend(loc="upper right")
         ax6.grid(True, alpha=0.3)
-        ax6.set_ylim([40, 110])
+        ax6.set_ylim((40.0, 110.0))
 
         # Plot 7: Signal quality assessment
         ax7 = fig.add_subplot(gs[thissubfig, 0])
@@ -372,7 +390,7 @@ def procppg(args: Any) -> None:
         ax7.set_title("Signal Quality Assessment (0=Poor, 1=Excellent)")
         ax7.legend(loc="upper right")
         ax7.grid(True, alpha=0.3)
-        ax7.set_ylim([0, 1])
+        ax7.set_ylim((0.0, 1.0))
 
         plt.tight_layout()
         plt.show()

rapidtide/workflows/calcSimFuncMap.py

@@ -41,10 +41,9 @@ def makeRIPTiDeRegressors(
     chunksize: int = 1000,
     targetstep: float = 2.5,
     edgepad: int = 0,
-    rt_floatset: Any = np.float64,
-    rt_floattype: str = "float64",
+    rt_floattype: np.dtype = np.float64,
     debug: bool = False,
-) -> None:
+) -> Tuple[NDArray, NDArray]:
     """
     Generate regressors for RIPTiDe (Regressors for Inverse Temporal Deconvolution).
 
@@ -77,20 +76,18 @@ def makeRIPTiDeRegressors(
         Target step size (in seconds) between lags (default is 2.5).
     edgepad : int, optional
         Number of padding steps at the beginning and end of the lag range (default is 0).
-    rt_floatset : dtype, optional
+    rt_floattype : np.dtype, optional
         Data type for the regressor matrix (default is np.float64).
-    rt_floattype : str, optional
-        String representation of the float data type (default is "float64").
     debug : bool, optional
         If True, print debug information during execution (default is False).
 
     Returns
     -------
-    tuple of (np.ndarray, np.ndarray)
+    tuple of (NDArray, NDArray)
         A tuple containing:
-        - regressorset : np.ndarray
+        - regressorset : NDArray
             The computed regressor matrix of shape (num_lags, num_timepoints).
-        - delaystouse : np.ndarray
+        - delaystouse : NDArray
             The array of delay values used for regressor generation.
 
     Notes
@@ -102,7 +99,6 @@ def makeRIPTiDeRegressors(
     Examples
     --------
     >>> import numpy as np
-    >>> from some_module import makeRIPTiDeRegressors
     >>> fmri_data = np.random.rand(100, 50)
     >>> regressors, delays = makeRIPTiDeRegressors(
     ...     initial_fmri_x=fmri_data,
@@ -134,7 +130,7 @@ def makeRIPTiDeRegressors(
         print(f"{delaystouse=}, {len(delaystouse)}")
         print(f"{len(initial_fmri_x)}")
 
-    regressorset = np.zeros((len(delaystouse), len(initial_fmri_x)), dtype=rt_floatset)
+    regressorset = np.zeros((len(delaystouse), len(initial_fmri_x)), dtype=rt_floattype)
 
     dummy = tide_makelagged.makelaggedtcs(
         lagtcgenerator,
@@ -147,7 +143,6 @@ def makeRIPTiDeRegressors(
         alwaysmultiproc=alwaysmultiproc,
         showprogressbar=showprogressbar,
         chunksize=chunksize,
-        rt_floatset=rt_floatset,
         rt_floattype=rt_floattype,
         debug=debug,
     )
@@ -201,12 +196,11 @@ def calcSimFunc(
     interptype: str = "univariate",
     showprogressbar: bool = True,
     chunksize: int = 1000,
-    rt_floatset: Any = np.float64,
-    rt_floattype: str = "float64",
+    rt_floattype: np.dtype = np.float64,
     mklthreads: int = 1,
     threaddebug: bool = False,
     debug: bool = False,
-) -> None:
+) -> str:
     """
     Compute similarity metrics (correlation, mutual information, or RIPtiDe) between fMRI data and a reference time series.
 
@@ -301,10 +295,8 @@ def calcSimFunc(
         Whether to show a progress bar. Default is True.
     chunksize : int, optional
         Size of chunks for processing. Default is 1000.
-    rt_floatset : Any, optional
-        Real-time floating-point data type. Default is np.float64.
-    rt_floattype : str, optional
-        String representation of floating-point type. Default is 'float64'.
+    rt_floattype : np.dtype, optional
+        Rapidtide floating-point data type. Default is np.float64.
     mklthreads : int, optional
         Number of threads for Intel MKL. Default is 1.
     threaddebug : bool, optional
@@ -400,7 +392,6 @@ def calcSimFunc(
             interptype=interptype,
             showprogressbar=showprogressbar,
             chunksize=chunksize,
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
             debug=debug,
         )
@@ -425,7 +416,6 @@ def calcSimFunc(
             interptype=interptype,
             showprogressbar=showprogressbar,
             chunksize=chunksize,
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
             debug=debug,
         )
@@ -452,7 +442,6 @@ def calcSimFunc(
                 showprogressbar=showprogressbar,
                 verbose=(LGR is not None),
                 chunksize=chunksize,
-                rt_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
                 debug=debug,
             )

rapidtide/workflows/ccorrica.py

@@ -320,9 +320,11 @@ def ccorrica(args: Any) -> None:
                 zeropadding=0,
                 displayplots=args.debug,
             )
-            thepxcorr = pearsonr(reformdata[component1, :] / tclen, reformdata[component2, :])
+            thepxcorr = pearsonr(
+                reformdata[component1, :] / tclen, reformdata[component2, :]
+            ).statistic
             outputdata[component1, component2, 0, :] = thexcorr
-            outputpdata[component1, component2, 0, :] = thepxcorr[0]
+            outputpdata[component1, component2, 0, :] = thepxcorr
             (
                 maxindex,
                 maxlag,

rapidtide/workflows/cleanregressor.py

@@ -56,8 +56,7 @@ def cleanregressor(
     respdelete: bool = False,
     displayplots: bool = False,
     debug: bool = False,
-    rt_floattype: str = "float64",
-    rt_floatset: Any = np.float64,
+    rt_floattype: np.dtype = np.float64,
 ) -> Tuple[
     NDArray,
     NDArray,
@@ -131,20 +130,18 @@ def cleanregressor(
         If True, display plots during processing. Default is False.
     debug : bool, optional
         If True, print debugging information. Default is False.
-    rt_floattype : str, optional
-        Data type for real-time processing. Default is "float64".
-    rt_floatset : Any, optional
-        Float type setting for real-time processing. Default is np.float64.
+    rt_floattype : np.dtype, optional
+        Float type setting for rapidtide processing. Default is np.float64.
 
     Returns
     -------
     tuple
         A tuple containing:
-        - cleaned_resampref_y : np.ndarray
+        - cleaned_resampref_y : NDArray
             Cleaned resampled reference signal.
-        - cleaned_referencetc : np.ndarray
+        - cleaned_referencetc : NDArray
             Cleaned reference time course.
-        - cleaned_nonosreferencetc : np.ndarray
+        - cleaned_nonosreferencetc : NDArray
             Cleaned non-oversampled reference signal.
         - despeckle_thresh : float
             Updated despeckle threshold.
@@ -214,7 +211,6 @@ def cleanregressor(
         print(f"\t{check_autocorrelation=}")
         print(f"\t{displayplots=}")
         print(f"\t{rt_floattype=}")
-        print(f"\t{rt_floatset=}")
 
     # check the regressor for periodic components in the passband
     dolagmod = True
@@ -262,7 +258,6 @@ def cleanregressor(
             despeckle_thresh=despeckle_thresh,
             lthreshval=lthreshval,
             fixdelay=fixdelay,
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
         tide_io.writebidstsv(

rapidtide/workflows/delayvar.py

@@ -30,7 +30,6 @@ import numpy as np
 from numpy.typing import NDArray
 from scipy.stats import pearsonr
 from sklearn.decomposition import PCA
-from tf_keras.src.dtensor.integration_test_utils import train_step
 
 import rapidtide.filter as tide_filt
 import rapidtide.io as tide_io
@@ -483,19 +482,15 @@ def delayvar(args: Any) -> None:
         sys.exit()
 
     if therunoptions["internalprecision"] == "double":
-        rt_floattype = "float64"
-        rt_floatset = np.float64
+        rt_floattype = np.float64
     else:
-        rt_floattype = "float32"
-        rt_floatset = np.float32
+        rt_floattype = np.float32
 
     # set the output precision
     if therunoptions["outputprecision"] == "double":
-        rt_outfloattype = "float64"
-        rt_outfloatset = np.float64
+        rt_outfloattype = np.float64
     else:
-        rt_outfloattype = "float32"
-        rt_outfloatset = np.float32
+        rt_outfloattype = np.float32
     therunoptions["saveminimumsLFOfiltfiles"] = args.saveminimumsLFOfiltfiles
 
     # read the fmri input files
@@ -960,7 +955,7 @@ def delayvar(args: Any) -> None:
         # pcadata = np.mean(reduceddata, axis=0)
         pcadata = thefit.components_[0]
         averagedata = np.mean(windoweddelayoffset, axis=0)
-        thepxcorr = pearsonr(averagedata, pcadata)[0]
+        thepxcorr = pearsonr(averagedata, pcadata).statistic
         LGR.info(f"pca/avg correlation = {thepxcorr}")
         if thepxcorr > 0.0:
             systemiccomp = 1.0 * pcadata
@@ -1102,21 +1097,21 @@ def delayvar(args: Any) -> None:
                     "systemicsLFOfitmean",
                     "info",
                     None,
-                    f"Constant coefficient for systemic filter",
+                    "Constant coefficient for systemic filter",
                 ),
                 (
                     systemicfitcoeff[:, 0],
                     "systemiccoffEV0",
                     "info",
                     None,
-                    f"Coefficient 0 for systemic filter",
+                    "Coefficient 0 for systemic filter",
                 ),
                 (
                     systemicfitcoeff[:, 1],
                     "systemiccoffEV1",
                     "info",
                     None,
-                    f"Coefficient 1 for systemic filter",
+                    "Coefficient 1 for systemic filter",
                 ),
             ]
     if reduceddata is not None:

rapidtide/workflows/fitSimFuncMap.py

@@ -70,8 +70,7 @@ def fitSimFunc(
     TimingLGR: Any,
     simplefit: bool = False,
     upsampfac: int = 8,
-    rt_floatset: Any = np.float64,
-    rt_floattype: str = "float64",
+    rt_floattype: np.dtype = np.float64,
 ) -> NDArray | None:
     """
     Perform similarity function fitting and time lag estimation for fMRI data.
@@ -160,10 +159,8 @@ def fitSimFunc(
         If True, perform simple fitting using upsampling. Default is False.
     upsampfac : int, optional
         Upsampling factor for simple fitting. Default is 8.
-    rt_floatset : dtype, optional
+    rt_floattype : np.dtype, optional
         Real-time floating-point data type. Default is np.float64.
-    rt_floattype : str, optional
-        Real-time floating-point type as string. Default is "float64".
 
     Returns
     -------
@@ -218,7 +215,6 @@ def fitSimFunc(
     ...     TimingLGR,
     ...     simplefit=False,
     ...     upsampfac=8,
-    ...     rt_floatset=np.float64,
     ...     rt_floattype="float64",
     ... )
     """
@@ -243,7 +239,6 @@ def fitSimFunc(
             interptype=optiondict["interptype"],
             showprogressbar=optiondict["showprogressbar"],
             chunksize=optiondict["mp_chunksize"],
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
         tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
@@ -318,7 +313,6 @@ def fitSimFunc(
             chunksize=optiondict["mp_chunksize"],
             despeckle_thresh=optiondict["despeckle_thresh"],
             initiallags=initlags,
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
         tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
@@ -386,7 +380,6 @@ def fitSimFunc(
                             chunksize=optiondict["mp_chunksize"],
                             despeckle_thresh=optiondict["despeckle_thresh"],
                             initiallags=initlags,
-                            rt_floatset=rt_floatset,
                             rt_floattype=rt_floattype,
                         )
                         tide_util.enablemkl(

rapidtide/workflows/happy.py

@@ -66,17 +66,17 @@ def happy_main(argparsingfunc: Any) -> None:
         Command line arguments containing processing options
     infodict : dict
         Dictionary containing processing information including shared memory settings
-    fmri_data : numpy.ndarray
+    fmri_data : NDArray
         4D fMRI data array (x, y, z, time)
-    mask : numpy.ndarray
+    mask : NDArray
         3D mask array indicating valid voxels
-    projmask_byslice : numpy.ndarray
+    projmask_byslice : NDArray
         2D mask array for each slice indicating valid projection locations
-    cardphasevals : numpy.ndarray
+    cardphasevals : NDArray
         2D array of cardiac phase values for each slice and timepoint
-    rawapp_byslice : numpy.ndarray
+    rawapp_byslice : NDArray
         3D array of raw cardiac signals for each slice and timepoint
-    outphases : numpy.ndarray
+    outphases : NDArray
         Array of cardiac phases
     timepoints : int
         Number of timepoints in the fMRI data