rapidtide 3.0a11__py3-none-any.whl → 3.0a13__py3-none-any.whl

rapidtide/workflows/happy.py

@@ -30,10 +30,10 @@ from tqdm import tqdm
 import rapidtide.correlate as tide_corr
 import rapidtide.filter as tide_filt
 import rapidtide.fit as tide_fit
-import rapidtide.glmpass as tide_glmpass
 import rapidtide.happy_supportfuncs as happy_support
 import rapidtide.helper_classes as tide_classes
 import rapidtide.io as tide_io
+import rapidtide.linfitfiltpass as tide_linfitfiltpass
 import rapidtide.maskutil as tide_mask
 import rapidtide.miscmath as tide_math
 import rapidtide.resample as tide_resample
@@ -157,8 +157,8 @@ def happy_main(argparsingfunc):
             args.mklthreads = mklmaxthreads
         mkl.set_num_threads(args.mklthreads)
 
-    # if we are going to do a glm, make sure we are generating app matrix
-    if (args.dotemporalglm or args.dospatialglm) and args.cardcalconly:
+    # if we are going to do noise regression, make sure we are generating app matrix
+    if (args.dotemporalregression or args.dospatialregression) and args.cardcalconly:
         print("doing glm fit requires phase projection - setting cardcalconly to False")
         args.cardcalconly = False
 
