niwrap-afni 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

niwrap_afni/afni/v_3d_clip_level.py

@@ -6,7 +6,7 @@ import pathlib
 from styxdefs import *
 
 V_3D_CLIP_LEVEL_METADATA = Metadata(
-    id="d74c5cd045e053e286d1b5c8e3587d88d871f128.boutiques",
+    id="e0dffc3fb16b61bec3a898141cfff2cf90509ea6.boutiques",
     name="3dClipLevel",
     package="afni",
     container_image_tag="afni/afni_make_build:AFNI_24.2.06",
@@ -16,6 +16,9 @@ V_3D_CLIP_LEVEL_METADATA = Metadata(
 V3dClipLevelParameters = typing.TypedDict('V3dClipLevelParameters', {
     "__STYX_TYPE__": typing.Literal["3dClipLevel"],
     "dataset": InputPathType,
+    "mfrac": typing.NotRequired[float | None],
+    "doall": bool,
+    "grad": typing.NotRequired[str | None],
 })
 
 
@@ -60,19 +63,31 @@ class V3dClipLevelOutputs(typing.NamedTuple):
 
 def v_3d_clip_level_params(
     dataset: InputPathType,
+    mfrac: float | None = None,
+    doall: bool = False,
+    grad: str | None = None,
 ) -> V3dClipLevelParameters:
     """
     Build parameters.
     
     Args:
         dataset: Input dataset (e.g. dataset.nii.gz).
+        mfrac: Use the number ff instead of 0.50 in the algorithm.
+        doall: Apply the algorithm to each sub-brick separately.
+        grad: Compute a 'gradual' clip level as a function of voxel position\
+            and output to a dataset with the given prefix.
     Returns:
         Parameter dictionary
     """
     params = {
         "__STYXTYPE__": "3dClipLevel",
         "dataset": dataset,
+        "doall": doall,
     }
+    if mfrac is not None:
+        params["mfrac"] = mfrac
+    if grad is not None:
+        params["grad"] = grad
     return params
 
 
@@ -91,8 +106,19 @@ def v_3d_clip_level_cargs(
     """
     cargs = []
     cargs.append("3dClipLevel")
-    cargs.append("[options]")
     cargs.append(execution.input_file(params.get("dataset")))
+    if params.get("mfrac") is not None:
+        cargs.extend([
+            "-mfrac",
+            str(params.get("mfrac"))
+        ])
+    if params.get("doall"):
+        cargs.append("-doall")
+    if params.get("grad") is not None:
+        cargs.extend([
+            "-grad",
+            params.get("grad")
+        ])
     return cargs
 
 
@@ -142,6 +168,9 @@ def v_3d_clip_level_execute(
 
 def v_3d_clip_level(
     dataset: InputPathType,
+    mfrac: float | None = None,
+    doall: bool = False,
+    grad: str | None = None,
     runner: Runner | None = None,
 ) -> V3dClipLevelOutputs:
     """
@@ -154,6 +183,10 @@ def v_3d_clip_level(
     
     Args:
         dataset: Input dataset (e.g. dataset.nii.gz).
+        mfrac: Use the number ff instead of 0.50 in the algorithm.
+        doall: Apply the algorithm to each sub-brick separately.
+        grad: Compute a 'gradual' clip level as a function of voxel position\
+            and output to a dataset with the given prefix.
         runner: Command runner.
     Returns:
         NamedTuple of outputs (described in `V3dClipLevelOutputs`).
@@ -162,6 +195,9 @@ def v_3d_clip_level(
     execution = runner.start_execution(V_3D_CLIP_LEVEL_METADATA)
     params = v_3d_clip_level_params(
         dataset=dataset,
+        mfrac=mfrac,
+        doall=doall,
+        grad=grad,
     )
     return v_3d_clip_level_execute(params, execution)
 

niwrap_afni/afni/v_3d_clust_sim.py

@@ -6,7 +6,7 @@ import pathlib
 from styxdefs import *
 
 V_3D_CLUST_SIM_METADATA = Metadata(
-    id="493de4c7d1501714af71d386a011e1fe097ca5fb.boutiques",
+    id="912b449ef9b8c9bbf2596a5e62a4511be33fefad.boutiques",
     name="3dClustSim",
     package="afni",
     container_image_tag="afni/afni_make_build:AFNI_24.2.06",
@@ -15,6 +15,28 @@ V_3D_CLUST_SIM_METADATA = Metadata(
 
 V3dClustSimParameters = typing.TypedDict('V3dClustSimParameters', {
     "__STYX_TYPE__": typing.Literal["3dClustSim"],
+    "nxyz": typing.NotRequired[str | None],
+    "dxyz": typing.NotRequired[str | None],
+    "ball": bool,
+    "mask": typing.NotRequired[InputPathType | None],
+    "oksmallmask": bool,
+    "inset": typing.NotRequired[list[InputPathType] | None],
+    "fwhm": typing.NotRequired[float | None],
+    "acf": typing.NotRequired[str | None],
+    "nopad": bool,
+    "pthr": typing.NotRequired[str | None],
+    "athr": typing.NotRequired[str | None],
+    "lots": bool,
+    "mega": bool,
+    "iter": typing.NotRequired[float | None],
+    "nodec": bool,
+    "seed": typing.NotRequired[float | None],
+    "niml": bool,
+    "both": bool,
+    "prefix": typing.NotRequired[str | None],
+    "cmd": typing.NotRequired[str | None],
+    "quiet": bool,
+    "ssave": typing.NotRequired[str | None],
 })
 
 
@@ -56,40 +78,121 @@ class V3dClustSimOutputs(typing.NamedTuple):
     """
     root: OutputPathType
     """Output root folder. This is the root folder for all outputs."""
-    output_nn1_1sided: OutputPathType
+    output_nn1_1sided: OutputPathType | None
     """Output file for NN1 with 1-sided thresholding"""
-    output_nn1_2sided: OutputPathType
+    output_nn1_2sided: OutputPathType | None
     """Output file for NN1 with 2-sided thresholding"""
-    output_nn1_bisided: OutputPathType
+    output_nn1_bisided: OutputPathType | None
     """Output file for NN1 with bi-sided thresholding"""
-    output_nn2_1sided: OutputPathType
+    output_nn2_1sided: OutputPathType | None
     """Output file for NN2 with 1-sided thresholding"""
-    output_nn2_2sided: OutputPathType
+    output_nn2_2sided: OutputPathType | None
     """Output file for NN2 with 2-sided thresholding"""
-    output_nn2_bisided: OutputPathType
+    output_nn2_bisided: OutputPathType | None
     """Output file for NN2 with bi-sided thresholding"""
-    output_nn3_1sided: OutputPathType
+    output_nn3_1sided: OutputPathType | None
     """Output file for NN3 with 1-sided thresholding"""
-    output_nn3_2sided: OutputPathType
+    output_nn3_2sided: OutputPathType | None
     """Output file for NN3 with 2-sided thresholding"""
-    output_nn3_bisided: OutputPathType
+    output_nn3_bisided: OutputPathType | None
     """Output file for NN3 with bi-sided thresholding"""
-    mask_compressed: OutputPathType
+    mask_compressed: OutputPathType | None
     """Compressed ASCII encoding of the mask volume"""
 
 
 def v_3d_clust_sim_params(
+    nxyz: str | None = None,
+    dxyz: str | None = None,
+    ball: bool = False,
+    mask: InputPathType | None = None,
+    oksmallmask: bool = False,
+    inset: list[InputPathType] | None = None,
+    fwhm: float | None = None,
+    acf: str | None = None,
+    nopad: bool = False,
+    pthr: str | None = None,
+    athr: str | None = None,
+    lots: bool = False,
+    mega: bool = False,
+    iter_: float | None = None,
+    nodec: bool = False,
+    seed: float | None = None,
+    niml: bool = False,
+    both: bool = False,
+    prefix: str | None = None,
+    cmd_: str | None = None,
+    quiet: bool = False,
+    ssave: str | None = None,
 ) -> V3dClustSimParameters:
     """
     Build parameters.
     
     Args:
+        nxyz: Size of 3D grid to use for simulation.
+        dxyz: Voxel sizes along each dimension.
+        ball: Mask off points outside a ball at the center of the grid.
+        mask: Use the 0 sub-brick of this dataset as a mask.
+        oksmallmask: Allow small masks with less than 128 nonzero voxels.
+        inset: Use these dataset(s) as the simulations to threshold and\
+            clusterize.
+        fwhm: Gaussian filter width in mm (use -fwhmxyz for different values\
+            per axis).
+        acf: Parameters a, b, c for the autocorrelation function.
+        nopad: Turn off padding slices added for edge effects.
+        pthr: List of uncorrected per voxel p-values.
+        athr: List of corrected whole volume alpha-values.
+        lots: Use a longer list of values for pthr and athr.
+        mega: Add even more values to the pthr and athr grids.
+        iter_: Number of Monte Carlo simulations.
+        nodec: Print the cluster size threshold as an integer.
+        seed: Random number seed.
+        niml: Output the table in XML/NIML format.
+        both: Output the table in both XML/NIML format and in .1D format.
+        prefix: Specify prefix for the output files.
+        cmd_: Write command for putting results into a file's header.
+        quiet: Don't print out progress reports.
+        ssave: Save un-thresholded generated random volumes.
     Returns:
         Parameter dictionary
     """
     params = {
         "__STYXTYPE__": "3dClustSim",
+        "ball": ball,
+        "oksmallmask": oksmallmask,
+        "nopad": nopad,
+        "lots": lots,
+        "mega": mega,
+        "nodec": nodec,
+        "niml": niml,
+        "both": both,
+        "quiet": quiet,
     }
+    if nxyz is not None:
+        params["nxyz"] = nxyz
+    if dxyz is not None:
+        params["dxyz"] = dxyz
+    if mask is not None:
+        params["mask"] = mask
+    if inset is not None:
+        params["inset"] = inset
+    if fwhm is not None:
+        params["fwhm"] = fwhm
+    if acf is not None:
+        params["acf"] = acf
+    if pthr is not None:
+        params["pthr"] = pthr
+    if athr is not None:
+        params["athr"] = athr
+    if iter_ is not None:
+        params["iter"] = iter_
+    if seed is not None:
+        params["seed"] = seed
+    if prefix is not None:
+        params["prefix"] = prefix
+    if cmd_ is not None:
+        params["cmd"] = cmd_
+    if ssave is not None:
+        params["ssave"] = ssave
     return params
 
 
@@ -108,7 +211,89 @@ def v_3d_clust_sim_cargs(
     """
     cargs = []
     cargs.append("3dClustSim")
-    cargs.append("[OPTIONS]")
+    if params.get("nxyz") is not None:
+        cargs.extend([
+            "-nxyz",
+            params.get("nxyz")
+        ])
+    if params.get("dxyz") is not None:
+        cargs.extend([
+            "-dxyz",
+            params.get("dxyz")
+        ])
+    if params.get("ball"):
+        cargs.append("-BALL")
+    if params.get("mask") is not None:
+        cargs.extend([
+            "-mask",
+            execution.input_file(params.get("mask"))
+        ])
+    if params.get("oksmallmask"):
+        cargs.append("-OKsmallmask")
+    if params.get("inset") is not None:
+        cargs.extend([
+            "-inset",
+            *[execution.input_file(f) for f in params.get("inset")]
+        ])
+    if params.get("fwhm") is not None:
+        cargs.extend([
+            "-fwhm",
+            str(params.get("fwhm"))
+        ])
+    if params.get("acf") is not None:
+        cargs.extend([
+            "-acf",
+            params.get("acf")
+        ])
+    if params.get("nopad"):
+        cargs.append("-nopad")
+    if params.get("pthr") is not None:
+        cargs.extend([
+            "-pthr",
+            params.get("pthr")
+        ])
+    if params.get("athr") is not None:
+        cargs.extend([
+            "-athr",
+            params.get("athr")
+        ])
+    if params.get("lots"):
+        cargs.append("-LOTS")
+    if params.get("mega"):
+        cargs.append("-MEGA")
+    if params.get("iter") is not None:
+        cargs.extend([
+            "-iter",
+            str(params.get("iter"))
+        ])
+    if params.get("nodec"):
+        cargs.append("-nodec")
+    if params.get("seed") is not None:
+        cargs.extend([
+            "-seed",
+            str(params.get("seed"))
+        ])
+    if params.get("niml"):
+        cargs.append("-niml")
+    if params.get("both"):
+        cargs.append("-both")
+    if params.get("prefix") is not None:
+        cargs.extend([
+            "-prefix",
+            params.get("prefix")
+        ])
+    if params.get("cmd") is not None:
+        cargs.extend([
+            "-cmd",
+            params.get("cmd")
+        ])
+    if params.get("quiet"):
+        cargs.append("-quiet")
+    if params.get("ssave") is not None:
+        cargs.extend([
+            "-ssave",
+            params.get("ssave")
+        ])
     return cargs
 
 
@@ -127,16 +312,16 @@ def v_3d_clust_sim_outputs(
     """
     ret = V3dClustSimOutputs(
         root=execution.output_file("."),
-        output_nn1_1sided=execution.output_file("[PREFIX].NN1_1sided.1D"),
-        output_nn1_2sided=execution.output_file("[PREFIX].NN1_2sided.1D"),
-        output_nn1_bisided=execution.output_file("[PREFIX].NN1_bisided.1D"),
-        output_nn2_1sided=execution.output_file("[PREFIX].NN2_1sided.1D"),
-        output_nn2_2sided=execution.output_file("[PREFIX].NN2_2sided.1D"),
-        output_nn2_bisided=execution.output_file("[PREFIX].NN2_bisided.1D"),
-        output_nn3_1sided=execution.output_file("[PREFIX].NN3_1sided.1D"),
-        output_nn3_2sided=execution.output_file("[PREFIX].NN3_2sided.1D"),
-        output_nn3_bisided=execution.output_file("[PREFIX].NN3_bisided.1D"),
-        mask_compressed=execution.output_file("[PREFIX].mask"),
+        output_nn1_1sided=execution.output_file(params.get("prefix") + ".NN1_1sided.1D") if (params.get("prefix") is not None) else None,
+        output_nn1_2sided=execution.output_file(params.get("prefix") + ".NN1_2sided.1D") if (params.get("prefix") is not None) else None,
+        output_nn1_bisided=execution.output_file(params.get("prefix") + ".NN1_bisided.1D") if (params.get("prefix") is not None) else None,
+        output_nn2_1sided=execution.output_file(params.get("prefix") + ".NN2_1sided.1D") if (params.get("prefix") is not None) else None,
+        output_nn2_2sided=execution.output_file(params.get("prefix") + ".NN2_2sided.1D") if (params.get("prefix") is not None) else None,
+        output_nn2_bisided=execution.output_file(params.get("prefix") + ".NN2_bisided.1D") if (params.get("prefix") is not None) else None,
+        output_nn3_1sided=execution.output_file(params.get("prefix") + ".NN3_1sided.1D") if (params.get("prefix") is not None) else None,
+        output_nn3_2sided=execution.output_file(params.get("prefix") + ".NN3_2sided.1D") if (params.get("prefix") is not None) else None,
+        output_nn3_bisided=execution.output_file(params.get("prefix") + ".NN3_bisided.1D") if (params.get("prefix") is not None) else None,
+        mask_compressed=execution.output_file(params.get("prefix") + ".mask") if (params.get("prefix") is not None) else None,
     )
     return ret
 
@@ -166,6 +351,28 @@ def v_3d_clust_sim_execute(
 
 
 def v_3d_clust_sim(
+    nxyz: str | None = None,
+    dxyz: str | None = None,
+    ball: bool = False,
+    mask: InputPathType | None = None,
+    oksmallmask: bool = False,
+    inset: list[InputPathType] | None = None,
+    fwhm: float | None = None,
+    acf: str | None = None,
+    nopad: bool = False,
+    pthr: str | None = None,
+    athr: str | None = None,
+    lots: bool = False,
+    mega: bool = False,
+    iter_: float | None = None,
+    nodec: bool = False,
+    seed: float | None = None,
+    niml: bool = False,
+    both: bool = False,
+    prefix: str | None = None,
+    cmd_: str | None = None,
+    quiet: bool = False,
+    ssave: str | None = None,
     runner: Runner | None = None,
 ) -> V3dClustSimOutputs:
     """
@@ -176,6 +383,30 @@ def v_3d_clust_sim(
     URL: https://afni.nimh.nih.gov/
     
     Args:
+        nxyz: Size of 3D grid to use for simulation.
+        dxyz: Voxel sizes along each dimension.
+        ball: Mask off points outside a ball at the center of the grid.
+        mask: Use the 0 sub-brick of this dataset as a mask.
+        oksmallmask: Allow small masks with less than 128 nonzero voxels.
+        inset: Use these dataset(s) as the simulations to threshold and\
+            clusterize.
+        fwhm: Gaussian filter width in mm (use -fwhmxyz for different values\
+            per axis).
+        acf: Parameters a, b, c for the autocorrelation function.
+        nopad: Turn off padding slices added for edge effects.
+        pthr: List of uncorrected per voxel p-values.
+        athr: List of corrected whole volume alpha-values.
+        lots: Use a longer list of values for pthr and athr.
+        mega: Add even more values to the pthr and athr grids.
+        iter_: Number of Monte Carlo simulations.
+        nodec: Print the cluster size threshold as an integer.
+        seed: Random number seed.
+        niml: Output the table in XML/NIML format.
+        both: Output the table in both XML/NIML format and in .1D format.
+        prefix: Specify prefix for the output files.
+        cmd_: Write command for putting results into a file's header.
+        quiet: Don't print out progress reports.
+        ssave: Save un-thresholded generated random volumes.
         runner: Command runner.
     Returns:
         NamedTuple of outputs (described in `V3dClustSimOutputs`).
@@ -183,6 +414,28 @@ def v_3d_clust_sim(
     runner = runner or get_global_runner()
     execution = runner.start_execution(V_3D_CLUST_SIM_METADATA)
     params = v_3d_clust_sim_params(
+        nxyz=nxyz,
+        dxyz=dxyz,
+        ball=ball,
+        mask=mask,
+        oksmallmask=oksmallmask,
+        inset=inset,
+        fwhm=fwhm,
+        acf=acf,
+        nopad=nopad,
+        pthr=pthr,
+        athr=athr,
+        lots=lots,
+        mega=mega,
+        iter_=iter_,
+        nodec=nodec,
+        seed=seed,
+        niml=niml,
+        both=both,
+        prefix=prefix,
+        cmd_=cmd_,
+        quiet=quiet,
+        ssave=ssave,
     )
     return v_3d_clust_sim_execute(params, execution)
 

niwrap_afni/afni/v_3d_cm.py

@@ -6,7 +6,7 @@ import pathlib
 from styxdefs import *
 
 V_3D_CM_METADATA = Metadata(
-    id="b067b12b1032c8b1f441c220e6f5349f1cfe1370.boutiques",
+    id="63ca74289af452584f6dd9b272bc4b15b6ffb8b0.boutiques",
     name="3dCM",
     package="afni",
     container_image_tag="afni/afni_make_build:AFNI_24.2.06",
@@ -16,6 +16,14 @@ V_3D_CM_METADATA = Metadata(
 V3dCmParameters = typing.TypedDict('V3dCmParameters', {
     "__STYX_TYPE__": typing.Literal["3dCM"],
     "dset": InputPathType,
+    "mask": typing.NotRequired[InputPathType | None],
+    "automask": bool,
+    "set_origin": typing.NotRequired[list[float] | None],
+    "local_ijk": bool,
+    "roi_vals": typing.NotRequired[list[float] | None],
+    "all_rois": bool,
+    "icent": bool,
+    "dcent": bool,
 })
 
 
@@ -63,19 +71,55 @@ class V3dCmOutputs(typing.NamedTuple):
 
 def v_3d_cm_params(
     dset: InputPathType,
+    mask: InputPathType | None = None,
+    automask: bool = False,
+    set_origin: list[float] | None = None,
+    local_ijk: bool = False,
+    roi_vals: list[float] | None = None,
+    all_rois: bool = False,
+    icent: bool = False,
+    dcent: bool = False,
 ) -> V3dCmParameters:
     """
     Build parameters.
     
     Args:
         dset: Input dataset.
+        mask: Use the specified dataset as a mask. Only voxels with nonzero\
+            values in 'mset' will be averaged from 'dataset'. Both datasets must\
+            have the same number of voxels.
+        automask: Generate the mask automatically.
+        set_origin: After computing the CM of the dataset, set the origin\
+            fields in the header so that the CM will be at (x,y,z) in DICOM\
+            coordinates.
+        local_ijk: Output values as (i,j,k) in local orientation.
+        roi_vals: Compute center of mass for each blob with specified voxel\
+            values.
+        all_rois: Automatically find all ROI values and compute their centers\
+            of mass.
+        icent: Compute Internal Center, which finds the center voxel closest to\
+            the center of mass.
+        dcent: Compute Distance Center, the center voxel with the shortest\
+            average distance to all other voxels. This is computationally\
+            expensive.
     Returns:
         Parameter dictionary
     """
     params = {
         "__STYXTYPE__": "3dCM",
         "dset": dset,
+        "automask": automask,
+        "local_ijk": local_ijk,
+        "all_rois": all_rois,
+        "icent": icent,
+        "dcent": dcent,
     }
+    if mask is not None:
+        params["mask"] = mask
+    if set_origin is not None:
+        params["set_origin"] = set_origin
+    if roi_vals is not None:
+        params["roi_vals"] = roi_vals
     return params
 
 
@@ -94,8 +138,32 @@ def v_3d_cm_cargs(
     """
     cargs = []
     cargs.append("3dCM")
-    cargs.append("[OPTIONS]")
     cargs.append(execution.input_file(params.get("dset")))
+    if params.get("mask") is not None:
+        cargs.extend([
+            "-mask",
+            execution.input_file(params.get("mask"))
+        ])
+    if params.get("automask"):
+        cargs.append("-automask")
+    if params.get("set_origin") is not None:
+        cargs.extend([
+            "-set",
+            *map(str, params.get("set_origin"))
+        ])
+    if params.get("local_ijk"):
+        cargs.append("-local_ijk")
+    if params.get("roi_vals") is not None:
+        cargs.extend([
+            "-roi_vals",
+            *map(str, params.get("roi_vals"))
+        ])
+    if params.get("all_rois"):
+        cargs.append("-all_rois")
+    if params.get("icent"):
+        cargs.append("-Icent")
+    if params.get("dcent"):
+        cargs.append("-Dcent")
     return cargs
 
 
@@ -145,6 +213,14 @@ def v_3d_cm_execute(
 
 def v_3d_cm(
     dset: InputPathType,
+    mask: InputPathType | None = None,
+    automask: bool = False,
+    set_origin: list[float] | None = None,
+    local_ijk: bool = False,
+    roi_vals: list[float] | None = None,
+    all_rois: bool = False,
+    icent: bool = False,
+    dcent: bool = False,
     runner: Runner | None = None,
 ) -> V3dCmOutputs:
     """
@@ -156,6 +232,23 @@ def v_3d_cm(
     
     Args:
         dset: Input dataset.
+        mask: Use the specified dataset as a mask. Only voxels with nonzero\
+            values in 'mset' will be averaged from 'dataset'. Both datasets must\
+            have the same number of voxels.
+        automask: Generate the mask automatically.
+        set_origin: After computing the CM of the dataset, set the origin\
+            fields in the header so that the CM will be at (x,y,z) in DICOM\
+            coordinates.
+        local_ijk: Output values as (i,j,k) in local orientation.
+        roi_vals: Compute center of mass for each blob with specified voxel\
+            values.
+        all_rois: Automatically find all ROI values and compute their centers\
+            of mass.
+        icent: Compute Internal Center, which finds the center voxel closest to\
+            the center of mass.
+        dcent: Compute Distance Center, the center voxel with the shortest\
+            average distance to all other voxels. This is computationally\
+            expensive.
         runner: Command runner.
     Returns:
         NamedTuple of outputs (described in `V3dCmOutputs`).
@@ -164,6 +257,14 @@ def v_3d_cm(
     execution = runner.start_execution(V_3D_CM_METADATA)
     params = v_3d_cm_params(
         dset=dset,
+        mask=mask,
+        automask=automask,
+        set_origin=set_origin,
+        local_ijk=local_ijk,
+        roi_vals=roi_vals,
+        all_rois=all_rois,
+        icent=icent,
+        dcent=dcent,
     )
     return v_3d_cm_execute(params, execution)