junifer 0.0.5__py3-none-any.whl → 0.0.5.dev24__py3-none-any.whl

junifer/external/BrainPrint/brainprint/surfaces.py

@@ -1,258 +0,0 @@
-"""
-Utility module holding surface generation related functions.
-"""
-import uuid
-from pathlib import Path
-from typing import Dict, List
-
-from lapy import TriaMesh
-
-from .utils.utils import run_shell_command
-
-
-def create_aseg_surface(
-    subject_dir: Path, destination: Path, indices: List[int]
-) -> Path:
-    """
-    Generate a surface from the aseg and label files.
-
-    Parameters
-    ----------
-    subject_dir : Path
-        Path to the subject's directory.
-    destination : Path
-        Path to the destination directory where the surface will be saved.
-    indices : List[int]
-        List of label indices to include in the surface generation.
-
-    Returns
-    -------
-    Path
-        Path to the generated surface in VTK format.
-    """
-    aseg_path = subject_dir / "mri/aseg.mgz"
-    norm_path = subject_dir / "mri/norm.mgz"
-    temp_name = "temp/aseg.{uid}".format(uid=uuid.uuid4())
-    indices_mask = destination / f"{temp_name}.mgz"
-    # binarize on selected labels (creates temp indices_mask)
-    # always binarize first, otherwise pretess may scale aseg if labels are
-    # larger than 255 (e.g. aseg+aparc, bug in mri_pretess?)
-    binarize_template = "mri_binarize --i {source} --match {match} --o {destination}"
-    binarize_command = binarize_template.format(
-        source=aseg_path, match=" ".join(indices), destination=indices_mask
-    )
-    run_shell_command(binarize_command)
-
-    label_value = "1"
-    # if norm exist, fix label (pretess)
-    if norm_path.is_file():
-        pretess_template = (
-            "mri_pretess {source} {label_value} {norm_path} {destination}"
-        )
-        pretess_command = pretess_template.format(
-            source=indices_mask,
-            label_value=label_value,
-            norm_path=norm_path,
-            destination=indices_mask,
-        )
-        run_shell_command(pretess_command)
-
-    # runs marching cube to extract surface
-    surface_name = "{name}.surf".format(name=temp_name)
-    surface_path = destination / surface_name
-    extraction_template = "mri_mc {source} {label_value} {destination}"
-    extraction_command = extraction_template.format(
-        source=indices_mask, label_value=label_value, destination=surface_path
-    )
-    run_shell_command(extraction_command)
-
-    # convert to vtk
-    relative_path = "surfaces/aseg.final.{indices}.vtk".format(
-        indices="_".join(indices)
-    )
-    conversion_destination = destination / relative_path
-    conversion_template = "mris_convert {source} {destination}"
-    conversion_command = conversion_template.format(
-        source=surface_path, destination=conversion_destination
-    )
-    run_shell_command(conversion_command)
-
-    return conversion_destination
-
-
-def create_aseg_surfaces(subject_dir: Path, destination: Path) -> Dict[str, Path]:
-    """
-    Create surfaces from FreeSurfer aseg labels.
-
-    Parameters
-    ----------
-    subject_dir : Path
-        Path to the subject's FreeSurfer directory.
-    destination : Path
-        Path to the destination directory for saving surfaces.
-
-    Returns
-    -------
-    Dict[str, Path]
-        Dictionary of label names mapped to corresponding surface Path objects.
-    """
-    # Define aseg labels
-
-    # combined and individual aseg labels:
-    # - Left  Striatum: left  Caudate + Putamen + Accumbens
-    # - Right Striatum: right Caudate + Putamen + Accumbens
-    # - CorpusCallosum: 5 subregions combined
-    # - Cerebellum: brainstem + (left+right) cerebellum WM and GM
-    # - Ventricles: (left+right) lat.vent + inf.lat.vent + choroidplexus + 3rdVent + CSF
-    # - Lateral-Ventricle: lat.vent + inf.lat.vent + choroidplexus
-    # - 3rd-Ventricle: 3rd-Ventricle + CSF
-
-    aseg_labels = {
-        "CorpusCallosum": ["251", "252", "253", "254", "255"],
-        "Cerebellum": ["7", "8", "16", "46", "47"],
-        "Ventricles": ["4", "5", "14", "24", "31", "43", "44", "63"],
-        "3rd-Ventricle": ["14", "24"],
-        "4th-Ventricle": ["15"],
-        "Brain-Stem": ["16"],
-        "Left-Striatum": ["11", "12", "26"],
-        "Left-Lateral-Ventricle": ["4", "5", "31"],
-        "Left-Cerebellum-White-Matter": ["7"],
-        "Left-Cerebellum-Cortex": ["8"],
-        "Left-Thalamus-Proper": ["10"],
-        "Left-Caudate": ["11"],
-        "Left-Putamen": ["12"],
-        "Left-Pallidum": ["13"],
-        "Left-Hippocampus": ["17"],
-        "Left-Amygdala": ["18"],
-        "Left-Accumbens-area": ["26"],
-        "Left-VentralDC": ["28"],
-        "Right-Striatum": ["50", "51", "58"],
-        "Right-Lateral-Ventricle": ["43", "44", "63"],
-        "Right-Cerebellum-White-Matter": ["46"],
-        "Right-Cerebellum-Cortex": ["47"],
-        "Right-Thalamus-Proper": ["49"],
-        "Right-Caudate": ["50"],
-        "Right-Putamen": ["51"],
-        "Right-Pallidum": ["52"],
-        "Right-Hippocampus": ["53"],
-        "Right-Amygdala": ["54"],
-        "Right-Accumbens-area": ["58"],
-        "Right-VentralDC": ["60"],
-    }
-    return {
-        label: create_aseg_surface(subject_dir, destination, indices)
-        for label, indices in aseg_labels.items()
-    }
-
-
-def create_cortical_surfaces(subject_dir: Path, destination: Path) -> Dict[str, Path]:
-    """
-    Create cortical surfaces from FreeSurfer labels.
-
-    Parameters
-    ----------
-    subject_dir : Path
-        Path to the subject's FreeSurfer directory.
-    destination : Path
-        Path to the destination directory where the surfaces will be saved.
-
-    Returns
-    -------
-    Dict[str, Path]
-        Dictionary mapping label names to associated surface Paths.
-    """
-    cortical_labels = {
-        "lh-white-2d": "lh.white",
-        "rh-white-2d": "rh.white",
-        "lh-pial-2d": "lh.pial",
-        "rh-pial-2d": "rh.pial",
-    }
-    return {
-        label: surf_to_vtk(
-            subject_dir / "surf" / name,
-            destination / "surfaces" / f"{name}.vtk",
-        )
-        for label, name in cortical_labels.items()
-    }
-
-
-def create_surfaces(
-    subject_dir: Path, destination: Path, skip_cortex: bool = False
-) -> Dict[str, Path]:
-    """
-    Create surfaces based on FreeSurfer labels.
-
-    Parameters
-    ----------
-    subject_dir : Path
-        Path to the subject's FreeSurfer directory.
-    destination : Path
-        Path to the destination directory where the surfaces will be saved.
-    skip_cortex : bool, optional
-        If True, cortical surfaces will not be created (default is False).
-
-    Returns
-    -------
-    Dict[str, Path]
-        Dict mapping label names to the corresponding Path objects of created surfaces.
-    """
-    surfaces = create_aseg_surfaces(subject_dir, destination)
-    if not skip_cortex:
-        cortical_surfaces = create_cortical_surfaces(subject_dir, destination)
-        surfaces.update(cortical_surfaces)
-    return surfaces
-
-
-def read_vtk(path: Path):
-    """
-    Read a VTK file and return a triangular mesh.
-
-    Parameters
-    ----------
-    path : Path
-        Path to the VTK file to be read.
-
-    Returns
-    -------
-    TriaMesh
-        A triangular mesh object representing the contents of the VTK file.
-
-    Raises
-    ------
-    RuntimeError
-        If there is an issue reading the VTK file or if the file is empty.
-    """
-    try:
-        triangular_mesh = TriaMesh.read_vtk(path)
-    except Exception:
-        message = "Failed to read VTK from the following path: {path}!".format(
-            path=path
-        )
-        raise RuntimeError(message)
-    else:
-        if triangular_mesh is None:
-            message = "Failed to read VTK from the following path: {path}!".format(
-                path=path
-            )
-            raise RuntimeError(message)
-        return triangular_mesh
-
-
-def surf_to_vtk(source: Path, destination: Path) -> Path:
-    """
-    Converted a FreeSurfer *.surf* file to *.vtk*.
-
-    Parameters
-    ----------
-    source : Path
-        FreeSurfer *.surf* file.
-    destination : Path
-        Equivalent *.vtk* file.
-
-    Returns
-    -------
-    Path
-        Resulting *.vtk* file.
-    """
-    TriaMesh.read_fssurf(source).write_vtk(destination)
-    return destination

