rapidtide 3.0a14__py3-none-any.whl → 3.0.1__py3-none-any.whl

rapidtide/workflows/applydlfilter.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.
@@ -26,6 +26,7 @@ import rapidtide.correlate as tide_corr
 import rapidtide.dlfilter as tide_dlfilt
 import rapidtide.filter as tide_filt
 import rapidtide.fit as tide_fit
+import rapidtide.happy_supportfuncs as happy_support
 import rapidtide.io as tide_io
 import rapidtide.miscmath as tide_math
 import rapidtide.util as tide_util
@@ -87,65 +88,6 @@ def _get_parser():
     return parser
 
 
-def checkcardmatch(reference, candidate, samplerate, refine=True, zeropadding=0, debug=False):
-    thecardfilt = tide_filt.NoncausalFilter(filtertype="cardiac")
-    trimlength = np.min([len(reference), len(candidate)])
-    thexcorr = tide_corr.fastcorrelate(
-        tide_math.corrnormalize(
-            thecardfilt.apply(samplerate, reference),
-            detrendorder=3,
-            windowfunc="hamming",
-        )[:trimlength],
-        tide_math.corrnormalize(
-            thecardfilt.apply(samplerate, candidate),
-            detrendorder=3,
-            windowfunc="hamming",
-        )[:trimlength],
-        usefft=True,
-        zeropadding=zeropadding,
-    )
-    xcorrlen = len(thexcorr)
-    sampletime = 1.0 / samplerate
-    xcorr_x = np.r_[0.0:xcorrlen] * sampletime - (xcorrlen * sampletime) / 2.0 + sampletime / 2.0
-    searchrange = 5.0
-    trimstart = tide_util.valtoindex(xcorr_x, -2.0 * searchrange)
-    trimend = tide_util.valtoindex(xcorr_x, 2.0 * searchrange)
-    (
-        maxindex,
-        maxdelay,
-        maxval,
-        maxsigma,
-        maskval,
-        failreason,
-        peakstart,
-        peakend,
-    ) = tide_fit.findmaxlag_gauss(
-        xcorr_x[trimstart:trimend],
-        thexcorr[trimstart:trimend],
-        -searchrange,
-        searchrange,
-        3.0,
-        refine=refine,
-        zerooutbadfit=False,
-        useguess=False,
-        fastgauss=False,
-        displayplots=False,
-    )
-    if debug:
-        print(
-            "CORRELATION: maxindex, maxdelay, maxval, maxsigma, maskval, failreason, peakstart, peakend:",
-            maxindex,
-            maxdelay,
-            maxval,
-            maxsigma,
-            maskval,
-            failreason,
-            peakstart,
-            peakend,
-        )
-    return maxval, maxdelay, failreason
-
-
 def applydlfilter(args):
     if args.display:
         import matplotlib as mpl
@@ -184,8 +126,6 @@ def applydlfilter(args):
     )
     thedlfilter = tide_dlfilt.DeepLearningFilter(modelpath=modelpath)
     thedlfilter.loadmodel(args.model)
-    model = thedlfilter.model
-    window_size = thedlfilter.window_size
     usebadpts = thedlfilter.usebadpts
 
     badpts = None
@@ -204,17 +144,32 @@ def applydlfilter(args):
         # read in the data
         if args.verbose:
             print("reading in", infilename)
-        fmridata = tide_io.readvec(infilename)
-
+        (
+            thesamplerate,
+            thestarttime,
+            thecolumns,
+            fmridata,
+            compressed,
+            filetype,
+        ) = tide_io.readvectorsfromtextfile(infilename, onecol=True, debug=args.verbose)
+        if args.verbose:
+            print("data is read")
+        if thesamplerate != 25.0:
+            print("sampling rate", thesamplerate)
+            sys.exit()
         if args.verbose:
             print("filtering...")
         predicteddata = thedlfilter.apply(fmridata, badpts=badpts)
+        if args.verbose:
+            print("done...")
 
         if args.verbose:
             print("writing to", outfilenamelist[idx])
         tide_io.writevec(predicteddata, outfilenamelist[idx])
 
-        maxval, maxdelay, failreason = checkcardmatch(fmridata, predicteddata, 25.0, debug=False)
+        maxval, maxdelay, failreason = happy_support.checkcardmatch(
+            fmridata, predicteddata, 25.0, debug=False
+        )
         print(infilename, "max correlation input to output:", maxval)
 
         if args.display:

