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

cloud/gmscalc-HCPYA

@@ -15,7 +15,7 @@ fi
 
 echo "Subject="${SUBJ}", RUN="${RUN}", PEDIR="${PEDIR}
 
-mkdir -p /data_out/HCP_1200/minpreprocglm/${SUBJ}
+mkdir -p /data_out/HCP_1200/minpreprocslfofilt/${SUBJ}
 gmscalc \
     /data_out/HCP_1200/${SUBJ}/rapidtide_rfMRI_${RUN}_${PEDIR}_desc-lfofilterCleaned_bold.nii.gz
     /data_out/HCP_1200/fixglm/${SUBJ}/rapidtide_rfMRI_${RUN}_${PEDIR}_lfofilteredCleanedGMS \

cloud/rapidtide-HCPYA

@@ -15,11 +15,11 @@ fi
 
 echo "Subject="${SUBJ}", RUN="${RUN}", PEDIR="${PEDIR}
 
-#    --glmsourcefile=/data_in/HCP_1200/${SUBJ}/MNINonLinear/Results/rfMRI_${RUN}_${PEDIR}/rfMRI_${RUN}_${PEDIR}_hp2000_clean.nii.gz \
-mkdir -p /data_out/HCP_1200/minpreprocglm/${SUBJ}
+#    --denoisesourcefile=/data_in/HCP_1200/${SUBJ}/MNINonLinear/Results/rfMRI_${RUN}_${PEDIR}/rfMRI_${RUN}_${PEDIR}_hp2000_clean.nii.gz \
+mkdir -p /data_out/HCP_1200/minpreprocslfofilt/${SUBJ}
 rapidtide \
     /data_in/HCP_1200/${SUBJ}/MNINonLinear/Results/rfMRI_${RUN}_${PEDIR}/rfMRI_${RUN}_${PEDIR}.nii.gz \
-    /data_out/HCP_1200/minpreprocglm/${SUBJ}/rapidtide_rfMRI_${RUN}_${PEDIR} \
+    /data_out/HCP_1200/minpreprocslfofilt/${SUBJ}/rapidtide_rfMRI_${RUN}_${PEDIR} \
     --despecklepasses 4 \
     --filterfreqs 0.009 0.15 \
     --searchrange -7.5 15.0 \

rapidtide/Colortables.py

@@ -66,7 +66,7 @@ def gen_thermal_state():
     thegradient = Gradients["thermal"]
     thegradient["name"] = "thermal"
     return thegradient
-    #return Gradients["thermal"]
+    # return Gradients["thermal"]
 
 
 def gen_flame_state():
@@ -75,7 +75,7 @@ def gen_flame_state():
     thegradient = Gradients["flame"]
     thegradient["name"] = "flame"
     return thegradient
-    #return Gradients["flame"]
+    # return Gradients["flame"]
 
 
 def gen_yellowy_state():
@@ -84,7 +84,7 @@ def gen_yellowy_state():
     thegradient = Gradients["yellowy"]
     thegradient["name"] = "yellowy"
     return thegradient
-    #return Gradients["yellowy"]
+    # return Gradients["yellowy"]
 
 
 def gen_bipolar_state():
@@ -93,7 +93,7 @@ def gen_bipolar_state():
     thegradient = Gradients["bipolar"]
     thegradient["name"] = "bipolar"
     return thegradient
-    #return Gradients["bipolar"]
+    # return Gradients["bipolar"]
 
 
 def gen_spectrum_state():
@@ -102,7 +102,7 @@ def gen_spectrum_state():
     thegradient = Gradients["spectrum"]
     thegradient["name"] = "spectrum"
     return thegradient
-    #return Gradients["spectrum"]
+    # return Gradients["spectrum"]
 
 
 def gen_turbo_state():
@@ -111,7 +111,7 @@ def gen_turbo_state():
     thegradient = Gradients["turbo"]
     thegradient["name"] = "turbo"
     return thegradient
-    #return Gradients["turbo"]
+    # return Gradients["turbo"]
 
 
 def gen_gray_state():
