junifer 0.0.3.dev186__py3-none-any.whl → 0.0.4__py3-none-any.whl

junifer/data/parcellations.py

@@ -9,18 +9,20 @@ import io
 import shutil
 import tarfile
 import tempfile
+import typing
 import zipfile
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
 
+import httpx
 import nibabel as nib
 import numpy as np
 import pandas as pd
-import requests
 from nilearn import datasets, image
-from requests.exceptions import ConnectionError, HTTPError, ReadTimeout
 
-from ..utils.logging import logger, raise_error, warn_with_log
+from ..pipeline import WorkDirManager
+from ..utils import logger, raise_error, run_ext_cmd, warn_with_log
+from .template_spaces import get_template, get_xfm
 from .utils import closest_resolution
 
 
@@ -33,6 +35,7 @@ if TYPE_CHECKING:
 
 # Each entry is a dictionary that must contain at least the following keys:
 # * 'family': the parcellation's family name (e.g. 'Schaefer', 'SUIT')
+# * 'space': the parcellation's space (e.g., 'MNI', 'SUIT')
 
 # Optional keys:
 # * 'valid_resolutions': a list of valid resolutions for the parcellation
@@ -41,7 +44,7 @@ if TYPE_CHECKING:
 # TODO: have separate dictionary for built-in
 _available_parcellations: Dict[str, Dict[Any, Any]] = {
     "SUITxSUIT": {"family": "SUIT", "space": "SUIT"},
-    "SUITxMNI": {"family": "SUIT", "space": "MNI"},
+    "SUITxMNI": {"family": "SUIT", "space": "MNI152NLin6Asym"},
 }
 
 # Add Schaefer parcellation info
@@ -52,6 +55,7 @@ for n_rois in range(100, 1001, 100):
             "family": "Schaefer",
             "n_rois": n_rois,
             "yeo_networks": t_net,
+            "space": "MNI152NLin6Asym",
         }
 # Add Tian parcellation info
 for scale in range(1, 5):
@@ -60,27 +64,28 @@ for scale in range(1, 5):
         "family": "Tian",
         "scale": scale,
         "magneticfield": "7T",
-        "space": "MNI6thgeneration",
+        "space": "MNI152NLin6Asym",
     }
     t_name = f"TianxS{scale}x3TxMNI6thgeneration"
     _available_parcellations[t_name] = {
         "family": "Tian",
         "scale": scale,
         "magneticfield": "3T",
-        "space": "MNI6thgeneration",
+        "space": "MNI152NLin6Asym",
     }
     t_name = f"TianxS{scale}x3TxMNInonlinear2009cAsym"
     _available_parcellations[t_name] = {
         "family": "Tian",
         "scale": scale,
         "magneticfield": "3T",
-        "space": "MNInonlinear2009cAsym",
+        "space": "MNI152NLin2009cAsym",
     }
 # Add AICHA parcellation info
 for version in (1, 2):
     _available_parcellations[f"AICHA_v{version}"] = {
         "family": "AICHA",
         "version": version,
+        "space": "IXI549Space",
     }
 # Add Shen parcellation info
 for year in (2013, 2015, 2019):
@@ -90,18 +95,21 @@ for year in (2013, 2015, 2019):
                 "family": "Shen",
                 "year": 2013,
                 "n_rois": n_rois,
+                "space": "MNI152NLin2009cAsym",
             }
     elif year == 2015:
         _available_parcellations["Shen_2015_268"] = {
             "family": "Shen",
             "year": 2015,
             "n_rois": 268,
+            "space": "MNI152NLin2009cAsym",
         }
     elif year == 2019:
         _available_parcellations["Shen_2019_368"] = {
             "family": "Shen",
             "year": 2019,
             "n_rois": 368,
+            "space": "MNI152NLin2009cAsym",
         }
 # Add Yan parcellation info
 for n_rois in range(100, 1001, 100):
@@ -111,12 +119,21 @@ for n_rois in range(100, 1001, 100):
             "family": "Yan",
             "n_rois": n_rois,
             "yeo_networks": yeo_network,
+            "space": "MNI152NLin6Asym",
         }
     # Add Kong networks
     _available_parcellations[f"Yan{n_rois}xKong17"] = {
         "family": "Yan",
         "n_rois": n_rois,
         "kong_networks": 17,
+        "space": "MNI152NLin6Asym",
+    }
+# Add Brainnetome parcellation info
+for threshold in [0, 25, 50]:
+    _available_parcellations[f"Brainnetome_thr{threshold}"] = {
+        "family": "Brainnetome",
+        "threshold": threshold,
+        "space": "MNI152NLin6Asym",
     }
 
 
