added in Ghislain's handwritten interfaces

pydra/tasks/ants/v2_5/__init__.py

@@ -0,0 +1,11 @@
+"""
+ANTs
+====
+
+>>> from pydra.tasks import ants
+"""
+
+from .apply_transforms import ApplyTransforms
+from .bias_correction import N4BiasFieldCorrection
+from .create_jacobian_determinant_image import CreateJacobianDeterminantImage
+from .registration import Registration, registration_syn, registration_syn_quick

pydra/tasks/ants/v2_5/apply_transforms.py

@@ -0,0 +1,195 @@
+__all__ = ["ApplyTransforms"]
+
+from os import PathLike
+from typing import Sequence
+
+from attrs import define, field
+from pydra.engine.specs import ShellSpec, SpecInfo
+from pydra.engine.task import ShellCommandTask
+
+
+def _format_output(
+    output_image: PathLike,
+    save_warp_field: bool,
+    output_warp_field: PathLike,
+    save_transform: bool,
+    output_transform: PathLike,
+    invert_transform: bool,
+) -> str:
+    return "-o {}".format(
+        "Linear[{},{:%d}]".format(output_transform, invert_transform)
+        if save_transform
+        else "[{},{:%d}]".format(output_warp_field, save_warp_field)
+        if save_warp_field
+        else f"{output_image}"
+    )
+
+
+def _format_interpolation(interpolator: str, sigma: float, alpha: float, order: int) -> str:
+    return "-n {}{}".format(
+        interpolator,
+        f"[{order}]"
+        if interpolator == "BSpline"
+        else f"[{sigma},{alpha}]"
+        if interpolator in ("MultiLabel", "Gaussian")
+        else "",
+    )
+
+
+class ApplyTransforms(ShellCommandTask):
+    """Task definition for antsApplyTransforms.
+
+    Examples
+    --------
+    >>> task = ApplyTransforms(moving_image="moving.nii", fixed_image="fixed.nii")
+    >>> task.cmdline    # doctest: +ELLIPSIS
+    'antsApplyTransforms -e scalar -i moving.nii -r fixed.nii -o .../moving_warped.nii -n Linear ...'
+
+    >>> task = ApplyTransforms(
+    ...     moving_image="moving.nii",
+    ...     fixed_image="fixed.nii",
+    ...     interpolator="BSpline",
+    ...     input_transforms=["affine.mat"],
+    ... )
+    >>> task.cmdline    # doctest: +ELLIPSIS
+    'antsApplyTransforms ... -n BSpline[3] -t affine.mat ...'
+
+    >>> task = ApplyTransforms(
+    ...     moving_image="moving.nii",
+    ...     fixed_image="fixed.nii",
+    ...     interpolator="Gaussian",
+    ...     sigma=4.0,
+    ...     alpha=1.0,
+    ...     input_transforms=["affine.mat", "warp_field.nii.gz"],
+    ...     invert_transforms=[True, False],
+    ... )
+    >>> task.cmdline    # doctest: +ELLIPSIS
+    'antsApplyTransforms ... -n Gaussian[4.0,1.0] -t [affine.mat,1] -t [warp_field.nii.gz,0] ...'
+    """
+
+    @define(kw_only=True)
+    class InputSpec(ShellSpec):
+        dimensionality: int = field(
+            metadata={"help_string": "image dimensionality", "argstr": "-d", "allowed_values": {2, 3, 4}}
+        )
+
+        image_type: str = field(
+            default="scalar",
+            metadata={
+                "help_string": (
+                    "specify the image type (0: scalar, 1: vector, 2: tensor, 3: time-series, 4: multichannel,"
+                    " 5: five-dimensional)"
+                ),
+                "argstr": "-e",
+                "allowed_values": {0, 1, 2, 3, 4, 5},
+            },
+        )
+
+        moving_image: PathLike = field(metadata={"help_string": "moving image", "mandatory": True, "argstr": "-i"})
+
+        fixed_image: PathLike = field(metadata={"help_string": "fixed image", "mandatory": True, "argstr": "-r"})
+
+        output_: str = field(
+            metadata={"help_string": "output parameter", "readonly": True, "formatter": _format_output}
+        )
+
+        output_image: str = field(
+            metadata={"help_string": "output image", "output_file_template": "{moving_image}_warped"}
+        )
+
+        save_warp_field: bool = field(metadata={"help_string": "save composite warp field"})
+
+        output_warp_field: str = field(
+            metadata={
+                "help_string": "output warp field",
+                "output_file_template": "{moving_image}_warpfield",
+                "requires": {"save_warp_field"},
+            }
+        )
+
+        save_transform: bool = field(metadata={"help_string": "save composite transform"})
+
+        output_transform: str = field(
+            metadata={
+                "help_string": "output transform",
+                "output_file_template": "{moving_image}_affine.mat",
+                "keep_extension": False,
+                "requires": {"save_transform"},
+            }
+        )
+
+        invert_transform: bool = field(default=False, metadata={"help_string": "invert composite transform"})
+
+        interpolation_: str = field(
+            metadata={"help_string": "interpolation parameter", "readonly": True, "formatter": _format_interpolation}
+        )
+
+        interpolator: str = field(
+            default="Linear",
+            metadata={
+                "help_string": "interpolation method",
+                "allowed_values": {
+                    "Linear",
+                    "NearestNeighbor",
+                    "Gaussian",
+                    "BSpline",
+                    "CosineWindowedSinc",
+                    "WelchWindowedSinc",
+                    "HammingWindowedSinc",
+                    "LanczosWindowedSinc",
+                },
+            },
+        )
+
+        sigma: float = field(default=1.0, metadata={"help_string": "sigma parameter interpolation"})
+
+        alpha: float = field(default=1.0, metadata={"help_string": "alpha parameter for interpolation"})
+
+        order: int = field(default=3, metadata={"help_string": "order parameter for interpolation"})
+
+        output_datatype: str = field(
+            metadata={
+                "help_string": "force output image datatype",
+                "argstr": "-u",
+                "allowed_values": {"char", "uchar", "short", "int", "float", "double", "default"},
+            }
+        )
+
+        input_transforms: Sequence[PathLike] = field(
+            metadata={
+                "help_string": "input transforms to apply",
+                "formatter": lambda input_transforms, invert_transforms: (
+                    ""
+                    if not input_transforms
+                    else " ".join(f"-t {f}" for f in input_transforms)
+                    if not invert_transforms
+                    else " ".join(f"-t [{f},{int(i)}]" for f, i in zip(input_transforms, invert_transforms))
+                ),
+            }
+        )
+
+        invert_transforms: Sequence[bool] = field(
+            metadata={"help_string": "which transforms to invert", "requires": {"input_transforms"}}
+        )
+
+        default_value: float = field(metadata={"help_string": "default voxel value", "argstr": "-f"})
+
+        use_float_precision: bool = field(
+            default=False,
+            metadata={
+                "help_string": "use float precision instead of double",
+                "formatter": lambda use_float_precision: f"--float {use_float_precision:d}",
+            },
+        )
+
+        verbose: bool = field(
+            default=False,
+            metadata={
+                "help_string": "enable verbose output",
+                "formatter": lambda verbose: f"--verbose {verbose:d}",
+            },
+        )
+
+    input_spec = SpecInfo(name="Input", bases=(InputSpec,))
+
+    executable = "antsApplyTransforms"

