rapidtide 3.0.5__py3-none-any.whl → 3.0.7__py3-none-any.whl

rapidtide/happy_supportfuncs.py

@@ -22,13 +22,14 @@ import warnings
 
 import numpy as np
 from scipy.signal import savgol_filter, welch
-from scipy.stats import kurtosis, skew
+from scipy.stats import kurtosis, skew, pearsonr
 from statsmodels.robust import mad
 from tqdm import tqdm
 
 import rapidtide.correlate as tide_corr
 import rapidtide.filter as tide_filt
 import rapidtide.fit as tide_fit
+import rapidtide.genericmultiproc as tide_genericmultiproc
 import rapidtide.io as tide_io
 import rapidtide.miscmath as tide_math
 import rapidtide.resample as tide_resample
@@ -364,7 +365,55 @@ def getcardcoeffs(
     return peakfreq
 
 
-def normalizevoxels(fmri_data, detrendorder, validvoxels, time, timings, showprogressbar=False):
+def _procOneVoxelDetrend(
+    vox,
+    voxelargs,
+    **kwargs,
+):
+    # unpack arguments
+    options = {
+        "detrendorder": 1,
+        "demean": False,
+        "debug": False,
+    }
+    options.update(kwargs)
+    detrendorder = options["detrendorder"]
+    demean = options["demean"]
+    debug = options["debug"]
+    [fmri_voxeldata] = voxelargs
+    if debug:
+        print(f"{vox=}, {detrendorder=}, {demean=}, {fmri_voxeldata.shape=}")
+
+    detrended_voxeldata = tide_fit.detrend(fmri_voxeldata, order=detrendorder, demean=demean)
+
+    return (
+        vox,
+        detrended_voxeldata,
+    )
+
+
+def _packDetrendvoxeldata(voxnum, voxelargs):
+    return [(voxelargs[0])[voxnum, :]]
+
+
+def _unpackDetrendvoxeldata(retvals, voxelproducts):
+    (voxelproducts[0])[retvals[0], :] = retvals[1]
+
+
+def normalizevoxels(
+    fmri_data,
+    detrendorder,
+    validvoxels,
+    time,
+    timings,
+    LGR=None,
+    mpcode=True,
+    nprocs=1,
+    alwaysmultiproc=False,
+    showprogressbar=True,
+    chunksize=1000,
+    debug=False,
+):
     print("Normalizing voxels...")
     normdata = fmri_data * 0.0
     demeandata = fmri_data * 0.0
@@ -373,17 +422,54 @@ def normalizevoxels(fmri_data, detrendorder, validvoxels, time, timings, showpro
     numspatiallocs = fmri_data.shape[0]
     if detrendorder > 0:
         print("Detrending to order", detrendorder, "...")
-        for idx, thevox in enumerate(
-            tqdm(
-                validvoxels,
-                desc="Voxel",
-                unit="voxels",
-                disable=(not showprogressbar),
-            )
-        ):
-            fmri_data[thevox, :] = tide_fit.detrend(
-                fmri_data[thevox, :], order=detrendorder, demean=False
+        if mpcode:
+            if debug:
+                print(f"detrend multiproc path: {detrendorder=}")
+            inputshape = fmri_data.shape
+            voxelargs = [
+                fmri_data,
+            ]
+            voxelfunc = _procOneVoxelDetrend
+            packfunc = _packDetrendvoxeldata
+            unpackfunc = _unpackDetrendvoxeldata
+            voxelmask = fmri_data[:, 0] * 0.0
+            voxelmask[validvoxels] = 1
+            voxeltargets = [fmri_data]
+
+            numspatiallocs = tide_genericmultiproc.run_multiproc(
+                voxelfunc,
+                packfunc,
+                unpackfunc,
+                voxelargs,
+                voxeltargets,
+                inputshape,
+                voxelmask,
+                LGR,
+                nprocs,
+                alwaysmultiproc,
+                showprogressbar,
+                chunksize,
+                debug=debug,
+                detrendorder=detrendorder,
+                demean=False,
             )
+        else:
+            if debug:
+                print(f"detrend nonmultiproc path: {detrendorder=}")
+            for idx, thevox in enumerate(
+                tqdm(
+                    validvoxels,
+                    desc="Voxel",
+                    unit="voxels",
+                    disable=(not showprogressbar),
+                )
+            ):
+                fmri_data[thevox, :] = tide_fit.detrend(
+                    fmri_data[thevox, :], order=detrendorder, demean=False
+                )
+            timings.append(["Detrending finished", time.time(), numspatiallocs, "voxels"])
+            print(" done")
+
         timings.append(["Detrending finished", time.time(), numspatiallocs, "voxels"])
         print(" done")
 
@@ -960,6 +1046,7 @@ def cardiaccycleaverage(
     congridbins,
     gridkernel,
     centric,
+    cache=True,
     cyclic=True,
 ):
     rawapp_bypoint = np.zeros(len(destinationphases), dtype=np.float64)
@@ -971,13 +1058,14 @@ def cardiaccycleaverage(
             1.0,
             congridbins,
             kernel=gridkernel,
+            cache=cache,
             cyclic=cyclic,
         )
         for i in range(len(theindices)):
             weight_bypoint[theindices[i]] += theweights[i]
             rawapp_bypoint[theindices[i]] += theweights[i] * waveform[t]
     rawapp_bypoint = np.where(
-        weight_bypoint > np.max(weight_bypoint) / 50.0,
+        weight_bypoint > (np.max(weight_bypoint) / 50.0),
         np.nan_to_num(rawapp_bypoint / weight_bypoint),
         0.0,
     )
@@ -998,6 +1086,285 @@ def circularderivs(timecourse):
     )
 
 
+def _procOnePhaseProject(slice, sliceargs, **kwargs):
+    options = {
+        "cache": True,
+        "debug": False,
+    }
+    options.update(kwargs)
+    cache = options["cache"]
+    debug = options["debug"]
+    (
+        validlocslist,
+        proctrs,
+        demeandata_byslice,
+        fmri_data_byslice,
+        outphases,
+        cardphasevals,
+        congridbins,
+        gridkernel,
+        weights_byslice,
+        cine_byslice,
+        destpoints,
+        rawapp_byslice,
+    ) = sliceargs
+    # now smooth the projected data along the time dimension
+    validlocs = validlocslist[slice]
+    if len(validlocs) > 0:
+        for t in proctrs:
+            filteredmr = -demeandata_byslice[validlocs, slice, t]
+            cinemr = fmri_data_byslice[validlocs, slice, t]
+            thevals, theweights, theindices = tide_resample.congrid(
+                outphases,
+                cardphasevals[slice, t],
+                1.0,
+                congridbins,
+                kernel=gridkernel,
+                cache=cache,
+                cyclic=True,
+            )
+            for i in range(len(theindices)):
+                weights_byslice[validlocs, slice, theindices[i]] += theweights[i]
+                rawapp_byslice[validlocs, slice, theindices[i]] += filteredmr
+                cine_byslice[validlocs, slice, theindices[i]] += theweights[i] * cinemr
+        for d in range(destpoints):
+            if weights_byslice[validlocs[0], slice, d] == 0.0:
+                weights_byslice[validlocs, slice, d] = 1.0
+        rawapp_byslice[validlocs, slice, :] = np.nan_to_num(
+            rawapp_byslice[validlocs, slice, :] / weights_byslice[validlocs, slice, :]
+        )
+        cine_byslice[validlocs, slice, :] = np.nan_to_num(
+            cine_byslice[validlocs, slice, :] / weights_byslice[validlocs, slice, :]
+        )
+    else:
+        rawapp_byslice[:, slice, :] = 0.0
+        cine_byslice[:, slice, :] = 0.0
+
+    return (
+        slice,
+        rawapp_byslice[:, slice, :],
+        cine_byslice[:, slice, :],
+        weights_byslice[:, slice, :],
+        validlocs,
+    )
+
+
+def _packslicedataPhaseProject(slicenum, sliceargs):
+    return [
+        sliceargs[0],
+        sliceargs[1],
+        sliceargs[2],
+        sliceargs[3],
+        sliceargs[4],
+        sliceargs[5],
+        sliceargs[6],
+        sliceargs[7],
+        sliceargs[8],
+        sliceargs[9],
+        sliceargs[10],
+        sliceargs[11],
+    ]
+
+
+def _unpackslicedataPhaseProject(retvals, voxelproducts):
+    (voxelproducts[0])[retvals[4], retvals[0], :] = (retvals[1])[retvals[4], :]
+    (voxelproducts[1])[retvals[4], retvals[0], :] = (retvals[2])[retvals[4], :]
+    (voxelproducts[2])[retvals[4], retvals[0], :] = (retvals[3])[retvals[4], :]
+
+
+def preloadcongrid(outphases, congridbins, gridkernel="kaiser", cyclic=True, debug=False):
+    outphasestep = outphases[1] - outphases[0]
+    outphasecenter = outphases[int(len(outphases) / 2)]
+    fillargs = outphasestep * (
+        np.linspace(-0.5, 0.5, 10001, endpoint=True, dtype=float) + outphasecenter
+    )
+    for thearg in fillargs:
+        dummy, dummy, dummy = tide_resample.congrid(
+            outphases,
+            thearg,
+            1.0,
+            congridbins,
+            kernel=gridkernel,
+            cyclic=cyclic,
+            cache=True,
+            debug=debug,
+        )
+
+
+def phaseprojectpass(
+    numslices,
+    demeandata_byslice,
+    fmri_data_byslice,
+    validlocslist,
+    proctrs,
+    weights_byslice,
+    cine_byslice,
+    rawapp_byslice,
+    outphases,
+    cardphasevals,
+    congridbins,
+    gridkernel,
+    destpoints,
+    mpcode=False,
+    nprocs=1,
+    alwaysmultiproc=False,
+    showprogressbar=True,
+    cache=True,
+    debug=False,
+):
+    if mpcode:
+        inputshape = rawapp_byslice.shape
+        sliceargs = [
+            validlocslist,
+            proctrs,
+            demeandata_byslice,
+            fmri_data_byslice,
+            outphases,
+            cardphasevals,
+            congridbins,
+            gridkernel,
+            weights_byslice,
+            cine_byslice,
+            destpoints,
+            rawapp_byslice,
+        ]
+        slicefunc = _procOnePhaseProject
+        packfunc = _packslicedataPhaseProject
+        unpackfunc = _unpackslicedataPhaseProject
+        slicetargets = [rawapp_byslice, cine_byslice, weights_byslice]
+        slicemask = rawapp_byslice[0, :, 0] * 0.0 + 1
+
+        slicetotal = tide_genericmultiproc.run_multiproc(
+            slicefunc,
+            packfunc,
+            unpackfunc,
+            sliceargs,
+            slicetargets,
+            inputshape,
+            slicemask,
+            None,
+            nprocs,
+            alwaysmultiproc,
+            showprogressbar,
+            8,
+            indexaxis=1,
+            procunit="slices",
+            cache=cache,
+            debug=debug,
+        )
+    else:
+        for theslice in tqdm(
+            range(numslices),
+            desc="Slice",
+            unit="slices",
+            disable=(not showprogressbar),
+        ):
+            validlocs = validlocslist[theslice]
+            if len(validlocs) > 0:
+                for t in proctrs:
+                    filteredmr = -demeandata_byslice[validlocs, theslice, t]
+                    cinemr = fmri_data_byslice[validlocs, theslice, t]
+                    thevals, theweights, theindices = tide_resample.congrid(
+                        outphases,
+                        cardphasevals[theslice, t],
+                        1.0,
+                        congridbins,
+                        kernel=gridkernel,
+                        cyclic=True,
+                        cache=cache,
+                        debug=debug,
+                    )
+                    for i in range(len(theindices)):
+                        weights_byslice[validlocs, theslice, theindices[i]] += theweights[i]
+                        rawapp_byslice[validlocs, theslice, theindices[i]] += filteredmr
+                        cine_byslice[validlocs, theslice, theindices[i]] += theweights[i] * cinemr
+                for d in range(destpoints):
+                    if weights_byslice[validlocs[0], theslice, d] == 0.0:
+                        weights_byslice[validlocs, theslice, d] = 1.0
+                rawapp_byslice[validlocs, theslice, :] = np.nan_to_num(
+                    rawapp_byslice[validlocs, theslice, :]
+                    / weights_byslice[validlocs, theslice, :]
+                )
+                cine_byslice[validlocs, theslice, :] = np.nan_to_num(
+                    cine_byslice[validlocs, theslice, :] / weights_byslice[validlocs, theslice, :]
+                )
+            else:
+                rawapp_byslice[:, theslice, :] = 0.0
+                cine_byslice[:, theslice, :] = 0.0
+
+
+def _procOneSliceSmoothing(slice, sliceargs, **kwargs):
+    options = {
+        "debug": False,
+    }
+    options.update(kwargs)
+    debug = options["debug"]
+    (validlocslist, rawapp_byslice, appsmoothingfilter, phaseFs, derivatives_byslice) = sliceargs
+    # now smooth the projected data along the time dimension
+    validlocs = validlocslist[slice]
+    if len(validlocs) > 0:
+        for loc in validlocs:
+            rawapp_byslice[loc, slice, :] = appsmoothingfilter.apply(
+                phaseFs, rawapp_byslice[loc, slice, :]
+            )
+            derivatives_byslice[loc, slice, :] = circularderivs(rawapp_byslice[loc, slice, :])
+    return slice, rawapp_byslice[:, slice, :], derivatives_byslice[:, slice, :]
+
+
+def _packslicedataSliceSmoothing(slicenum, sliceargs):
+    return [
+        sliceargs[0],
+        sliceargs[1],
+        sliceargs[2],
+        sliceargs[3],
+        sliceargs[4],
+    ]
+
+
+def _unpackslicedataSliceSmoothing(retvals, voxelproducts):
+    (voxelproducts[0])[:, retvals[0], :] = retvals[1]
+    (voxelproducts[1])[:, retvals[0], :] = retvals[2]
+
+
+def tcsmoothingpass(
+    numslices,
+    validlocslist,
+    rawapp_byslice,
+    appsmoothingfilter,
+    phaseFs,
+    derivatives_byslice,
+    nprocs=1,
+    alwaysmultiproc=False,
+    showprogressbar=True,
+    debug=False,
+):
+    inputshape = rawapp_byslice.shape
+    sliceargs = [validlocslist, rawapp_byslice, appsmoothingfilter, phaseFs, derivatives_byslice]
+    slicefunc = _procOneSliceSmoothing
+    packfunc = _packslicedataSliceSmoothing
+    unpackfunc = _unpackslicedataSliceSmoothing
+    slicetargets = [rawapp_byslice, derivatives_byslice]
+    slicemask = rawapp_byslice[0, :, 0] * 0.0 + 1
+
+    slicetotal = tide_genericmultiproc.run_multiproc(
+        slicefunc,
+        packfunc,
+        unpackfunc,
+        sliceargs,
+        slicetargets,
+        inputshape,
+        slicemask,
+        None,
+        nprocs,
+        alwaysmultiproc,
+        showprogressbar,
+        16,
+        indexaxis=1,
+        procunit="slices",
+        debug=debug,
+    )
+
+
 def phaseproject(
     input_data,
     demeandata_byslice,
@@ -1030,112 +1397,156 @@ def phaseproject(
     xsize, ysize, numslices, timepoints = input_data.getdims()
     fmri_data_byslice = input_data.byslice()
 
+    # first find the validlocs for each slice
+    validlocslist = []
+    if args.verbose:
+        print("Finding validlocs")
+    for theslice in range(numslices):
+        validlocslist.append(np.where(projmask_byslice[:, theslice] > 0)[0])
+
+    # phase project each slice
+    print("Phase projecting")
+    phaseprojectpass(
+        numslices,
+        demeandata_byslice,
+        fmri_data_byslice,
+        validlocslist,
+        proctrs,
+        weights_byslice,
+        cine_byslice,
+        rawapp_byslice,
+        outphases,
+        cardphasevals,
+        args.congridbins,
+        args.gridkernel,
+        args.destpoints,
+        cache=args.congridcache,
+        mpcode=args.mpphaseproject,
+        nprocs=args.nprocs,
+        showprogressbar=args.showprogressbar,
+    )
+
+    # smooth the phase projection, if requested
+    if args.smoothapp:
+        print("Smoothing timecourses")
+        tcsmoothingpass(
+            numslices,
+            validlocslist,
+            rawapp_byslice,
+            appsmoothingfilter,
+            phaseFs,
+            derivatives_byslice,
+            nprocs=args.nprocs,
+            showprogressbar=args.showprogressbar,
+        )
+
+    # now do the flips
+    print("Doing flips")
     for theslice in tqdm(
         range(numslices),
         desc="Slice",
         unit="slices",
         disable=(not args.showprogressbar),
     ):
-        if args.verbose:
-            print("Phase projecting for slice", theslice)
-        validlocs = np.where(projmask_byslice[:, theslice] > 0)[0]
-        # indexlist = range(0, len(cardphasevals[theslice, :]))
+        # now do the flips
+        validlocs = validlocslist[theslice]
         if len(validlocs) > 0:
-            for t in proctrs:
-                filteredmr = -demeandata_byslice[validlocs, theslice, t]
-                cinemr = fmri_data_byslice[validlocs, theslice, t]
-                thevals, theweights, theindices = tide_resample.congrid(
-                    outphases,
-                    cardphasevals[theslice, t],
-                    1.0,
-                    args.congridbins,
-                    kernel=args.gridkernel,
-                    cyclic=True,
-                )
-                for i in range(len(theindices)):
-                    weights_byslice[validlocs, theslice, theindices[i]] += theweights[i]
-                    # rawapp_byslice[validlocs, theslice, theindices[i]] += (
-                    #    theweights[i] * filteredmr
-                    # )
-                    rawapp_byslice[validlocs, theslice, theindices[i]] += filteredmr
-                    cine_byslice[validlocs, theslice, theindices[i]] += theweights[i] * cinemr
-            for d in range(args.destpoints):
-                if weights_byslice[validlocs[0], theslice, d] == 0.0:
-                    weights_byslice[validlocs, theslice, d] = 1.0
-            rawapp_byslice[validlocs, theslice, :] = np.nan_to_num(
-                rawapp_byslice[validlocs, theslice, :] / weights_byslice[validlocs, theslice, :]
+            appflips_byslice = np.where(
+                -derivatives_byslice[:, :, 2] > derivatives_byslice[:, :, 0], -1.0, 1.0
             )
-            cine_byslice[validlocs, theslice, :] = np.nan_to_num(
-                cine_byslice[validlocs, theslice, :] / weights_byslice[validlocs, theslice, :]
+            timecoursemean = np.mean(rawapp_byslice[validlocs, theslice, :], axis=1).reshape(
+                (-1, 1)
+            )
+            if args.fliparteries:
+                corrected_rawapp_byslice[validlocs, theslice, :] = (
+                    rawapp_byslice[validlocs, theslice, :] - timecoursemean
+                ) * appflips_byslice[validlocs, theslice, None] + timecoursemean
+                if args.doaliasedcorrelation and (thispass > 0):
+                    for theloc in validlocs:
+                        thecorrfunc_byslice[theloc, theslice, :] = theAliasedCorrelator.apply(
+                            -appflips_byslice[theloc, theslice]
+                            * demeandata_byslice[theloc, theslice, :],
+                            int(sliceoffsets[theslice]),
+                        )[corrstartloc : correndloc + 1]
+                        maxloc = np.argmax(thecorrfunc_byslice[theloc, theslice, :])
+                        wavedelay_byslice[theloc, theslice] = (
+                            thealiasedcorrx[corrstartloc : correndloc + 1]
+                        )[maxloc]
+                        waveamp_byslice[theloc, theslice] = np.fabs(
+                            thecorrfunc_byslice[theloc, theslice, maxloc]
+                        )
+                        wavedelayCOM_byslice[theloc, theslice] = theCOM(
+                            thealiasedcorrx[corrstartloc : correndloc + 1],
+                            np.fabs(thecorrfunc_byslice[theloc, theslice, :]),
+                        )
+            else:
+                corrected_rawapp_byslice[validlocs, theslice, :] = rawapp_byslice[
+                    validlocs, theslice, :
+                ]
+                if args.doaliasedcorrelation and (thispass > 0):
+                    for theloc in validlocs:
+                        thecorrfunc_byslice[theloc, theslice, :] = theAliasedCorrelator.apply(
+                            -demeandata_byslice[theloc, theslice, :],
+                            int(sliceoffsets[theslice]),
+                        )[corrstartloc : correndloc + 1]
+                        maxloc = np.argmax(np.abs(thecorrfunc_byslice[theloc, theslice, :]))
+                        wavedelay_byslice[theloc, theslice] = (
+                            thealiasedcorrx[corrstartloc : correndloc + 1]
+                        )[maxloc]
+                        waveamp_byslice[theloc, theslice] = np.fabs(
+                            thecorrfunc_byslice[theloc, theslice, maxloc]
+                        )
+            timecoursemin = np.min(
+                corrected_rawapp_byslice[validlocs, theslice, :], axis=1
+            ).reshape((-1, 1))
+            app_byslice[validlocs, theslice, :] = (
+                corrected_rawapp_byslice[validlocs, theslice, :] - timecoursemin
+            )
+            normapp_byslice[validlocs, theslice, :] = np.nan_to_num(
+                app_byslice[validlocs, theslice, :] / means_byslice[validlocs, theslice, None]
             )
-        else:
-            rawapp_byslice[:, theslice, :] = 0.0
-            cine_byslice[:, theslice, :] = 0.0
-
-        # smooth the projected data along the time dimension
-        if args.smoothapp:
-            for loc in validlocs:
-                rawapp_byslice[loc, theslice, :] = appsmoothingfilter.apply(
-                    phaseFs, rawapp_byslice[loc, theslice, :]
-                )
-                derivatives_byslice[loc, theslice, :] = circularderivs(
-                    rawapp_byslice[loc, theslice, :]
-                )
-        appflips_byslice = np.where(
-            -derivatives_byslice[:, :, 2] > derivatives_byslice[:, :, 0], -1.0, 1.0
-        )
-        timecoursemean = np.mean(rawapp_byslice[validlocs, theslice, :], axis=1).reshape((-1, 1))
-        if args.fliparteries:
-            corrected_rawapp_byslice[validlocs, theslice, :] = (
-                rawapp_byslice[validlocs, theslice, :] - timecoursemean
-            ) * appflips_byslice[validlocs, theslice, None] + timecoursemean
-            if args.doaliasedcorrelation and (thispass > 0):
-                for theloc in validlocs:
-                    thecorrfunc_byslice[theloc, theslice, :] = theAliasedCorrelator.apply(
-                        -appflips_byslice[theloc, theslice]
-                        * demeandata_byslice[theloc, theslice, :],
-                        int(sliceoffsets[theslice]),
-                    )[corrstartloc : correndloc + 1]
-                    maxloc = np.argmax(thecorrfunc_byslice[theloc, theslice, :])
-                    wavedelay_byslice[theloc, theslice] = (
-                        thealiasedcorrx[corrstartloc : correndloc + 1]
-                    )[maxloc]
-                    waveamp_byslice[theloc, theslice] = np.fabs(
-                        thecorrfunc_byslice[theloc, theslice, maxloc]
-                    )
-                    wavedelayCOM_byslice[theloc, theslice] = theCOM(
-                        thealiasedcorrx[corrstartloc : correndloc + 1],
-                        np.fabs(thecorrfunc_byslice[theloc, theslice, :]),
-                    )
-        else:
-            corrected_rawapp_byslice[validlocs, theslice, :] = rawapp_byslice[
-                validlocs, theslice, :
-            ]
-            if args.doaliasedcorrelation and (thispass > 0):
-                for theloc in validlocs:
-                    thecorrfunc_byslice[theloc, theslice, :] = theAliasedCorrelator.apply(
-                        -demeandata_byslice[theloc, theslice, :],
-                        int(sliceoffsets[theslice]),
-                    )[corrstartloc : correndloc + 1]
-                    maxloc = np.argmax(np.abs(thecorrfunc_byslice[theloc, theslice, :]))
-                    wavedelay_byslice[theloc, theslice] = (
-                        thealiasedcorrx[corrstartloc : correndloc + 1]
-                    )[maxloc]
-                    waveamp_byslice[theloc, theslice] = np.fabs(
-                        thecorrfunc_byslice[theloc, theslice, maxloc]
-                    )
-        timecoursemin = np.min(corrected_rawapp_byslice[validlocs, theslice, :], axis=1).reshape(
-            (-1, 1)
-        )
-        app_byslice[validlocs, theslice, :] = (
-            corrected_rawapp_byslice[validlocs, theslice, :] - timecoursemin
-        )
-        normapp_byslice[validlocs, theslice, :] = np.nan_to_num(
-            app_byslice[validlocs, theslice, :] / means_byslice[validlocs, theslice, None]
-        )
     return appflips_byslice
 
 
+def findvessels(
+    app,
+    normapp,
+    validlocs,
+    numspatiallocs,
+    outputroot,
+    unnormvesselmap,
+    destpoints,
+    softvesselfrac,
+    histlen,
+    outputlevel,
+    debug=False,
+):
+    if unnormvesselmap:
+        app2d = app.reshape((numspatiallocs, destpoints))
+    else:
+        app2d = normapp.reshape((numspatiallocs, destpoints))
+    histinput = app2d[validlocs, :].reshape((len(validlocs), destpoints))
+    if outputlevel > 0:
+        namesuffix = "_desc-apppeaks_hist"
+        tide_stats.makeandsavehistogram(
+            histinput,
+            histlen,
+            0,
+            outputroot + namesuffix,
+            debug=debug,
+        )
+
+    # find vessel thresholds
+    tide_util.logmem("before making vessel masks")
+    hardvesselthresh = tide_stats.getfracvals(np.max(histinput, axis=1), [0.98])[0] / 2.0
+    softvesselthresh = softvesselfrac * hardvesselthresh
+    print(
+        "hard, soft vessel thresholds set to",
+        "{:.3f}".format(hardvesselthresh),
+        "{:.3f}".format(softvesselthresh),
+    )
+
+
 def upsampleimage(input_data, numsteps, sliceoffsets, slicesamplerate, outputroot):
     fmri_data = input_data.byvol()
     timepoints = input_data.timepoints
@@ -1180,3 +1591,93 @@ def upsampleimage(input_data, numsteps, sliceoffsets, slicesamplerate, outputroo
     )
     tide_io.savetonifti(upsampleimage, theheader, outputroot + "_upsampled")
     print("upsampling complete")
+
+
+def wrightmap(
+    input_data,
+    demeandata_byslice,
+    rawapp_byslice,
+    projmask_byslice,
+    outphases,
+    cardphasevals,
+    proctrs,
+    congridbins,
+    gridkernel,
+    destpoints,
+    iterations=100,
+    nprocs=-1,
+    verbose=False,
+    debug=False,
+):
+    xsize = input_data.xsize
+    ysize = input_data.ysize
+    numslices = input_data.numslices
+    # make a vessel map using Wright's method
+    wrightcorrs_byslice = np.zeros((xsize * ysize, numslices, iterations))
+    # first find the validlocs for each slice
+    validlocslist = []
+    if verbose:
+        print("Finding validlocs")
+    for theslice in range(numslices):
+        validlocslist.append(np.where(projmask_byslice[:, theslice] > 0)[0])
+    for theiteration in range(iterations):
+        print(f"wright iteration: {theiteration + 1} of {iterations}")
+        # split timecourse into two sets
+        scrambledprocs = np.random.permutation(proctrs)
+        proctrs1 = scrambledprocs[: int(len(scrambledprocs) // 2)]
+        proctrs2 = scrambledprocs[int(len(scrambledprocs) // 2) :]
+        if debug:
+            print(f"{proctrs1=}, {proctrs2=}")
+
+        # phase project each slice
+        rawapp_byslice1 = rawapp_byslice * 0.0
+        cine_byslice1 = rawapp_byslice * 0.0
+        weights_byslice1 = rawapp_byslice * 0.0
+        phaseprojectpass(
+            numslices,
+            demeandata_byslice,
+            input_data.byslice(),
+            validlocslist,
+            proctrs1,
+            weights_byslice1,
+            cine_byslice1,
+            rawapp_byslice1,
+            outphases,
+            cardphasevals,
+            congridbins,
+            gridkernel,
+            destpoints,
+            nprocs=nprocs,
+            showprogressbar=False,
+        )
+        rawapp_byslice2 = rawapp_byslice * 0.0
+        cine_byslice2 = rawapp_byslice * 0.0
+        weights_byslice2 = rawapp_byslice * 0.0
+        phaseprojectpass(
+            numslices,
+            demeandata_byslice,
+            input_data.byslice(),
+            validlocslist,
+            proctrs2,
+            weights_byslice2,
+            cine_byslice2,
+            rawapp_byslice2,
+            outphases,
+            cardphasevals,
+            congridbins,
+            gridkernel,
+            destpoints,
+            nprocs=nprocs,
+            showprogressbar=False,
+        )
+        for theslice in range(numslices):
+            for thepoint in validlocslist[theslice]:
+                theRvalue, thepvalue = pearsonr(
+                    rawapp_byslice1[thepoint, theslice, :],
+                    rawapp_byslice2[thepoint, theslice, :],
+                )
+                if debug:
+                    print("theRvalue = ", theRvalue)
+                wrightcorrs_byslice[thepoint, theslice, theiteration] = theRvalue
+    wrightcorrs = np.mean(wrightcorrs_byslice, axis=2).reshape(xsize, ysize, numslices)
+    return wrightcorrs