mediml 0.9.9__py3-none-any.whl

MEDiml/utils/mode.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from typing import Tuple, Union
+
+import numpy as np
+
+
+def mode(x: np.ndarray,
+        return_counts=False) -> Union[Tuple[np.ndarray, np.ndarray],
+                                      np.ndarray]:
+    """Implementation of mode that also returns counts, unlike the standard statistics.mode.
+
+    Args:
+        x (ndarray): n-dimensional array of which to find mode.
+        return_counts (bool): If True, also return the number of times each unique item appears in ``x``.
+
+    Returns:
+        2-element tuple containing
+        
+        - ndarray: Array of the modal (most common) value in the given array.
+        - ndarray: Array of the counts if ``return_counts`` is True.
+    """
+
+    unique_values, counts = np.unique(x, return_counts=True)
+
+    if return_counts:
+        return unique_values[np.argmax(counts)], np.max(counts)
+
+    return unique_values[np.argmax(counts)]

MEDiml/utils/parse_contour_string.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from typing import List, Tuple, Union
+
+import numpy as np
+
+from ..utils.strfind import strfind
+
+
+def parse_contour_string(contour_string) -> Union[Tuple[float, List[str]],
+                                                  Tuple[int, List[str]],
+                                                  Tuple[List[int], List[str]]]:
+    """Finds the delimeters (:math:`'+'` and :math:`'-'`) and the contour indexe(s) from the given string.
+
+    Args:
+        contour_string (str, float or int): Index or string of indexes with
+        delimeters. For example: :math:`'3'` or :math:`'1-3+2'`.
+
+    Returns:
+        float, int: If ``contour_string`` is a an int or float we return ``contour_string``.
+        List[str]: List of the delimeters.
+        List[int]: List of the contour indexes.
+
+    Example:
+        >>> ``contour_string`` = '1-3+2'
+        >>> :function: parse_contour_string(contour_string)
+        [1, 2, 3], ['+', '-']
+        >>> ``contour_string`` = 1
+        >>> :function: parse_contour_string(contour_string)
+        1, []
+    """
+
+    if isinstance(contour_string, (int, float)):
+        return contour_string, []
+
+    ind_plus = strfind(string=contour_string, pattern='\+')
+    ind_minus = strfind(string=contour_string, pattern='\-')
+    ind_operations = np.sort(np.hstack((ind_plus, ind_minus))).astype(int)
+
+    # Parsing operations and contour numbers
+    # AZ: I assume that contour_number is an integer
+    if ind_operations.size == 0:
+        operations = []
+        contour_number = [int(contour_string)]
+    else:
+        n_op = len(ind_operations)
+        operations = [contour_string[ind_operations[i]] for i in np.arange(n_op)]
+
+        contour_number = np.zeros(n_op + 1, dtype=int)
+        contour_number[0] = int(contour_string[0:ind_operations[0]])
+        for c in np.arange(start=1, stop=n_op):
+            contour_number[c] = int(contour_string[(ind_operations[c-1]+1) : ind_operations[c]])
+
+        contour_number[-1] = int(contour_string[(ind_operations[-1]+1):])
+        contour_number.tolist()
+
+    return contour_number, operations

MEDiml/utils/save_MEDscan.py

@@ -0,0 +1,30 @@
+import pickle
+from pathlib import Path
+
+from ..MEDscan import MEDscan
+
+
+def save_MEDscan(medscan: MEDscan,
+                  path_save: Path) -> str:
+    """Saves MEDscan class instance in a pickle object
+    
+    Args:
+        medscan (MEDscan): MEDscan instance
+        path_save (Path): MEDscan instance saving paths
+    
+    Returns:
+        None.
+    """
+
+    series_description = medscan.series_description.translate({ord(ch): '-' for ch in '/\\ ()&:*'})
+    name_id = medscan.patientID
+    name_id = name_id.translate({ord(ch): '-' for ch in '/\\ ()&:*'})
+
+    # final saving name
+    name_complete = name_id + '__' + series_description + '.' + medscan.type + '.npy'
+    
+    # save
+    with open(path_save / name_complete,'wb') as f: 
+        pickle.dump(medscan, f)
+
+    return name_complete

