Merge branch 'develop' into lite-bc

Author: sgiavasis

.github/Dockerfiles/base-standard.Dockerfile

@@ -22,6 +22,12 @@ Standard software dependencies for C-PAC standard images"
 LABEL org.opencontainers.image.source=https://github.com/FCP-INDI/C-PAC
 USER root
 
+# Installing ANTs
+ENV LANG="en_US.UTF-8" \
+    LC_ALL="en_US.UTF-8" \
+    ANTSPATH=/usr/lib/ants/bin \
+    PATH=/usr/lib/ants/bin:$PATH
+
 # Installing FreeSurfer
 RUN apt-get update \
     && yes | mamba install tcsh \

CHANGELOG.md

@@ -70,6 +70,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Lingering calls to `cpac_outputs.csv` (was changed to `cpac_outputs.tsv` in v1.8.1).
 - A bug in the `freesurfer_abcd_preproc` nodeblock where the `Template` image was incorrectly used as `reference` during the `inverse_warp` step. Replacing it with the subject-specific `T1w` image resolved the issue of the `desc-restoreBrain_T1w` being chipped off.
 - A bug in `ideal_bandpass` where the frequency mask was incorrectly applied, which caused filter to fail in certain cases.
+- A bug where `$ANTSPATH` was unset in C-PAC with FreeSurfer images.
 
 ### Upgraded dependencies
 

CPAC/distortion_correction/distortion_correction.py

@@ -36,7 +36,7 @@
 from CPAC.pipeline import nipype_pipeline_engine as pe
 from CPAC.pipeline.nodeblock import nodeblock
 from CPAC.utils import function
-from CPAC.utils.datasource import match_epi_fmaps
+from CPAC.utils.datasource import match_epi_fmaps_function_node
 from CPAC.utils.interfaces.function import Function
 
 
@@ -406,23 +406,7 @@ def distcor_blip_afni_qwarp(wf, cfg, strat_pool, pipe_num, opt=None):
            3dQWarp. The output of this can then proceed to
            func_preproc.
     """
-    match_epi_imports = ["import json"]
-    match_epi_fmaps_node = pe.Node(
-        Function(
-            input_names=[
-                "bold_pedir",
-                "epi_fmap_one",
-                "epi_fmap_params_one",
-                "epi_fmap_two",
-                "epi_fmap_params_two",
-            ],
-            output_names=["opposite_pe_epi", "same_pe_epi"],
-            function=match_epi_fmaps,
-            imports=match_epi_imports,
-            as_module=True,
-        ),
-        name=f"match_epi_fmaps_{pipe_num}",
-    )
+    match_epi_fmaps_node = match_epi_fmaps_function_node(f"match_epi_fmaps_{pipe_num}")
 
     node, out = strat_pool.get_data("epi-1")
     wf.connect(node, out, match_epi_fmaps_node, "epi_fmap_one")

CPAC/seg_preproc/tests/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (C) 2025  C-PAC Developers
+
+# This file is part of C-PAC.
+
+# C-PAC is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version.
+
+# C-PAC is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+# License for more details.
+
+# 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/>.
+"""Tests for segmentation utilities."""

CPAC/seg_preproc/tests/test_utils.py

@@ -0,0 +1,34 @@
+# Copyright (C) 2025  C-PAC Developers
+
+# This file is part of C-PAC.
+
+# C-PAC is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version.
+
+# C-PAC is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+# License for more details.
+
+# 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/>.
+"""Tests for segmentation utilities."""
+
+import subprocess
+
+
+def test_ants_joint_label_fusion_script() -> None:
+    """Test antsJointLabelFusion.sh script can run in this environment."""
+    try:
+        subprocess.run(
+            ["antsJointLabelFusion.sh"],
+            check=True,
+            capture_output=True,
+        )
+    except subprocess.CalledProcessError as e:
+        # There's no explicit 'help' option, but if the script can run,
+        # the error message does not contain the string "Error".
+        if "Error" in e.stderr.decode():
+            raise e

CPAC/utils/datasource.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2024  C-PAC Developers
+# Copyright (C) 2012-2025  C-PAC Developers
 
 # This file is part of C-PAC.
 
@@ -20,6 +20,7 @@
 import json
 from pathlib import Path
 import re
+from typing import Any, Optional
 
 from voluptuous import RequiredFieldInvalid
 from nipype.interfaces import utility as util
@@ -463,12 +464,12 @@ def gather_echo_times(echotime_1, echotime_2, echotime_3=None, echotime_4=None):
 
 
 def match_epi_fmaps(
-    bold_pedir,
-    epi_fmap_one,
-    epi_fmap_params_one,
-    epi_fmap_two=None,
-    epi_fmap_params_two=None,
-):
+    bold_pedir: str,
+    epi_fmap_one: str,
+    epi_fmap_params_one: dict[str, Any],
+    epi_fmap_two: Optional[str] = None,
+    epi_fmap_params_two: Optional[dict[str, Any]] = None,
+) -> tuple[str, str]:
     """Match EPI field maps to the BOLD scan.
 
     Parse the field map files in the data configuration and determine which