pydra/tasks/ants/v2_5/bias_correction.py

@@ -0,0 +1,108 @@
+__all__ = ["N4BiasFieldCorrection"]
+
+from os import PathLike
+from typing import Sequence
+
+from attrs import define, field
+from pydra.engine.specs import ShellSpec, SpecInfo
+from pydra.engine.task import ShellCommandTask
+
+
+class N4BiasFieldCorrection(ShellCommandTask):
+    """Task definition for N4BiasFieldCorrection.
+
+    Examples
+    --------
+    >>> task = N4BiasFieldCorrection(input_image="input.nii")
+    >>> task.cmdline    # doctest: +ELLIPSIS
+    'N4BiasFieldCorrection -i input.nii -r 1 -s 4 -b [200,3] -c [50x50x50x50,0.0] -t [0.15,0.01,200] \
+-o .../input_corrected.nii'
+    """
+
+    @define(kw_only=True)
+    class InputSpec(ShellSpec):
+        dimensionality: int = field(
+            metadata={"help_string": "image dimensionality", "argstr": "-d", "allowed_values": {2, 3, 4}}
+        )
+
+        input_image: PathLike = field(metadata={"help_string": "input image", "mandatory": True, "argstr": "-i"})
+
+        mask_image: PathLike = field(metadata={"help_string": "mask image", "argstr": "-x"})
+
+        rescale_intensities: bool = field(
+            default=True,
+            metadata={
+                "help_string": "rescale intensities",
+                "formatter": lambda rescale_intensities: f"-r {rescale_intensities:d}",
+            },
+        )
+
+        weight_image: PathLike = field(metadata={"help_string": "weight image", "argstr": "-w"})
+
+        shrink_factor: int = field(default=4, metadata={"help_string": "shrink factor", "argstr": "-s"})
+
+        bspline_fitting_: str = field(
+            metadata={
+                "help_string": "b-spline fitting parameter",
+                "argstr": "-b [{spline_distance},{spline_order}]",
+                "readonly": True,
+            }
+        )
+
+        spline_distance: float = field(default=200, metadata={"help_string": "spline distance"})
+
+        spline_order: int = field(default=3, metadata={"help_string": "spline order"})
+
+        convergence_: str = field(
+            metadata={
+                "help_string": "convergence parameters",
+                "readonly": True,
+                "formatter": lambda num_iterations, threshold: (
+                    "-c [{},{}]".format("x".join(str(i) for i in num_iterations), threshold)
+                ),
+            }
+        )
+
+        num_iterations: Sequence[int] = field(
+            default=(50, 50, 50, 50), metadata={"help_string": "number of iterations"}
+        )
+
+        threshold: float = field(default=0.0, metadata={"help_string": "convergence threshold"})
+
+        histogram_sharpening_: str = field(
+            metadata={
+                "help_string": "histogram sharpening parameter",
+                "argstr": "-t [{bias_field_fwhm},{wiener_filter_noise},{num_histogram_bins}]",
+                "readonly": True,
+            }
+        )
+
+        bias_field_fwhm: float = field(default=0.15, metadata={"help_string": "Bias field FWHM"})
+
+        wiener_filter_noise: float = field(default=0.01, metadata={"help_string": "Wiener filter noise"})
+
+        num_histogram_bins: int = field(default=200, metadata={"help_string": "number of histogram bins"})
+
+        output_ = field(
+            metadata={
+                "help_string": "output parameters",
+                "readonly": True,
+                "formatter": lambda output_image, save_bias_field, output_bias_field: (
+                    f"-o [{output_image},{output_bias_field}]" if save_bias_field else f"-o {output_image}"
+                ),
+            }
+        )
+
+        output_image: str = field(
+            metadata={"help_string": "output image", "output_file_template": "{input_image}_corrected"}
+        )
+
+        save_bias_field: bool = field(default=False, metadata={"help_string": "save bias field"})
+
+        output_bias_field: str = field(
+            metadata={"help_string": "output bias field", "output_file_template": "{input_image}_biasfield"}
+        )
+
+    input_spec = SpecInfo(name="Input", bases=(InputSpec,))
+
+    executable = "N4BiasFieldCorrection"