MEDiml/utils/strfind.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from re import finditer
+from typing import List
+
+
+def strfind(pattern: str,
+            string: str) -> List[int]:
+    """Finds indices of ``pattern`` in ``string``. Based on regex.
+
+    Note:
+        Be careful with + and - symbols. Use :math:`\+` and :math:`\-` instead.
+
+    Args:
+        pattern (str): Substring to be searched in the ``string``.
+        string (str): String used to find matches.
+
+    Returns:
+        List[int]: List of indexes of every occurence of ``pattern`` in the passed ``string``.
+
+    Raises:
+        ValueError: If the ``pattern`` does not use backslash with special regex symbols
+    """
+
+    if pattern in ('+', '-'):
+        raise ValueError(
+            "Please use a backslash with special regex symbols in findall.")
+
+    ind = [m.start() for m in finditer(pattern, string)]
+
+    return ind

MEDiml/utils/textureTools.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from typing import List, Union
+
+import numpy as np
+
+
+def get_neighbour_direction(d=1.8,
+                            distance="euclidian",
+                            centre=False,
+                            complete=False,
+                            dim3=True) -> np.ndarray:
+    """Defines transitions to neighbour voxels.
+
+    Note:
+        This code was adapted from the in-house radiomics software created at
+        OncoRay, Dresden, Germany.
+
+    Args:
+        d (float, optional): Max ``distance`` between voxels.
+        distance (str, optional): Distance norm used to compute distances. must be
+                                  "manhattan", "l1", "l_1", "euclidian", "l2", "l_2", "chebyshev", "linf" or "l_inf".
+        centre (bool, optional): Flags whether the [0,0,0] direction should be included
+        complete(bool, optional): Flags whether all directions should be computed (True)
+                                  or just the primary ones (False). For example, including [0,0,1] and [0,0,-1]
+                                  directions may lead to redundant texture matrices.
+        dim3(bool, optional): flags whether full 3D (True) or only in-slice (2D; False)
+                              directions should be considered.
+
+    Returns:
+        ndarray: set of k neighbour direction vectors.
+    """
+
+    # Base transition vector
+    trans = np.arange(start=-np.ceil(d), stop=np.ceil(d)+1)
+    n = np.size(trans)
+
+    # Build transition array [x,y,z]
+    nbrs = np.array([rep(x=trans, each=n * n, times=1),
+                     rep(x=trans, each=n, times=n),
+                     rep(x=trans, each=1, times=n * n)], dtype=np.int32)
+
+    # Initiate maintenance index
+    index = np.zeros(np.shape(nbrs)[1], dtype=bool)
+
+    # Remove neighbours more than distance d from the center ----------------
+
+    # Manhattan distance
+    if distance.lower() in ["manhattan", "l1", "l_1"]:
+        index = np.logical_or(index, np.sum(np.abs(nbrs), axis=0) <= d)
+    # Eucldian distance
+    if distance.lower() in ["euclidian", "l2", "l_2"]:
+        index = np.logical_or(index, np.sqrt(
+            np.sum(np.multiply(nbrs, nbrs), axis=0)) <= d)
+    # Chebyshev distance
+    if distance.lower() in ["chebyshev", "linf", "l_inf"]:
+        index = np.logical_or(index, np.max(np.abs(nbrs), axis=0) <= d)
+
+    # Check if centre voxel [0,0,0] should be maintained; False indicates removal
+    if centre is False:
+        index = np.logical_and(index, (np.sum(np.abs(nbrs), axis=0)) > 0)
+
+    # Check if a complete neighbourhood should be returned
+    # False indicates that only half of the vectors are returned
+    if complete is False:
+        index[np.arange(start=0, stop=len(index)//2 + 1)] = False
+
+    # Check if neighbourhood should be 3D or 2D
+    if dim3 is False:
+        index[nbrs[2, :] != 0] = False
+
+    return nbrs[:, index]
+
+
+def rep(x: np.ndarray,
+        each=1,
+        times=1) -> np.ndarray:
+    """Replicates the values in ``x``.
+    Replicates the :func:`"rep"` function found in R for tiling and repeating vectors.
+
+    Note:
+        Code was adapted from the in-house radiomics software created at OncoRay,
+        Dresden, Germany.
+
+    Args:
+        x (ndarray): Array to replicate.
+        each (int): Integer (non-negative) giving the number of times to repeat
+                    each element of the passed array.
+        times (int): Integer (non-negative). Each element of ``x`` is repeated each times.
+
+    Returns:
+        ndarray: Array with same values but replicated.
+    """
+
+    each = int(each)
+    times = int(times)
+
+    if each > 1:
+        x = np.repeat(x, repeats=each)
+
+    if times > 1:
+        x = np.tile(x, reps=times)
+
+    return x
+
+def get_value(x: np.ndarray,
+              index: int,
+              replace_invalid=True) -> np.ndarray:
+    """Retrieves intensity values from an image intensity table used for computing
+    texture features.
+
+    Note:
+        Code was adapted from the in-house radiomics software created at OncoRay,
+        Dresden, Germany.
+
+    Args:
+        x (ndarray): set of intensity values.
+        index (int): Index to the provided set of intensity values.
+        replace_invalid (bool, optional): If True, invalid indices will be replaced
+                                          by a placeholder "NaN" value.
+
+    Returns:
+        ndarray: Array of the intensity values found at the requested indices.
+
+    """
+
+    # Initialise placeholder
+    read_x = np.zeros(np.shape(x))
+
+    # Read variables for valid indices
+    read_x[index >= 0] = x[index[index >= 0]]
+
+    if replace_invalid:
+        # Set variables for invalid indices to nan
+        read_x[index < 0] = np.nan
+
+        # Set variables for invalid initial indices to nan
+        read_x[np.isnan(x)] = np.nan
+
+    return read_x
+
+
+def coord2index(x: np.ndarray,
+                y: np.ndarray,
+                z: np.ndarray,
+                dims: Union[List, np.ndarray]) -> Union[np.ndarray,
+                                                        List]:
+    """Translate requested coordinates to row indices in image intensity tables.
+
+    Note:
+        Code was adapted from the in-house radiomics software created at OncoRay,
+        Dresden, Germany.
+
+    Args:
+        x (ndarray): set of discrete x-coordinates.
+        y (ndarray): set of discrete y-coordinates.
+        z (ndarray): set of discrete z-coordinates.
+        dims (ndarray or List): dimensions of the image.
+
+    Returns:
+        ndarray or List: Array or List of indexes corresponding the requested coordinates
+
+    """
+
+    # Translate coordinates to indices
+    index = z + y * dims[2] + x * dims[2] * dims[1]
+
+    # Mark invalid transitions
+    index[np.logical_or(x < 0, x >= dims[0])] = -99999
+    index[np.logical_or(y < 0, y >= dims[1])] = -99999
+    index[np.logical_or(z < 0, z >= dims[2])] = -99999
+
+    return index
+
+
+def is_list_all_none(x: List) -> bool:
+    """Determines if all list elements are None.
+
+    Args:
+        x (List): List of elements to check.
+
+    Returns:
+        bool: True if all elemets in `x` are None.
+
+    """
+    return all(y is None for y in x)

MEDiml/utils/texture_features_names.py

@@ -0,0 +1,115 @@
+glcm_features_names = [
+    "Fcm_joint_max",
+    "Fcm_joint_avg",
+    "Fcm_joint_var",
+    "Fcm_joint_entr",
+    "Fcm_diff_avg",
+    "Fcm_diff_var",
+    "Fcm_diff_entr",
+    "Fcm_sum_avg",
+    "Fcm_sum_var",
+    "Fcm_sum_entr",
+    "Fcm_energy",
+    "Fcm_contrast",
+    "Fcm_dissimilarity",
+    "Fcm_inv_diff",
+    "Fcm_inv_diff_norm",
+    "Fcm_inv_diff_mom",
+    "Fcm_inv_diff_mom_norm",
+    "Fcm_inv_var",
+    "Fcm_corr",
+    "Fcm_auto_corr",
+    "Fcm_info_corr1",
+    "Fcm_info_corr2",
+    "Fcm_clust_tend",
+    "Fcm_clust_shade",
+    "Fcm_clust_prom"
+]
+glrlm_features_names = [
+    "Frlm_sre",
+    "Frlm_lre",
+    "Frlm_lgre",
+    "Frlm_hgre",
+    "Frlm_srlge",
+    "Frlm_srhge",
+    "Frlm_lrlge",
+    "Frlm_lrhge",
+    "Frlm_glnu",
+    "Frlm_glnu_norm",
+    "Frlm_rlnu",
+    "Frlm_rlnu_norm",
+    "Frlm_r_perc",
+    "Frlm_gl_var",
+    "Frlm_rl_var",
+    "Frlm_rl_entr"
+]
+glszm_features_names = [
+    "Fszm_sze",
+    "Fszm_lze",
+    "Fszm_lgze",
+    "Fszm_hgze",
+    "Fszm_szlge",
+    "Fszm_szhge",
+    "Fszm_lzlge",
+    "Fszm_lzhge",
+    "Fszm_glnu",
+    "Fszm_glnu_norm",
+    "Fszm_zsnu",
+    "Fszm_zsnu_norm",
+    "Fszm_z_perc",
+    "Fszm_gl_var",
+    "Fszm_zs_var",
+    "Fszm_zs_entr",
+]
+gldzm_features_names = [
+    "Fdzm_sde",
+    "Fdzm_lde",
+    "Fdzm_lgze",
+    "Fdzm_hgze",
+    "Fdzm_sdlge",
+    "Fdzm_sdhge",
+    "Fdzm_ldlge",
+    "Fdzm_ldhge",
+    "Fdzm_glnu",
+    "Fdzm_glnu_norm",
+    "Fdzm_zdnu",
+    "Fdzm_zdnu_norm",
+    "Fdzm_z_perc",
+    "Fdzm_gl_var",
+    "Fdzm_zd_var",
+    "Fdzm_zd_entr"
+]
+ngtdm_features_names = [
+    "Fngt_coarseness"
+    "Fngt_contrast"
+    "Fngt_busyness"
+    "Fngt_complexity"
+    "Fngt_strength"
+]
+ngldm_features_names = [
+    "Fngl_lde",
+    "Fngl_hde",
+    "Fngl_lgce",
+    "Fngl_hgce",
+    "Fngl_ldlge",
+    "Fngl_ldhge",
+    "Fngl_hdlge",
+    "Fngl_hdhge",
+    "Fngl_glnu",
+    "Fngl_glnu_norm",
+    "Fngl_dcnu",
+    "Fngl_dcnu_norm",
+    "Fngl_gl_var",
+    "Fngl_dc_var",
+    "Fngl_dc_entr",
+    "Fngl_dc_energy"
+]
+# PS: DO NOT CHANGE THE ORDER OF THE LISTS BELOW, CHANGING THE ORDER WILL BREAK THE CODE (RESULTS CLASS)
+texture_features_all = [
+    glcm_features_names,
+    ngtdm_features_names,
+    ngldm_features_names,
+    glrlm_features_names,
+    gldzm_features_names,
+    glszm_features_names
+]

MEDiml/utils/write_radiomics_csv.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from pathlib import Path
+from typing import Union
+
+import numpy as np
+
+
+def write_radiomics_csv(path_radiomics_table: Union[Path, str]) -> None:
+    """
+    Loads a radiomics structure (dict with radiomics features) to convert it to a CSV file and save it.
+
+    Args:
+        path_radiomics_table(Union[Path, str]): path to the radiomics dict.
+    
+    Returns:
+        None.
+    """
+
+    # INITIALIZATION
+    path_radiomics_table = Path(path_radiomics_table)
+    path_to_table = path_radiomics_table.parent
+    name_table = path_radiomics_table.stem
+
+    # LOAD RADIOMICS TABLE
+    radiomics_table_dict = np.load(path_radiomics_table, allow_pickle=True)[0]
+
+    # WRITE RADIOMICS TABLE IN CSV FORMAT
+    csv_name = name_table + '.csv'
+    csv_path = path_to_table / csv_name
+    radiomics_table_dict['Table'] = radiomics_table_dict['Table'].fillna(value='NaN')
+    radiomics_table_dict['Table'] = radiomics_table_dict['Table'].sort_index()
+    radiomics_table_dict['Table'].to_csv(csv_path,
+                                       sep=',',
+                                       encoding='utf-8',
+                                       index=True,
+                                       index_label=radiomics_table_dict['Properties']['DimensionNames'][0])
+
+    # WRITE DEFINITIONS.TXT
+    txt_name = name_table + '.txt'
+    txt_Path = path_to_table / txt_name
+
+    # WRITE THE CSV
+    fid = open(txt_Path, 'w')
+    fid.write(radiomics_table_dict['Properties']['UserData'])
+    fid.close()