rapidtide 2.9.6__py3-none-any.whl → 3.1.3__py3-none-any.whl

rapidtide/workflows/filttc.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.
@@ -18,17 +18,42 @@
 #
 import argparse
 import sys
+from argparse import Namespace
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import numpy as np
+from numpy.typing import NDArray
 
 import rapidtide.io as tide_io
 import rapidtide.miscmath as tide_math
 import rapidtide.workflows.parser_funcs as pf
 
 
-def _get_parser():
+def _get_parser() -> Any:
     """
-    Argument parser for filttc
+    Argument parser for filttc.
+
+    This function constructs and returns an `argparse.ArgumentParser` object configured
+    for parsing command-line arguments for the `filttc` tool, which filters timecourse
+    data in text files. It includes support for specifying sampling rate or timestep,
+    filter options, normalization methods, and miscellaneous flags.
+
+    Returns
+    -------
+    argparse.ArgumentParser
+        Configured argument parser for the filttc tool.
+
+    Notes
+    -----
+    The `--samplerate` and `--sampletstep` arguments are mutually exclusive and define
+    the sampling frequency of the input timecourses. The sampling frequency can be
+    specified either as a frequency (Hz) or as a timestep (seconds), with the latter
+    being the inverse of the former.
+
+    Examples
+    --------
+    >>> parser = _get_parser()
+    >>> args = parser.parse_args(['--inputfile', 'input.txt', '--outputfile', 'output.txt'])
     """
     parser = argparse.ArgumentParser(
         prog="filttc",
@@ -104,7 +129,53 @@ def _get_parser():
     return parser
 
 
-def filttc(args):
+def filttc(args: Any) -> None:
+    """
+    Apply a filter to timecourse data read from a text file and write the filtered output.
+
+    This function reads timecourse data from a specified input file, applies a filter
+    to each timecourse, and writes the filtered data to an output file. It supports
+    normalization, demeaning, and automatic sampling rate detection from the input file
+    or command-line arguments.
+
+    Parameters
+    ----------
+    args : Any
+        An object containing command-line arguments. Expected attributes include:
+        - `inputfile`: Path to the input text file containing timecourse data.
+        - `outputfile`: Path to the output text file where filtered data will be written.
+        - `samplerate`: Sampling rate of the data, or 'auto' to detect from file.
+        - `normfirst`: Boolean indicating whether to normalize before filtering.
+        - `normmethod`: Normalization method to use (e.g., 'zscore', 'minmax').
+        - `demean`: Boolean indicating whether to remove the mean from the filtered data.
+
+    Returns
+    -------
+    None
+        This function does not return a value. It writes the filtered timecourse data
+        to the specified output file.
+
+    Notes
+    -----
+    - The input file must contain a header specifying the sampling rate, or the
+      sampling rate must be provided via command-line arguments.
+    - The filtering and normalization are applied independently to each timecourse.
+    - If `normfirst` is True, normalization is applied before filtering; otherwise,
+      filtering is applied before normalization.
+
+    Examples
+    --------
+    >>> import argparse
+    >>> args = argparse.Namespace(
+    ...     inputfile='input.txt',
+    ...     outputfile='output.txt',
+    ...     samplerate='auto',
+    ...     normfirst=False,
+    ...     normmethod='zscore',
+    ...     demean=True
+    ... )
+    >>> filttc(args)
+    """
     args, thefilter = pf.postprocessfilteropts(args)
 
     # read in data
@@ -136,7 +207,7 @@ def filttc(args):
     else:
         print("there are", numvecs, "timecourses")
     print("samplerate is", samplerate)
-    outvecs = invecs * 0.0
+    outvecs = np.zeros_like(invecs)
     for i in range(numvecs):
         if args.normfirst:
             outvecs[i, :] = thefilter.apply(

rapidtide/workflows/fitSimFuncMap.py

@@ -0,0 +1,578 @@
+#!/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.
+#
+#
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy import ndimage
+
+import rapidtide.io as tide_io
+import rapidtide.patchmatch as tide_patch
+import rapidtide.peakeval as tide_peakeval
+import rapidtide.resample as tide_resample
+import rapidtide.simfuncfit as tide_simfuncfit
+import rapidtide.util as tide_util
+
+
+def fitSimFunc(
+    fmri_data_valid: NDArray[np.floating[Any]],
+    validsimcalcstart: int,
+    validsimcalcend: int,
+    osvalidsimcalcstart: int,
+    osvalidsimcalcend: int,
+    initial_fmri_x: NDArray[np.floating[Any]],
+    os_fmri_x: NDArray[np.floating[Any]],
+    theMutualInformationator: Any,
+    cleaned_referencetc: Any,
+    corrout: NDArray[np.floating[Any]],
+    outputname: str,
+    validvoxels: Any,
+    nativespaceshape: Any,
+    bidsbasedict: Any,
+    numspatiallocs: Any,
+    gaussout: Any,
+    theinitialdelay: Any,
+    windowout: Any,
+    R2: Any,
+    thesizes: Any,
+    internalspaceshape: Any,
+    numvalidspatiallocs: Any,
+    theinputdata: Any,
+    theheader: Any,
+    theFitter: Any,
+    fitmask: Any,
+    lagtimes: Any,
+    lagstrengths: Any,
+    lagsigma: Any,
+    failreason: Any,
+    outmaparray: Any,
+    trimmedcorrscale: Any,
+    similaritytype: Any,
+    thepass: Any,
+    optiondict: Any,
+    LGR: Any,
+    TimingLGR: Any,
+    simplefit: bool = False,
+    upsampfac: int = 8,
+    rt_floattype: np.dtype = np.float64,
+) -> NDArray | None:
+    """
+    Perform similarity function fitting and time lag estimation for fMRI data.
+
+    This function conducts either a simple or full fitting process for estimating time lags
+    between fMRI signals and a reference time course. It supports hybrid similarity metrics
+    and includes optional despeckling and patch shifting steps.
+
+    Parameters
+    ----------
+    fmri_data_valid : NDArray[np.floating[Any]]
+        Valid fMRI data for processing.
+    validsimcalcstart : int
+        Start index for valid similarity calculation.
+    validsimcalcend : int
+        End index for valid similarity calculation.
+    osvalidsimcalcstart : int
+        Start index for oversampled valid similarity calculation.
+    osvalidsimcalcend : int
+        End index for oversampled valid similarity calculation.
+    initial_fmri_x : NDArray[np.floating[Any]]
+        Initial fMRI x values.
+    os_fmri_x : NDArray[np.floating[Any]]
+        Oversampled fMRI x values.
+    theMutualInformationator : object
+        Mutual information calculator.
+    cleaned_referencetc : array_like
+        Cleaned reference time course.
+    corrout : NDArray[np.floating[Any]]
+        Correlation output array.
+    outputname : str
+        Output filename prefix.
+    validvoxels : array_like
+        Indices of valid voxels.
+    nativespaceshape : tuple
+        Native space shape of the data.
+    bidsbasedict : dict
+        BIDS-based dictionary for output metadata.
+    numspatiallocs : int
+        Number of spatial locations.
+    gaussout : array_like
+        Gaussian output array.
+    theinitialdelay : float
+        Initial delay value.
+    windowout : array_like
+        Window output array.
+    R2 : array_like
+        R-squared values.
+    thesizes : array_like
+        Sizes for processing.
+    internalspaceshape : tuple
+        Internal space shape.
+    numvalidspatiallocs : int
+        Number of valid spatial locations.
+    theinputdata : object
+        Input data object.
+    theheader : dict
+        Header information.
+    theFitter : object
+        Fitter object for similarity function fitting.
+    fitmask : array_like
+        Mask for fitting.
+    lagtimes : array_like
+        Array to store estimated lag times.
+    lagstrengths : array_like
+        Array to store lag strengths.
+    lagsigma : array_like
+        Array to store sigma values for lags.
+    failreason : array_like
+        Array to store failure reasons.
+    outmaparray : array_like
+        Output map array.
+    trimmedcorrscale : array_like
+        Trimmed correlation scale.
+    similaritytype : str
+        Type of similarity metric used.
+    thepass : int
+        Current pass number.
+    optiondict : dict
+        Dictionary of options for processing.
+    LGR : object
+        Logger for general messages.
+    TimingLGR : object
+        Logger for timing information.
+    simplefit : bool, optional
+        If True, perform simple fitting using upsampling. Default is False.
+    upsampfac : int, optional
+        Upsampling factor for simple fitting. Default is 8.
+    rt_floattype : np.dtype, optional
+        Real-time floating-point data type. Default is np.float64.
+
+    Returns
+    -------
+    internaldespeckleincludemask : NDArray[np.floating[Any]] or None
+        Mask indicating which voxels were included in despeckling, or None if no despeckling was performed.
+
+    Notes
+    -----
+    - This function supports both simple and hybrid similarity metrics.
+    - Despeckling and patch shifting steps are optional and controlled by `optiondict`.
+    - The function modifies `lagtimes`, `lagstrengths`, `lagsigma`, and `fitmask` in-place.
+
+    Examples
+    --------
+    >>> fitSimFunc(
+    ...     fmri_data_valid,
+    ...     validsimcalcstart,
+    ...     validsimcalcend,
+    ...     osvalidsimcalcstart,
+    ...     osvalidsimcalcend,
+    ...     initial_fmri_x,
+    ...     os_fmri_x,
+    ...     theMutualInformationator,
+    ...     cleaned_referencetc,
+    ...     corrout,
+    ...     outputname,
+    ...     validvoxels,
+    ...     nativespaceshape,
+    ...     bidsbasedict,
+    ...     numspatiallocs,
+    ...     gaussout,
+    ...     theinitialdelay,
+    ...     windowout,
+    ...     R2,
+    ...     thesizes,
+    ...     internalspaceshape,
+    ...     numvalidspatiallocs,
+    ...     theinputdata,
+    ...     theheader,
+    ...     theFitter,
+    ...     fitmask,
+    ...     lagtimes,
+    ...     lagstrengths,
+    ...     lagsigma,
+    ...     failreason,
+    ...     outmaparray,
+    ...     trimmedcorrscale,
+    ...     similaritytype,
+    ...     thepass,
+    ...     optiondict,
+    ...     LGR,
+    ...     TimingLGR,
+    ...     simplefit=False,
+    ...     upsampfac=8,
+    ...     rt_floattype="float64",
+    ... )
+    """
+    # Do a peak prefit if doing hybrid
+    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_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 = np.zeros_like(lagtimes)
+        for i in range(numvalidspatiallocs):
+            if len(thepeakdict[str(i)]) > 0:
+                mipeaks[i] = thepeakdict[str(i)][0][0]
+    else:
+        thepeakdict = None
+
+    if simplefit:
+        basedelay = trimmedcorrscale[0]
+        delaystep = (trimmedcorrscale[1] - trimmedcorrscale[0]) / upsampfac
+        for thevox in range(numvalidspatiallocs):
+            fitmask[thevox] = 1
+            upsampcorrout = tide_resample.upsample(
+                corrout[thevox, :], 1, upsampfac, intfac=True, dofilt=False
+            )
+            if optiondict["bipolar"]:
+                thismax = np.argmax(np.fabs(upsampcorrout))
+            else:
+                thismax = np.argmax(upsampcorrout)
+            lagtimes[thevox] = basedelay + thismax * delaystep
+            lagstrengths[thevox] = upsampcorrout[thismax]
+            lagsigma[thevox] = 1.0
+        internaldespeckleincludemask = None
+    else:
+        # 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_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",
+            },
+        )
+
+        # 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_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",
+                },
+            )
+        else:
+            internaldespeckleincludemask = None
+
+        # 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