@@ -124,6 +141,7 @@ def register_parcellation(
     name: str,
     parcellation_path: Union[str, Path],
     parcels_labels: List[str],
+    space: str,
     overwrite: bool = False,
 ) -> None:
     """Register a custom user parcellation.
@@ -136,6 +154,8 @@ def register_parcellation(
         The path to the parcellation file.
     parcels_labels : list of str
         The list of labels for the parcellation.
+    space : str
+        The template space of the parcellation, for e.g., "MNI152NLin6Asym".
     overwrite : bool, optional
         If True, overwrite an existing parcellation with the same name.
         Does not apply to built-in parcellations (default False).
@@ -161,8 +181,8 @@ def register_parcellation(
                 )
         else:
             raise_error(
-                f"Parcellation {name} already registered. Set `overwrite=True`"
-                "to update its value."
+                f"Parcellation {name} already registered. Set "
+                "`overwrite=True` to update its value."
             )
     # Convert str to Path
     if not isinstance(parcellation_path, Path):
@@ -172,6 +192,7 @@ def register_parcellation(
         "path": str(parcellation_path.absolute()),
         "labels": parcels_labels,
         "family": "CustomUserParcellation",
+        "space": space,
     }
 
 
@@ -187,12 +208,210 @@ def list_parcellations() -> List[str]:
     return sorted(_available_parcellations.keys())
 
 
-# def _check_resolution(resolution, valid_resolution):
-#     if resolution is None:
-#         return None
-#     if resolution not in valid_resolution:
-#         raise ValueError(f'Invalid resolution: {resolution}')
-#     return resolution
+def get_parcellation(
+    parcellation: List[str],
+    target_data: Dict[str, Any],
+    extra_input: Optional[Dict[str, Any]] = None,
+) -> Tuple["Nifti1Image", List[str]]:
+    """Get parcellation, tailored for the target image.
+
+    Parameters
+    ----------
+    parcellation : list of str
+        The name(s) of the parcellation(s).
+    target_data : dict
+        The corresponding item of the data object to which the parcellation
+        will be applied.
+    extra_input : dict, optional
+        The other fields in the data object. Useful for accessing other data
+        kinds that needs to be used in the computation of parcellations
+        (default None).
+
+    Returns
+    -------
+    Nifti1Image
+        The parcellation image.
+    list of str
+        Parcellation labels.
+
+    Raises
+    ------
+    RuntimeError
+        If warp / transformation file extension is not ".mat" or ".h5".
+    ValueError
+        If ``extra_input`` is None when ``target_data``'s space is native.
+
+    """
+    # Check pre-requirements for space manipulation
+    target_space = target_data["space"]
+    # Set target standard space to target space
+    target_std_space = target_space
+    # Extra data type requirement check if target space is native
+    if target_space == "native":
+        # Check for extra inputs
+        if extra_input is None:
+            raise_error(
+                "No extra input provided, requires `Warp` and `T1w` "
+                "data types in particular for transformation to "
+                f"{target_data['space']} space for further computation."
+            )
+        # Set target standard space to warp file space source
+        target_std_space = extra_input["Warp"]["src"]
+
+    # Get the min of the voxels sizes and use it as the resolution
+    target_img = target_data["data"]
+    resolution = np.min(target_img.header.get_zooms()[:3])
+
+    # Create component-scoped tempdir
+    tempdir = WorkDirManager().get_tempdir(prefix="parcellations")
+    # Create element-scoped tempdir so that warped parcellation is
+    # available later as nibabel stores file path reference for
+    # loading on computation
+    element_tempdir = WorkDirManager().get_element_tempdir(
+        prefix="parcellations"
+    )
+
+    # Load the parcellations
+    all_parcellations = []
+    all_labels = []
+    for name in parcellation:
+        img, labels, _, space = load_parcellation(
+            name=name,
+            resolution=resolution,
+        )
+
+        # Convert parcellation spaces if required
+        if space != target_std_space:
+            # Get xfm file
+            xfm_file_path = get_xfm(src=space, dst=target_std_space)
+            # Get target standard space template
+            target_std_space_template_img = get_template(
+                space=target_std_space,
+                target_data=target_data,
+                extra_input=extra_input,
+            )
+
+            # Save parcellation image to a component-scoped tempfile
+            parcellation_path = tempdir / f"{name}.nii.gz"
+            nib.save(img, parcellation_path)
+
+            # Save template
+            target_std_space_template_path = (
+                tempdir / f"{target_std_space}_T1w_{resolution}.nii.gz"
+            )
+            nib.save(
+                target_std_space_template_img, target_std_space_template_path
+            )
+
+            # Set warped parcellation path
+            warped_parcellation_path = element_tempdir / (
+                f"{name}_warped_from_{space}_to_" f"{target_std_space}.nii.gz"
+            )
+
+            logger.debug(
+                f"Using ANTs to warp {name} "
+                f"from {space} to {target_std_space}"
+            )
+            # Set antsApplyTransforms command
+            apply_transforms_cmd = [
+                "antsApplyTransforms",
+                "-d 3",
+                "-e 3",
+                "-n 'GenericLabel[NearestNeighbor]'",
+                f"-i {parcellation_path.resolve()}",
+                f"-r {target_std_space_template_path.resolve()}",
+                f"-t {xfm_file_path.resolve()}",
+                f"-o {warped_parcellation_path.resolve()}",
+            ]
+            # Call antsApplyTransforms
+            run_ext_cmd(name="antsApplyTransforms", cmd=apply_transforms_cmd)
+
+            img = nib.load(warped_parcellation_path)
+
+        # Resample parcellation to target image
+        img_to_merge = image.resample_to_img(
+            source_img=img,
+            target_img=target_img,
+            interpolation="nearest",
+            copy=True,
+        )
+
+        all_parcellations.append(img_to_merge)
+        all_labels.append(labels)
+
+    # Avoid merging if there is only one parcellation
+    if len(all_parcellations) == 1:
+        resampled_parcellation_img = all_parcellations[0]
+        labels = all_labels[0]
+    # Parcellations are already transformed to target standard space
+    else:
+        resampled_parcellation_img, labels = merge_parcellations(
+            parcellations_list=all_parcellations,
+            parcellations_names=parcellation,
+            labels_lists=all_labels,
+        )
+
+    # Warp parcellation if target space is native
+    if target_space == "native":
+        # Save parcellation image to a component-scoped tempfile
+        prewarp_parcellation_path = tempdir / "prewarp_parcellation.nii.gz"
+        nib.save(resampled_parcellation_img, prewarp_parcellation_path)
+
+        # Create an element-scoped tempfile for warped output
+        warped_parcellation_path = (
+            element_tempdir / "parcellation_warped.nii.gz"
+        )
+
+        # Check for warp file type to use correct tool
+        warp_file_ext = extra_input["Warp"]["path"].suffix
+        if warp_file_ext == ".mat":
+            logger.debug("Using FSL for parcellation warping")
+            # Set applywarp command
+            applywarp_cmd = [
+                "applywarp",
+                "--interp=nn",
+                f"-i {prewarp_parcellation_path.resolve()}",
+                # use resampled reference
+                f"-r {target_data['reference_path'].resolve()}",
+                f"-w {extra_input['Warp']['path'].resolve()}",
+                f"-o {warped_parcellation_path.resolve()}",
+            ]
+            # Call applywarp
+            run_ext_cmd(name="applywarp", cmd=applywarp_cmd)
+
+        elif warp_file_ext == ".h5":
+            logger.debug("Using ANTs for parcellation warping")
+            # Set antsApplyTransforms command
+            apply_transforms_cmd = [
+                "antsApplyTransforms",
+                "-d 3",
+                "-e 3",
+                "-n 'GenericLabel[NearestNeighbor]'",
+                f"-i {prewarp_parcellation_path.resolve()}",
+                # use resampled reference
+                f"-r {target_data['reference_path'].resolve()}",
+                f"-t {extra_input['Warp']['path'].resolve()}",
+                f"-o {warped_parcellation_path.resolve()}",
+            ]
+            # Call antsApplyTransforms
+            run_ext_cmd(name="antsApplyTransforms", cmd=apply_transforms_cmd)
+
+        else:
+            raise_error(
+                msg=(
+                    "Unknown warp / transformation file extension: "
+                    f"{warp_file_ext}"
+                ),
+                klass=RuntimeError,
+            )
+
+        # Load nifti
+        resampled_parcellation_img = nib.load(warped_parcellation_path)
+
+    # Delete tempdir
+    WorkDirManager().delete_tempdir(tempdir)
+
+    return resampled_parcellation_img, labels  # type: ignore
 
 
 def load_parcellation(
@@ -200,11 +419,11 @@ def load_parcellation(
     parcellations_dir: Union[str, Path, None] = None,
     resolution: Optional[float] = None,
     path_only: bool = False,
-) -> Tuple[Optional["Nifti1Image"], List[str], Path]:
+) -> Tuple[Optional["Nifti1Image"], List[str], Path, str]:
     """Load a brain parcellation (including a label file).
 
