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

rapidtide/genericmultiproc.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2016-2025 Blaise Frederick
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+import gc
+import logging
+
+import numpy as np
+from tqdm import tqdm
+
+import rapidtide.multiproc as tide_multiproc
+
+
+def run_multiproc(
+    voxelfunc,
+    packfunc,
+    unpackfunc,
+    voxelargs,
+    voxelproducts,
+    inputshape,
+    voxelmask,
+    LGR,
+    nprocs,
+    alwaysmultiproc,
+    showprogressbar,
+    chunksize,
+    indexaxis=0,
+    procunit="voxels",
+    debug=False,
+    **kwargs,
+):
+    if debug:
+        print(f"{len(voxelproducts)=}, {voxelproducts[0].shape}")
+    if nprocs > 1 or alwaysmultiproc:
+        # define the consumer function here so it inherits most of the arguments
+        def theconsumerfunc(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(
+                        voxelfunc(
+                            val,
+                            packfunc(val, voxelargs),
+                            debug=debug,
+                            **kwargs,
+                        )
+                    )
+                except Exception as e:
+                    print("error!", e)
+                    break
+
+        data_out = tide_multiproc.run_multiproc(
+            theconsumerfunc,
+            inputshape,
+            voxelmask,
+            indexaxis=indexaxis,
+            procunit=procunit,
+            verbose=(LGR is not None),
+            nprocs=nprocs,
+            showprogressbar=showprogressbar,
+            chunksize=chunksize,
+        )
+
+        # unpack the data
+        volumetotal = 0
+        for returnvals in data_out:
+            volumetotal += 1
+            unpackfunc(returnvals, voxelproducts)
+        del data_out
+    else:
+        volumetotal = 0
+        for vox in tqdm(
+            range(0, inputshape[indexaxis]),
+            desc="Voxel",
+            unit=procunit,
+            disable=(not showprogressbar),
+        ):
+            if voxelmask[vox] > 0:
+                dothisone = True
+            else:
+                dothisone = False
+            if dothisone:
+                returnvals = voxelfunc(
+                    vox,
+                    packfunc(vox, voxelargs),
+                    debug=debug,
+                    **kwargs,
+                )
+                unpackfunc(returnvals, voxelproducts)
+                volumetotal += 1
+
+    # garbage collect
+    uncollected = gc.collect()
+    if uncollected != 0:
+        if LGR is not None:
+            LGR.info(f"garbage collected - unable to collect {uncollected} objects")
+    else:
+        if LGR is not None:
+            LGR.info("garbage collected")
+
+    return volumetotal

rapidtide/happy_supportfuncs.py

@@ -364,7 +364,16 @@ def getcardcoeffs(
     return peakfreq
 
 
-def normalizevoxels(fmri_data, detrendorder, validvoxels, time, timings, showprogressbar=False):
+def normalizevoxels(
+    fmri_data,
+    detrendorder,
+    validvoxels,
+    time,
+    timings,
+    LGR=None,
+    nprocs=1,
+    showprogressbar=False,
+):
     print("Normalizing voxels...")
     normdata = fmri_data * 0.0
     demeandata = fmri_data * 0.0

rapidtide/io.py

@@ -1426,6 +1426,8 @@ def writebidstsv(
     yaxislabel="arbitrary value",
     starttime=0.0,
     append=False,
+    samplerate_tolerance=1e-6,
+    starttime_tolerance=1e-6,
     colsinjson=True,
     colsintsv=False,
     omitjson=False,
@@ -1498,8 +1500,8 @@ def writebidstsv(
                 )
             compressed = incompressed
             if (
-                (insamplerate == samplerate)
-                and (instarttime == starttime)
+                np.fabs(insamplerate - samplerate) < samplerate_tolerance
+                and np.fabs(instarttime - starttime) < starttime_tolerance
                 and reshapeddata.shape[1] == indata.shape[1]
             ):
                 startcol = len(incolumns)

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/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_externaltools.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2016-2025 Blaise Frederick
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+import os
+
+import matplotlib as mpl
+
+import rapidtide.externaltools as tide_exttools
+from rapidtide.tests.utils import get_examples_path, get_test_temp_path, mse
+
+
+def test_externaltools(debug=False, local=False):
+    # set input and output directories
+    if local:
+        exampleroot = "../data/examples/src"
+        testtemproot = "./tmp"
+    else:
+        exampleroot = get_examples_path()
+        testtemproot = get_test_temp_path()
+
+    thefsldir = tide_exttools.fslinfo()
+    if debug:
+        print(f"{thefsldir=}")
+
+    if not local:
+        os.environ["FSLDIR"] = "/plausible_FSLDIR"
+
+    thefsldir = tide_exttools.fslinfo()
+    if debug:
+        print(f"{thefsldir=}")
+
+    fslexists, c3dexists, antsexists = tide_exttools.whatexists()
+    if debug:
+        print(f"{fslexists=}, {c3dexists=}, {antsexists=}")
+
+    fslsubcmd, flirtcmd, applywarpcmd = tide_exttools.getfslcmds()
+    if debug:
+        print(f"{fslsubcmd=}, {flirtcmd=}, {applywarpcmd=}")
+
+    tide_exttools.runflirt(
+        "inputname", "targetname", "xform", "outputname", warpfile="thewarp", fake=True
+    )
+    tide_exttools.runflirt("inputname", "targetname", "xform", "outputname", fake=True)
+
+    tide_exttools.n4correct("inputname", "outputdir", fake=True)
+
+    tide_exttools.antsapply(
+        "inputname", "targetname", "outputroot", ["transform1", "transform2"], fake=True
+    )
+
+
+if __name__ == "__main__":
+    mpl.use("TkAgg")
+    test_externaltools(debug=True, local=True)

rapidtide/tests/test_fastresampler.py

@@ -45,6 +45,7 @@ def test_FastResampler(debug=False):
     if debug:
         print(f"{genlaggedtc.initstart=}, {genlaggedtc.initend=}, {genlaggedtc.initstep=}")
         print(f"{genlaggedtc.hiresstart=}, {genlaggedtc.hiresend=}, {genlaggedtc.hiresstep=}")
+    genlaggedtc.info()
 
     # save and reload with another name
     resamplername = os.path.join(get_test_temp_path(), "savedresampler")

rapidtide/tests/test_fullrunrapidtide_v2.py

@@ -68,6 +68,7 @@ def test_fullrunrapidtide_v2(debug=False, local=False, displayplots=False):
         "--outputlevel",
         "max",
         "--calccoherence",
+        "--cleanrefined",
         "--dispersioncalc",
         "--nprocs",
         "1",