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

rapidtide/workflows/showarbcorr.py

@@ -297,6 +297,8 @@ def showarbcorr(args):
         sys.exit()
     if starttime1 == None:
         starttime1 = 0.0
+    endtime1 = starttime1 + len(inputdata1) / Fs1
+    print(f"inputdata1 goes from {starttime1} to {endtime1}")
 
     if args.samplerate2 is not None:
         Fs2 = args.samplerate2
@@ -305,9 +307,19 @@ def showarbcorr(args):
         sys.exit()
     if starttime2 == None:
         starttime2 = 0.0
+    endtime2 = starttime2 + len(inputdata2) / Fs2
+    print(f"inputdata2 goes from {starttime2} to {endtime2}")
 
-    trimdata1 = inputdata1
-    trimdata2 = inputdata2
+    matchedinput1, matchedinput2, commonFs = tide_corr.matchsamplerates(
+        inputdata1,
+        Fs1,
+        inputdata2,
+        Fs2,
+        method="univariate",
+        debug=args.debug,
+    )
+    trimdata1 = matchedinput1
+    trimdata2 = matchedinput2
 
     if args.trimdata:
         minlen = np.min([len(trimdata1), len(trimdata2)])
@@ -324,12 +336,12 @@ def showarbcorr(args):
         if args.verbose:
             print("filtering to ", theprefilter.gettype(), " band")
     filtereddata1 = tide_math.corrnormalize(
-        theprefilter.apply(Fs1, trimdata1),
+        theprefilter.apply(commonFs, trimdata1),
         detrendorder=args.detrendorder,
         windowfunc=args.windowfunc,
     )
     filtereddata2 = tide_math.corrnormalize(
-        theprefilter.apply(Fs2, trimdata2),
+        theprefilter.apply(commonFs, trimdata2),
         detrendorder=args.detrendorder,
         windowfunc=args.windowfunc,
     )
@@ -341,9 +353,9 @@ def showarbcorr(args):
         print(f"{Fs1=}, {Fs2=}, {starttime1=}, {starttime2=}, {args.windowfunc=}")
     xcorr_x, thexcorr, corrFs, zeroloc = tide_corr.arbcorr(
         filtereddata1,
-        Fs1,
+        commonFs,
         filtereddata2,
-        Fs2,
+        commonFs,
         start1=starttime1,
         start2=starttime2,
         windowfunc=args.windowfunc,
@@ -375,6 +387,7 @@ def showarbcorr(args):
     thexcorr_trim = thexcorr[lowerlim:upperlim]
     print("trimmed Correlator lengths (x, y):", len(xcorr_x_trim), len(thexcorr_trim))
 
+    print(f"{len(filtereddata1)=}, {len(filtereddata2)=}")
     thepxcorr = pearsonr(filtereddata1, filtereddata2)
 
     # initialize the correlation fitter

rapidtide/workflows/simdata.py

@@ -18,12 +18,13 @@
 #
 import argparse
 
-import numpy as np
 from matplotlib.pyplot import *
 
+import rapidtide.filter as tide_filt
 import rapidtide.io as tide_io
 import rapidtide.miscmath as tide_math
 import rapidtide.resample as tide_resample
+import rapidtide.voxelData as tide_voxelData
 import rapidtide.workflows.parser_funcs as pf
 
 
@@ -38,21 +39,30 @@ def _get_parser():
     )
 
     # Required arguments
