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

rapidtide/linfitfiltpass.py

@@ -91,10 +91,12 @@ def linfitfiltpass(
     filtereddata,
     nprocs=1,
     alwaysmultiproc=False,
+    voxelspecific=True,
     confoundregress=False,
+    coefficientsonly=False,
     procbyvoxel=True,
     showprogressbar=True,
-    mp_chunksize=1000,
+    chunksize=1000,
     rt_floatset=np.float64,
     rt_floattype="float64",
     verbose=True,
@@ -141,7 +143,7 @@ def linfitfiltpass(
 
                     # process and send the data
                     if procbyvoxel:
-                        if confoundregress:
+                        if confoundregress or (not voxelspecific):
                             outQ.put(
                                 _procOneRegressionFitItem(
                                     val,
@@ -162,7 +164,7 @@ def linfitfiltpass(
                                 )
                             )
                     else:
-                        if confoundregress:
+                        if confoundregress or (not voxelspecific):
                             outQ.put(
                                 _procOneRegressionFitItem(
                                     val,
@@ -196,7 +198,7 @@ def linfitfiltpass(
             indexaxis=indexaxis,
             procunit=procunit,
             showprogressbar=showprogressbar,
-            chunksize=mp_chunksize,
+            chunksize=chunksize,
         )
 
         # unpack the data
@@ -207,6 +209,18 @@ def linfitfiltpass(
                     r2value[voxel[0]] = voxel[3]
                     filtereddata[voxel[0], :] = voxel[7]
                     itemstotal += 1
+            elif coefficientsonly:
+                for voxel in data_out:
+                    meanvalue[voxel[0]] = voxel[1]
+                    rvalue[voxel[0]] = voxel[2]
+                    r2value[voxel[0]] = voxel[3]
+                    if theevs.ndim > 1:
+                        fitcoeff[voxel[0], :] = voxel[4]
+                        fitNorm[voxel[0], :] = voxel[5]
+                    else:
+                        fitcoeff[voxel[0]] = voxel[4]
+                        fitNorm[voxel[0]] = voxel[5]
+                    itemstotal += 1
             else:
                 for voxel in data_out:
                     meanvalue[voxel[0]] = voxel[1]
@@ -227,6 +241,18 @@ def linfitfiltpass(
                     r2value[timepoint[0]] = timepoint[3]
                     filtereddata[:, timepoint[0]] = timepoint[7]
                     itemstotal += 1
+            elif coefficientsonly:
+                for timepoint in data_out:
+                    meanvalue[timepoint[0]] = timepoint[1]
+                    rvalue[timepoint[0]] = timepoint[2]
+                    r2value[timepoint[0]] = timepoint[3]
+                    if theevs.ndim > 1:
+                        fitcoeff[:, timepoint[0]] = timepoint[4]
+                        fitNorm[:, timepoint[0]] = timepoint[5]
+                    else:
+                        fitcoeff[timepoint[0]] = timepoint[4]
+                        fitNorm[timepoint[0]] = timepoint[5]
+                    itemstotal += 1
             else:
                 for timepoint in data_out:
                     meanvalue[timepoint[0]] = timepoint[1]
@@ -271,6 +297,41 @@ def linfitfiltpass(
                             rt_floatset=rt_floatset,
                             rt_floattype=rt_floattype,
                         )
+                    elif coefficientsonly:
+                        if voxelspecific:
+                            (
+                                dummy,
+                                meanvalue[vox],
+                                rvalue[vox],
+                                r2value[vox],
+                                fitcoeff[vox],
+                                fitNorm[vox],
+                                dummy,
+                                dummy,
+                            ) = _procOneRegressionFitItem(
+                                vox,
+                                theevs[vox, :],
+                                thedata,
+                                rt_floatset=rt_floatset,
+                                rt_floattype=rt_floattype,
+                            )
+                        else:
+                            (
+                                dummy,
+                                meanvalue[vox],
+                                rvalue[vox],
+                                r2value[vox],
+                                fitcoeff[vox],
+                                fitNorm[vox],
+                                dummy,
+                                dummy,
+                            ) = _procOneRegressionFitItem(
+                                vox,
+                                theevs,
+                                thedata,
+                                rt_floatset=rt_floatset,
+                                rt_floattype=rt_floattype,
+                            )
                     else:
                         (
                             dummy,
@@ -315,6 +376,23 @@ def linfitfiltpass(
                             rt_floatset=rt_floatset,
                             rt_floattype=rt_floattype,
                         )
+                    elif coefficientsonly:
+                        (
+                            dummy,
+                            meanvalue[timepoint],
+                            rvalue[timepoint],
+                            r2value[timepoint],
+                            fitcoeff[timepoint],
+                            fitNorm[timepoint],
+                            dummy,
+                            dummy,
+                        ) = _procOneRegressionFitItem(
+                            timepoint,
+                            theevs[:, timepoint],
+                            thedata,
+                            rt_floatset=rt_floatset,
+                            rt_floattype=rt_floattype,
+                        )
                     else:
                         (
                             dummy,

rapidtide/makelaggedtcs.py

@@ -71,7 +71,14 @@ def makelaggedtcs(
     chunksize=1000,
     rt_floatset=np.float64,
     rt_floattype="float64",
+    debug=False,
 ):
+    if debug:
+        print("makelaggedtcs: Starting")
+        print(f"\t{lagtc.shape=}")
+        print(f"\t{lagtimes.shape=}")
+        print(f"\t{timeaxis.shape=}")
+
     inputshape = lagtc.shape
     voxelargs = [
         lagtcgenerator,
@@ -110,4 +117,7 @@ def makelaggedtcs(
         if LGR is not None:
             LGR.info("garbage collected")
 
+    if debug:
+        print("makelaggedtcs: End\n\n")
+
     return volumetotal

rapidtide/refinedelay.py

@@ -282,18 +282,6 @@ def ratiotodelay(theratio, offset=0.0, debug=False):
             closestindex = offsetindex
     closestoffset = funcoffsets[closestindex]
     distance = np.fabs(funcoffsets[closestindex] - offset)
-    """if (maplimits[0] < theratio < maplimits[1]) and (
-        distance < (funcoffsets[1] - funcoffsets[0]) / 2
-    ):
-        return (
-            ratiotooffsetfunc[closestindex](theratio) + (offset - closestoffset),
-            closestoffset,
-        )
-    else:
-        return (
-            0.0,
-            closestoffset,
-        )"""
 
     if theratio < maplimits[0]:
         return (
@@ -302,7 +290,7 @@ def ratiotodelay(theratio, offset=0.0, debug=False):
         )
     elif theratio > maplimits[1]:
         return (
-            ratiotooffsetfunc[closestindex](maplimits[1]),
+            ratiotooffsetfunc[closestindex](maplimits[1]) - (offset - closestoffset),
             closestoffset,
         )
     else:
@@ -371,12 +359,12 @@ def getderivratios(
     if endtr is None:
         endtr = fmri_data_valid.shape[1]
     if debug:
-        print("getderivratios")
-        print(f"{fitNorm.shape=}")
-        print(f"{fitcoeff.shape=}")
-        print(f"{regressderivs=}")
-        print(f"{starttr=}")
-        print(f"{endtr=}")
+        print("getderivratios: Starting")
+        print(f"\t{fitNorm.shape=}")
+        print(f"\t{fitcoeff.shape=}")
+        print(f"\t{regressderivs=}")
+        print(f"\t{starttr=}")
+        print(f"\t{endtr=}")
 
     voxelsprocessed_regressionfilt, regressorset, evset = tide_regressfrommaps.regressfrommaps(
         fmri_data_valid[:, starttr:endtr],
@@ -403,9 +391,10 @@ def getderivratios(
         nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
         nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
         regressderivs=regressderivs,
-        mp_chunksize=optiondict["mp_chunksize"],
+        chunksize=optiondict["mp_chunksize"],
         showprogressbar=optiondict["showprogressbar"],
         alwaysmultiproc=optiondict["alwaysmultiproc"],
+        coefficientsonly=True,
         debug=debug,
     )
 
@@ -418,6 +407,8 @@ def getderivratios(
         for i in range(regressderivs):
             regressderivratios[i, :] = np.nan_to_num(fitcoeff[:, i + 1] / fitcoeff[:, 0])
 
+    if debug:
+        print("getderivratios: End\n\n")
     return regressderivratios, rvalue
 
 

rapidtide/refineregressor.py

@@ -590,7 +590,7 @@ def dorefine(
                 sys.exit()
         LGR.info(
             f"Using {len(thefit.components_)} component(s), accounting for "
-            + f"{100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]}% of the variance"
+            + f"{100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]:.2f}% of the variance"
         )
         reduceddata = thefit.inverse_transform(thefit.transform(refinevoxels))
         if debug:

rapidtide/resample.py

@@ -597,7 +597,7 @@ def arbresample(
         return resampled
 
 
-def upsample(inputdata, Fs_init, Fs_higher, method="univariate", intfac=False, debug=False):
+def upsample(inputdata, Fs_init, Fs_higher, method="univariate", intfac=False, dofilt=True, debug=False):
     starttime = time.time()
     if Fs_higher <= Fs_init:
         print("upsample: target frequency must be higher than initial frequency")
@@ -607,19 +607,19 @@ def upsample(inputdata, Fs_init, Fs_higher, method="univariate", intfac=False, d
     orig_x = np.linspace(0.0, (1.0 / Fs_init) * len(inputdata), num=len(inputdata), endpoint=False)
     endpoint = orig_x[-1] - orig_x[0]
     ts_higher = 1.0 / Fs_higher
-    numresamppts = int(endpoint // ts_higher + 1)
     if intfac:
         numresamppts = int(Fs_higher // Fs_init) * len(inputdata)
     else:
         numresamppts = int(endpoint // ts_higher + 1)
     upsampled_x = np.arange(0.0, ts_higher * numresamppts, ts_higher)
     upsampled_y = doresample(orig_x, inputdata, upsampled_x, method=method)
-    initfilter = tide_filt.NoncausalFilter(
-        filtertype="arb", transferfunc="trapezoidal", debug=debug
-    )
-    stopfreq = np.min([1.1 * Fs_init / 2.0, Fs_higher / 2.0])
-    initfilter.setfreqs(0.0, 0.0, Fs_init / 2.0, stopfreq)
-    upsampled_y = initfilter.apply(Fs_higher, upsampled_y)
+    if dofilt:
+        initfilter = tide_filt.NoncausalFilter(
+            filtertype="arb", transferfunc="trapezoidal", debug=debug
+        )
+        stopfreq = np.min([1.1 * Fs_init / 2.0, Fs_higher / 2.0])
+        initfilter.setfreqs(0.0, 0.0, Fs_init / 2.0, stopfreq)
+        upsampled_y = initfilter.apply(Fs_higher, upsampled_y)
     if debug:
         print("upsampling took", time.time() - starttime, "seconds")
     return upsampled_y