-    If it is a built-in parcellaions and file is not present in the
-    `parcellations_dir` directory, it will be downloaded.
+    If it is a built-in parcellation and the file is not present in the
+    ``parcellations_dir`` directory, it will be downloaded.
 
     Parameters
     ----------
@@ -230,18 +449,33 @@ def load_parcellation(
         Parcellation labels.
     pathlib.Path
         File path to the parcellation image.
+    str
+        The space of the parcellation.
+
+    Raises
+    ------
+    ValueError
+        If ``name`` is invalid or if the parcellation values and labels
+        don't have equal dimension or if the value range is invalid.
 
     """
-    # Invalid parcellation name
+    # Check for valid parcellation name
     if name not in _available_parcellations:
         raise_error(
             f"Parcellation {name} not found. "
             f"Valid options are: {list_parcellations()}"
         )
 
+    # Copy parcellation definition to avoid edits in original object
     parcellation_definition = _available_parcellations[name].copy()
     t_family = parcellation_definition.pop("family")
+    # Remove space conditionally
+    if t_family not in ["SUIT", "Tian"]:
+        space = parcellation_definition.pop("space")
+    else:
+        space = parcellation_definition["space"]
 
+    # Check if the parcellation family is custom or built-in
     if t_family == "CustomUserParcellation":
         parcellation_fname = Path(parcellation_definition["path"])
         parcellation_labels = parcellation_definition["labels"]
@@ -253,25 +487,32 @@ def load_parcellation(
             **parcellation_definition,
         )
 
+    # Load parcellation image and values
     logger.info(f"Loading parcellation {parcellation_fname.absolute()!s}")
-
     parcellation_img = None
     if path_only is False:
+        # Load image via nibabel
         parcellation_img = nib.load(parcellation_fname)
+        # Get unique values
         parcel_values = np.unique(parcellation_img.get_fdata())
+        # Check for dimension
         if len(parcel_values) - 1 != len(parcellation_labels):
             raise_error(
                 f"Parcellation {name} has {len(parcel_values) - 1} parcels "
                 f"but {len(parcellation_labels)} labels."
             )
+        # Sort values
         parcel_values.sort()
+        # Check if value range is invalid
         if np.any(np.diff(parcel_values) != 1):
             raise_error(
                 f"Parcellation {name} must have all the values in the range  "
                 f"[0, {len(parcel_values)}]."
             )
 
-    return parcellation_img, parcellation_labels, parcellation_fname
+    # Type-cast to remove errors
+    parcellation_img = typing.cast("Nifti1Image", parcellation_img)
+    return parcellation_img, parcellation_labels, parcellation_fname, space
 
 
 def _retrieve_parcellation(
@@ -312,13 +553,13 @@ def _retrieve_parcellation(
     * Tian :
         ``scale`` : {1, 2, 3, 4}
             Scale of parcellation (defines granularity).
-        ``space`` : {"MNI6thgeneration", "MNInonlinear2009cAsym"}, optional
-            Space of parcellation (default "MNI6thgeneration"). (For more
+        ``space`` : {"MNI152NLin6Asym", "MNI152NLin2009cAsym"}, optional
+            Space of parcellation (default "MNI152NLin6Asym"). (For more
             information see https://github.com/yetianmed/subcortex)
         ``magneticfield`` : {"3T", "7T"}, optional
             Magnetic field (default "3T").
     * SUIT :
-        ``space`` : {"MNI", "SUIT"}, optional
+        ``space`` : {"MNI152NLin6Asym", "SUIT"}, optional
             Space of parcellation (default "MNI"). (For more information
             see http://www.diedrichsenlab.org/imaging/suit.htm).
     * AICHA :
@@ -338,6 +579,9 @@ def _retrieve_parcellation(
             Number of Yeo networks to use (default None).
         ``kong_networks`` : {17}, optional
             Number of Kong networks to use (default None).
+    * Brainnetome :
+        ``threshold`` : {0, 25, 50}
+            Threshold for the probabilistic maps of subregion.
 
     Returns
     -------
@@ -401,6 +645,12 @@ def _retrieve_parcellation(
             resolution=resolution,
             **kwargs,
         )
+    elif family == "Brainnetome":
+        parcellation_fname, parcellation_labels = _retrieve_brainnetome(
+            parcellations_dir=parcellations_dir,
+            resolution=resolution,
+            **kwargs,
+        )
     else:
         raise_error(
             f"The provided parcellation name {family} cannot be retrieved."
@@ -451,24 +701,27 @@ def _retrieve_schaefer(
     logger.info(f"\tn_rois: {n_rois}")
     logger.info(f"\tyeo_networks: {yeo_networks}")
 
+    # Check n_rois value
     _valid_n_rois = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
-    _valid_networks = [7, 17]
-    _valid_resolutions = [1, 2]
-
     if n_rois not in _valid_n_rois:
         raise_error(
             f"The parameter `n_rois` ({n_rois}) needs to be one of the "
             f"following: {_valid_n_rois}"
         )
+
+    # Check networks
+    _valid_networks = [7, 17]
     if yeo_networks not in _valid_networks:
         raise_error(
             f"The parameter `yeo_networks` ({yeo_networks}) needs to be one "
             f"of the following: {_valid_networks}"
         )
 
+    # Check resolution
+    _valid_resolutions = [1, 2]
     resolution = closest_resolution(resolution, _valid_resolutions)
 
-    # define file names
+    # Define parcellation and label file names
     parcellation_fname = (
         parcellations_dir
         / "schaefer_2018"
@@ -483,7 +736,7 @@ def _retrieve_schaefer(
         / (f"Schaefer2018_{n_rois}Parcels_{yeo_networks}Networks_order.txt")
     )
 
-    # check existence of parcellation
+    # Check existence of parcellation
     if not (parcellation_fname.exists() and parcellation_lname.exists()):
         logger.info(
             "At least one of the parcellation files are missing. "
@@ -493,14 +746,9 @@ def _retrieve_schaefer(
             n_rois=n_rois,
             yeo_networks=yeo_networks,
             resolution_mm=resolution,  # type: ignore we know it's 1 or 2
-            data_dir=str(parcellations_dir.absolute()),
+            data_dir=parcellations_dir.resolve(),
         )
 
-        if not (
-            parcellation_fname.exists() and parcellation_lname.exists()
-        ):  # pragma: no cover
-            raise_error("There was a problem fetching the parcellations.")
-
     # Load labels
     labels = [
         "_".join(x.split("_")[1:])
@@ -516,7 +764,7 @@ def _retrieve_tian(
     parcellations_dir: Path,
     resolution: Optional[float] = None,
     scale: Optional[int] = None,
-    space: str = "MNI6thgeneration",
+    space: str = "MNI152NLin6Asym",
     magneticfield: str = "3T",
 ) -> Tuple[Path, List[str]]:
     """Retrieve Tian parcellation.
@@ -533,8 +781,8 @@ def _retrieve_tian(
         parcellation depend on the space and magnetic field.
     scale : {1, 2, 3, 4}, optional
         Scale of parcellation (defines granularity) (default None).
-    space : {"MNI6thgeneration", "MNInonlinear2009cAsym"}, optional
-        Space of parcellation (default "MNI6thgeneration"). (For more
+    space : {"MNI152NLin6Asym", "MNI152NLin2009cAsym"}, optional
+        Space of parcellation (default "MNI152NLin6Asym"). (For more
         information see https://github.com/yetianmed/subcortex)
     magneticfield : {"3T", "7T"}, optional
         Magnetic field (default "3T").
@@ -548,19 +796,20 @@ def _retrieve_tian(
 
     Raises
     ------
+    RuntimeError
+        If there is a problem fetching files.
     ValueError
         If invalid value is provided for ``scale`` or ``magneticfield`` or
-        ``space`` or if there is a problem fetching the parcellation.
+        ``space``.
 
     """
-    # show parameters to user
     logger.info("Parcellation parameters:")
     logger.info(f"\tresolution: {resolution}")
     logger.info(f"\tscale: {scale}")
     logger.info(f"\tspace: {space}")
     logger.info(f"\tmagneticfield: {magneticfield}")
 
-    # check validity of parameters
+    # Check scale
     _valid_scales = [1, 2, 3, 4]
     if scale not in _valid_scales:
         raise_error(
@@ -568,12 +817,13 @@ def _retrieve_tian(
             f"following: {_valid_scales}"
         )
 
+    # Check resolution
     _valid_resolutions = []  # avoid pylance error
     if magneticfield == "3T":
-        _valid_spaces = ["MNI6thgeneration", "MNInonlinear2009cAsym"]
-        if space == "MNI6thgeneration":
+        _valid_spaces = ["MNI152NLin6Asym", "MNI152NLin2009cAsym"]
+        if space == "MNI152NLin6Asym":
             _valid_resolutions = [1, 2]
-        elif space == "MNInonlinear2009cAsym":
+        elif space == "MNI152NLin2009cAsym":
             _valid_resolutions = [2]
         else:
             raise_error(
@@ -582,20 +832,19 @@ def _retrieve_tian(
             )
     elif magneticfield == "7T":
         _valid_resolutions = [1.6]
-        if space != "MNI6thgeneration":
+        if space != "MNI152NLin6Asym":
             raise_error(
                 f"The parameter `space` ({space}) for 7T needs to be "
-                f"MNI6thgeneration"
+                f"MNI152NLin6Asym"
             )
     else:
         raise_error(
             f"The parameter `magneticfield` ({magneticfield}) needs to be "
             f"one of the following: 3T or 7T"
         )
-
     resolution = closest_resolution(resolution, _valid_resolutions)
 
-    # define file names
+    # Define parcellation and label file names
     if magneticfield == "3T":
         parcellation_fname_base_3T = (
             parcellations_dir / "Tian2020MSA_v1.1" / "3T" / "Subcortex-Only"
@@ -603,7 +852,7 @@ def _retrieve_tian(
         parcellation_lname = parcellation_fname_base_3T / (
             f"Tian_Subcortex_S{scale}_3T_label.txt"
         )
-        if space == "MNI6thgeneration":
+        if space == "MNI152NLin6Asym":
             parcellation_fname = parcellation_fname_base_3T / (
                 f"Tian_Subcortex_S{scale}_{magneticfield}.nii.gz"
             )
@@ -612,7 +861,7 @@ def _retrieve_tian(
                     parcellation_fname_base_3T
                     / f"Tian_Subcortex_S{scale}_{magneticfield}_1mm.nii.gz"
                 )
-        elif space == "MNInonlinear2009cAsym":
+        elif space == "MNI152NLin2009cAsym":
             space = "2009cAsym"
             parcellation_fname = parcellation_fname_base_3T / (
                 f"Tian_Subcortex_S{scale}_{magneticfield}_{space}.nii.gz"
@@ -644,45 +893,53 @@ def _retrieve_tian(
             "parcellation. A simple numbering scheme for distinction was "
             "therefore used."
         )
-    else:  # pragma: no cover
-        raise_error("This should not happen. Please report this error.")
 
-    # check existence of parcellation
+    # Check existence of parcellation
     if not (parcellation_fname.exists() and parcellation_lname.exists()):
         logger.info(
             "At least one of the parcellation files are missing, fetching."
         )
-
-        url_basis = (
+        # Set URL
+        url = (
             "https://www.nitrc.org/frs/download.php/12012/Tian2020MSA_v1.1.zip"
         )
 
-        logger.info(f"Downloading TIAN from {url_basis}")
+        logger.info(f"Downloading TIAN from {url}")
+        # Store initial download in a tempdir
         with tempfile.TemporaryDirectory() as tmpdir:
-            parcellation_download = requests.get(url_basis)
-            parcellation_zip_fname = Path(tmpdir) / "Tian2020MSA_v1.1.zip"
-            with open(parcellation_zip_fname, "wb") as f:
-                f.write(parcellation_download.content)
-            with zipfile.ZipFile(parcellation_zip_fname, "r") as zip_ref:
-                zip_ref.extractall(parcellations_dir.as_posix())
-            # clean after unzipping
-            if (parcellations_dir / "__MACOSX").exists():
-                shutil.rmtree((parcellations_dir / "__MACOSX").as_posix())
-
-        labels = pd.read_csv(parcellation_lname, sep=" ", header=None)[
-            0
-        ].to_list()
-
-        if not (parcellation_fname.exists() and parcellation_lname.exists()):
-            raise_error("There was a problem fetching the parcellations.")
+            # Make HTTP request
+            try:
+                resp = httpx.get(url)
+                resp.raise_for_status()
+            except httpx.HTTPError as exc:
+                raise_error(
+                    f"Error response {exc.response.status_code} while "
+                    f"requesting {exc.request.url!r}",
+                    klass=RuntimeError,
+                )
+            else:
+                # Set tempfile for storing initial content and unzipping
+                zip_fname = Path(tmpdir) / "Tian2020MSA_v1.1.zip"
+                # Open tempfile and write content
+                with open(zip_fname, "wb") as f:
+                    f.write(resp.content)
+                # Unzip tempfile
+                with zipfile.ZipFile(zip_fname, "r") as zip_ref:
+                    zip_ref.extractall(parcellations_dir.as_posix())
+                # Clean after unzipping
+                if (parcellations_dir / "__MACOSX").exists():
+                    shutil.rmtree((parcellations_dir / "__MACOSX").as_posix())
 
+    # Load labels
     labels = pd.read_csv(parcellation_lname, sep=" ", header=None)[0].to_list()
 
     return parcellation_fname, labels
 
 
 def _retrieve_suit(
-    parcellations_dir: Path, resolution: Optional[float], space: str = "MNI"
+    parcellations_dir: Path,
+    resolution: Optional[float],
+    space: str = "MNI152NLin6Asym",
 ) -> Tuple[Path, List[str]]:
     """Retrieve SUIT parcellation.
 
@@ -696,9 +953,9 @@ def _retrieve_suit(
         resolution higher than the desired one. By default, will load the
         highest one (default None). Available resolutions for this parcellation
         are 1mm and 2mm.
-    space : {"MNI", "SUIT"}, optional
-        Space of parcellation (default "MNI"). (For more information
-        see http://www.diedrichsenlab.org/imaging/suit.htm).
+    space : {"MNI152NLin6Asym", "SUIT"}, optional
+        Space of parcellation (default "MNI152NLin6Asym"). (For more
+        information see http://www.diedrichsenlab.org/imaging/suit.htm).
 
     Returns
     -------
@@ -709,30 +966,33 @@ def _retrieve_suit(
 
     Raises
     ------
+    RuntimeError
+        If there is a problem fetching files.
     ValueError
-        If invalid value is provided for ``space`` or if there is a problem
-        fetching the parcellation.
+        If invalid value is provided for ``space``.
 
     """
     logger.info("Parcellation parameters:")
     logger.info(f"\tresolution: {resolution}")
     logger.info(f"\tspace: {space}")
 
-    _valid_spaces = ["MNI", "SUIT"]
-
-    # check validity of parameters
+    # Check space
+    _valid_spaces = ["MNI152NLin6Asym", "SUIT"]
     if space not in _valid_spaces:
         raise_error(
             f"The parameter `space` ({space}) needs to be one of the "
             f"following: {_valid_spaces}"
         )
 
-    # TODO: Validate this with Vera
+    # Check resolution
     _valid_resolutions = [1]
-
     resolution = closest_resolution(resolution, _valid_resolutions)
 
-    # define file names
+    # Format space if MNI; required for the file name
+    if space == "MNI152NLin6Asym":
+        space = "MNI"
+
+    # Define parcellation and label file names
     parcellation_fname = (
         parcellations_dir / "SUIT" / (f"SUIT_{space}Space_{resolution}mm.nii")
     )
@@ -740,45 +1000,61 @@ def _retrieve_suit(
         parcellations_dir / "SUIT" / (f"SUIT_{space}Space_{resolution}mm.tsv")
     )
 
-    # check existence of parcellation
+    # Check existence of parcellation
     if not (parcellation_fname.exists() and parcellation_lname.exists()):
-        parcellation_fname.parent.mkdir(exist_ok=True, parents=True)
         logger.info(
             "At least one of the parcellation files is missing, fetching."
         )
-
+        # Create local directory if not present
+        parcellation_fname.parent.mkdir(exist_ok=True, parents=True)
+        # Set URL
         url_basis = (
             "https://github.com/DiedrichsenLab/cerebellar_atlases/raw"
-            "/master/Diedrichsen_2009/"
+            "/master/Diedrichsen_2009"
         )
-        url_MNI = url_basis + "atl-Anatom_space-MNI_dseg.nii"
-        url_SUIT = url_basis + "atl-Anatom_space-SUIT_dseg.nii"
-        url_labels = url_basis + "atl-Anatom.tsv"
-
         if space == "MNI":
-            logger.info(f"Downloading {url_MNI}")
-            parcellation_download = requests.get(url_MNI)
-            with open(parcellation_fname, "wb") as f:
-                f.write(parcellation_download.content)
+            url = f"{url_basis}/atl-Anatom_space-MNI_dseg.nii"
         else:  # if not MNI, then SUIT
-            logger.info(f"Downloading {url_SUIT}")
-            parcellation_download = requests.get(url_SUIT)
-            with open(parcellation_fname, "wb") as f:
-                f.write(parcellation_download.content)
-
-        labels_download = requests.get(url_labels)
-        labels = pd.read_csv(
-            io.StringIO(labels_download.content.decode("utf-8")),
-            sep="\t",
-            usecols=["name"],
-        )
+            url = f"{url_basis}/atl-Anatom_space-SUIT_dseg.nii"
+        url_labels = f"{url_basis}/atl-Anatom.tsv"
 
-        labels.to_csv(parcellation_lname, sep="\t", index=False)
-        if (
-            not parcellation_fname.exists() and parcellation_lname.exists()
-        ):  # pragma: no cover
-            raise_error("There was a problem fetching the parcellations.")
+        # Make HTTP requests
+        with httpx.Client(follow_redirects=True) as client:
+            # Download parcellation file
+            logger.info(f"Downloading SUIT parcellation from {url}")
+            try:
+                img_resp = client.get(url)
+                img_resp.raise_for_status()
+            except httpx.HTTPError as exc:
+                raise_error(
+                    f"Error response {exc.response.status_code} while "
+                    f"requesting {exc.request.url!r}",
+                    klass=RuntimeError,
+                )
+            else:
+                with open(parcellation_fname, "wb") as f:
+                    f.write(img_resp.content)
+            # Download label file
+            logger.info(f"Downloading SUIT labels from {url_labels}")
+            try:
+                label_resp = client.get(url_labels)
+                label_resp.raise_for_status()
+            except httpx.HTTPError as exc:
+                raise_error(
+                    f"Error response {exc.response.status_code} while "
+                    f"requesting {exc.request.url!r}",
+                    klass=RuntimeError,
+                )
+            else:
+                # Load labels
+                labels = pd.read_csv(
+                    io.StringIO(label_resp.content.decode("utf-8")),
+                    sep="\t",
+                    usecols=["name"],
+                )
+                labels.to_csv(parcellation_lname, sep="\t", index=False)
 
+    # Load labels
     labels = pd.read_csv(parcellation_lname, sep="\t", usecols=["name"])[
         "name"
     ].to_list()
@@ -815,9 +1091,15 @@ def _retrieve_aicha(
 
     Raises
     ------
+    RuntimeError
+        If there is a problem fetching files.
     ValueError
-        If invalid value is provided for ``version`` or if there is a problem
-        fetching the parcellation.
+        If invalid value is provided for ``version``.
+
+    Warns
+    -----
+    RuntimeWarning
+        Until the authors confirm the space, the warning will be issued.
 
     Notes
     -----
@@ -825,28 +1107,33 @@ def _retrieve_aicha(
     1mm, it is only for display purpose as noted in the release document.
 
     """
-    # show parameters to user
+    # Issue warning until space is confirmed by authors
+    warn_with_log(
+        "The current space for AICHA parcellations are IXI549Space, but are "
+        "not confirmed by authors, until that this warning will be issued."
+    )
+
     logger.info("Parcellation parameters:")
     logger.info(f"\tresolution: {resolution}")
     logger.info(f"\tversion: {version}")
 
-    # Check version value
-    _valid_version = (1, 2)
+    # Check version
+    _valid_version = [1, 2]
     if version not in _valid_version:
         raise_error(
             f"The parameter `version` ({version}) needs to be one of the "
             f"following: {_valid_version}"
         )
 
+    # Check resolution
     _valid_resolutions = [1]
     resolution = closest_resolution(resolution, _valid_resolutions)
 
-    # Define image file
+    # Define parcellation and label file names
     parcellation_fname = (
         parcellations_dir / f"AICHA_v{version}" / "AICHA" / "AICHA.nii"
     )
-
-    # Define label file name according to version
+    parcellation_lname = Path()
     if version == 1:
         parcellation_lname = (
             parcellations_dir
@@ -867,54 +1154,60 @@ def _retrieve_aicha(
         logger.info(
             "At least one of the parcellation files are missing, fetching."
         )
-
         # Set file name on server according to version
+        server_filename = ""
         if version == 1:
             server_filename = "aicha_v1.zip"
         elif version == 2:
             server_filename = "AICHA_v2.tar.zip"
-
         # Set URL
         url = f"http://www.gin.cnrs.fr/wp-content/uploads/{server_filename}"
 
         logger.info(f"Downloading AICHA v{version} from {url}")
+        # Store initial download in a tempdir
         with tempfile.TemporaryDirectory() as tmpdir:
             # Make HTTP request
             try:
-                resp = requests.get(url)
+                resp = httpx.get(url, follow_redirects=True)
                 resp.raise_for_status()
-            except (ConnectionError, ReadTimeout, HTTPError) as err:
+            except httpx.HTTPError as exc:
                 raise_error(
-                    f"Failed to download AICHA v{version} due to: {err}"
+                    f"Error response {exc.response.status_code} while "
+                    f"requesting {exc.request.url!r}",
+                    klass=RuntimeError,
                 )
             else:
+                # Set tempfile for storing initial content and unzipping
                 parcellation_zip_path = Path(tmpdir) / server_filename
+                # Open tempfile and write content
                 with open(parcellation_zip_path, "wb") as f:
                     f.write(resp.content)
-
-            # Extract zipfile
-            with zipfile.ZipFile(parcellation_zip_path, "r") as zip_ref:
-                if version == 1:
-                    zip_ref.extractall(
-                        (parcellations_dir / "AICHA_v1").as_posix()
-                    )
-                elif version == 2:
-                    zip_ref.extractall(Path(tmpdir).as_posix())
-                    # Extract tarfile for v2
-                    with tarfile.TarFile(
-                        Path(tmpdir) / "aicha_v2.tar", "r"
-                    ) as tar_ref:
-                        tar_ref.extractall(
-                            (parcellations_dir / "AICHA_v2").as_posix()
+                # Unzip tempfile
+                with zipfile.ZipFile(parcellation_zip_path, "r") as zip_ref:
+                    if version == 1:
+                        zip_ref.extractall(
+                            (parcellations_dir / "AICHA_v1").as_posix()
                         )
-
-            # Cleanup after unzipping
-            if (parcellations_dir / f"AICHA_v{version}" / "__MACOSX").exists():
-                shutil.rmtree(
-                    (
-                        parcellations_dir / f"AICHA_v{version}" / "__MACOSX"
-                    ).as_posix()
-                )
+                    elif version == 2:
+                        zip_ref.extractall(Path(tmpdir).as_posix())
+                        # Extract tarfile for v2
+                        with tarfile.TarFile(
+                            Path(tmpdir) / "aicha_v2.tar", "r"
+                        ) as tar_ref:
+                            tar_ref.extractall(
+                                (parcellations_dir / "AICHA_v2").as_posix()
+                            )
+                # Cleanup after unzipping
+                if (
+                    parcellations_dir / f"AICHA_v{version}" / "__MACOSX"
+                ).exists():
+                    shutil.rmtree(
+                        (
+                            parcellations_dir
+                            / f"AICHA_v{version}"
+                            / "__MACOSX"
+                        ).as_posix()
+                    )
 
     # Load labels
     labels = pd.read_csv(
@@ -959,12 +1252,13 @@ def _retrieve_shen(  # noqa: C901
 
     Raises
     ------
+    RuntimeError
+        If there is a problem fetching files.
     ValueError
-        If invalid value or combination is provided for ``year`` and ``n_rois``
-        or if there is a problem fetching the parcellation.
+        If invalid value or combination is provided for ``year`` and
+        ``n_rois``.
 
     """
-    # show parameters to user
     logger.info("Parcellation parameters:")
     logger.info(f"\tresolution: {resolution}")
     logger.info(f"\tyear: {year}")
@@ -1012,7 +1306,7 @@ def _retrieve_shen(  # noqa: C901
             f"`year = {year}` is invalid"
         )
 
-    # Define image file according to constraints
+    # Define parcellation and label file names
     if year == 2013:
         parcellation_fname = (
             parcellations_dir
@@ -1059,27 +1353,31 @@ def _retrieve_shen(  # noqa: C901
             url = "https://www.nitrc.org/frs/download.php/11629/shen_368.zip"
 
         logger.info(f"Downloading Shen {year} from {url}")
+        # Store initial download in a tempdir
         with tempfile.TemporaryDirectory() as tmpdir:
             # Make HTTP request
             try:
-                resp = requests.get(url)
+                resp = httpx.get(url)
                 resp.raise_for_status()
-            except (ConnectionError, ReadTimeout, HTTPError) as err:
-                raise_error(f"Failed to download Shen {year} due to {err}")
+            except httpx.HTTPError as exc:
+                raise_error(
+                    f"Error response {exc.response.status_code} while "
+                    f"requesting {exc.request.url!r}",
+                    klass=RuntimeError,
+                )
             else:
                 if year in (2013, 2019):
                     parcellation_zip_path = Path(tmpdir) / f"Shen{year}.zip"
+                    # Open tempfile and write content
                     with open(parcellation_zip_path, "wb") as f:
                         f.write(resp.content)
-
-                    # Extract zipfile
+                    # Unzip tempfile
                     with zipfile.ZipFile(
                         parcellation_zip_path, "r"
                     ) as zip_ref:
                         zip_ref.extractall(
                             (parcellations_dir / f"Shen_{year}").as_posix()
                         )
-
                     # Cleanup after unzipping
                     if (
                         parcellations_dir / f"Shen_{year}" / "__MACOSX"
@@ -1089,16 +1387,18 @@ def _retrieve_shen(  # noqa: C901
                                 parcellations_dir / f"Shen_{year}" / "__MACOSX"
                             ).as_posix()
                         )
-
                 elif year == 2015:
                     img_dir_path = parcellations_dir / "Shen_2015"
+                    # Create local directory if not present
                     img_dir_path.mkdir(parents=True, exist_ok=True)
                     img_path = (
                         img_dir_path
                         / f"shen_{resolution}mm_268_parcellation.nii.gz"
                     )
+                    # Create local file if not present
                     img_path.touch(exist_ok=True)
-                    with open(img_path.as_posix(), "wb") as f:
+                    # Open tempfile and write content
+                    with open(img_path, "wb") as f:
                         f.write(resp.content)
 
     # Load labels based on year
@@ -1156,9 +1456,11 @@ def _retrieve_yan(
 
     Raises
     ------
+    RuntimeError
+        If there is a problem fetching files.
     ValueError
         If invalid value is provided for ``n_rois``, ``yeo_networks`` or
-        ``kong_networks`` or if there is a problem fetching the parcellation.
+        ``kong_networks``.
 
     """
     logger.info("Parcellation parameters:")
@@ -1188,6 +1490,8 @@ def _retrieve_yan(
             f"following: {_valid_n_rois}"
         )
 
+    parcellation_fname = Path()
+    parcellation_lname = Path()
     if yeo_networks:
         # Check yeo_networks value
         _valid_yeo_networks = [7, 17]
@@ -1240,6 +1544,8 @@ def _retrieve_yan(
         )
 
         # Set URL based on network
+        img_url = ""
+        label_url = ""
         if yeo_networks:
             img_url = (
                 "https://raw.githubusercontent.com/ThomasYeoLab/CBIG/"
@@ -1267,38 +1573,165 @@ def _retrieve_yan(
                 "Kong2022_17Networks_LUT.txt"
             )
 
-        # Initiate a session and make HTTP requests
-        session = requests.Session()
-        # Download parcellation file
-        logger.info(f"Downloading Yan 2023 parcellation from {img_url}")
+        # Make HTTP requests
+        with httpx.Client() as client:
+            # Download parcellation file
+            logger.info(f"Downloading Yan 2023 parcellation from {img_url}")
+            try:
+                img_resp = client.get(img_url)
+                img_resp.raise_for_status()
+            except httpx.HTTPError as exc:
+                raise_error(
+                    f"Error response {exc.response.status_code} while "
+                    f"requesting {exc.request.url!r}",
+                    klass=RuntimeError,
+                )
+            else:
+                parcellation_img_path = Path(parcellation_fname)
+                # Create local directory if not present
+                parcellation_img_path.parent.mkdir(parents=True, exist_ok=True)
+                # Create local file if not present
+                parcellation_img_path.touch(exist_ok=True)
+                # Open file and write content
+                with open(parcellation_img_path, "wb") as f:
+                    f.write(img_resp.content)
+            # Download label file
+            logger.info(f"Downloading Yan 2023 labels from {label_url}")
+            try:
+                label_resp = client.get(label_url)
+                label_resp.raise_for_status()
+            except httpx.HTTPError as exc:
+                raise_error(
+                    f"Error response {exc.response.status_code} while "
+                    f"requesting {exc.request.url!r}",
+                    klass=RuntimeError,
+                )
+            else:
+                parcellation_labels_path = Path(parcellation_lname)
+                # Create local file if not present
+                parcellation_labels_path.touch(exist_ok=True)
+                # Open file and write content
+                with open(parcellation_labels_path, "wb") as f:
+                    f.write(label_resp.content)
+
+    # Load label file
+    labels = pd.read_csv(parcellation_lname, sep=" ", header=None)[1].to_list()
+
+    return parcellation_fname, labels
+
+
+def _retrieve_brainnetome(
+    parcellations_dir: Path,
+    resolution: Optional[float] = None,
+    threshold: Optional[int] = None,
+) -> Tuple[Path, List[str]]:
+    """Retrieve Brainnetome parcellation.
+
+    Parameters
+    ----------
+    parcellations_dir : pathlib.Path
+        The path to the parcellation data directory.
+    resolution : {1.0, 1.25, 2.0}, optional
+        The desired resolution of the parcellation to load. If it is not
+        available, the closest resolution will be loaded. Preferably, use a
+        resolution higher than the desired one. By default, will load the
+        highest one (default None). Available resolutions for this
+        parcellation are 1mm, 1.25mm and 2mm.
+    threshold : {0, 25, 50}, optional
+        The threshold for the probabilistic maps of subregion (default None).
+
+    Returns
+    -------
+    pathlib.Path
+        File path to the parcellation image.
+    list of str
+        Parcellation labels.
+
+    Raises
+    ------
+    RuntimeError
+        If there is a problem fetching files.
+    ValueError
+        If invalid value is provided for ``threshold``.
+
+    """
+    logger.info("Parcellation parameters:")
+    logger.info(f"\tresolution: {resolution}")
+    logger.info(f"\tthreshold: {threshold}")
+
+    # Check resolution
+    _valid_resolutions = [1.0, 1.25, 2.0]
+    resolution = closest_resolution(resolution, _valid_resolutions)
+
+    # Check threshold value
+    _valid_threshold = [0, 25, 50]
+    if threshold not in _valid_threshold:
+        raise_error(
+            f"The parameter `threshold` ({threshold}) needs to be one of the "
+            f"following: {_valid_threshold}"
+        )
+    # Correct resolution for further stuff
+    if resolution in [1.0, 2.0]:
+        resolution = int(resolution)
+
+    parcellation_fname = (
+        parcellations_dir
+        / "BNA246"
+        / f"BNA-maxprob-thr{threshold}-{resolution}mm.nii.gz"
+    )
+
+    # Check for existence of parcellation
+    if not parcellation_fname.exists():
+        # Set URL
+        url = f"http://neurovault.org/media/images/1625/BNA-maxprob-thr{threshold}-{resolution}mm.nii.gz"
+
+        logger.info(f"Downloading Brainnetome from {url}")
+        # Make HTTP request
         try:
-            img_resp = session.get(img_url)
-            img_resp.raise_for_status()
-        except (ConnectionError, ReadTimeout, HTTPError) as err:
+            resp = httpx.get(url, follow_redirects=True)
+            resp.raise_for_status()
+        except httpx.HTTPError as exc:
             raise_error(
-                f"Failed to download Yan 2023 parcellation due to: {err}"
+                f"Error response {exc.response.status_code} while "
+                f"requesting {exc.request.url!r}",
+                klass=RuntimeError,
             )
         else:
-            parcellation_img_path = Path(parcellation_fname)
-            parcellation_img_path.parent.mkdir(parents=True, exist_ok=True)
-            parcellation_img_path.touch(exist_ok=True)
-            with open(parcellation_img_path, "wb") as f:
-                f.write(img_resp.content)
-        # Download label file
-        logger.info(f"Downloading Yan 2023 labels from {label_url}")
-        try:
-            label_resp = session.get(label_url)
-            label_resp.raise_for_status()
-        except (ConnectionError, ReadTimeout, HTTPError) as err:
-            raise_error(f"Failed to download Yan 2023 labels due to: {err}")
-        else:
-            parcellation_labels_path = Path(parcellation_lname)
-            parcellation_labels_path.touch(exist_ok=True)
-            with open(parcellation_labels_path, "wb") as f:
-                f.write(label_resp.content)
+            # Create local directory if not present
+            parcellation_fname.parent.mkdir(parents=True, exist_ok=True)
+            # Create file if not present
+            parcellation_fname.touch(exist_ok=True)
+            # Open file and write bytes
+            parcellation_fname.write_bytes(resp.content)
 
-    # Load label file
-    labels = pd.read_csv(parcellation_lname, sep=" ", header=None)[1].to_list()
+    # Load labels
+    labels = (
+        sorted([f"SFG_L(R)_7_{i}" for i in range(1, 8)] * 2)
+        + sorted([f"MFG_L(R)_7_{i}" for i in range(1, 8)] * 2)
+        + sorted([f"IFG_L(R)_6_{i}" for i in range(1, 7)] * 2)
+        + sorted([f"OrG_L(R)_6_{i}" for i in range(1, 7)] * 2)
+        + sorted([f"PrG_L(R)_6_{i}" for i in range(1, 7)] * 2)
+        + sorted([f"PCL_L(R)_2_{i}" for i in range(1, 3)] * 2)
+        + sorted([f"STG_L(R)_6_{i}" for i in range(1, 7)] * 2)
+        + sorted([f"MTG_L(R)_4_{i}" for i in range(1, 5)] * 2)
+        + sorted([f"ITG_L(R)_7_{i}" for i in range(1, 8)] * 2)
+        + sorted([f"FuG_L(R)_3_{i}" for i in range(1, 4)] * 2)
+        + sorted([f"PhG_L(R)_6_{i}" for i in range(1, 7)] * 2)
+        + sorted([f"pSTS_L(R)_2_{i}" for i in range(1, 3)] * 2)
+        + sorted([f"SPL_L(R)_5_{i}" for i in range(1, 6)] * 2)
+        + sorted([f"IPL_L(R)_6_{i}" for i in range(1, 7)] * 2)
+        + sorted([f"PCun_L(R)_4_{i}" for i in range(1, 5)] * 2)
+        + sorted([f"PoG_L(R)_4_{i}" for i in range(1, 5)] * 2)
+        + sorted([f"INS_L(R)_6_{i}" for i in range(1, 7)] * 2)
+        + sorted([f"CG_L(R)_7_{i}" for i in range(1, 8)] * 2)
+        + sorted([f"MVOcC _L(R)_5_{i}" for i in range(1, 6)] * 2)
+        + sorted([f"LOcC_L(R)_4_{i}" for i in range(1, 5)] * 2)
+        + sorted([f"LOcC_L(R)_2_{i}" for i in range(1, 3)] * 2)
+        + sorted([f"Amyg_L(R)_2_{i}" for i in range(1, 3)] * 2)
+        + sorted([f"Hipp_L(R)_2_{i}" for i in range(1, 3)] * 2)
+        + sorted([f"BG_L(R)_6_{i}" for i in range(1, 7)] * 2)
+        + sorted([f"Tha_L(R)_8_{i}" for i in range(1, 9)] * 2)
+    )
 
     return parcellation_fname, labels