junifer/external/BrainPrint/brainprint/utils/__init__.py

@@ -1 +0,0 @@
-"""Utilities module."""

junifer/external/BrainPrint/brainprint/utils/_config.py

@@ -1,112 +0,0 @@
-import platform
-import re
-import sys
-from functools import partial
-from importlib.metadata import requires, version
-from typing import IO, Callable, List, Optional
-
-import psutil
-
-
-def sys_info(fid: Optional[IO] = None, developer: bool = False):
-    """Print the system information for debugging.
-
-    Parameters
-    ----------
-    fid : file-like, default=None
-        The file to write to, passed to :func:`print`.
-        Can be None to use :data:`sys.stdout`.
-    developer : bool, default=False
-        If True, display information about optional dependencies.
-    """
-
-    ljust = 26
-    out = partial(print, end="", file=fid)
-    package = __package__.split(".")[0]
-
-    # OS information - requires python 3.8 or above
-    out("Platform:".ljust(ljust) + platform.platform() + "\n")
-    # Python information
-    out("Python:".ljust(ljust) + sys.version.replace("\n", " ") + "\n")
-    out("Executable:".ljust(ljust) + sys.executable + "\n")
-    # CPU information
-    out("CPU:".ljust(ljust) + platform.processor() + "\n")
-    out("Physical cores:".ljust(ljust) + str(psutil.cpu_count(False)) + "\n")
-    out("Logical cores:".ljust(ljust) + str(psutil.cpu_count(True)) + "\n")
-    # Memory information
-    out("RAM:".ljust(ljust))
-    out(f"{psutil.virtual_memory().total / float(2 ** 30):0.1f} GB\n")
-    out("SWAP:".ljust(ljust))
-    out(f"{psutil.swap_memory().total / float(2 ** 30):0.1f} GB\n")
-
-    # dependencies
-    out("\nDependencies info\n")
-    out(f"{package}:".ljust(ljust) + version(package) + "\n")
-    dependencies = [
-        elt.split(";")[0].rstrip() for elt in requires(package) if "extra" not in elt
-    ]
-    _list_dependencies_info(out, ljust, dependencies)
-
-    # extras
-    if developer:
-        keys = (
-            "build",
-            "doc",
-            "test",
-            "style",
-        )
-        for key in keys:
-            dependencies = [
-                elt.split(";")[0].rstrip()
-                for elt in requires(package)
-                if f"extra == '{key}'" in elt or f'extra == "{key}"' in elt
-            ]
-            if len(dependencies) == 0:
-                continue
-            out(f"\nOptional '{key}' info\n")
-            _list_dependencies_info(out, ljust, dependencies)
-
-
-def _list_dependencies_info(out: Callable, ljust: int, dependencies: List[str]):
-    """List dependencies names and versions.
-
-    Parameters
-    ----------
-    out : Callable
-        output function
-    ljust : int
-         length of returned string
-    dependencies : List[str]
-        list of dependencies
-
-    """
-
-    for dep in dependencies:
-        # handle dependencies with version specifiers
-        specifiers_pattern = r"(~=|==|!=|<=|>=|<|>|===)"
-        specifiers = re.findall(specifiers_pattern, dep)
-        if len(specifiers) != 0:
-            dep, _ = dep.split(specifiers[0])
-            while not dep[-1].isalpha():
-                dep = dep[:-1]
-        # handle dependencies provided with a [key], e.g. pydocstyle[toml]
-        if "[" in dep:
-            dep = dep.split("[")[0]
-        try:
-            version_ = version(dep)
-        except Exception:
-            version_ = "Not found."
-
-        # handle special dependencies with backends, C dep, ..
-        if dep in ("matplotlib", "seaborn") and version_ != "Not found.":
-            try:
-                from matplotlib import pyplot as plt
-
-                backend = plt.get_backend()
-            except Exception:
-                backend = "Not found"
-
-            out(f"{dep}:".ljust(ljust) + version_ + f" (backend: {backend})\n")
-
-        else:
-            out(f"{dep}:".ljust(ljust) + version_ + "\n")