@@ -504,13 +505,41 @@ def match_epi_fmaps(
             with open(scan_params, "r") as f:
                 scan_params = json.load(f)
         if "PhaseEncodingDirection" in scan_params:
-            epi_pedir = scan_params["PhaseEncodingDirection"]
+            epi_pedir: str | bytes = scan_params["PhaseEncodingDirection"]
+            if isinstance(epi_pedir, bytes):
+                epi_pedir = epi_pedir.decode("utf-8")
             if epi_pedir == bold_pedir:
                 same_pe_epi = epi_scan
             elif epi_pedir[0] == bold_pedir[0]:
                 opposite_pe_epi = epi_scan
 
-    return (opposite_pe_epi, same_pe_epi)
+    if same_pe_epi is None:
+        msg = f"Same phase encoding EPI: {bold_pedir}"
+        raise FileNotFoundError(msg)
+    if opposite_pe_epi is None:
+        msg = f"Opposite phase encoding EPI: {bold_pedir}"
+        raise FileNotFoundError(msg)
+
+    return opposite_pe_epi, same_pe_epi
+
+
+def match_epi_fmaps_function_node(name: str = "match_epi_fmaps"):
+    """Return a Function node for `~CPAC.utils.datasource.match_epi_fmaps`."""
+    return pe.Node(
+        Function(
+            input_names=[
+                "bold_pedir",
+                "epi_fmap_one",
+                "epi_fmap_params_one",
+                "epi_fmap_two",
+                "epi_fmap_params_two",
+            ],
+            output_names=["opposite_pe_epi", "same_pe_epi"],
+            function=match_epi_fmaps,
+            as_module=True,
+        ),
+        name=name,
+    )
 
 
 def ingress_func_metadata(

CPAC/utils/monitoring/draw_gantt_chart.py

@@ -39,20 +39,19 @@
 
 # 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/>.
-"""Module to draw an html gantt chart from logfile produced by
-``CPAC.utils.monitoring.log_nodes_cb()``.
+"""Module to draw an html gantt chart from logfile produced by `~CPAC.utils.monitoring.log_nodes_cb`.
 
 See https://nipype.readthedocs.io/en/latest/api/generated/nipype.utils.draw_gantt_chart.html
 """
 
 from collections import OrderedDict
-from datetime import datetime
+from datetime import datetime, timedelta
 import random
 from warnings import warn
 
 from nipype.utils.draw_gantt_chart import draw_lines, draw_resource_bar, log_to_dict
 
-from CPAC.utils.monitoring.monitoring import DatetimeWithSafeNone
+from CPAC.utils.monitoring.monitoring import _NoTime, DatetimeWithSafeNone
 
 
 def create_event_dict(start_time, nodes_list):
@@ -404,37 +403,38 @@ def generate_gantt_chart(
 
     for node in nodes_list:
         if "duration" not in node and (node["start"] and node["finish"]):
-            node["duration"] = (node["finish"] - node["start"]).total_seconds()
+            _duration = node["finish"] - node["start"]
+            assert isinstance(_duration, timedelta)
+            node["duration"] = _duration.total_seconds()
 
     # Create the header of the report with useful information
     start_node = nodes_list[0]
     last_node = nodes_list[-1]
+    start = DatetimeWithSafeNone(start_node["start"])
+    finish = DatetimeWithSafeNone(last_node["finish"])
+    if isinstance(start, _NoTime) or isinstance(finish, _NoTime):
+        return
+    start, finish = DatetimeWithSafeNone.sync_tz(start, finish)
     try:
-        duration = (last_node["finish"] - start_node["start"]).total_seconds()
+        duration = (finish - start).total_seconds()
     except TypeError:
         # no duration
         return
 
     # Get events based dictionary of node run stats
-    events = create_event_dict(start_node["start"], nodes_list)
+    events = create_event_dict(start, nodes_list)
 
     # Summary strings of workflow at top
-    html_string += (
-        "<p>Start: " + start_node["start"].strftime("%Y-%m-%d %H:%M:%S") + "</p>"
-    )
-    html_string += (
-        "<p>Finish: " + last_node["finish"].strftime("%Y-%m-%d %H:%M:%S") + "</p>"
-    )
+    html_string += "<p>Start: " + start.strftime("%Y-%m-%d %H:%M:%S") + "</p>"
+    html_string += "<p>Finish: " + finish.strftime("%Y-%m-%d %H:%M:%S") + "</p>"
     html_string += "<p>Duration: " + f"{duration / 60:.2f}" + " minutes</p>"
     html_string += "<p>Nodes: " + str(len(nodes_list)) + "</p>"
     html_string += "<p>Cores: " + str(cores) + "</p>"
     html_string += close_header
     # Draw nipype nodes Gantt chart and runtimes
-    html_string += draw_lines(
-        start_node["start"], duration, minute_scale, space_between_minutes
-    )
+    html_string += draw_lines(start, duration, minute_scale, space_between_minutes)
     html_string += draw_nodes(
-        start_node["start"],
+        start,
         nodes_list,
         cores,
         minute_scale,
@@ -448,8 +448,8 @@ def generate_gantt_chart(
     # Plot gantt chart
     resource_offset = 120 + 30 * cores
     html_string += draw_resource_bar(
-        start_node["start"],
-        last_node["finish"],
+        start,
+        finish,
         estimated_mem_ts,
         space_between_minutes,
         minute_scale,
@@ -458,8 +458,8 @@ def generate_gantt_chart(
         "Memory",
     )
     html_string += draw_resource_bar(
-        start_node["start"],
-        last_node["finish"],
+        start,
+        finish,
         runtime_mem_ts,
         space_between_minutes,
         minute_scale,
@@ -473,8 +473,8 @@ def generate_gantt_chart(
     runtime_threads_ts = calculate_resource_timeseries(events, "runtime_threads")
     # Plot gantt chart
     html_string += draw_resource_bar(
-        start_node["start"],
-        last_node["finish"],
+        start,
+        finish,
         estimated_threads_ts,
         space_between_minutes,
         minute_scale,
@@ -483,8 +483,8 @@ def generate_gantt_chart(
         "Threads",
     )
     html_string += draw_resource_bar(
-        start_node["start"],
-        last_node["finish"],
+        start,
+        finish,
         runtime_threads_ts,
         space_between_minutes,
         minute_scale,