rapidtide 3.0.5__py3-none-any.whl → 3.0.7__py3-none-any.whl

rapidtide/linfitfiltpass.py

@@ -106,6 +106,12 @@ def linfitfiltpass(
         print(f"{fmri_data.shape=}")
         print(f"{threshval=}")
         print(f"{theevs.shape=}")
+    if procbyvoxel:
+        indexaxis = 0
+        procunit = "voxels"
+    else:
+        indexaxis = 1
+        procunit = "timepoints"
     if threshval is None:
         themask = None
     else:
@@ -187,7 +193,8 @@ def linfitfiltpass(
             themask,
             verbose=verbose,
             nprocs=nprocs,
-            procbyvoxel=procbyvoxel,
+            indexaxis=indexaxis,
+            procunit=procunit,
             showprogressbar=showprogressbar,
             chunksize=mp_chunksize,
         )

rapidtide/makelaggedtcs.py

@@ -17,32 +17,47 @@
 #
 #
 import gc
-import logging
 
 import numpy as np
-from tqdm import tqdm
 
-import rapidtide.multiproc as tide_multiproc
+import rapidtide.genericmultiproc as tide_genericmultiproc
 
 
 def _procOneVoxelMakelagtc(
     vox,
-    lagtcgenerator,
-    maxlag,
-    timeaxis,
-    rt_floatset=np.float64,
-    rt_floattype="float64",
+    voxelargs,
+    **kwargs,
 ):
+    # unpack arguments
+    options = {
+        "rt_floatset": np.float64,
+        "debug": False,
+    }
+    options.update(kwargs)
+    rt_floatset = options["rt_floatset"]
+    debug = options["debug"]
+    (lagtcgenerator, thelag, timeaxis) = voxelargs
+    if debug:
+        print(f"{vox=}, {thelag=}, {timeaxis=}")
+
     # question - should maxlag be added or subtracted?  As of 10/18, it is subtracted
     #  potential answer - tried adding, results are terrible.
-    thelagtc = rt_floatset(lagtcgenerator.yfromx(timeaxis - maxlag))
+    thelagtc = rt_floatset(lagtcgenerator.yfromx(timeaxis - thelag))
 
     return (
         vox,
-        thelagtc,
+        (thelagtc),
     )
 
 
+def _packvoxeldata(voxnum, voxelargs):
+    return [voxelargs[0], (voxelargs[1])[voxnum], voxelargs[2]]
+
+
+def _unpackvoxeldata(retvals, voxelproducts):
+    (voxelproducts[0])[retvals[0], :] = retvals[1]
+
+
 def makelaggedtcs(
     lagtcgenerator,
     timeaxis,
@@ -58,75 +73,31 @@ def makelaggedtcs(
     rt_floattype="float64",
 ):
     inputshape = lagtc.shape
-    if nprocs > 1 or alwaysmultiproc:
-        # define the consumer function here so it inherits most of the arguments
-        def makelagtc_consumer(inQ, outQ):
-            while True:
-                try:
-                    # get a new message
-                    val = inQ.get()
-
-                    # this is the 'TERM' signal
-                    if val is None:
-                        break
-
-                    # process and send the data
-                    outQ.put(
-                        _procOneVoxelMakelagtc(
-                            val,
-                            lagtcgenerator,
-                            lagtimes[val],
-                            timeaxis,
-                            rt_floatset=rt_floatset,
-                            rt_floattype=rt_floattype,
-                        )
-                    )
-                except Exception as e:
-                    print("error!", e)
-                    break
-
-        data_out = tide_multiproc.run_multiproc(
-            makelagtc_consumer,
-            inputshape,
-            lagmask,
-            verbose=(LGR is not None),
-            nprocs=nprocs,
-            showprogressbar=showprogressbar,
-            chunksize=chunksize,
-        )
-
-        # unpack the data
-        volumetotal = 0
-        for voxel in data_out:
-            volumetotal += 1
-            lagtc[voxel[0], :] = voxel[1]
-        del data_out
-    else:
-        volumetotal = 0
-        for vox in tqdm(
-            range(0, inputshape[0]),
-            desc="Voxel",
-            unit="voxels",
-            disable=(not showprogressbar),
-        ):
-            if lagmask[vox] > 0:
-                dothisone = True
-            else:
-                dothisone = False
-            if dothisone:
-                (
-                    dummy,
-                    lagtc[vox, :],
-                ) = _procOneVoxelMakelagtc(
-                    vox,
-                    lagtcgenerator,
-                    lagtimes[vox],
-                    timeaxis,
-                    rt_floatset=rt_floatset,
-                    rt_floattype=rt_floattype,
-                )
-                volumetotal += 1
+    voxelargs = [
+        lagtcgenerator,
+        lagtimes,
+        timeaxis,
+    ]
+    voxelfunc = _procOneVoxelMakelagtc
+    packfunc = _packvoxeldata
+    unpackfunc = _unpackvoxeldata
+    voxeltargets = [lagtc]
 
+    volumetotal = tide_genericmultiproc.run_multiproc(
+        voxelfunc,
+        packfunc,
+        unpackfunc,
+        voxelargs,
+        voxeltargets,
+        inputshape,
+        lagmask,
+        LGR,
+        nprocs,
+        alwaysmultiproc,
+        showprogressbar,
+        chunksize,
+        rt_floatset=rt_floatset,
+    )
     if LGR is not None:
         LGR.info(f"\nLagged timecourses created for {volumetotal} voxels")
 

rapidtide/multiproc.py

@@ -36,7 +36,7 @@ def maxcpus(reservecpu=True):
         return mp.cpu_count()
 
 
-def _process_data(data_in, inQ, outQ, showprogressbar=True, reportstep=1000, chunksize=10000):
+def _process_data(data_in, inQ, outQ, showprogressbar=True, chunksize=10000):
     # send pos/data to workers
     data_out = []
     totalnum = len(data_in)
@@ -89,7 +89,8 @@ def run_multiproc(
     maskarray,
     nprocs=1,
     verbose=True,
-    procbyvoxel=True,
+    indexaxis=0,
+    procunit="voxels",
     showprogressbar=True,
     chunksize=1000,
 ):
@@ -113,13 +114,6 @@ def run_multiproc(
     for i, w in enumerate(workers):
         w.start()
 
-    if procbyvoxel:
-        indexaxis = 0
-        procunit = "voxels"
-    else:
-        indexaxis = 1
-        procunit = "timepoints"
-
     # check that the mask array matches the index dimension
     if maskarray is not None:
         if inputshape[indexaxis] != len(maskarray):
@@ -159,7 +153,8 @@ def run_multithread(
     maskarray,
     verbose=True,
     nprocs=1,
-    procbyvoxel=True,
+    indexaxis=0,
+    procunit="voxels",
     showprogressbar=True,
     chunksize=1000,
 ):
@@ -171,13 +166,6 @@ def run_multithread(
     for i, w in enumerate(workers):
         w.start()
 
-    if procbyvoxel:
-        indexaxis = 0
-        procunit = "voxels"
-    else:
-        indexaxis = 1
-        procunit = "timepoints"
-
     # check that the mask array matches the index dimension
     if maskarray is not None:
         if inputshape[indexaxis] != len(maskarray):

rapidtide/refineregressor.py

@@ -23,12 +23,11 @@ import sys
 import numpy as np
 from scipy.stats import pearsonr
 from sklearn.decomposition import PCA, FastICA
-from tqdm import tqdm
 
 import rapidtide.fit as tide_fit
+import rapidtide.genericmultiproc as tide_genericmultiproc
 import rapidtide.io as tide_io
 import rapidtide.miscmath as tide_math
-import rapidtide.multiproc as tide_multiproc
 import rapidtide.resample as tide_resample
 import rapidtide.stats as tide_stats
 
@@ -37,15 +36,26 @@ LGR = logging.getLogger("GENERAL")
 
 def _procOneVoxelTimeShift(
     vox,
-    fmritc,
-    lagtime,
-    padtrs,
-    fmritr,
-    detrendorder=1,
-    offsettime=0.0,
-    rt_floatset=np.float64,
-    rt_floattype="float64",
+    voxelargs,
+    **kwargs,
 ):
+    options = {
+        "detrendorder": 1,
+        "offsettime": 0.0,
+        "debug": False,
+    }
+    options.update(kwargs)
+    detrendorder = options["detrendorder"]
+    offsettime = options["offsettime"]
+    debug = options["debug"]
+    if debug:
+        print(f"{detrendorder=} {offsettime=}")
+    (
+        fmritc,
+        lagtime,
+        padtrs,
+        fmritr,
+    ) = voxelargs
     if detrendorder > 0:
         normtc = tide_fit.detrend(fmritc, order=detrendorder, demean=True)
     else:
@@ -57,6 +67,17 @@ def _procOneVoxelTimeShift(
     return vox, shiftedtc, weights, paddedshiftedtc, paddedweights
 
 
+def _packvoxeldata(voxnum, voxelargs):
+    return [(voxelargs[0])[voxnum, :], (voxelargs[1])[voxnum], voxelargs[2], voxelargs[3]]
+
+
+def _unpackvoxeldata(retvals, voxelproducts):
+    (voxelproducts[0])[retvals[0], :] = retvals[1]
+    (voxelproducts[1])[retvals[0], :] = retvals[2]
+    (voxelproducts[2])[retvals[0], :] = retvals[3]
+    (voxelproducts[3])[retvals[0], :] = retvals[4]
+
+
 def alignvoxels(
     fmridata,
     fmritr,
@@ -150,83 +171,40 @@ def alignvoxels(
         Mask of voxels used for refinement
     """
     inputshape = np.shape(fmridata)
-    volumetotal = np.sum(lagmask)
+    voxelargs = [fmridata, lagtimes, padtrs, fmritr]
+    voxelfunc = _procOneVoxelTimeShift
+    packfunc = _packvoxeldata
+    unpackfunc = _unpackvoxeldata
+    voxeltargets = [
+        shiftedtcs,
+        weights,
+        paddedshiftedtcs,
+        paddedweights,
+    ]
     if debug:
         print("alignvoxels: {inputshape}")
         print("volumetotal: {volumetotal}")
 
     # timeshift the valid voxels
-    if nprocs > 1 or alwaysmultiproc:
-        # define the consumer function here so it inherits most of the arguments
-        def timeshift_consumer(inQ, outQ):
-            while True:
-                try:
-                    # get a new message
-                    val = inQ.get()
-
-                    # this is the 'TERM' signal
-                    if val is None:
-                        break
-
-                    # process and send the data
-                    outQ.put(
-                        _procOneVoxelTimeShift(
-                            val,
-                            fmridata[val, :],
-                            lagtimes[val],
-                            padtrs,
-                            fmritr,
-                            detrendorder=detrendorder,
-                            offsettime=offsettime,
-                            rt_floatset=rt_floatset,
-                            rt_floattype=rt_floattype,
-                        )
-                    )
-
-                except Exception as e:
-                    print("error!", e)
-                    break
-
-        data_out = tide_multiproc.run_multiproc(
-            timeshift_consumer,
-            inputshape,
-            lagmask,
-            nprocs=nprocs,
-            showprogressbar=showprogressbar,
-            chunksize=chunksize,
-        )
-
-        # unpack the data
-        for voxel in data_out:
-            shiftedtcs[voxel[0], :] = voxel[1]
-            weights[voxel[0], :] = voxel[2]
-            paddedshiftedtcs[voxel[0], :] = voxel[3]
-            paddedweights[voxel[0], :] = voxel[4]
-        del data_out
+    # NOTE need to figure out how to use kwargs to pass extra arguments
+    volumetotal = tide_genericmultiproc.run_multiproc(
+        voxelfunc,
+        packfunc,
+        unpackfunc,
+        voxelargs,
+        voxeltargets,
+        inputshape,
+        lagmask,
+        LGR,
+        nprocs,
+        alwaysmultiproc,
+        showprogressbar,
+        chunksize,
+        detrendorder=detrendorder,
+        offsettime=offsettime,
+        debug=debug,
+    )
 
-    else:
-        for vox in tqdm(
-            range(0, inputshape[0]),
-            desc="Voxel timeshifts",
-            unit="voxels",
-            disable=(not showprogressbar),
-        ):
-            if lagmask[vox] > 0.5:
-                retvals = _procOneVoxelTimeShift(
-                    vox,
-                    fmridata[vox, :],
-                    lagtimes[vox],
-                    padtrs,
-                    fmritr,
-                    detrendorder=detrendorder,
-                    offsettime=offsettime,
-                    rt_floatset=rt_floatset,
-                    rt_floattype=rt_floattype,
-                )
-                shiftedtcs[retvals[0], :] = retvals[1]
-                weights[retvals[0], :] = retvals[2]
-                paddedshiftedtcs[retvals[0], :] = retvals[3]
-                paddedweights[retvals[0], :] = retvals[4]
     LGR.info(
         "Timeshift applied to " + str(int(volumetotal)) + " voxels",
     )

rapidtide/resample.py

@@ -124,7 +124,17 @@ congridyvals["kernel"] = "kaiser"
 congridyvals["width"] = 3.0
 
 
-def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
+def congrid(
+    xaxis,
+    loc,
+    val,
+    width,
+    kernel="kaiser",
+    cache=True,
+    cyclic=True,
+    debug=False,
+    onlykeynotices=True,
+):
     """
     Perform a convolution gridding operation with a Kaiser-Bessel or Gaussian kernel of width 'width'.  Grid
     parameters are cached for performance.
@@ -164,10 +174,10 @@ def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
 
     if (congridyvals["kernel"] != kernel) or (congridyvals["width"] != width):
         if congridyvals["kernel"] != kernel:
-            if debug:
+            if debug and not onlykeynotices:
                 print(congridyvals["kernel"], "!=", kernel)
         if congridyvals["width"] != width:
-            if debug:
+            if debug and not onlykeynotices:
                 print(congridyvals["width"], "!=", width)
         if debug:
             print("(re)initializing congridyvals")
@@ -191,7 +201,7 @@ def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
 
     # find the closest grid point to the target location, calculate relative offsets from this point
     center = tide_util.valtoindex(xaxis, loc)
-    offset = np.fmod(np.round((loc - xaxis[center]) / xstep, 3), 1.0)  # will vary from -0.5 to 0.5
+    offset = np.fmod(np.round((loc - xaxis[center]) / xstep, 4), 1.0)  # will vary from -0.5 to 0.5
     if cyclic:
         if center == len(xaxis) - 1 and offset > 0.5:
             center = 0
@@ -224,12 +234,13 @@ def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
                 )
                 + offset
             )
-            congridyvals[offsetkey] = tide_fit.gauss_eval(xvals, np.array([1.0, 0.0, width]))
-            yvals = congridyvals[offsetkey]
+            yvals = tide_fit.gauss_eval(xvals, np.array([1.0, 0.0, width]))
+            if cache:
+                congridyvals[offsetkey] = 1.0 * yvals
         startpt = int(center - widthinpts // 2)
         indices = range(startpt, startpt + widthinpts)
         indices = np.remainder(indices, len(xaxis))
-        if debug:
+        if debug and not onlykeynotices:
             print("center, offset, indices, yvals", center, offset, indices, yvals)
         return val * yvals, yvals, indices
     else:
@@ -245,19 +256,18 @@ def congrid(xaxis, loc, val, width, kernel="kaiser", cyclic=True, debug=False):
             xvals = indices - center + offset
             if kernel == "gauss":
                 sigma = optsigma[kernelindex]
-                congridyvals[offsetkey] = tide_fit.gauss_eval(xvals, np.array([1.0, 0.0, sigma]))
+                yvals = tide_fit.gauss_eval(xvals, np.array([1.0, 0.0, sigma]))
             elif kernel == "kaiser":
                 beta = optbeta[kernelindex]
-                congridyvals[offsetkey] = tide_fit.kaiserbessel_eval(
-                    xvals, np.array([beta, width / 2.0])
-                )
+                yvals = tide_fit.kaiserbessel_eval(xvals, np.array([beta, width / 2.0]))
             else:
                 print("illegal kernel value in congrid - exiting")
                 sys.exit()
-            yvals = congridyvals[offsetkey]
-            if debug:
+            if cache:
+                congridyvals[offsetkey] = 1.0 * yvals
+            if debug and not onlykeynotices:
                 print("xvals, yvals", xvals, yvals)
-        if debug:
+        if debug and not onlykeynotices:
             print("center, offset, indices, yvals", center, offset, indices, yvals)
         return val * yvals, yvals, indices
 

rapidtide/tests/.coveragerc

@@ -11,13 +11,22 @@ omit =
     ../OrthoImageItem.py
     ../wiener2.py
     ../tidepoolTemplate.py
+    ../tidepoolTemplate_qt6.py
     ../tidepoolTemplate_alt.py
+    ../tidepoolTemplate_alt_qt6.py
+    ../tidepoolTemplate_big.py
+    ../tidepoolTemplate_big_qt6.py
+    ../notreadyforprimetime/*
 
 [report]
 exclude_lines = 
     # Don't complain if non-runnable code isn't run:
     if displayplots:
+    if doplot:
     if args.displayplots:
     if debug:
+    if self.debug:
     if False:
     if __name__ == .__main__.:
+    except np.lib.RankWarning:
+    except IndexError:

rapidtide/tests/test_congrid.py

@@ -21,6 +21,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 from rapidtide.resample import congrid
+from rapidtide.happy_supportfuncs import preloadcongrid
 from rapidtide.tests.utils import mse
 
 
@@ -74,86 +75,74 @@ def test_congrid(debug=False, displayplots=False):
         weights = np.zeros((gridlen), dtype=float)
         griddeddata = np.zeros((gridlen), dtype=float)
 
-        for gridkernel in kernellist:
-            for congridbins in binslist:
-                print("about to grid")
-
-                # reinitialize grid outputs
-                weights *= 0.0
-                griddeddata *= 0.0
-
-                for i in range(numsamples):
-                    thevals, theweights, theindices = congrid(
-                        gridaxis,
-                        testvals[i],
-                        funcvalue2(testvals[i], frequency=cycles),
-                        congridbins,
-                        kernel=gridkernel,
-                        debug=False,
-                    )
-                    for i in range(len(theindices)):
-                        weights[theindices[i]] += theweights[i]
-                        griddeddata[theindices[i]] += thevals[i]
-
-                griddeddata = np.where(weights > 0.0, griddeddata / weights, 0.0)
-
-                target = np.float64(gridaxis * 0.0)
-                for i in range(len(gridaxis)):
-                    target[i] = funcvalue2(gridaxis[i], frequency=cycles)
-
-                print("gridding done")
-                print("debug:", debug)
-
-                # plot if we are doing that
-                if displayplots:
-                    offset = 0.0
-                    legend = []
-                    plt.plot(sourceaxis, timecoursein)
-                    legend.append("Original")
-                    # offset += 1.0
-                    plt.plot(gridaxis, target + offset)
-                    legend.append("Target")
-                    # offset += 1.0
-                    plt.plot(gridaxis, griddeddata + offset)
-                    legend.append("Gridded")
-                    plt.plot(gridaxis, weights)
-                    legend.append("Weights")
-                    plt.legend(legend)
-                    plt.show()
-
-                # do the tests
-                msethresh = 6.0e-2
-                themse = mse(target, griddeddata)
-                if debug:
-                    if themse >= msethresh:
-                        extra = "FAIL"
-                    else:
-                        extra = ""
-                    print(
-                        "mse for",
-                        cycles,
-                        "cycles:",
-                        gridkernel,
-                        str(congridbins),
-                        ":",
-                        themse,
-                        extra,
-                    )
-                    outputlines.append(
-                        " ".join(
-                            [
-                                "mse for",
-                                str(cycles),
-                                "cycles:",
-                                gridkernel,
-                                str(congridbins),
-                                ":",
-                                str(themse),
-                            ]
+        for prefill in [True, False]:
+            for gridkernel in kernellist:
+                for congridbins in binslist:
+                    print("about to grid")
+
+                    # reinitialize grid outputs
+                    weights *= 0.0
+                    griddeddata *= 0.0
+
+                    if prefill:
+                        preloadcongrid(
+                            gridaxis, congridbins, gridkernel=gridkernel, cyclic=True, debug=False
+                        )
+                    for i in range(numsamples):
+                        thevals, theweights, theindices = congrid(
+                            gridaxis,
+                            testvals[i],
+                            funcvalue2(testvals[i], frequency=cycles),
+                            congridbins,
+                            kernel=gridkernel,
+                            debug=False,
+                        )
+                        for i in range(len(theindices)):
+                            weights[theindices[i]] += theweights[i]
+                            griddeddata[theindices[i]] += thevals[i]
+
+                    griddeddata = np.where(weights > 0.0, griddeddata / weights, 0.0)
+
+                    target = np.float64(gridaxis * 0.0)
+                    for i in range(len(gridaxis)):
+                        target[i] = funcvalue2(gridaxis[i], frequency=cycles)
+
+                    print("gridding done")
+                    print("debug:", debug)
+
+                    # plot if we are doing that
+                    if displayplots:
+                        offset = 0.0
+                        legend = []
+                        plt.plot(sourceaxis, timecoursein)
+                        legend.append("Original")
+                        # offset += 1.0
+                        plt.plot(gridaxis, target + offset)
+                        legend.append("Target")
+                        # offset += 1.0
+                        plt.plot(gridaxis, griddeddata + offset)
+                        legend.append("Gridded")
+                        plt.plot(gridaxis, weights)
+                        legend.append("Weights")
+                        plt.legend(legend)
+                        plt.show()
+
+                    # do the tests
+                    msethresh = 6.0e-2
+                    themse = mse(target, griddeddata)
+                    if debug:
+                        if themse >= msethresh:
+                            extra = "FAIL"
+                        else:
+                            extra = ""
+                        print(
+                            f"mse for {cycles} cycles: {prefill=}, {gridkernel} {congridbins}: {themse} {extra}"
+                        )
+                        outputlines.append(
+                            f"mse for {cycles} cycles: {prefill=}, {gridkernel} {congridbins}: {themse}"
                         )
-                    )
-                if not debug:
-                    assert themse < msethresh
+                    if not debug:
+                        assert themse < msethresh
     if debug:
         for theline in outputlines:
             print(theline)