junifer/external/BrainPrint/brainprint/utils/utils.py

@@ -1,188 +0,0 @@
-"""
-Utilities for the :mod:`brainprint` module.
-"""
-import os
-import shlex
-import subprocess
-from pathlib import Path
-from typing import Dict
-
-import numpy as np
-import pandas as pd
-
-
-def validate_environment() -> None:
-    """
-    Checks whether required environment variables are set.
-    """
-    if not os.getenv("FREESURFER_HOME"):
-        raise RuntimeError(
-            "FreeSurfer root directory must be set as the $FREESURFER_HOME "
-            "environment variable!"
-        )
-
-
-def test_freesurfer() -> None:
-    """
-    Tests FreeSurfer binarize are accessible and executable.
-
-    Raises
-    ------
-    RuntimeError
-        Failed to execute test FreeSurfer command
-    """
-    command = "mri_binarize -version"
-    try:
-        run_shell_command(command)
-    except FileNotFoundError:
-        raise RuntimeError(
-            "Failed to run FreeSurfer command, please check the required binaries "
-            "are included in your $PATH."
-        )
-
-
-def run_shell_command(command: str, verbose: bool = False):
-    """
-    Execute shell command.
-
-    Parameters
-    ----------
-    command : str
-        Shell command to be executed
-
-    Raises
-    ------
-    RuntimeError
-        Shell command execution failure
-    """
-    if verbose:
-        print(f"Executing command:\t{command}", end="\n")
-    args = shlex.split(command)
-    try:
-        return_code = subprocess.call(args)
-    except Exception as e:
-        message = (
-            "Failed to execute the following command:\n{command}\n"
-            "The following exception was raised:\n{exception}".format(
-                command=command, exception=e
-            )
-        )
-        print(message)
-        raise
-    if return_code != 0:
-        message = (
-            "Execution of the following command:\n{command}\n"
-            "Returned non-zero exit code!".format(command=command)
-        )
-        raise RuntimeError(message)
-
-
-def validate_subject_dir(subjects_dir: Path, subject_id: str) -> Path:
-    """
-    Checks the input FreeSurfer preprocessing results directory exists.
-
-    Parameters
-    ----------
-    subjects_dir : Path
-        FreeSurfer's subjects directory
-    subject_id : str
-        The subject identifier, as defined within the FreeSurfer's subjects
-        directory
-
-    Raises
-    ------
-    FileNotFoundError
-        Subject results directory does not exist
-    """
-    subject_dir = Path(subjects_dir) / subject_id
-    if not subject_dir.is_dir():
-        message = "FreeSurfer results directory at {path} does not exist!".format(
-            path=subject_dir
-        )
-        raise FileNotFoundError(message)
-    return subject_dir
-
-
-def resolve_destination(subject_dir: Path, destination: Path = None) -> Path:
-    if destination is None:
-        return Path(subject_dir) / "brainprint"
-    return destination
-
-
-def create_output_paths(subject_dir: Path = None, destination: Path = None) -> None:
-    """
-    Creates the output directories in which the BrainPrint analysis derivatives
-    will be created. One of *subject_dir* or *destination* must be
-    provided.
-
-    Parameters
-    ----------
-    subject_dir : Path, optional
-        If provided, will simply nest results in the provided directory, by
-        default None
-    destination : Path, optional
-        If provided, will use this path as the results root directory, by
-        default None
-
-    Raises
-    ------
-    ValueError
-        No *subject_dir* or *destination* provided
-    """
-    destination = resolve_destination(subject_dir, destination)
-    destination.mkdir(parents=True, exist_ok=True)
-    (destination / "surfaces").mkdir(parents=True, exist_ok=True)
-    (destination / "temp").mkdir(parents=True, exist_ok=True)
-    return destination
-
-
-def export_brainprint_results(
-    destination: Path,
-    eigenvalues: np.ndarray,
-    eigenvectors: np.ndarray = None,
-    distances: np.ndarray = None,
-) -> Dict[str, Path]:
-    """
-    Writes the BrainPrint analysis results to CSV files.
-
-    Parameters
-    ----------
-    destination : Path
-        Eigenvalues CSV file destination
-    eigenvalues : np.ndarray
-        Eigenvalues
-    eigenvectors : np.ndarray, optional
-        Eigenvectors, by default None
-    distances : np.ndarray, optional
-        Distances, by default None
-    """
-    files = {}
-    df = pd.DataFrame(eigenvalues).sort_index(axis=1)
-    ev_indices = [f"ev{i}" for i in range(len(df) - 2)]
-    df.index = ["area", "volume"] + ev_indices
-    df.to_csv(destination, index=True, na_rep="NaN")
-    files["eigenvalues"] = destination
-
-    if eigenvectors is not None:
-        eigenvectors_dir = destination.parent / "eigenvectors"
-        eigenvectors_dir.mkdir(parents=True, exist_ok=True)
-        for key, value in eigenvectors.items():
-            suffix = ".evecs-{key}.csv".format(key=key)
-            name = destination.with_suffix(suffix).name
-            vectors_destination = eigenvectors_dir / name
-            pd.DataFrame(value).to_csv(
-                vectors_destination,
-                index=True,
-                na_rep="NaN",
-            )
-        files["eigenvectors"] = eigenvectors_dir
-
-    if distances is not None:
-        distances_destination = destination.with_suffix(".asymmetry.csv")
-        pd.DataFrame([distances]).to_csv(
-            distances_destination,
-            index=False,
-            na_rep="NaN",
-        )
-        files["distances"] = distances_destination
-    return files