rapidtide 2.9.6__py3-none-any.whl → 3.1.3__py3-none-any.whl

rapidtide/tests/test_padvec.py

@@ -0,0 +1,216 @@
+#!/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 matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+import scipy as sp
+
+from rapidtide.filter import NoncausalFilter
+
+
+def maketestwaves(timeaxis):
+    # construct some test waveforms for end effects
+    tclen = len(timeaxis)
+    testwaves = []
+    testwaves.append(
+        {
+            "name": "constant high",
+            "timeaxis": 1.0 * timeaxis,
+            "waveform": np.ones((tclen), dtype="float"),
+        }
+    )
+    testwaves.append(
+        {
+            "name": "white noise",
+            "timeaxis": 1.0 * timeaxis,
+            "waveform": 0.3 * np.random.normal(size=tclen),
+        }
+    )
+
+    scratch = np.zeros_like(timeaxis)
+    scratch[int(tclen / 5) : int(2 * tclen / 5)] = 1.0
+    scratch[int(3 * tclen / 5) : int(4 * tclen / 5)] = 1.0
+    testwaves.append(
+        {
+            "name": "block regressor",
+            "timeaxis": 1.0 * timeaxis,
+            "waveform": 1.0 * scratch,
+        }
+    )
+
+    scratch = np.zeros_like(timeaxis)
+    scratch[int(tclen / 2) :] = 1.0
+    testwaves.append(
+        {
+            "name": "step regressor",
+            "timeaxis": 1.0 * timeaxis,
+            "waveform": 1.0 * scratch,
+        }
+    )
+
+    scratch = np.exp(-timeaxis / timeaxis[2])
+    testwaves.append(
+        {
+            "name": "damped exponential regressor",
+            "timeaxis": 1.0 * timeaxis,
+            "waveform": 1.0 * scratch,
+        }
+    )
+
+    testwaves.append(
+        {
+            "name": "white noise plus exponential",
+            "timeaxis": 1.0 * timeaxis,
+            "waveform": 0.3 * np.random.normal(size=tclen) + scratch,
+        }
+    )
+    return testwaves
+
+
+def eval_padvecprops(
+    sampletime=0.72, tclengthinsecs=300.0, numruns=100, displayplots=False, debug=False
+):
+    np.random.seed(12345)
+    tclen = int(tclengthinsecs // sampletime)
+    print("Testing transfer function:")
+    lowestfreq = 1.0 / (sampletime * tclen)
+    nyquist = 0.5 / sampletime
+    print(
+        "    sampletime=",
+        sampletime,
+        ", timecourse length=",
+        tclengthinsecs,
+        "s,  possible frequency range:",
+        lowestfreq,
+        nyquist,
+    )
+    timeaxis = np.linspace(0.0, sampletime * tclen, num=tclen, endpoint=False)
+
+    overall = np.random.normal(size=tclen)
+    nperseg = np.min([tclen, 2048])
+    f, dummy = sp.signal.welch(overall, fs=1.0 / sampletime, nperseg=nperseg)
+
+    padtypelist = ["reflect", "zero", "cyclic", "constant", "constant+"]
+    transferfunclist = ["brickwall", "trapezoidal", "butterworth"]
+
+    # construct some test waveforms for end effects
+    testwaves = maketestwaves(timeaxis)
+
+    for padtype in padtypelist:
+        allfilters = []
+        # construct all the physiological filters
+        for filtertype in ["None", "lfo", "resp", "cardiac", "hrv_lf", "hrv_hf", "hrv_vhf"]:
+            testfilter = NoncausalFilter(filtertype=filtertype, padtype=padtype)
+            lstest, lptest, uptest, ustest = testfilter.getfreqs()
+            if lptest < nyquist:
+                for transferfunc in transferfunclist:
+                    allfilters.append(
+                        {
+                            "name": filtertype + " " + transferfunc + " " + padtype,
+                            "filter": NoncausalFilter(
+                                filtertype=filtertype,
+                                transferfunc=transferfunc,
+                                padtype=padtype,
+                                debug=False,
+                            ),
+                        }
+                    )
+
+        # make the lowpass filters
+        for transferfunc in transferfunclist:
+            testfilter = NoncausalFilter(
+                filtertype="arb",
+                transferfunc=transferfunc,
+                initlowerstop=0.0,
+                initlowerpass=0.0,
+                initupperpass=0.1,
+                initupperstop=0.11,
+            )
+            lstest, lptest, uptest, ustest = testfilter.getfreqs()
+            if lptest < nyquist:
+                allfilters.append(
+                    {
+                        "name": "0.1Hz LP " + transferfunc,
+                        "filter": NoncausalFilter(
+                            filtertype="arb",
+                            transferfunc=transferfunc,
+                            initlowerstop=0.0,
+                            initlowerpass=0.0,
+                            initupperpass=0.1,
+                            initupperstop=0.11,
+                            debug=False,
+                        ),
+                    }
+                )
+
+        # make the highpass filters
+        for transferfunc in transferfunclist:
+            testfilter = NoncausalFilter(
+                filtertype="arb",
+                transferfunc=transferfunc,
+                initlowerstop=0.09,
+                initlowerpass=0.1,
+                initupperpass=1.0e20,
+                initupperstop=1.0e20,
+            )
+            lstest, lptest, uptest, ustest = testfilter.getfreqs()
+            if lptest < nyquist:
+                allfilters.append(
+                    {
+                        "name": "0.1Hz HP " + transferfunc,
+                        "filter": NoncausalFilter(
+                            filtertype="arb",
+                            transferfunc=transferfunc,
+                            initlowerstop=0.09,
+                            initlowerpass=0.1,
+                            initupperpass=1.0e20,
+                            initupperstop=1.0e20,
+                            debug=False,
+                        ),
+                    }
+                )
+
+        # show the end effects waveforms
+        if displayplots:
+            plt.figure()
+            plt.ylim([-2.2, 2.2 * len(testwaves)])
+            for thewave in testwaves:
+                legend = []
+                offset = 0.0
+                for thefilter in allfilters:
+                    plt.plot(
+                        thewave["timeaxis"],
+                        offset + thefilter["filter"].apply(1.0 / sampletime, thewave["waveform"]),
+                    )
+                    legend.append(thewave["name"] + ": " + thefilter["name"])
+                    offset += 1.25
+                plt.legend(legend)
+                plt.title(padtype)
+                plt.show()
+
+
+def test_padvec(displayplots=False, debug=False):
+    eval_padvecprops(
+        sampletime=0.72, tclengthinsecs=300.0, numruns=100, displayplots=displayplots, debug=debug
+    )
+
+
+if __name__ == "__main__":
+    mpl.use("TkAgg")
+    test_padvec(displayplots=True, debug=True)

rapidtide/tests/test_parserfuncs.py

@@ -0,0 +1,101 @@
+#!/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 argparse
+import os
+
+import rapidtide.io as tide_io
+import rapidtide.workflows.parser_funcs as pf
+from rapidtide.tests.utils import get_examples_path, get_test_temp_path
+
+
+def proccolspec(thecolspec):
+    if thecolspec is not None:
+        # see if this is a numeric or text list
+        tokenlist = (thecolspec.split(",")[0]).split("-")
+        try:
+            firstelement = int(tokenlist[0])
+            return tide_io.colspectolist(thecolspec)
+        except ValueError:
+            return thecolspec.split(",")
+    else:
+        return [None]
+
+
+def _get_parser():
+    """
+    Argument parser for adjust offset
+    """
+    parser = argparse.ArgumentParser(
+        prog="dummy",
+        description="dummy",
+        allow_abbrev=False,
+    )
+
+    # Required arguments
+    parser.add_argument(
+        "inputmap",
+        type=lambda x: pf.is_valid_file(parser, x),
+        help="The name of the rapidtide maxtime map.",
+    )
+
+    return parser
+
+
+def test_parserfuncs(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()
+
+    theparser = _get_parser()
+
+    testvecs = [
+        ["sub-RAPIDTIDETEST_desc-oversampledmovingregressor_timeseries.json", [None]],
+        [
+            "sub-RAPIDTIDETEST_desc-oversampledmovingregressor_timeseries.json:acolname",
+            ["acolname"],
+        ],
+        [
+            "sub-RAPIDTIDETEST_desc-oversampledmovingregressor_timeseries.json:acolname,bcolname",
+            ["acolname", "bcolname"],
+        ],
+        [
+            "sub-RAPIDTIDETEST_desc-oversampledmovingregressor_timeseries.tsv.gz:1,2,5-10",
+            [1, 2, 5, 6, 7, 8, 9, 10],
+        ],
+        [
+            "sub-RAPIDTIDETEST_desc-oversampledmovingregressor_timeseries.json:3,2,7,5-10,6-11",
+            [2, 3, 5, 6, 7, 8, 9, 10, 11],
+        ],
+    ]
+    for infile, expectedcols in testvecs:
+        filename = os.path.join(exampleroot, infile)
+        retval = pf.is_valid_file(theparser, filename)
+        thename, thecolspec = tide_io.parsefilespec(retval)
+        collist = proccolspec(thecolspec)
+        if debug:
+            print(filename, retval, thename, thecolspec, collist)
+        assert collist == expectedcols
+
+
+if __name__ == "__main__":
+    test_parserfuncs(debug=True, local=True)

rapidtide/tests/test_phaseanalysis.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-#   Copyright 2018-2024 Blaise Frederick
+#   Copyright 2018-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.

rapidtide/tests/test_rapidtideparser.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-#   Copyright 2016-2024 Blaise Frederick
+#   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.
@@ -18,7 +18,8 @@
 #
 import numpy as np
 
-from rapidtide.workflows.rapidtide_parser import process_args
+import rapidtide.workflows.parser_funcs as pf
+import rapidtide.workflows.rapidtide_parser as rp
 
 testlist = {}
 testlist["searchrange"] = {
@@ -72,16 +73,37 @@ testlist["numnull"] = {
     "command": ["--numnull", "0"],
     "results": [["numestreps", 0], ["ampthreshfromsig", False]],
 }
-testlist["fixdelay"] = {
-    "command": ["--fixdelay", "0.0"],
+testlist["initialdelay"] = {
+    "command": ["--initialdelay", "0.0"],
     "results": [
-        ["fixeddelayvalue", 0.0, "isfloat"],
+        ["initialdelayvalue", 0.0, "isfloat"],
+    ],
+}
+testlist["nodelayfit"] = {
+    "command": ["--nodelayfit"],
+    "results": [
+        ["fixdelay", True],
+    ],
+}
+testlist["delaymapping"] = {
+    "command": ["--delaymapping"],
+    "results": [
+        ["fixdelay", True],
+        ["passes", rp.DEFAULT_DELAYMAPPING_PASSES],
+        ["despeckle_passes", rp.DEFAULT_DELAYMAPPING_DESPECKLE_PASSES],
+        ["gausssigma", rp.DEFAULT_DELAYMAPPING_SPATIALFILT],
+        ["lagmin", rp.DEFAULT_DELAYMAPPING_LAGMIN],
+        ["lagmax", rp.DEFAULT_DELAYMAPPING_LAGMAX],
+        ["refineoffset", True],
+        ["refinedelay", True],
+        ["outputlevel", "normal"],
+        ["dolinfitfilt", True],
     ],
 }
 
 
-def checktests(testvec, testlist, theargs, epsilon):
-    for thetest in testvec:
+def checktests(thetestvec, testlist, theargs, epsilon):
+    for thetest in thetestvec:
         for theresult in testlist[thetest]["results"]:
             print("testing", testlist[thetest]["command"], "effect on", theresult[0])
             if len(theresult) <= 2:
@@ -101,25 +123,9 @@ def checktests(testvec, testlist, theargs, epsilon):
                     assert np.fabs(theargs[theresult[0]] - theresult[1]) < epsilon
 
 
-def main():
-    epsilon = 0.00001
-
-    # construct the first test vector
-    testvec = []
-    testvec.append("filterband")
-    testvec.append("filtertype")
-    testvec.append("searchrange")
-    testvec.append("pickleft")
-    testvec.append("corrweighting")
-    testvec.append("datafreq")
-    testvec.append("noantialias")
-    testvec.append("invert")
-    testvec.append("interptype")
-    testvec.append("offsettime")
-    testvec.append("datafreq")
-
+def checkavector(thetestvec, epsilon):
     print(testlist)
-    print(testvec)
+    print(thetestvec)
 
     # make the argument and results lists
     arglist = [
@@ -127,7 +133,7 @@ def main():
         "../data/examples/dst/parsertestdummy",
     ]
     resultlist = []
-    for thetest in testvec:
+    for thetest in thetestvec:
         arglist += testlist[thetest]["command"]
         for theresult in testlist[thetest]["results"]:
             resultlist += [theresult]
@@ -135,38 +141,38 @@ def main():
     print(arglist)
     print(resultlist)
 
-    theargs, ncprefilter = process_args(inputargs=arglist)
-
-    checktests(testvec, testlist, theargs, epsilon)
+    theargs, ncprefilter = rp.process_args(inputargs=arglist)
 
-    # construct the second test vector
-    testvec = []
-    testvec.append("filterfreqs")
-    testvec.append("datatstep")
-    testvec.append("timerange")
-    testvec.append("numnull")
-    testvec.append("fixdelay")
-
-    print(testlist)
-    print(testvec)
+    checktests(thetestvec, testlist, theargs, epsilon)
 
-    # make the argument and results lists
-    arglist = [
-        "../data/examples/src/sub-RAPIDTIDETEST.nii.gz",
-        "../data/examples/dst/parsertestdummy",
-    ]
-    resultlist = []
-    for thetest in testvec:
-        arglist += testlist[thetest]["command"]
-        for theresult in testlist[thetest]["results"]:
-            resultlist += [theresult]
 
-    print(arglist)
-    print(resultlist)
+def main():
+    epsilon = 0.00001
 
-    theargs, ncprefilter = process_args(inputargs=arglist)
+    # construct the first test vector
+    thetestvec = []
+    thetestvec.append("filterband")
+    thetestvec.append("filtertype")
+    thetestvec.append("searchrange")
+    thetestvec.append("pickleft")
+    thetestvec.append("corrweighting")
+    thetestvec.append("datafreq")
+    thetestvec.append("noantialias")
+    thetestvec.append("invert")
+    thetestvec.append("interptype")
+    thetestvec.append("offsettime")
+    thetestvec.append("datafreq")
+    checkavector(thetestvec, epsilon)
 
-    checktests(testvec, testlist, theargs, epsilon)
+    # construct the second test vector
+    thetestvec = []
+    thetestvec.append("filterfreqs")
+    thetestvec.append("datatstep")
+    thetestvec.append("timerange")
+    thetestvec.append("numnull")
+    thetestvec.append("initialdelay")
+    thetestvec.append("nodelayfit")
+    checkavector(thetestvec, epsilon)
 
 
 if __name__ == "__main__":