RF: Replace fslmaths chain with MakeRibbon

Author: effigies

smriprep/workflows/anatomical.py

@@ -310,7 +310,7 @@ def init_anat_preproc_wf(
                 ('outputnode.fsnative2t1w_xfm', 'inputnode.fsnative2t1w_xfm'),
             ]),
             (anat_fit_wf, anat_ribbon_wf, [
-                ('outputnode.t1w_mask', 'inputnode.t1w_mask'),
+                ('outputnode.t1w_mask', 'inputnode.ref_file'),
             ]),
             (surface_derivatives_wf, anat_ribbon_wf, [
                 ('outputnode.white', 'inputnode.white'),

smriprep/workflows/surfaces.py

@@ -31,13 +31,14 @@
 from nipype.pipeline import engine as pe
 from nipype.interfaces.base import Undefined
 from nipype.interfaces import (
-    fsl,
     io as nio,
     utility as niu,
     freesurfer as fs,
     workbench as wb,
 )
 
+from smriprep.interfaces.surf import MakeRibbon
+
 from ..data import load_resource
 from ..interfaces.freesurfer import ReconAll, MakeMidthickness
 
@@ -1049,23 +1050,10 @@ def init_anat_ribbon_wf(name="anat_ribbon_wf"):
     workflow = pe.Workflow(name=name)
 
     inputnode = pe.Node(
-        niu.IdentityInterface(
-            fields=[
-                "white",
-                "pial",
-                "t1w_mask",
-            ]
-        ),
+        niu.IdentityInterface(fields=["white", "pial", "ref_file"]),
         name="inputnode",
     )
-    outputnode = pe.Node(
-        niu.IdentityInterface(
-            fields=[
-                "anat_ribbon",
-            ]
-        ),
-        name="outputnode",
-    )
+    outputnode = pe.Node(niu.IdentityInterface(fields=["anat_ribbon"]), name="outputnode")
 
     create_wm_distvol = pe.MapNode(
         CreateSignedDistanceVolume(),
@@ -1079,102 +1067,22 @@ def init_anat_ribbon_wf(name="anat_ribbon_wf"):
         name="create_pial_distvol",
     )
 
-    thresh_wm_distvol = pe.MapNode(
-        fsl.maths.MathsCommand(args="-thr 0 -bin -mul 255"),
-        iterfield=["in_file"],
-        name="thresh_wm_distvol",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-    )
-
-    uthresh_pial_distvol = pe.MapNode(
-        fsl.maths.MathsCommand(args="-uthr 0 -abs -bin -mul 255"),
-        iterfield=["in_file"],
-        name="uthresh_pial_distvol",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-    )
-
-    bin_wm_distvol = pe.MapNode(
-        fsl.maths.UnaryMaths(operation="bin"),
-        iterfield=["in_file"],
-        name="bin_wm_distvol",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-    )
-
-    bin_pial_distvol = pe.MapNode(
-        fsl.maths.UnaryMaths(operation="bin"),
-        iterfield=["in_file"],
-        name="bin_pial_distvol",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-    )
-
-    split_wm_distvol = pe.Node(
-        niu.Split(splits=[1, 1]),
-        name="split_wm_distvol",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-        run_without_submitting=True,
-    )
-
-    merge_wm_distvol_no_flatten = pe.Node(
-        niu.Merge(2),
-        no_flatten=True,
-        name="merge_wm_distvol_no_flatten",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-        run_without_submitting=True,
-    )
-
-    make_ribbon_vol = pe.MapNode(
-        fsl.maths.MultiImageMaths(op_string="-mas %s -mul 255"),
-        iterfield=["in_file", "operand_files"],
-        name="make_ribbon_vol",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-    )
-
-    bin_ribbon_vol = pe.MapNode(
-        fsl.maths.UnaryMaths(operation="bin"),
-        iterfield=["in_file"],
-        name="bin_ribbon_vol",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-    )
-
-    split_squeeze_ribbon_vol = pe.Node(
-        niu.Split(splits=[1, 1], squeeze=True),
-        name="split_squeeze_ribbon",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-        run_without_submitting=True,
-    )
-
-    combine_ribbon_vol_hemis = pe.Node(
-        fsl.maths.BinaryMaths(operation="add"),
-        name="combine_ribbon_vol_hemis",
-        mem_gb=DEFAULT_MEMORY_MIN_GB,
-    )
+    make_ribbon = pe.Node(MakeRibbon(), name="make_ribbon", mem_gb=DEFAULT_MEMORY_MIN_GB)
 
-    # make HCP-style ribbon volume in T1w space
     # fmt: off
     workflow.connect(
         [
             (inputnode, create_wm_distvol, [
                 ("white", "surf_file"),
-                ("t1w_mask", "ref_file"),
+                ("ref_file", "ref_file"),
             ]),
             (inputnode, create_pial_distvol, [
                 ("pial", "surf_file"),
-                ("t1w_mask", "ref_file"),
+                ("ref_file", "ref_file"),
             ]),
-            (create_wm_distvol, thresh_wm_distvol, [("out_file", "in_file")]),
-            (create_pial_distvol, uthresh_pial_distvol, [("out_file", "in_file")]),
-            (thresh_wm_distvol, bin_wm_distvol, [("out_file", "in_file")]),
-            (uthresh_pial_distvol, bin_pial_distvol, [("out_file", "in_file")]),
-            (bin_wm_distvol, split_wm_distvol, [("out_file", "inlist")]),
-            (split_wm_distvol, merge_wm_distvol_no_flatten, [("out1", "in1")]),
-            (split_wm_distvol, merge_wm_distvol_no_flatten, [("out2", "in2")]),
-            (bin_pial_distvol, make_ribbon_vol, [("out_file", "in_file")]),
-            (merge_wm_distvol_no_flatten, make_ribbon_vol, [("out", "operand_files")]),
-            (make_ribbon_vol, bin_ribbon_vol, [("out_file", "in_file")]),
-            (bin_ribbon_vol, split_squeeze_ribbon_vol, [("out_file", "inlist")]),
-            (split_squeeze_ribbon_vol, combine_ribbon_vol_hemis, [("out1", "in_file")]),
-            (split_squeeze_ribbon_vol, combine_ribbon_vol_hemis, [("out2", "operand_file")]),
-            (combine_ribbon_vol_hemis, outputnode, [("out_file", "anat_ribbon")]),
+            (create_wm_distvol, make_ribbon, [("out_file", "white_distvols")]),
+            (create_pial_distvol, make_ribbon, [("out_file", "pial_distvols")]),
+            (make_ribbon, outputnode, [("ribbon", "anat_ribbon")]),
         ]
     )
     # fmt: on

smriprep/workflows/tests/test_surfaces.py

@@ -1,4 +1,5 @@
 import os
+from pathlib import Path
 from shutil import which
 
 import nibabel as nb
@@ -10,7 +11,7 @@
 from ...data import load_resource
 
 
-def test_ribbon_workflow(tmp_path):
+def test_ribbon_workflow(tmp_path: Path):
     """Create ribbon mask for fsaverage subject"""
 
     for command in ("mris_convert", "wb_command", "fslmaths"):
@@ -28,32 +29,26 @@ def test_ribbon_workflow(tmp_path):
 
     gifti_surfaces_wf = init_gifti_surfaces_wf(surfaces=['white', 'pial'])
     anat_ribbon_wf = init_anat_ribbon_wf()
-    anat_ribbon_wf.inputs.inputnode.t1w_mask = test_ribbon
+    anat_ribbon_wf.inputs.inputnode.ref_file = test_ribbon
 
     gifti_surfaces_wf.inputs.inputnode.subjects_dir = os.getenv('SUBJECTS_DIR')
     gifti_surfaces_wf.inputs.inputnode.subject_id = 'fsaverage'
 
     wf = pe.Workflow(name='test_ribbon_wf', base_dir=tmp_path)
-    wf.connect(
-        [
-            (
-                gifti_surfaces_wf,
-                anat_ribbon_wf,
-                [
-                    ('outputnode.white', 'inputnode.white'),
-                    ('outputnode.pial', 'inputnode.pial'),
-                ],
-            ),
-        ]
-    )
+    # fmt: off
+    wf.connect([
+        (gifti_surfaces_wf, anat_ribbon_wf, [
+            ('outputnode.white', 'inputnode.white'),
+            ('outputnode.pial', 'inputnode.pial'),
+        ]),
+    ])
+    # fmt: on
     result = wf.run()
 
-    combine_ribbon_vol_hemis = next(
-        node for node in result.nodes() if node.name == 'combine_ribbon_vol_hemis'
-    )
+    make_ribbon = next(node for node in result.nodes() if node.name == 'make_ribbon')
 
     expected = nb.load(test_ribbon)
-    ribbon = nb.load(combine_ribbon_vol_hemis.result.outputs.out_file)
+    ribbon = nb.load(make_ribbon.result.outputs.ribbon)
 
     assert ribbon.shape == expected.shape
     assert np.allclose(ribbon.affine, expected.affine)