🚧 WIP ✨ Drop in mri_robust_template

Author: shnizzedy

CPAC/longitudinal/robust_template.py

@@ -16,3 +16,115 @@
 # You should have received a copy of the GNU Lesser General Public
 # License along with C-PAC. If not, see <https://www.gnu.org/licenses/>.
 """Create longitudinal template using ``mri_robust_template``."""
+
+import os
+from typing import cast, Literal
+
+from nipype.interfaces.base import (
+    File,
+    InputMultiPath,
+    isdefined,
+    OutputMultiPath,
+    traits,
+)
+from nipype.interfaces.freesurfer import longitudinal
+
+from CPAC.pipeline import nipype_pipeline_engine as pe
+from CPAC.utils.configuration import Configuration
+
+
+class RobustTemplateInputSpec(longitudinal.RobustTemplateInputSpec):  # noqa: D101
+    affine = traits.Bool(default_value=False, desc="compute 12 DOF registration")
+    mapmov = traits.Either(
+        InputMultiPath(File(exists=False)),
+        traits.Bool,
+        argstr="--mapmov %s",
+        desc="output images: map and resample each input to template",
+    )
+    maxit = traits.Int(
+        argstr="--maxit %d",
+        mandatory=False,
+        desc="iterate max # times (if #tp>2 default 6, else 5 for 2tp reg.)",
+    )
+
+
+class RobustTemplateOutputSpec(longitudinal.RobustTemplateOutputSpec):  # noqa: D101
+    mapmov = OutputMultiPath(
+        File(exists=True),
+        desc="each input mapped and resampled to longitudinal template",
+    )
+
+
+class RobustTemplate(longitudinal.RobustTemplate):  # noqa: D101
+    # STATEMENT OF CHANGES:
+    #     This class is derived from sources licensed under the Apache-2.0 terms,
+    #     and this class has been changed.
+
+    # CHANGES:
+    #     * Added handling for `affind`, `mapmov` and `maxit`
+
+    # ORIGINAL WORK'S ATTRIBUTION NOTICE:
+    #    Copyright (c) 2009-2016, Nipype developers
+
+    #    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.
+
+    #    Prior to release 0.12, Nipype was licensed under a BSD license.
+
+    # Modifications copyright (C) 2024  C-PAC Developers
+    input_spec = RobustTemplateInputSpec
+    output_spec = RobustTemplateOutputSpec
+
+    def _format_arg(self, name, spec, value):
+        if name == "average_metric":
+            # return enumeration value
+            return spec.argstr % {"mean": 0, "median": 1}[value]
+        if name in ("mapmov", "transform_outputs", "scaled_intensity_outputs"):
+            value = self._list_outputs()[name]
+        return super()._format_arg(name, spec, value)
+
+    def _list_outputs(self):
+        """:py:meth:`~nipype.interfaces.freesurfer.RobustTemplate._list_outputs` + `mapmov`."""
+        outputs = self.output_spec().get()
+        outputs["out_file"] = os.path.abspath(self.inputs.out_file)
+        n_files = len(self.inputs.in_files)
+        fmt = "{}{:02d}.{}" if n_files > 9 else "{}{:d}.{}"  # noqa: PLR2004
+        for key, prefix, ext in [
+            ("transform_outputs", "tp", "lta"),
+            ("scaled_intensity_outputs", "is", "txt"),
+            ("mapmov", "space-longitudinal", "nii.gz"),
+        ]:
+            if isdefined(getattr(self.inputs, key)):
+                fnames = getattr(self.inputs, key)
+                if fnames is True:
+                    fnames = [fmt.format(prefix, i + 1, ext) for i in range(n_files)]
+                outputs[key] = [os.path.abspath(x) for x in fnames]
+        return outputs
+
+
+def mri_robust_template(name: str, cfg: Configuration) -> pe.Node:
+    """Return a Node to run `mri_robust_template` with common options."""
+    node = pe.Node(RobustTemplate(), name=name)
+    node.set_input("mapmov", True)
+    node.set_input("transform_outputs", True)
+    node.set_input(
+        "average_metric", cfg["longitudinal_template_generation", "average_method"]
+    )
+    node.set_input("affine", cfg["longitudinal_template_generation", "dof"] == 12)  # noqa: PLR2004
+    max_iter = cast(
+        int | Literal["default"], cfg["longitudinal_template_generation", "max_iter"]
+    )
+    if isinstance(max_iter, int):
+        node.set_input("maxit", max_iter)
+    node.set_input("auto_detect_sensitivity", True)
+
+    return node