rapidtide 3.0a13__py3-none-any.whl → 3.0a15__py3-none-any.whl

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.
@@ -135,6 +135,15 @@ def _get_parser():
         ),
         default=None,
     )
+    parser.add_argument(
+        "--regionlabelfile",
+        type=lambda x: pf.is_valid_file(parser, x),
+        help=(
+            "The name of of a text file containing the labels of the regions, one per line.  The first line is "
+            "the label integer value 1, etc."
+        ),
+        default=None,
+    )
     parser.add_argument(
         "--includemask",
         dest="includespec",
@@ -224,11 +233,9 @@ def atlasaverage(args):
         sys.exit()
 
     print("reshaping")
-    xsize = thedims[1]
-    ysize = thedims[2]
-    numslices = thedims[3]
-    numtimepoints = thedims[4]
-    numvoxels = int(xsize) * int(ysize) * int(numslices)
+    xdim, ydim, numslices, numtimepoints = tide_io.parseniftidims(thedims)
+    xsize, ysize, slicethickness, tr = tide_io.parseniftisizes(thesizes)
+    numvoxels = int(xdim) * int(ydim) * int(numslices)
 
     templatevoxels = np.reshape(template_data, numvoxels).astype(int)
     inputvoxels = np.reshape(input_data, (numvoxels, numtimepoints))
@@ -273,7 +280,7 @@ def atlasaverage(args):
         themask = themask * includemask.reshape((numvoxels))
         if args.debug:
             tide_io.savetonifti(
-                includemask.reshape((xsize, ysize, numslices)),
+                includemask.reshape((xdim, ydim, numslices)),
                 template_hdr,
                 f"{args.outputroot}_includemask",
             )
@@ -281,7 +288,7 @@ def atlasaverage(args):
         themask = themask * (1 - excludemask.reshape((numvoxels)))
         if args.debug:
             tide_io.savetonifti(
-                excludemask.reshape((xsize, ysize, numslices)),
+                excludemask.reshape((xdim, ydim, numslices)),
                 template_hdr,
                 f"{args.outputroot}_excludemask",
             )
@@ -289,11 +296,21 @@ def atlasaverage(args):
         themask = themask * extramask.reshape((numvoxels))
         if args.debug:
             tide_io.savetonifti(
-                extramask.reshape((xsize, ysize, numslices)),
+                extramask.reshape((xdim, ydim, numslices)),
                 template_hdr,
                 f"{args.outputroot}_extramask",
             )
 
+    # get the region names
+    if args.regionlabelfile is None:
+        regionlabels = []
+        numregions = np.max(templatevoxels)
+        numdigits = int(np.log10(numregions)) + 1
+        for regnum in range(1, numregions + 1):
+            regionlabels.append(f"region_{str(regnum).zfill(numdigits)}")
+    else:
+        regionlabels = tide_io.readlabels(args.regionlabelfile)
+
     # decide what regions we will summarize
     if args.regionlistfile is None:
         numregions = np.max(templatevoxels)
@@ -301,6 +318,11 @@ def atlasaverage(args):
     else:
         regionlist = tide_io.readvec(args.regionlistfile).astype(int)
         numregions = len(regionlist)
+        newlabels = []
+        for theregion in range(numregions):
+            newlabels.append(regionlabels[theregion])
+        regionlabels = newlabels
+
     timecourses = np.zeros((numregions, numtimepoints), dtype="float")
     print(f"{numregions=}, {regionlist=}")
 
@@ -348,7 +370,13 @@ def atlasaverage(args):
                 )
         if args.debug:
             print("timecourses shape:", timecourses.shape)
-        tide_io.writenpvecs(timecourses, args.outputroot)
+        tide_io.writebidstsv(
+            args.outputroot,
+            timecourses,
+            1.0 / tr,
+            columns=regionlabels,
+            yaxislabel="delay offset",
+        )
     else:
         print("processing 3D input file")
         outputvoxels = inputvoxels * 0.0
@@ -416,19 +444,19 @@ def atlasaverage(args):
                 segmentedatlasvoxels += scratchvoxels
         template_hdr["dim"][4] = 1
         tide_io.savetonifti(
-            outputvoxels.reshape((xsize, ysize, numslices)),
+            outputvoxels.reshape((xdim, ydim, numslices)),
             template_hdr,
             args.outputroot,
         )
         tide_io.savetonifti(
-            segmentedatlasvoxels.reshape((xsize, ysize, numslices)),
+            segmentedatlasvoxels.reshape((xdim, ydim, numslices)),
             template_hdr,
             args.outputroot + "_percentiles",
         )
 
         if args.includename is not None or args.excludename is not None:
             tide_io.savetonifti(
-                (templatevoxels * themask).reshape((xsize, ysize, numslices)),
+                (templatevoxels * themask).reshape((xdim, ydim, numslices)),
                 template_hdr,
                 f"{args.outputroot}_maskedatlas",
             )

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,
+    )