rapidtide 3.0.8__py3-none-any.whl → 3.0.10__py3-none-any.whl

rapidtide/workflows/estimateDelayMap.py

@@ -1,536 +0,0 @@
-#!/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
-from scipy import ndimage
-
-import rapidtide.calcsimfunc as tide_calcsimfunc
-import rapidtide.io as tide_io
-import rapidtide.patchmatch as tide_patch
-import rapidtide.peakeval as tide_peakeval
-import rapidtide.simfuncfit as tide_simfuncfit
-import rapidtide.stats as tide_stats
-import rapidtide.util as tide_util
-
-try:
-    import mkl
-
-    mklexists = True
-except ImportError:
-    mklexists = False
-
-
-def disablemkl(numprocs, debug=False):
-    if mklexists:
-        if numprocs > 1:
-            if debug:
-                print("disablemkl: setting threads to 1")
-            mkl.set_num_threads(1)
-
-
-def enablemkl(numthreads, debug=False):
-    if mklexists:
-        if debug:
-            print(f"enablemkl: setting threads to {numthreads}")
-        mkl.set_num_threads(numthreads)
-
-
-def estimateDelay(
-    fmri_data_valid,
-    validsimcalcstart,
-    validsimcalcend,
-    osvalidsimcalcstart,
-    osvalidsimcalcend,
-    initial_fmri_x,
-    os_fmri_x,
-    theCorrelator,
-    theMutualInformationator,
-    cleaned_referencetc,
-    corrout,
-    meanval,
-    corrscale,
-    outputname,
-    outcorrarray,
-    validvoxels,
-    nativecorrshape,
-    nativespaceshape,
-    bidsbasedict,
-    numspatiallocs,
-    gaussout,
-    theinitialdelay,
-    windowout,
-    R2,
-    thesizes,
-    internalspaceshape,
-    numvalidspatiallocs,
-    theinputdata,
-    theheader,
-    theFitter,
-    fitmask,
-    lagtimes,
-    lagstrengths,
-    lagsigma,
-    failreason,
-    outmaparray,
-    lagmininpts,
-    lagmaxinpts,
-    thepass,
-    optiondict,
-    LGR,
-    TimingLGR,
-    rt_floatset=np.float64,
-    rt_floattype="float64",
-):
-    # Step 1 - Correlation step
-    if optiondict["similaritymetric"] == "mutualinfo":
-        similaritytype = "Mutual information"
-    elif optiondict["similaritymetric"] == "correlation":
-        similaritytype = "Correlation"
-    else:
-        similaritytype = "MI enhanced correlation"
-    LGR.info(f"\n\n{similaritytype} calculation, pass {thepass}")
-    TimingLGR.info(f"{similaritytype} calculation start, pass {thepass}")
-
-    tide_util.disablemkl(optiondict["nprocs_calcsimilarity"], debug=optiondict["threaddebug"])
-    if optiondict["similaritymetric"] == "mutualinfo":
-        theMutualInformationator.setlimits(lagmininpts, lagmaxinpts)
-        (
-            voxelsprocessed_cp,
-            theglobalmaxlist,
-            trimmedcorrscale,
-        ) = tide_calcsimfunc.correlationpass(
-            fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
-            cleaned_referencetc,
-            theMutualInformationator,
-            initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
-            os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
-            lagmininpts,
-            lagmaxinpts,
-            corrout,
-            meanval,
-            nprocs=optiondict["nprocs_calcsimilarity"],
-            alwaysmultiproc=optiondict["alwaysmultiproc"],
-            oversampfactor=optiondict["oversampfactor"],
-            interptype=optiondict["interptype"],
-            showprogressbar=optiondict["showprogressbar"],
-            chunksize=optiondict["mp_chunksize"],
-            rt_floatset=rt_floatset,
-            rt_floattype=rt_floattype,
-            debug=optiondict["focaldebug"],
-        )
-    else:
-        (
-            voxelsprocessed_cp,
-            theglobalmaxlist,
-            trimmedcorrscale,
-        ) = tide_calcsimfunc.correlationpass(
-            fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
-            cleaned_referencetc,
-            theCorrelator,
-            initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
-            os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
-            lagmininpts,
-            lagmaxinpts,
-            corrout,
-            meanval,
-            nprocs=optiondict["nprocs_calcsimilarity"],
-            alwaysmultiproc=optiondict["alwaysmultiproc"],
-            oversampfactor=optiondict["oversampfactor"],
-            interptype=optiondict["interptype"],
-            showprogressbar=optiondict["showprogressbar"],
-            chunksize=optiondict["mp_chunksize"],
-            rt_floatset=rt_floatset,
-            rt_floattype=rt_floattype,
-            debug=optiondict["focaldebug"],
-        )
-    tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
-
-    for i in range(len(theglobalmaxlist)):
-        theglobalmaxlist[i] = corrscale[theglobalmaxlist[i]] - optiondict["simcalcoffset"]
-    namesuffix = "_desc-globallag_hist"
-    tide_stats.makeandsavehistogram(
-        np.asarray(theglobalmaxlist),
-        len(corrscale),
-        0,
-        outputname + namesuffix,
-        displaytitle="Histogram of lag times from global lag calculation",
-        therange=(corrscale[0], corrscale[-1]),
-        refine=False,
-        dictvarname="globallaghist_pass" + str(thepass),
-        append=(optiondict["echocancel"] or (thepass > 1)),
-        thedict=optiondict,
-    )
-
-    if optiondict["checkpoint"]:
-        outcorrarray[:, :] = 0.0
-        outcorrarray[validvoxels, :] = corrout[:, :]
-        if theinputdata.filetype == "text":
-            tide_io.writenpvecs(
-                outcorrarray.reshape(nativecorrshape),
-                f"{outputname}_corrout_prefit_pass" + str(thepass) + ".txt",
-            )
-        else:
-            savename = f"{outputname}_desc-corroutprefit_pass-" + str(thepass)
-            tide_io.savetonifti(outcorrarray.reshape(nativecorrshape), theheader, savename)
-
-    TimingLGR.info(
-        f"{similaritytype} calculation end, pass {thepass}",
-        {
-            "message2": voxelsprocessed_cp,
-            "message3": "voxels",
-        },
-    )
-
-    # Step 1b.  Do a peak prefit
-    if optiondict["similaritymetric"] == "hybrid":
-        LGR.info(f"\n\nPeak prefit calculation, pass {thepass}")
-        TimingLGR.info(f"Peak prefit calculation start, pass {thepass}")
-
-        tide_util.disablemkl(optiondict["nprocs_peakeval"], debug=optiondict["threaddebug"])
-        voxelsprocessed_pe, thepeakdict = tide_peakeval.peakevalpass(
-            fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
-            cleaned_referencetc,
-            initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
-            os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
-            theMutualInformationator,
-            trimmedcorrscale,
-            corrout,
-            nprocs=optiondict["nprocs_peakeval"],
-            alwaysmultiproc=optiondict["alwaysmultiproc"],
-            bipolar=optiondict["bipolar"],
-            oversampfactor=optiondict["oversampfactor"],
-            interptype=optiondict["interptype"],
-            showprogressbar=optiondict["showprogressbar"],
-            chunksize=optiondict["mp_chunksize"],
-            rt_floatset=rt_floatset,
-            rt_floattype=rt_floattype,
-        )
-        tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
-
-        TimingLGR.info(
-            f"Peak prefit end, pass {thepass}",
-            {
-                "message2": voxelsprocessed_pe,
-                "message3": "voxels",
-            },
-        )
-        mipeaks = lagtimes * 0.0
-        for i in range(numvalidspatiallocs):
-            if len(thepeakdict[str(i)]) > 0:
-                mipeaks[i] = thepeakdict[str(i)][0][0]
-    else:
-        thepeakdict = None
-
-    # Step 2 - similarity function fitting and time lag estimation
-    # write out the current version of the run options
-    optiondict["currentstage"] = f"presimfuncfit_pass{thepass}"
-    tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
-    LGR.info(f"\n\nTime lag estimation pass {thepass}")
-    TimingLGR.info(f"Time lag estimation start, pass {thepass}")
-
-    theFitter.setfunctype(optiondict["similaritymetric"])
-    theFitter.setcorrtimeaxis(trimmedcorrscale)
-
-    # use initial lags if this is a hybrid fit
-    if optiondict["similaritymetric"] == "hybrid" and thepeakdict is not None:
-        initlags = mipeaks
-    else:
-        initlags = None
-
-    tide_util.disablemkl(optiondict["nprocs_fitcorr"], debug=optiondict["threaddebug"])
-    voxelsprocessed_fc = tide_simfuncfit.fitcorr(
-        trimmedcorrscale,
-        theFitter,
-        corrout,
-        fitmask,
-        failreason,
-        lagtimes,
-        lagstrengths,
-        lagsigma,
-        gaussout,
-        windowout,
-        R2,
-        despeckling=False,
-        peakdict=thepeakdict,
-        nprocs=optiondict["nprocs_fitcorr"],
-        alwaysmultiproc=optiondict["alwaysmultiproc"],
-        fixdelay=optiondict["fixdelay"],
-        initialdelayvalue=theinitialdelay,
-        showprogressbar=optiondict["showprogressbar"],
-        chunksize=optiondict["mp_chunksize"],
-        despeckle_thresh=optiondict["despeckle_thresh"],
-        initiallags=initlags,
-        rt_floatset=rt_floatset,
-        rt_floattype=rt_floattype,
-    )
-    tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
-
-    TimingLGR.info(
-        f"Time lag estimation end, pass {thepass}",
-        {
-            "message2": voxelsprocessed_fc,
-            "message3": "voxels",
-        },
-    )
-
-    # Step 2b - Correlation time despeckle
-    if optiondict["despeckle_passes"] > 0:
-        LGR.info(f"\n\n{similaritytype} despeckling pass {thepass}")
-        LGR.info(f"\tUsing despeckle_thresh = {optiondict['despeckle_thresh']:.3f}")
-        TimingLGR.info(f"{similaritytype} despeckle start, pass {thepass}")
-
-        # find lags that are very different from their neighbors, and refit starting at the median lag for the point
-        voxelsprocessed_fc_ds = 0
-        despecklingdone = False
-        lastnumdespeckled = 1000000
-        for despecklepass in range(optiondict["despeckle_passes"]):
-            LGR.info(f"\n\n{similaritytype} despeckling subpass {despecklepass + 1}")
-            outmaparray *= 0.0
-            outmaparray[validvoxels] = eval("lagtimes")[:]
-
-            # find voxels to despeckle
-            medianlags = ndimage.median_filter(outmaparray.reshape(nativespaceshape), 3).reshape(
-                numspatiallocs
-            )
-            # voxels that we're happy with have initlags set to -1000000.0
-            initlags = np.where(
-                np.abs(outmaparray - medianlags) > optiondict["despeckle_thresh"],
-                medianlags,
-                -1000000.0,
-            )[validvoxels]
-
-            if len(initlags) > 0:
-                numdespeckled = len(np.where(initlags != -1000000.0)[0])
-                if lastnumdespeckled > numdespeckled > 0:
-                    lastnumdespeckled = numdespeckled
-                    tide_util.disablemkl(
-                        optiondict["nprocs_fitcorr"], debug=optiondict["threaddebug"]
-                    )
-                    voxelsprocessed_thispass = tide_simfuncfit.fitcorr(
-                        trimmedcorrscale,
-                        theFitter,
-                        corrout,
-                        fitmask,
-                        failreason,
-                        lagtimes,
-                        lagstrengths,
-                        lagsigma,
-                        gaussout,
-                        windowout,
-                        R2,
-                        despeckling=True,
-                        peakdict=thepeakdict,
-                        nprocs=optiondict["nprocs_fitcorr"],
-                        alwaysmultiproc=optiondict["alwaysmultiproc"],
-                        fixdelay=optiondict["fixdelay"],
-                        initialdelayvalue=theinitialdelay,
-                        showprogressbar=optiondict["showprogressbar"],
-                        chunksize=optiondict["mp_chunksize"],
-                        despeckle_thresh=optiondict["despeckle_thresh"],
-                        initiallags=initlags,
-                        rt_floatset=rt_floatset,
-                        rt_floattype=rt_floattype,
-                    )
-                    tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
-
-                    voxelsprocessed_fc_ds += voxelsprocessed_thispass
-                    optiondict[
-                        "despecklemasksize_pass" + str(thepass) + "_d" + str(despecklepass + 1)
-                    ] = voxelsprocessed_thispass
-                    optiondict[
-                        "despecklemaskpct_pass" + str(thepass) + "_d" + str(despecklepass + 1)
-                    ] = (100.0 * voxelsprocessed_thispass / optiondict["corrmasksize"])
-                else:
-                    despecklingdone = True
-            else:
-                despecklingdone = True
-            if despecklingdone:
-                LGR.info("Nothing left to do! Terminating despeckling")
-                break
-
-        internaldespeckleincludemask = np.where(
-            np.abs(outmaparray - medianlags) > optiondict["despeckle_thresh"],
-            medianlags,
-            0.0,
-        )
-        if optiondict["savedespecklemasks"] and (optiondict["despeckle_passes"] > 0):
-            despecklesavemask = np.where(internaldespeckleincludemask[validvoxels] == 0.0, 0, 1)
-            if thepass == optiondict["passes"]:
-                if theinputdata.filetype != "text":
-                    if theinputdata.filetype == "cifti":
-                        timeindex = theheader["dim"][0] - 1
-                        spaceindex = theheader["dim"][0]
-                        theheader["dim"][timeindex] = 1
-                        theheader["dim"][spaceindex] = numspatiallocs
-                    else:
-                        theheader["dim"][0] = 3
-                        theheader["dim"][4] = 1
-                        theheader["pixdim"][4] = 1.0
-                masklist = [
-                    (
-                        despecklesavemask,
-                        "despeckle",
-                        "mask",
-                        None,
-                        "Voxels that underwent despeckling in the final pass",
-                    )
-                ]
-                tide_io.savemaplist(
-                    outputname,
-                    masklist,
-                    validvoxels,
-                    nativespaceshape,
-                    theheader,
-                    bidsbasedict,
-                    filetype=theinputdata.filetype,
-                    rt_floattype=rt_floattype,
-                    cifti_hdr=theinputdata.cifti_hdr,
-                )
-        LGR.info(
-            f"\n\n{voxelsprocessed_fc_ds} voxels despeckled in "
-            f"{optiondict['despeckle_passes']} passes"
-        )
-        TimingLGR.info(
-            f"{similaritytype} despeckle end, pass {thepass}",
-            {
-                "message2": voxelsprocessed_fc_ds,
-                "message3": "voxels",
-            },
-        )
-
-    # Step 2c - patch shifting
-    if optiondict["patchshift"]:
-        outmaparray *= 0.0
-        outmaparray[validvoxels] = eval("lagtimes")[:]
-        # new method
-        masklist = [
-            (
-                outmaparray[validvoxels],
-                f"lagtimes_prepatch_pass{thepass}",
-                "map",
-                None,
-                f"Input lagtimes map prior to patch map generation pass {thepass}",
-            ),
-        ]
-        tide_io.savemaplist(
-            outputname,
-            masklist,
-            validvoxels,
-            nativespaceshape,
-            theheader,
-            bidsbasedict,
-            filetype=theinputdata.filetype,
-            rt_floattype=rt_floattype,
-            cifti_hdr=theinputdata.cifti_hdr,
-        )
-
-        # create list of anomalous 3D regions that don't match surroundings
-        if theinputdata.nim_affine is not None:
-            # make an atlas of anomalous patches - each patch shares the same integer value
-            step1 = tide_patch.calc_DoG(
-                outmaparray.reshape(nativespaceshape).copy(),
-                theinputdata.nim_affine,
-                thesizes,
-                fwhm=optiondict["patchfwhm"],
-                ratioopt=False,
-                debug=True,
-            )
-            masklist = [
-                (
-                    step1.reshape(internalspaceshape)[validvoxels],
-                    f"DoG_pass{thepass}",
-                    "map",
-                    None,
-                    f"DoG map for pass {thepass}",
-                ),
-            ]
-            tide_io.savemaplist(
-                outputname,
-                masklist,
-                validvoxels,
-                nativespaceshape,
-                theheader,
-                bidsbasedict,
-                filetype=theinputdata.filetype,
-                rt_floattype=rt_floattype,
-                cifti_hdr=theinputdata.cifti_hdr,
-            )
-            step2 = tide_patch.invertedflood3D(
-                step1,
-                1,
-            )
-            masklist = [
-                (
-                    step2.reshape(internalspaceshape)[validvoxels],
-                    f"invertflood_pass{thepass}",
-                    "map",
-                    None,
-                    f"Inverted flood map for pass {thepass}",
-                ),
-            ]
-            tide_io.savemaplist(
-                outputname,
-                masklist,
-                validvoxels,
-                nativespaceshape,
-                theheader,
-                bidsbasedict,
-                filetype=theinputdata.filetype,
-                rt_floattype=rt_floattype,
-                cifti_hdr=theinputdata.cifti_hdr,
-            )
-
-            patchmap = tide_patch.separateclusters(
-                step2,
-                sizethresh=optiondict["patchminsize"],
-                debug=True,
-            )
-            # patchmap = tide_patch.getclusters(
-            #   outmaparray.reshape(nativespaceshape),
-            #    theinputdata.nim_affine,
-            #    thesizes,
-            #    fwhm=optiondict["patchfwhm"],
-            #    ratioopt=True,
-            #    sizethresh=optiondict["patchminsize"],
-            #    debug=True,
-            # )
-            masklist = [
-                (
-                    patchmap[validvoxels],
-                    f"patch_pass{thepass}",
-                    "map",
-                    None,
-                    f"Patch map for despeckling pass {thepass}",
-                ),
-            ]
-            tide_io.savemaplist(
-                outputname,
-                masklist,
-                validvoxels,
-                nativespaceshape,
-                theheader,
-                bidsbasedict,
-                filetype=theinputdata.filetype,
-                rt_floattype=rt_floattype,
-                cifti_hdr=theinputdata.cifti_hdr,
-            )
-
-        # now shift the patches to align with the majority of the image
-        tide_patch.interppatch(lagtimes, patchmap[validvoxels])
-
-        return internaldespeckleincludemask