@@ -244,7 +244,7 @@ def happy_main(argparsingfunc):
             order=args.motfilt_order,
         )
         (motionregressors, motionregressorlabels, filtereddata, confoundr2) = (
-            tide_glmpass.confoundregress(
+            tide_linfitfiltpass.confoundregress(
                 confoundregressors,
                 confoundregressorlabels,
                 fmri_data[validprojvoxels, :],
@@ -438,6 +438,14 @@ def happy_main(argparsingfunc):
                 append=False,
                 debug=args.debug,
             )
+            tide_io.writebidstsv(
+                outputroot + "_desc-sliceresrespfromfmri_timeseries",
+                respfromfmri_sliceres,
+                slicesamplerate,
+                columns=["respfromfmri"],
+                append=False,
+                debug=args.debug,
+            )
 
         # stash away a copy of the waveform if we need it later
         raw_cardfromfmri_sliceres = np.array(cardfromfmri_sliceres)
@@ -471,6 +479,14 @@ def happy_main(argparsingfunc):
                     append=True,
                     debug=args.debug,
                 )
+                tide_io.writebidstsv(
+                    outputroot + "_desc-sliceresrespfromfmri_timeseries",
+                    respfromfmri_sliceres * (1.0 - thebadcardpts),
+                    slicesamplerate,
+                    columns=["respfromfmri_censored"],
+                    append=False,
+                    debug=args.debug,
+                )
         peakfreq_bold = happy_support.getcardcoeffs(
             (1.0 - thebadcardpts) * cardiacwaveform,
             slicesamplerate,
@@ -1370,11 +1386,14 @@ def happy_main(argparsingfunc):
                 )
                 wavedelay = np.zeros((xsize, ysize, numslices), dtype=np.float64)
                 wavedelay_byslice = wavedelay.reshape((xsize * ysize, numslices))
+                wavedelayCOM = np.zeros((xsize, ysize, numslices), dtype=np.float64)
+                wavedelayCOM_byslice = wavedelayCOM.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
+                wavedelayCOM *= 0.0
                 waveamp *= 0.0
 
         # now project the data
@@ -1455,6 +1474,10 @@ def happy_main(argparsingfunc):
                         waveamp_byslice[theloc, theslice] = np.fabs(
                             thecorrfunc_byslice[theloc, theslice, maxloc]
                         )
+                        wavedelayCOM_byslice[theloc, theslice] = happy_support.theCOM(
+                            thealiasedcorrx[corrstartloc : correndloc + 1],
+                            np.fabs(thecorrfunc_byslice[theloc, theslice, :]),
+                        )
             else:
                 corrected_rawapp_byslice[validlocs, theslice, :] = rawapp_byslice[
                     validlocs, theslice, :
@@ -1543,15 +1566,18 @@ def happy_main(argparsingfunc):
             theheader["pixdim"][4] = thealiasedcorrx[1] - thealiasedcorrx[0]
             corrfuncfilename = outputroot + "_desc-corrfunc_info"
             wavedelayfilename = outputroot + "_desc-wavedelay_map"
+            wavedelayCOMfilename = outputroot + "_desc-wavedelayCOM_map"
             waveampfilename = outputroot + "_desc-waveamp_map"
             bidsdict = bidsbasedict.copy()
             tide_io.writedicttojson(bidsdict, waveampfilename + ".json")
             bidsdict["Units"] = "second"
             tide_io.writedicttojson(bidsdict, corrfuncfilename + ".json")
             tide_io.writedicttojson(bidsdict, wavedelayfilename + ".json")
+            tide_io.writedicttojson(bidsdict, wavedelayCOMfilename + ".json")
             tide_io.savetonifti(thecorrfunc, theheader, corrfuncfilename)
             theheader["dim"][4] = 1
             tide_io.savetonifti(wavedelay, theheader, wavedelayfilename)
+            tide_io.savetonifti(wavedelayCOM, theheader, wavedelayCOMfilename)
             tide_io.savetonifti(waveamp, theheader, waveampfilename)
 
         # make and save a voxel intensity histogram
@@ -1678,7 +1704,7 @@ def happy_main(argparsingfunc):
     )
 
     # now generate aliased cardiac signals and regress them out of the data
-    if args.dotemporalglm or args.dospatialglm:
+    if args.dotemporalregression or args.dospatialregression:
         # generate the signals
         timings.append(["Cardiac signal regression started", time.time(), None, None])
         tide_util.logmem("before cardiac regression")
@@ -1721,15 +1747,15 @@ def happy_main(argparsingfunc):
         validlocs = np.where(mask > 0)[0]
         numvalidspatiallocs = len(validlocs)
         threshval = 0.0
-        if args.dospatialglm:
+        if args.dospatialregression:
             meanvals = np.zeros(timepoints, dtype=np.float64)
             rvals = np.zeros(timepoints, dtype=np.float64)
             r2vals = np.zeros(timepoints, dtype=np.float64)
             fitcoffs = np.zeros(timepoints, dtype=np.float64)
             fitNorm = np.zeros(timepoints, dtype=np.float64)
             datatoremove = 0.0 * fmri_data
-            print("Running spatial glm on", timepoints, "timepoints")
-            tide_glmpass.glmpass(
+            print("Running spatial regression on", timepoints, "timepoints")
+            tide_linfitfiltpass.linfitfiltpass(
                 timepoints,
                 fmri_data[validlocs, :],
                 threshval,
@@ -1781,15 +1807,15 @@ def happy_main(argparsingfunc):
                 ]
             )
 
-        if args.dotemporalglm:
+        if args.dotemporalregression:
             meanvals = np.zeros(numspatiallocs, dtype=np.float64)
             rvals = np.zeros(numspatiallocs, dtype=np.float64)
             r2vals = np.zeros(numspatiallocs, dtype=np.float64)
             fitcoffs = np.zeros(numspatiallocs, dtype=np.float64)
             fitNorm = np.zeros(numspatiallocs, dtype=np.float64)
             datatoremove = 0.0 * fmri_data
-            print("Running temporal glm on", numvalidspatiallocs, "voxels")
-            tide_glmpass.glmpass(
+            print("Running temporal regression on", numvalidspatiallocs, "voxels")
+            tide_linfitfiltpass.linfitfiltpass(
                 numvalidspatiallocs,
                 fmri_data[validlocs, :],
                 threshval,

rapidtide/workflows/happy_parser.py

@@ -443,15 +443,15 @@ def _get_parser():
     # Output processing
     output_proc = parser.add_argument_group("Output processing")
     output_proc.add_argument(
-        "--spatialglm",
-        dest="dospatialglm",
+        "--spatialregression",
+        dest="dospatialregression",
         action="store_true",
         help="Generate framewise cardiac signal maps and filter them out of the input data. ",
         default=False,
     )
     output_proc.add_argument(
-        "--temporalglm",
-        dest="dotemporalglm",
+        "--temporalregression",
+        dest="dotemporalregression",
         action="store_true",
         help="Generate voxelwise aliased synthetic cardiac regressors and filter them out of the input data. ",
         default=False,

rapidtide/workflows/{glmfilt.py → linfitfilt.py}

@@ -28,10 +28,10 @@ from rapidtide.workflows.parser_funcs import is_valid_file
 
 def _get_parser():
     """
-    Argument parser for glmfilt
+    Argument parser for linfitfilt
     """
     parser = argparse.ArgumentParser(
-        prog="glmfilt",
+        prog="linfitfilt",
         description="Fits and removes the effect of voxel specific and/or global regressors.",
         allow_abbrev=False,
     )
@@ -76,7 +76,7 @@ def _get_parser():
     return parser
 
 
-def glmfilt(inputfile, numskip, outputroot, evfilename, datamaskname, saveall=True):
+def linfitfilt(inputfile, numskip, outputroot, evfilename, datamaskname, saveall=True):
     # initialize some variables
     evdata = []
     evisnifti = []
@@ -245,7 +245,7 @@ def main():
         _get_parser().print_help()
         raise
 
-    glmfilt(
+    linfitfilt(
         args["inputfile"],
         args["numskip"],
         args["outputroot"],

rapidtide/workflows/parser_funcs.py

@@ -83,7 +83,7 @@ def invert_float(parser, arg):
     return arg
 
 
-def is_float(parser, arg):
+def is_float(parser, arg, minval=None, maxval=None):
     """
     Check if argument is float or auto.
     """
@@ -92,6 +92,10 @@ def is_float(parser, arg):
             arg = float(arg)
         except parser.error:
             parser.error('Value {0} is not a float or "auto"'.format(arg))
+        if minval is not None and arg < minval:
+            parser.error("Value {0} is smaller than {1}".format(arg, minval))
+        if maxval is not None and arg > maxval:
+            parser.error("Value {0} is larger than {1}".format(arg, maxval))
 
     return arg
 
@@ -115,7 +119,7 @@ def is_valid_file_or_float(parser, arg):
     return arg
 
 
-def is_int(parser, arg):
+def is_int(parser, arg, minval=None, maxval=None):
     """
     Check if argument is int or auto.
     """
@@ -124,6 +128,10 @@ def is_int(parser, arg):
             arg = int(arg)
         except parser.error:
             parser.error('Value {0} is not an int or "auto"'.format(arg))
+        if minval is not None and arg < minval:
+            parser.error("Value {0} is smaller than {1}".format(arg, minval))
+        if maxval is not None and arg > maxval:
+            parser.error("Value {0} is larger than {1}".format(arg, maxval))
 
     return arg