rapidtide/workflows/atlasaverage.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.

rapidtide/workflows/atlastool.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.

rapidtide/workflows/calctexticc.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.

rapidtide/workflows/ccorrica.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.

rapidtide/workflows/cleanregressor.py

@@ -0,0 +1,243 @@
+#!/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 numpy as np
+
+import rapidtide.correlate as tide_corr
+import rapidtide.filter as tide_filt
+import rapidtide.helper_classes as tide_classes
+import rapidtide.io as tide_io
+import rapidtide.miscmath as tide_math
+import rapidtide.simfuncfit as tide_simfuncfit
+
+
+def cleanregressor(
+    outputname,
+    thepass,
+    referencetc,
+    resampref_y,
+    resampnonosref_y,
+    fmrifreq,
+    oversampfreq,
+    osvalidsimcalcstart,
+    osvalidsimcalcend,
+    lagmininpts,
+    lagmaxinpts,
+    theFitter,
+    theCorrelator,
+    lagmin,
+    lagmax,
+    LGR=None,
+    check_autocorrelation=True,
+    fix_autocorrelation=True,
+    despeckle_thresh=5.0,
+    lthreshval=0.0,
+    fixdelay=False,
+    detrendorder=3,
+    windowfunc="hamming",
+    respdelete=False,
+    debug=False,
+    rt_floattype="float64",
+    rt_floatset=np.float64,
+):
+    # check the regressor for periodic components in the passband
+    dolagmod = True
+    doreferencenotch = True
+    if respdelete:
+        resptracker = tide_classes.FrequencyTracker(nperseg=64)
+        thetimes, thefreqs = resptracker.track(resampref_y, oversampfreq)
+        tide_io.writevec(thefreqs, f"{outputname}_peakfreaks_pass{thepass}.txt")
+        resampref_y = resptracker.clean(resampref_y, oversampfreq, thetimes, thefreqs)
+        tide_io.writevec(resampref_y, f"{outputname}_respfilt_pass{thepass}.txt")
+        referencetc = tide_math.corrnormalize(
+            resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1],
+            detrendorder=detrendorder,
+            windowfunc=windowfunc,
+        )
+
+    if check_autocorrelation:
+        if LGR is not None:
+            LGR.info("checking reference regressor autocorrelation properties")
+        lagmod = 1000.0
+        lagindpad = np.max((lagmininpts, lagmaxinpts))
+        acmininpts = lagindpad
+        acmaxinpts = lagindpad
+        theCorrelator.setreftc(referencetc)
+        theCorrelator.setlimits(acmininpts, acmaxinpts)
+        # theCorrelator.setlimits(lagmininpts, lagmaxinpts)
+        print("check_autocorrelation:", acmininpts, acmaxinpts, lagmininpts, lagmaxinpts)
+        thexcorr, accheckcorrscale, dummy = theCorrelator.run(
+            resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1]
+        )
+        theFitter.setcorrtimeaxis(accheckcorrscale)
+        (
+            dummy,
+            dummy,
+            dummy,
+            acwidth,
+            dummy,
+            dummy,
+            dummy,
+            dummy,
+        ) = tide_simfuncfit.onesimfuncfit(
+            thexcorr,
+            theFitter,
+            despeckle_thresh=despeckle_thresh,
+            lthreshval=lthreshval,
+            fixdelay=fixdelay,
+            rt_floatset=rt_floatset,
+            rt_floattype=rt_floattype,
+        )
+        tide_io.writebidstsv(
+            f"{outputname}_desc-autocorr_timeseries",
+            thexcorr,
+            1.0 / (accheckcorrscale[1] - accheckcorrscale[0]),
+            starttime=accheckcorrscale[0],
+            extraheaderinfo={
+                "Description": "Autocorrelation of the probe regressor for each pass"
+            },
+            columns=[f"pass{thepass}"],
+            append=(thepass > 1),
+        )
+        thelagthresh = np.max((abs(lagmin), abs(lagmax)))
+        theampthresh = 0.1
+        if LGR is not None:
+            LGR.info(
+                f"searching for sidelobes with amplitude > {theampthresh} "
+                f"with abs(lag) < {thelagthresh} s"
+            )
+        sidelobetime, sidelobeamp = tide_corr.check_autocorrelation(
+            accheckcorrscale,
+            thexcorr,
+            acampthresh=theampthresh,
+            aclagthresh=thelagthresh,
+            detrendorder=detrendorder,
+        )
+        absmaxsigma = acwidth * 10.0
+        passsuffix = "_pass" + str(thepass)
+        if sidelobetime is not None:
+            despeckle_thresh = np.max([despeckle_thresh, sidelobetime / 2.0])
+            LGR.warning(
+                f"\n\nWARNING: check_autocorrelation found bad sidelobe at {sidelobetime} "
+                f"seconds ({1.0 / sidelobetime} Hz)..."
+            )
+            # bidsify
+            """tide_io.writebidstsv(
+                f"{outputname}_desc-movingregressor_timeseries",
+                tide_math.stdnormalize(resampnonosref_y),
+                1.0 / fmritr,
+                columns=["pass1"],
+                append=False,
+            )"""
+            tide_io.writenpvecs(
+                np.array([sidelobetime]),
+                f"{outputname}_autocorr_sidelobetime" + passsuffix + ".txt",
+            )
+            if fix_autocorrelation:
+                if LGR is not None:
+                    LGR.info("Removing sidelobe")
+                if dolagmod:
+                    if LGR is not None:
+                        LGR.info("subjecting lag times to modulus")
+                    lagmod = sidelobetime / 2.0
+                if doreferencenotch:
+                    if LGR is not None:
+                        LGR.info("removing spectral component at sidelobe frequency")
+                    acstopfreq = 1.0 / sidelobetime
+                    acfixfilter = tide_filt.NoncausalFilter(
+                        debug=debug,
+                    )
+                    acfixfilter.settype("arb_stop")
+                    acfixfilter.setfreqs(
+                        acstopfreq * 0.9,
+                        acstopfreq * 0.95,
+                        acstopfreq * 1.05,
+                        acstopfreq * 1.1,
+                    )
+                    cleaned_resampref_y = tide_math.corrnormalize(
+                        acfixfilter.apply(oversampfreq, resampref_y),
+                        windowfunc="None",
+                        detrendorder=detrendorder,
+                    )
+                    cleaned_referencetc = tide_math.corrnormalize(
+                        cleaned_resampref_y,
+                        detrendorder=detrendorder,
+                        windowfunc=windowfunc,
+                    )
+                    cleaned_nonosreferencetc = tide_math.stdnormalize(
+                        acfixfilter.apply(fmrifreq, resampnonosref_y)
+                    )
+                    tide_io.writebidstsv(
+                        f"{outputname}_desc-cleanedreferencefmrires_info",
+                        cleaned_nonosreferencetc,
+                        fmrifreq,
+                        columns=[f"pass{thepass}"],
+                        append=(thepass > 1),
+                    )
+                    tide_io.writebidstsv(
+                        f"{outputname}_desc-cleanedreference_info",
+                        cleaned_referencetc,
+                        oversampfreq,
+                        columns=[f"pass{thepass}"],
+                        append=(thepass > 1),
+                    )
+                    tide_io.writebidstsv(
+                        f"{outputname}_desc-cleanedresamprefy_info",
+                        cleaned_resampref_y,
+                        oversampfreq,
+                        columns=[f"pass{thepass}"],
+                        append=(thepass > 1),
+                    )
+            else:
+                cleaned_resampref_y = 1.0 * tide_math.corrnormalize(
+                    resampref_y,
+                    windowfunc="None",
+                    detrendorder=detrendorder,
+                )
+                cleaned_referencetc = 1.0 * referencetc
+                cleaned_nonosreferencetc = 1.0 * resampnonosref_y
+        else:
+            if LGR is not None:
+                LGR.info("no sidelobes found in range")
+            cleaned_resampref_y = 1.0 * tide_math.corrnormalize(
+                resampref_y,
+                windowfunc="None",
+                detrendorder=detrendorder,
+            )
+            cleaned_referencetc = 1.0 * referencetc
+            cleaned_nonosreferencetc = 1.0 * resampnonosref_y
+    else:
+        acwidth = None
+        absmaxsigma = None
+        cleaned_resampref_y = 1.0 * tide_math.corrnormalize(
+            resampref_y, windowfunc="None", detrendorder=detrendorder
+        )
+        cleaned_referencetc = 1.0 * referencetc
+        cleaned_nonosreferencetc = 1.0 * resampnonosref_y
+
+    return (
+        cleaned_resampref_y,
+        cleaned_referencetc,
+        cleaned_nonosreferencetc,
+        despeckle_thresh,
+        sidelobeamp,
+        sidelobetime,
+        lagmod,
+        acwidth,
+        absmaxsigma,
+    )