rapidtide 3.0a6__py3-none-any.whl → 3.0a8__py3-none-any.whl

rapidtide/util.py

@@ -26,8 +26,7 @@ import subprocess
 import sys
 import time
 from datetime import datetime
-from multiprocessing import RawArray, shared_memory
-from os.path import split
+from multiprocessing import shared_memory
 
 import matplotlib.pyplot as plt
 import numpy as np

rapidtide/workflows/happy.py

@@ -236,8 +236,10 @@ def happy_main(argparsingfunc):
     # filter out motion regressors here
     if args.motionfilename is not None:
         timings.append(["Motion filtering start", time.time(), None, None])
+        motiondict = tide_io.readmotion(args.motionfilename, tr=tr)
         confoundregressors, confoundregressorlabels = tide_fit.calcexpandedregressors(
-            tide_io.readconfounds(args.motionfilename),
+            motiondict,
+            labels=["xtrans", "ytrans", "ztrans", "xrot", "yrot", "zrot"],
             deriv=args.motfilt_deriv,
             order=args.motfilt_order,
         )
@@ -284,10 +286,21 @@ def happy_main(argparsingfunc):
             timings.append(["Motion filtered data saved", time.time(), numspatiallocs, "voxels"])
 
     # get slice times
-    slicetimes, normalizedtotr = tide_io.getslicetimesfromfile(slicetimename)
+    slicetimes, normalizedtotr, fileisbidsjson = tide_io.getslicetimesfromfile(slicetimename)
     if normalizedtotr and not args.slicetimesareinseconds:
         slicetimes *= tr
-
+    if args.teoffset is not None:
+        teoffset = float(args.teoffset)
+    else:
+        if fileisbidsjson:
+            jsoninfodict = tide_io.readdictfromjson(slicetimename)
+            try:
+                teoffset = jsoninfodict["EchoTime"]
+            except KeyError:
+                teoffset = 0.0
+        else:
+            teoffset = 0.0
+    infodict["teoffset"] = teoffset
     timings.append(["Slice times determined", time.time(), None, None])
 
     # normalize the input data
@@ -317,30 +330,32 @@ def happy_main(argparsingfunc):
     tide_io.savetonifti(mads.reshape((xsize, ysize, numslices)), theheader, madsfilename)
 
     # read in estimation mask if present. Otherwise, otherwise use intensity mask.
-    infodict["estmaskname"] = args.estmaskname
+    infodict["estweightsname"] = args.estweightsname
     if args.debug:
-        print(args.estmaskname)
-    if args.estmaskname is not None:
-        tide_util.logmem("before reading in estmask")
-        estmask = happy_support.readextmask(
-            args.estmaskname, nim_hdr, xsize, ysize, numslices, args.debug
+        print(args.estweightsname)
+    if args.estweightsname is not None:
+        tide_util.logmem("before reading in estweights")
+        estweights = happy_support.readextmask(
+            args.estweightsname, nim_hdr, xsize, ysize, numslices, args.debug
         )
-        # * np.float64(mask_byslice)
-        estmask_byslice = estmask.reshape(xsize * ysize, numslices)
-        print("using estmask from file", args.estmaskname)
+        estweights_byslice = estweights.reshape(xsize * ysize, numslices)
+        print("using estweights from file", args.estweightsname)
         numpasses = 1
     else:
         # just fall back to the intensity mask
-        estmask_byslice = mask_byslice.astype("float64")
+        estweights_byslice = mask_byslice.astype("float64")
         numpasses = 2
         print("Not using separate estimation mask - doing initial estimate using intensity mask")
-    if args.fliparteries:
-        # add another pass to refine the waveform after getting the new appflips
+
+    # add another pass to refine the waveform after getting the new appflips
+    if args.fliparteries or args.doaliasedcorrelation:
         numpasses += 1
-        print("Adding a pass to regenerate cardiac waveform using better appflips")
+        print("Adding a pass to regenerate cardiac waveform using better vessel specification")
 
     # output mask size
-    print(f"estmask has {len(np.where(estmask_byslice[:, :] > 0)[0])} voxels above threshold.")
+    print(
+        f"estweights has {len(np.where(estweights_byslice[:, :] > 0)[0])} voxels above threshold."
+    )
 
     infodict["numpasses"] = numpasses
 
@@ -369,7 +384,7 @@ def happy_main(argparsingfunc):
             slicenorms,
         ) = happy_support.cardiacfromimage(
             normdata_byslice,
-            estmask_byslice,
+            estweights_byslice,
             numslices,
             timepoints,
             tr,
@@ -396,43 +411,15 @@ def happy_main(argparsingfunc):
             ]
         )
         infodict["cardfromfmri_normfac"] = cardfromfmri_normfac