pydra/tasks/ants/v2_5/create_jacobian_determinant_image.py

@@ -0,0 +1,50 @@
+__all__ = ["CreateJacobianDeterminantImage"]
+
+from os import PathLike
+
+from attrs import define, field
+from pydra.engine.specs import ShellSpec, SpecInfo
+from pydra.engine.task import ShellCommandTask
+
+
+class CreateJacobianDeterminantImage(ShellCommandTask):
+    """Task definition for CreateJacobianDeterminantImage.
+
+    Examples
+    --------
+    >>> task = CreateJacobianDeterminantImage(dimensionality=3, warp_field="warp.nii.gz")
+    >>> task.cmdline    # doctest: +ELLIPSIS
+    'CreateJacobianDeterminantImage 3 warp.nii.gz .../warp_jac.nii.gz 0 0'
+    """
+
+    @define(kw_only=True)
+    class InputSpec(ShellSpec):
+        dimensionality: int = field(
+            metadata={"help_string": "image dimensionality", "mandatory": True, "argstr": "", "allowed_values": {2, 3}}
+        )
+
+        warp_field: PathLike = field(metadata={"help_string": "displacement field", "mandatory": True, "argstr": ""})
+
+        output_image: str = field(
+            metadata={"help_string": "output image", "argstr": "", "output_file_template": "{warp_field}_jac"}
+        )
+
+        calculate_log_jacobian: bool = field(
+            default=False,
+            metadata={
+                "help_string": "calculate log jacobian",
+                "formatter": lambda calculate_log_jacobian: f"{calculate_log_jacobian:d}",
+            },
+        )
+
+        calculate_geometric_jacobian: bool = field(
+            default=False,
+            metadata={
+                "help_string": "calculate geometric jacobian",
+                "formatter": lambda calculate_geometric_jacobian: f"{calculate_geometric_jacobian:d}",
+            },
+        )
+
+    input_spec = SpecInfo(name="Input", bases=(InputSpec,))
+
+    executable = "CreateJacobianDeterminantImage"