-    pf.addreqinputniftifile(
-        parser, "fmrifilename", addedtext="An exemplar BOLD fMRI file with the target dimensions"
+    parser.add_argument(
+        "fmritr",
+        type=lambda x: pf.is_float(parser, x, minval=0.0),
+        help="TR of the simulated data, in seconds.",
+    )
+    parser.add_argument(
+        "numtrs",
+        type=lambda x: pf.is_int(parser, x, minval=1),
+        help="Number of TRs in the simulated data.",
     )
     pf.addreqinputniftifile(
         parser, "immeanfilename", addedtext="3D file with the mean value for each voxel"
     )
     parser.add_argument("outputroot", type=str, help="Root name for the output files.")
-    parser.add_argument(
-        "slicetimefile",
-        type=str,
-        help="Slice acquisition time file, either FSL format or BIDS sidecar.",
-    )
 
     for band in ["lfo", "resp", "cardiac"]:
-        parser.add_argument(
+        if band == "lfo":
+            bandopts = parser.add_argument_group("LFO band options")
+        elif band == "resp":
+            bandopts = parser.add_argument_group("Resp band options")
+        else:
+            bandopts = parser.add_argument_group("Cardiac band options")
+        strengthopts = bandopts.add_mutually_exclusive_group()
+        strengthopts.add_argument(
             f"--{band}pctfile",
             dest=(f"{band}pctfile"),
             action="store",
@@ -61,7 +71,18 @@ def _get_parser():
             help=(f"3D NIFTI file with the {band} amplitude in percent of mean at every point"),
             default=None,
         )
-        parser.add_argument(
+        strengthopts.add_argument(
+            f"--{band}signalfraction",
+            dest=(f"{band}sigfracfile"),
+            action="store",
+            type=lambda x: pf.is_valid_file(parser, x),
+            metavar="FILE",
+            help=(
+                f"3D NIFTI file with the {band} amplitude expressed as the percentage of inband variance accounted for by the regressor"
+            ),
+            default=None,
+        )
+        bandopts.add_argument(
             f"--{band}lagfile",
             dest=(f"{band}lagfile"),
             action="store",
@@ -70,7 +91,7 @@ def _get_parser():
             help=(f"3D NIFTI file with the {band} delay value in seconds at every point"),
             default=None,
         )
-        parser.add_argument(
+        bandopts.add_argument(
             f"--{band}regressor",
             dest=(f"{band}regressor"),
             action="store",
@@ -79,7 +100,7 @@ def _get_parser():
             help=(f"The {band} regressor text file"),
             default=None,
         )
-        parser.add_argument(
+        bandopts.add_argument(
             f"--{band}samprate",
             dest=(f"{band}samprate"),
             action="store",
@@ -88,7 +109,7 @@ def _get_parser():
             help=(f"The sample rate of the {band} regressor file, in Hz"),
             default=None,
         )
-        parser.add_argument(
+        bandopts.add_argument(
             f"--{band}starttime",
             dest=(f"{band}starttime"),
             action="store",
@@ -103,6 +124,16 @@ def _get_parser():
         )
 
     # optional arguments
+    parser.add_argument(
+        "--slicetimefile",
+        dest="slicetimefile",
+        action="store",
+        type=str,
+        metavar="FILE",
+        help="Slice acquisition time file, either FSL format or BIDS sidecar.",
+        default=None,
+    )
+
     parser.add_argument(
         "--numskip",
         dest="numskip",
@@ -127,7 +158,9 @@ def _get_parser():
         action="store",
         type=float,
         metavar="LEVEL",
-        help=("The variance of the voxel specific noise.  Default is 0.0"),
+        help=(
+            "The variance of the voxel specific noise, as percent of the voxel mean.  Default is 0.0"
+        ),
         default=0.0,
     )
     parser.add_argument(
@@ -144,8 +177,9 @@ def _get_parser():
 
 
 def prepareband(
-    fmridims,
+    simdatadims,
     pctfile,
+    sigfracfile,
     lagfile,
     regressorfile,
     samprate,
@@ -155,8 +189,9 @@ def prepareband(
     debug=False,
 ):
     if debug:
-        print("fmridims:", fmridims)
+        print("simdatadims:", simdatadims)
         print("pctfile:", pctfile)
+        print("sigfracfile:", sigfracfile)
         print("lagfile:", lagfile)
         print("regressorfile:", regressorfile)
         print("regressorname:", regressorname)
@@ -204,44 +239,66 @@ def prepareband(
         regressor_x[-1],
     )
 
-    nim_pct, pctdata, pctheader, pctdims, pctsizes = tide_io.readfromnifti(pctfile)
-    if not tide_io.checkspacedimmatch(pctdims, fmridims):
-        print(regressorname, "pct file does not match fmri")
-        exit()
+    if pctfile is not None:
+        nim_pct, pctdata, pctheader, pctdims, pctsizes = tide_io.readfromnifti(pctfile)
+        pctscale = True
+    else:
+        nim_pct, pctdata, pctheader, pctdims, pctsizes = tide_io.readfromnifti(sigfracfile)
+        pctscale = False
+        if not tide_io.checkspacedimmatch(pctdims, simdatadims):
+            print(regressorname, "pct file does not match fmri")
+            exit()
+        pctdata /= 100.0
     nim_lag, lagdata, lagheader, lagdims, lagsizes = tide_io.readfromnifti(lagfile)
-    if not tide_io.checkspacedimmatch(lagdims, fmridims):
+    if not tide_io.checkspacedimmatch(lagdims, simdatadims):
         print(regressorname, "lag file does not match fmri")
         exit()
 
     generator = tide_resample.FastResampler(
         regressor_x, regressor_y, padtime=padtime, doplot=False
     )
-    return pctdata, lagdata, generator
+    return pctdata, pctscale, lagdata, generator
 
 
 def fmrisignal(
+    Fs,
     times,
     meanvalue,
     dolfo=False,
     lfowave=None,
     lfomag=None,
     lfodelay=None,
+    lfonoise=0.0,
+    lfofilter=None,
     doresp=False,
     respwave=None,
     respmag=None,
     respdelay=None,
+    respnoise=0.0,
+    respfilter=None,
     docardiac=False,
     cardiacwave=None,
     cardiacmag=None,
     cardiacdelay=None,
+    cardiacnoise=0.0,
+    cardiacfilter=None,
 ):
     thesignal = np.zeros((len(times)), dtype=float)
     if dolfo:
-        thesignal += meanvalue * (lfomag / 100.0) * lfowave.yfromx(times - lfodelay)
+        thesignal += meanvalue * (
+            lfomag * lfowave.yfromx(times - lfodelay)
+            + lfonoise * lfofilter.apply(Fs, np.random.standard_normal(len(times)))
+        )
     if doresp:
-        thesignal += meanvalue * (respmag / 100.0) * respwave.yfromx(times - respdelay)
+        thesignal += meanvalue * (
+            respmag * respwave.yfromx(times - respdelay)
+            + respnoise * respfilter.apply(Fs, np.random.standard_normal(len(times)))
+        )
     if docardiac:
-        thesignal += meanvalue * (cardiacmag / 100.0) * cardiacwave.yfromx(times - cardiacdelay)
+        thesignal += meanvalue * (
+            cardiacmag * cardiacwave.yfromx(times - cardiacdelay)
+            + cardiacnoise * cardiacfilter.apply(Fs, np.random.standard_normal(len(times)))
+        )
     return thesignal + meanvalue
 
 
@@ -250,33 +307,38 @@ def simdata(args):
     lfopctdata = None
     lfolagdata = None
     lfogenerator = None
+    lfofilter = None
 
     resppctdata = None
     resplagdata = None
     respgenerator = None
+    respfilter = None
 
     cardiacpctdata = None
     cardiaclagdata = None
     cardiacgenerator = None
+    cardiacfilter = None
 
     # check for complete information
     if (
-        (args.lfopctfile is None)
+        ((args.lfopctfile is None) and (args.lfosigfracfile is None))
         or (args.lfolagfile is None)
         or (args.lforegressor is None)
         or ((args.lfosamprate is None) and (tide_io.parsefilespec(args.lforegressor)[1] is None))
     ):
         print("lfopctfile:", args.lfopctfile)
+        print("lfosigfracfile:", args.lfosigfracfile)
         print("lfolagfile:", args.lfolagfile)
         print("lforegressor:", args.lforegressor)
         print("lfopctsamprate:", args.lfosamprate)
         dolfo = False
     else:
         dolfo = True
+        lfofilter = tide_filt.NoncausalFilter("lfo")
         print("LFO information is complete, will be included.")
 
     if (
-        (args.resppctfile is None)
+        ((args.resppctfile is None) and (args.respsigfracfile is None))
         or (args.resplagfile is None)
         or (args.respregressor is None)
         or ((args.respsamprate is None) and (tide_io.parsefilespec(args.respregressor)[1] is None))
@@ -284,10 +346,11 @@ def simdata(args):
         doresp = False
     else:
         doresp = True
+        respfilter = tide_filt.NoncausalFilter("resp")
         print("Respiratory information is complete, will be included.")
 
     if (
-        (args.cardiacpctfile is None)
+        ((args.cardiacpctfile is None) and (args.cardiacsigfracfile is None))
         or (args.cardiaclagfile is None)
         or (args.cardiacregressor is None)
         or (
@@ -298,6 +361,7 @@ def simdata(args):
         docardiac = False
     else:
         docardiac = True
+        cardiacfilter = tide_filt.NoncausalFilter("cardiac")
         print("Cardiac information is complete, will be included.")
     if not (dolfo or doresp or docardiac):
         print(
@@ -306,23 +370,17 @@ def simdata(args):
         _get_parser().print_help()
         sys.exit()
 
-    sliceoffsettimes, normalizedtotr, fileisjson = tide_io.getslicetimesfromfile(
-        args.slicetimefile
-    )
-
-    fmritr, numtrs = tide_io.fmritimeinfo(args.fmrifilename)
-    if normalizedtotr:
-        sliceoffsettimes *= fmritr
-
-    nim_fmri, fmridata, fmriheader, fmridims, fmrisizes = tide_io.readfromnifti(args.fmrifilename)
-    print(f"fmri data: {numtrs} timepoints, tr = {fmritr}")
+    print(f"simulated fmri data: {args.numtrs} timepoints, tr = {args.fmritr}")
 
     # prepare the output timepoints
     initial_fmri_x = (
         np.linspace(
-            0.0, fmritr * (numtrs - args.numskip), num=(numtrs - args.numskip), endpoint=False
+            0.0,
+            args.fmritr * (args.numtrs - args.numskip),
+            num=(args.numtrs - args.numskip),
+            endpoint=False,
         )
-        + fmritr * args.numskip
+        + args.fmritr * args.numskip
     )
     print("length of fmri after removing skip:", len(initial_fmri_x))
     print(
@@ -332,34 +390,36 @@ def simdata(args):
 
     # read in the immean file
     print("reading in source files")
-    (
-        nim_immean,
-        immeandata,
-        immeanheader,
-        immeandims,
-        immeansizes,
-    ) = tide_io.readfromnifti(args.immeanfilename)
-    if not tide_io.checkspacedimmatch(immeandims, fmridims):
-        print("immean file does not match")
-        exit()
+    theimmeandata = tide_voxelData.VoxelData(args.immeanfilename, timestep=args.fmritr)
+    immeandata = theimmeandata.byvol()
 
     # now set up the simulated data array
-    thedims = fmridims
-    xsize = thedims[1]
-    ysize = thedims[2]
-    numslices = thedims[3]
-    simdata = np.zeros((xsize, ysize, numslices, len(initial_fmri_x)), dtype="float")
+    simdataheader = theimmeandata.copyheader(
+        numtimepoints=len(initial_fmri_x), tr=args.fmritr, toffset=args.numskip * args.fmritr
+    )
+    simdatadims = simdataheader["dim"].copy()
+    xsize, ysize, numslices, timepoints = tide_io.parseniftidims(simdatadims)
+    simdata = np.zeros((xsize, ysize, numslices, timepoints), dtype="float")
+
+    # read in the slicetimes file if we have one
+    if args.slicetimefile is not None:
+        sliceoffsettimes, normalizedtotr, fileisjson = tide_io.getslicetimesfromfile(
+            args.slicetimefile
+        )
+    else:
+        sliceoffsettimes = np.zeros((numslices), dtype=float)
 
     # set up fast resampling
     padtime = 60.0
-    numpadtrs = int(padtime / fmritr)
-    padtime = fmritr * numpadtrs
+    numpadtrs = int(padtime / args.fmritr)
+    padtime = args.fmritr * numpadtrs
 
     # prepare the input data for interpolation
     if dolfo:
-        lfopctdata, lfolagdata, lfogenerator = prepareband(
-            fmridims,
+        lfopctdata, lfopctscale, lfolagdata, lfogenerator = prepareband(
+            simdatadims,
             args.lfopctfile,
+            args.lfosigfracfile,
             args.lfolagfile,
             args.lforegressor,
             args.lfosamprate,
@@ -369,9 +429,10 @@ def simdata(args):
             debug=args.debug,
         )
     if doresp:
-        resppctdata, resplagdata, respgenerator = prepareband(
-            fmridims,
+        resppctdata, resppctscale, resplagdata, respgenerator = prepareband(
+            simdatadims,
             args.resppctfile,
+            args.respsigfracfile,
             args.resplagfile,
             args.respregressor,
             args.respsamprate,
@@ -381,9 +442,10 @@ def simdata(args):
             debug=args.debug,
         )
     if docardiac:
-        cardiacpctdata, cardiaclagdata, cardiacgenerator = prepareband(
-            fmridims,
+        cardiacpctdata, cardiacpctscale, cardiaclagdata, cardiacgenerator = prepareband(
+            simdatadims,
             args.cardiacpctfile,
+            args.cardiacsigfracfile,
             args.cardiaclagfile,
             args.cardiacregressor,
             args.cardiacsamprate,
@@ -408,42 +470,64 @@ def simdata(args):
                 # add in the signals
                 if dolfo:
                     lfopct = lfopctdata[i, j, k]
+                    if lfopctscale:
+                        lfonoise = 0.0
+                    else:
+                        lfonoise = 1.0 - lfopct
                     lfolag = lfolagdata[i, j, k]
                 else:
                     lfopct = 0.0
                     lfolag = 0.0
+                    lfonoise = 0.0
                 if doresp:
                     resppct = resppctdata[i, j, k]
+                    if resppctscale:
+                        respnoise = 0.0
+                    else:
+                        respnoise = 1.0 - resppct
                     resplag = resplagdata[i, j, k]
                 else:
                     resppct = 0.0
                     resplag = 0.0
+                    respnoise = 0.0
                 if docardiac:
                     cardiacpct = cardiacpctdata[i, j, k]
+                    if cardiacpctscale:
+                        cardiacnoise = 0.0
+                    else:
+                        cardiacnoise = 1.0 - cardiacpct
                     cardiaclag = cardiaclagdata[i, j, k]
                 else:
                     cardiacpct = 0.0
                     cardiaclag = 0.0
+                    cardiacnoise = 0.0
 
                 simdata[i, j, k, :] = (
                     fmrisignal(
+                        (1.0 / args.fmritr),
                         fmri_x_slice,
                         immeandata[i, j, k],
                         dolfo=dolfo,
                         lfowave=lfogenerator,
                         lfomag=lfopct,
                         lfodelay=lfolag,
+                        lfonoise=lfonoise,
+                        lfofilter=lfofilter,
                         doresp=doresp,
                         respwave=respgenerator,
                         respmag=resppct,
                         respdelay=resplag,
+                        respnoise=respnoise,
+                        respfilter=respfilter,
                         docardiac=docardiac,
                         cardiacwave=cardiacgenerator,
                         cardiacmag=cardiacpct,
                         cardiacdelay=cardiaclag,
+                        cardiacnoise=cardiacnoise,
+                        cardiacfilter=cardiacfilter,
                     )
                     + theglobalnoise
-                    + thevoxelnoise
+                    + (thevoxelnoise) / 100.0 * immeandata[i, j, k]
                 )
 
-    tide_io.savetonifti(simdata, fmriheader, args.outputroot)
+    tide_io.savetonifti(simdata, simdataheader, args.outputroot)

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

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