@@ -142,7 +142,7 @@ def gen_viridis_state():
     thegradient = Gradients["viridis"]
     thegradient["name"] = "viridis"
     return thegradient
-    #return Gradients["viridis"]
+    # return Gradients["viridis"]
 
 
 def gen_inferno_state():
@@ -151,7 +151,7 @@ def gen_inferno_state():
     thegradient = Gradients["inferno"]
     thegradient["name"] = "inferno"
     return thegradient
-    #return Gradients["inferno"]
+    # return Gradients["inferno"]
 
 
 def gen_plasma_state():
@@ -160,7 +160,7 @@ def gen_plasma_state():
     thegradient = Gradients["plasma"]
     thegradient["name"] = "plasma"
     return thegradient
-    #return Gradients["plasma"]
+    # return Gradients["plasma"]
 
 
 def gen_magma_state():
@@ -169,7 +169,7 @@ def gen_magma_state():
     thegradient = Gradients["magma"]
     thegradient["name"] = "magma"
     return thegradient
-    #return Gradients["magma"]
+    # return Gradients["magma"]
 
 
 def gen_g2y2r_state():

rapidtide/DerivativeDelay.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2016-2024 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.
+#
+#
+"""
+A class to impmement regressor refinement
+"""
+import copy
+
+import numpy as np
+
+import rapidtide.fit as tide_fit
+import rapidtide.io as tide_io
+import rapidtide.miscmath as tide_math
+import rapidtide.refinedelay as tide_refinedelay
+import rapidtide.resample as tide_resample
+import rapidtide.stats as tide_stats
+import rapidtide.util as tide_util
+from rapidtide.tests.utils import mse
+
+
+class DerivativeDelay:
+    def __init__(
+        self,
+        internalvalidfmrishape,
+        internalvalidpaddedfmrishape,
+        pid,
+        outputname,
+        initial_fmri_x,
+        paddedinitial_fmri_x,
+        os_fmri_x,
+        genlagtc,
+        sharedmem=False,
+        gausssigma=-1,
+        numderivs=1,
+        lagminthresh=0.25,
+        lagmaxthresh=3.0,
+        sigmathresh=1000.0,
+        cleanrefined=False,
+        bipolar=False,
+        fixdelay=False,
+        includemask=None,
+        excludemask=None,
+        LGR=None,
+        nprocs=1,
+        detrendorder=1,
+        alwaysmultiproc=False,
+        showprogressbar=True,
+        chunksize=50000,
+        padtrs=10,
+        refineprenorm="var",
+        refineweighting=None,
+        refinetype="pca",
+        pcacomponents=0.8,
+        dodispersioncalc=False,
+        dispersioncalc_lower=-5.0,
+        dispersioncalc_upper=5.0,
+        dispersioncalc_step=0.5,
+        windowfunc="hamming",
+        passes=3,
+        maxpasses=15,
+        convergencethresh=None,
+        interptype="univariate",
+        usetmask=False,
+        tmask_y=None,
+        tmaskos_y=None,
+        fastresamplerpadtime=45.0,
+        debug=False,
+        rt_floattype="float64",
+        rt_floatset=np.float64,
+    ):
+        self.outputname = outputname
+        self.numderivs = numderivs
+        if gausssigma < 0.0:
+            # set gausssigma automatically
+            self.gausssigma = np.mean([xdim, ydim, slicedim]) / 2.0
+        else:
+            self.gausssigma = gausssigma
+        self.debug = debug
+        self.setgenlagtc(genlagtc)
+
+    def setgenlagtc(self, genlagtc):
+        self.genlagtc = genlagtc
+
+    def getderivratios(
+        self, fmri_data_valid, validvoxels, initial_fmri_x, lagtimes_valid, corrmask_valid
+    ):
+        print("Refinement calibration start")
+        regressderivratios = tide_refinedelay.getderivratios(
+            fmri_data_valid,
+            validvoxels,
+            initial_fmri_x,
+            lagtimes_valid,
+            corrmask_valid,
+            self.genlagtc,
+            "glm",
+            self.outputname,
+            oversamptr,
+            sLFOfitmean,
+            rvalue,
+            r2value,
+            fitNorm[:, : (self.numderivs + 1)],
+            fitcoeff[:, : (self.numderivs + 1)],
+            movingsignal,
+            lagtc,
+            filtereddata,
+            LGR,
+            TimingLGR,
+            therunoptions,
+            regressderivs=self.numderivs,
+            debug=self.debug,
+        )
+
+    def calibrate(self):
+        if self.numderivs == 1:
+            medfiltregressderivratios, filteredregressderivratios, delayoffsetMAD = (
+                tide_refinedelay.filterderivratios(
+                    regressderivratios,
+                    (xsize, ysize, numslices),
+                    validvoxels,
+                    (xdim, ydim, slicedim),
+                    gausssigma=args.delayoffsetgausssigma,
+                    patchthresh=args.delaypatchthresh,
+                    fileiscifti=False,
+                    textio=False,
+                    rt_floattype=rt_floattype,
+                    debug=args.debug,
+                )
+            )
+
+            # find the mapping of derivative ratios to delays
+            tide_refinedelay.trainratiotooffset(
+                self.genlagtc,
+                initial_fmri_x,
+                self.outputname,
+                args.outputlevel,
+                mindelay=args.mindelay,
+                maxdelay=args.maxdelay,
+                numpoints=args.numpoints,
+                debug=args.debug,
+            )
+            TimingLGR.info("Refinement calibration end")
+
+            # now calculate the delay offsets
+            TimingLGR.info("Calculating delay offsets")
+            delayoffset = np.zeros_like(filteredregressderivratios)
+            if args.focaldebug:
+                print(f"calculating delayoffsets for {filteredregressderivratios.shape[0]} voxels")
+            for i in range(filteredregressderivratios.shape[0]):
+                delayoffset[i] = tide_refinedelay.ratiotodelay(filteredregressderivratios[i])
+            refinedvoxelstoreport = filteredregressderivratios.shape[0]
+        else:
+            medfiltregressderivratios = np.zeros_like(regressderivratios)
+            filteredregressderivratios = np.zeros_like(regressderivratios)
+            delayoffsetMAD = np.zeros(args.refineregressderivs, dtype=float)
+            for i in range(args.refineregressderivs):
+                (
+                    medfiltregressderivratios[i, :],
+                    filteredregressderivratios[i, :],
+                    delayoffsetMAD[i],
+                ) = tide_refinedelay.filterderivratios(
+                    regressderivratios[i, :],
+                    (xsize, ysize, numslices),
+                    validvoxels,
+                    (xdim, ydim, slicedim),
+                    gausssigma=args.delayoffsetgausssigma,
+                    patchthresh=args.delaypatchthresh,
+                    fileiscifti=False,
+                    textio=False,
+                    rt_floattype=rt_floattype,
+                    debug=args.debug,
+                )
+
+    def getdelays(self):
+        # now calculate the delay offsets
+        delayoffset = np.zeros_like(filteredregressderivratios[0, :])
+        if self.debug:
+            print(f"calculating delayoffsets for {filteredregressderivratios.shape[1]} voxels")
+        for i in range(filteredregressderivratios.shape[1]):
+            delayoffset[i] = tide_refinedelay.coffstodelay(
+                filteredregressderivratios[:, i],
+                mindelay=self.mindelay,
+                maxdelay=self.maxdelay,
+            )
+        refinedvoxelstoreport = filteredregressderivratios.shape[1]
+
+    def savestats(self):
+        namesuffix = "_desc-delayoffset_hist"
+        tide_stats.makeandsavehistogram(
+            delayoffset,
+            therunoptions["histlen"],
+            1,
+            self.outputname + namesuffix,
+            displaytitle="Histogram of delay offsets calculated from coefficient ratios",
+            dictvarname="delayoffsethist",
+            thedict=None,
+        )