-        slicetimeaxis = np.linspace(
-            0.0, tr * timepoints, num=(timepoints * numsteps), endpoint=False
+        slicetimeaxis = (
+            np.linspace(0.0, tr * timepoints, num=(timepoints * numsteps), endpoint=False)
+            + teoffset
         )
         if (thispass == 0) and args.doupsampling:
-            # allocate the upsampled image
-            upsampleimage = np.zeros((xsize, ysize, numslices, numsteps * timepoints), dtype=float)
-            upsampleimage_byslice = upsampleimage.reshape(
-                xsize * ysize, numslices, numsteps * timepoints
+            happy_support.upsampleimage(
+                input_data, nim_hdr, numsteps, sliceoffsets, slicesamplerate, outputroot
             )
-
-            # drop in the raw data
-            for theslice in range(numslices):
-                upsampleimage[
-                    :, :, theslice, sliceoffsets[theslice] : timepoints * numsteps : numsteps
-                ] = fmri_data.reshape((xsize, ysize, numslices, timepoints))[:, :, theslice, :]
-
-            # interpolate along the slice direction
-            for thestep in range(numsteps):
-                print(f"interpolating step {thestep}")
-                thesrclocs = np.where(sliceoffsets == thestep)[0]
-                print(f"sourcelocs: {thesrclocs}")
-                thedstlocs = np.linspace(0, numslices, num=len(sliceoffsets), endpoint=False)
-                print(f"len(destlocst), destlocs: {len(thedstlocs)}, {thedstlocs}")
-                for thetimepoint in range(0, timepoints * numsteps):
-                    print(f"timepoint: {thetimepoint}")
-                    for thexyvoxel in range(xsize * ysize):
-                        theinterps = np.interp(
-                            thedstlocs,
-                            1.0 * thesrclocs,
-                            upsampleimage_byslice[thexyvoxel, thesrclocs, thetimepoint],
-                        )
-                        upsampleimage_byslice[thexyvoxel, :, thetimepoint] = 1.0 * theinterps
-
-            theheader = copy.deepcopy(nim_hdr)
-            theheader["dim"][4] = timepoints * numsteps
-            theheader["pixdim"][4] = 1.0 / slicesamplerate
-            tide_io.savetonifti(upsampleimage, theheader, outputroot + "_upsampled")
+            sys.exit(0)
 
         if thispass == numpasses - 1:
             tide_io.writebidstsv(
@@ -1171,20 +1158,12 @@ def happy_main(argparsingfunc):
         # construct the destination arrays
         tide_util.logmem("before making destination arrays")
         app = np.zeros((xsize, ysize, numslices, args.destpoints), dtype=np.float64)
-        app_byslice = app.reshape((xsize * ysize, numslices, args.destpoints))
         cine = np.zeros((xsize, ysize, numslices, args.destpoints), dtype=np.float64)
-        cine_byslice = cine.reshape((xsize * ysize, numslices, args.destpoints))
         rawapp = np.zeros((xsize, ysize, numslices, args.destpoints), dtype=np.float64)
-        rawapp_byslice = rawapp.reshape((xsize * ysize, numslices, args.destpoints))
         corrected_rawapp = np.zeros((xsize, ysize, numslices, args.destpoints), dtype=np.float64)
-        corrected_rawapp_byslice = rawapp.reshape((xsize * ysize, numslices, args.destpoints))
         normapp = np.zeros((xsize, ysize, numslices, args.destpoints), dtype=np.float64)
-        normapp_byslice = normapp.reshape((xsize * ysize, numslices, args.destpoints))
         weights = np.zeros((xsize, ysize, numslices, args.destpoints), dtype=np.float64)
-        weight_byslice = weights.reshape((xsize * ysize, numslices, args.destpoints))
         derivatives = np.zeros((xsize, ysize, numslices, 4), dtype=np.float64)
-        derivatives_byslice = derivatives.reshape((xsize * ysize, numslices, 4))
-
         timings.append(["Output arrays allocated" + passstring, time.time(), None, None])
 
         if args.centric:
@@ -1198,6 +1177,42 @@ def happy_main(argparsingfunc):
         # now do the phase projection
         #
         #
+        """app, rawapp, corrected_rawapp, normapp, weights, cine, derivatives = (
+            happy_support.phaseproject(
+                demeandata,
+                means,
+                args.destpoints,
+                numsteps,
+                timings,
+                cardfromfmri_sliceres,
+                instantaneous_cardiacphase,
+                thispass,
+                numpasses,
+                args,
+                outputroot,
+                slicesamplerate,
+                pleth_sliceres,
+                mrsamplerate,
+                projmask_byslice,
+                cardphasevals,
+                thetimes,
+                centric=True,
+                passstring="",
+                badpointlist=None,
+                congridbins=3.0,
+                gridkernel="kaiser",
+            )
+        )"""
+        app_byslice = app.reshape((xsize * ysize, numslices, args.destpoints))
+        rawapp_byslice = rawapp.reshape((xsize * ysize, numslices, args.destpoints))
+        corrected_rawapp_byslice = corrected_rawapp.reshape(
+            (xsize * ysize, numslices, args.destpoints)
+        )
+        normapp_byslice = normapp.reshape((xsize * ysize, numslices, args.destpoints))
+        weights_byslice = weights.reshape((xsize * ysize, numslices, args.destpoints))
+        cine_byslice = cine.reshape((xsize * ysize, numslices, args.destpoints))
+        derivatives_byslice = derivatives.reshape((xsize * ysize, numslices, 4))
+
         demeandata_byslice = demeandata.reshape((xsize * ysize, numslices, timepoints))
         means_byslice = means.reshape((xsize * ysize, numslices))
 
@@ -1216,7 +1231,7 @@ def happy_main(argparsingfunc):
             procpoints = np.where(censorpoints < 1)[0]
 
         # do phase averaging
-        app_bypoint, weight_bypoint = happy_support.cardiaccycleaverage(
+        app_bypoint, weights_bypoint = happy_support.cardiaccycleaverage(
             instantaneous_cardiacphase,
             outphases,
             cardfromfmri_sliceres,
@@ -1238,7 +1253,7 @@ def happy_main(argparsingfunc):
             )
             tide_io.writebidstsv(
                 outputroot + "_desc-cardiaccycleweightfromfmri_timeseries",
-                weight_bypoint,
+                weights_bypoint,
                 1.0 / (outphases[1] - outphases[0]),
                 starttime=outphases[0],
                 columns=["cardiaccycleweightfromfmri"],
@@ -1295,7 +1310,7 @@ def happy_main(argparsingfunc):
         outtimes = np.linspace(
             0.0, maxtime, num=int(maxtime / args.pulsereconstepsize), endpoint=False
         )
-        atp_bypoint, atpweight_bypoint = happy_support.cardiaccycleaverage(
+        atp_bypoint, atpweights_bypoint = happy_support.cardiaccycleaverage(
             instantaneous_cardiactime,
             outtimes,
             cardfromfmri_sliceres,
@@ -1326,13 +1341,14 @@ def happy_main(argparsingfunc):
         appsmoothingfilter.setfreqs(0.0, 0.0, phaseFc, phaseFc)
 
         # setup for aliased correlation if we're going to do it
-        if args.doaliasedcorrelation and (thispass == numpasses - 1):
+        if args.doaliasedcorrelation:
             if args.cardiacfilename and False:
                 signal_sliceres = pleth_sliceres
-                # signal_stdres = pleth_stdres
             else:
                 signal_sliceres = cardfromfmri_sliceres
-                # signal_stdres = dlfilteredcard_stdres
+
+            # zero out bad points
+            signal_sliceres *= 1.0 - badpointlist
 
             theAliasedCorrelator = tide_corr.AliasedCorrelator(
                 signal_sliceres,
@@ -1345,16 +1361,21 @@ def happy_main(argparsingfunc):
             )
             correndloc = tide_util.valtoindex(thealiasedcorrx, args.aliasedcorrelationwidth / 2.0)
             aliasedcorrelationpts = correndloc - corrstartloc + 1
-            thecorrfunc = np.zeros(
-                (xsize, ysize, numslices, aliasedcorrelationpts), dtype=np.float64
-            )
-            thecorrfunc_byslice = thecorrfunc.reshape(
-                (xsize * ysize, numslices, aliasedcorrelationpts)
-            )
-            wavedelay = np.zeros((xsize, ysize, numslices), dtype=np.float64)
-            wavedelay_byslice = wavedelay.reshape((xsize * ysize, numslices))
-            waveamp = np.zeros((xsize, ysize, numslices), dtype=np.float64)
-            waveamp_byslice = waveamp.reshape((xsize * ysize, numslices))
+            if thispass == 0:
+                thecorrfunc = np.zeros(
+                    (xsize, ysize, numslices, aliasedcorrelationpts), dtype=np.float64
+                )
+                thecorrfunc_byslice = thecorrfunc.reshape(
+                    (xsize * ysize, numslices, aliasedcorrelationpts)
+                )
+                wavedelay = np.zeros((xsize, ysize, numslices), dtype=np.float64)
+                wavedelay_byslice = wavedelay.reshape((xsize * ysize, numslices))
+                waveamp = np.zeros((xsize, ysize, numslices), dtype=np.float64)
+                waveamp_byslice = waveamp.reshape((xsize * ysize, numslices))
+            else:
+                thecorrfunc *= 0.0
+                wavedelay *= 0.0
+                waveamp *= 0.0
 
         # now project the data
         fmri_data_byslice = input_data.byslice()
@@ -1381,20 +1402,21 @@ def happy_main(argparsingfunc):
                         cyclic=True,
                     )
                     for i in range(len(theindices)):
-                        weight_byslice[validlocs, theslice, theindices[i]] += theweights[i]
+                        weights_byslice[validlocs, theslice, theindices[i]] += theweights[i]
                         # rawapp_byslice[validlocs, theslice, theindices[i]] += (
                         #    theweights[i] * filteredmr
                         # )
                         rawapp_byslice[validlocs, theslice, theindices[i]] += filteredmr
                         cine_byslice[validlocs, theslice, theindices[i]] += theweights[i] * cinemr
                 for d in range(args.destpoints):
-                    if weight_byslice[validlocs[0], theslice, d] == 0.0:
-                        weight_byslice[validlocs, theslice, d] = 1.0
+                    if weights_byslice[validlocs[0], theslice, d] == 0.0:
+                        weights_byslice[validlocs, theslice, d] = 1.0
                 rawapp_byslice[validlocs, theslice, :] = np.nan_to_num(
-                    rawapp_byslice[validlocs, theslice, :] / weight_byslice[validlocs, theslice, :]
+                    rawapp_byslice[validlocs, theslice, :]
+                    / weights_byslice[validlocs, theslice, :]
                 )
                 cine_byslice[validlocs, theslice, :] = np.nan_to_num(
-                    cine_byslice[validlocs, theslice, :] / weight_byslice[validlocs, theslice, :]
+                    cine_byslice[validlocs, theslice, :] / weights_byslice[validlocs, theslice, :]
                 )
             else:
                 rawapp_byslice[:, theslice, :] = 0.0
@@ -1419,7 +1441,7 @@ def happy_main(argparsingfunc):
                 corrected_rawapp_byslice[validlocs, theslice, :] = (
                     rawapp_byslice[validlocs, theslice, :] - timecoursemean
                 ) * appflips_byslice[validlocs, theslice, None] + timecoursemean
-                if args.doaliasedcorrelation and (thispass == numpasses - 1):
+                if args.doaliasedcorrelation and (thispass > 0):
                     for theloc in validlocs:
                         thecorrfunc_byslice[theloc, theslice, :] = theAliasedCorrelator.apply(
                             -appflips_byslice[theloc, theslice]
@@ -1430,14 +1452,14 @@ def happy_main(argparsingfunc):
                         wavedelay_byslice[theloc, theslice] = (
                             thealiasedcorrx[corrstartloc : correndloc + 1]
                         )[maxloc]
-                        waveamp_byslice[theloc, theslice] = thecorrfunc_byslice[
-                            theloc, theslice, maxloc
-                        ]
+                        waveamp_byslice[theloc, theslice] = np.fabs(
+                            thecorrfunc_byslice[theloc, theslice, maxloc]
+                        )
             else:
                 corrected_rawapp_byslice[validlocs, theslice, :] = rawapp_byslice[
                     validlocs, theslice, :
                 ]
-                if args.doaliasedcorrelation and (thispass == numpasses - 1):
+                if args.doaliasedcorrelation and (thispass > 0):
                     for theloc in validlocs:
                         thecorrfunc_byslice[theloc, theslice, :] = theAliasedCorrelator.apply(
                             -demeandata_byslice[theloc, theslice, :],
@@ -1447,9 +1469,9 @@ def happy_main(argparsingfunc):
                         wavedelay_byslice[theloc, theslice] = (
                             thealiasedcorrx[corrstartloc : correndloc + 1]
                         )[maxloc]
-                        waveamp_byslice[theloc, theslice] = thecorrfunc_byslice[
-                            theloc, theslice, maxloc
-                        ]
+                        waveamp_byslice[theloc, theslice] = np.fabs(
+                            thecorrfunc_byslice[theloc, theslice, maxloc]
+                        )
             timecoursemin = np.min(
                 corrected_rawapp_byslice[validlocs, theslice, :], axis=1
             ).reshape((-1, 1))
@@ -1622,8 +1644,18 @@ def happy_main(argparsingfunc):
                 tide_io.savetonifti(veins, theheader, veinmapfilename)
         timings.append(["Masks saved" + passstring, time.time(), None, None])
 
+        # save the mask we used for this pass
+        tide_io.savetonifti(
+            estweights_byslice.reshape((xsize, ysize, numslices)),
+            theheader,
+            f"{outputroot}_desc-estweightspass{thispass}_map",
+        )
+
         # now get ready to start again with a new mask
-        estmask_byslice = vesselmask.reshape((xsize * ysize, numslices)) + 0
+        if args.doaliasedcorrelation and thispass > 0:
+            estweights_byslice = waveamp_byslice * vesselmask.reshape((xsize * ysize, numslices))
+        else:
+            estweights_byslice = vesselmask.reshape((xsize * ysize, numslices)) + 0
 
     # save a vessel image
     if args.unnormvesselmap:

rapidtide/workflows/happy_parser.py

@@ -17,13 +17,14 @@
 #
 #
 import argparse
-import sys
 
 import numpy as np
 
 import rapidtide.io as tide_io
 import rapidtide.workflows.parser_funcs as pf
 
+DEFAULT_ALIASEDCORRELATIONWIDTH = 5.0
+
 
 def _get_parser():
     """
@@ -207,10 +208,10 @@ def _get_parser():
     # Cardiac estimation tuning
     cardiac_est_tuning = parser.add_argument_group("Cardiac estimation tuning")
     cardiac_est_tuning.add_argument(
-        "--estmask",
-        dest="estmaskname",
+        "--estweights",
+        dest="estweightsname",
         action="store",
-        metavar="MASKNAME",
+        metavar="WEIGHTSNAME",
         help=(
             "Generation of cardiac waveform from data will be restricted to "
             "voxels in MASKNAME and weighted by the mask intensity.  If this is "
@@ -292,6 +293,15 @@ def _get_parser():
         ),
         default=False,
     )
+    cardiac_est_tuning.add_argument(
+        "--teoffset",
+        dest="teoffset",
+        action="store",
+        metavar="TE",
+        type=lambda x: pf.is_float(parser, x),
+        help="Specify the echo time in seconds.  This is used when combining multiecho data.  Default is 0. ",
+        default=None,
+    )
 
     # External cardiac waveform options
     external_cardiac_opts = parser.add_argument_group("External cardiac waveform options")
@@ -538,6 +548,15 @@ def _get_parser():
         help="Attempt to calculate absolute delay using an aliased correlation (experimental).",
         default=False,
     )
+    misc_opts.add_argument(
+        "--aliasedcorrelationwidth",
+        dest="aliasedcorrelationwidth",
+        metavar="WIDTH",
+        action="store",
+        type=lambda x: pf.is_float(parser, x),
+        help=f"Width of the aliased correlation calculation (default is {DEFAULT_ALIASEDCORRELATIONWIDTH}). ",
+        default=DEFAULT_ALIASEDCORRELATIONWIDTH,
+    )
     misc_opts.add_argument(
         "--upsample",
         dest="doupsampling",
@@ -666,23 +685,7 @@ def process_args(inputargs=None):
     """
     Compile arguments for rapidtide workflow.
     """
-    if inputargs is None:
-        print("processing command line arguments")
-        # write out the command used
-        try:
-            args = _get_parser().parse_args()
-            argstowrite = sys.argv
-        except SystemExit:
-            _get_parser().print_help()
-            raise
-    else:
-        print("processing passed argument list:")
-        try:
-            args = _get_parser().parse_args(inputargs)
-            argstowrite = inputargs
-        except SystemExit:
-            print("Use --help option for detailed information on options.")
-            raise
+    args, argstowrite = pf.setargs(_get_parser, inputargs=inputargs)
 
     # save the raw and formatted command lines
     args.commandline = " ".join(argstowrite)
@@ -723,7 +726,6 @@ def process_args(inputargs=None):
     args.upsamplefac = 100
     args.centric = True
     args.pulsereconstepsize = 0.01
-    args.aliasedcorrelationwidth = 3.0
     args.unnormvesselmap = True
     args.histlen = 100
     args.softvesselfrac = 0.4

rapidtide/workflows/simdata.py

@@ -308,7 +308,9 @@ def simdata(args):
         _get_parser().print_help()
         sys.exit()
 
-    sliceoffsettimes, normalizedtotr = tide_io.getslicetimesfromfile(args.slicetimefile)
+    sliceoffsettimes, normalizedtotr, fileisjson = tide_io.getslicetimesfromfile(
+        args.slicetimefile
+    )
 
     fmritr, numtrs = tide_io.fmritimeinfo(args.fmrifilename)
     if normalizedtotr: