cell.py

# Copyright CNRS/Inria/UNS
# Contributor(s): Eric Debreuve (since 2019), Morgane Nadal (2020)
#
# eric.debreuve@cnrs.fr
#
# This software is governed by the CeCILL  license under French law and
# abiding by the rules of distribution of free software.  You can  use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and  rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty  and the software's author,  the holder of the
# economic rights,  and the successive licensors  have only  limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading,  using,  modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean  that it is complicated to manipulate,  and  that  also
# therefore means  that it is reserved for developers  and  experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and,  more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.

from typing import Any, Dict, Sequence, Union

import numpy as nmpy
import pandas as pd_
import scipy.stats as st_
from logger_36 import LOGGER

import brick.task.ellipsoid_fit as bf_
import brick.task.unit
from brick.type.base import array_t
from brick.type.soma import soma_t


def FindGraphsRootWithEdges(
    soma: soma_t, ext_nfo: Dict[str, Union[array_t, Any]]
) -> dict:
    """
    Finds the soma roots of the graph extension.
    """
    # For a given soma, find the roots of the graphs
    root_nodes = {}

    # Finds the primary extensions
    primary_extension_uids = tuple(extension.uid for extension in soma.extensions)
    # print(primary_extension_uids, '\nn = ', len(primary_extension_uids))

    # List of the degree 1 nodes of the graph
    for node1_id, node2_id, edge_nfo in soma.skl_graph.edges.data("details"):
        if (soma.skl_graph.degree[node1_id] == 1) or (
            soma.skl_graph.degree[node2_id] == 1
        ):
            # Find the pixels of the terminal extension
            sites = ext_nfo["lmp_soma"][edge_nfo.sites]
            ext_uid = nmpy.unique(sites)[-1]
            # sites > 0 because ext_nfo['lmp'] do not contain the connexions

            # Save the root node candidates (one-degree nodes)
            if ext_uid in primary_extension_uids:
                if soma.skl_graph.degree[node1_id] == 1:
                    root_node = node1_id
                else:
                    root_node = node2_id

                # Get the node coordinates and extend them to the 26 neighboring voxels
                # tuple('x-y-z') -> list[(x,y,z)]
                root_node_coor = soma.skl_graph.nodes[root_node][
                    "details"
                ].position.tolist()  # _GetNodesCoordinates((root_node,))[0]

                root_sites = set(
                    (
                        root_node_coor[0] + i,
                        root_node_coor[1] + j,
                        root_node_coor[2] + k,
                    )
                    for i in (-1, 0, 1)
                    for j in (-1, 0, 1)
                    for k in (-1, 0, 1)
                    if i != 0 or j != 0 or k != 0
                )

                # Find the intersection between the extended root node candidate and the soma contour points
                intersections = set(soma.contour_points).intersection(root_sites)

                # if the graph root sites are included in the soma extensions sites (non-nul intersection):
                if len(intersections) > 0:
                    # Keep the info of the root node. Key = ext uid, Value = root node
                    root_nodes[ext_uid] = root_node
                    ## By construction, only one root node possible for an ext

    # TODO: find out why there are less root points than extensions !!
    return root_nodes


def FindGraphsRootWithNodes(soma: soma_t) -> dict:
    """
    Find the roots of the {extension+connexion} graphs to be lined to the soma.
    Add a key "root" (bool) in the dict of nodes attributes.
    """
    is_end_point = []
    node_label = []
    coordinates = []
    for label, degree in soma.skl_graph.degree:
        is_end_point.append(degree == 1)
        node_label.append(label)
        coordinates.append(
            tuple(soma.skl_graph.nodes[label]["details"].position.tolist())
        )

    # Find the nodes of degree == 1, and the str coordinates of the nodes
    # is_end_point = tuple(degree == 1 for _, degree in soma.skl_graph.degree)
    # node_label = tuple(xyz for xyz, _ in soma.skl_graph.degree)

    root_nodes = {}

    # get the coordinates of the nodes (x,y,z)
    # coordinates = _GetNodesCoordinates(node_label)

    # get a list with elements = (extension_uid, root coordinates), which length is the number of primary extensions
    roots = soma.ext_roots

    # for each node in the graph, search among the degree 1 nodes the nodes that are roots (linked to soma)
    for node in range(len(coordinates)):
        if is_end_point[node]:
            # compare the coor with end points
            for ext_root in roots:
                if ext_root[1] == coordinates[node]:
                    root_nodes[ext_root[0]] = node_label[node]

    if root_nodes.__len__() != roots.__len__():
        # raise ValueError("Number of extensions roots not equal to number of graph roots.")
        LOGGER.warning(
            f"Number of extensions roots: {root_nodes.__len__()} "
            f"not equal to number of graph roots: {roots.__len__()}."
        )

    return root_nodes


# def _GetNodesCoordinates(node_coord: Tuple[str, ...]) -> list:
#     """
#     Input: nodes attributes -> Tuple('x1-y1-z1', 'x2-y2-z2', ...) .
#     Output: coordinates -> List[Tuple(x1,y1,z1), Tuple(x2,y2,z2), ...]
#     """
#     coord = []
#     for c in node_coord:
#         coord.append(c)
#
#     for node in range(len(node_coord)):
#         coord_node = coord[node]
#         pattern = r"\d+"
#         coord_node = re_.findall(pattern, coord_node)
#         coor = []
#         for i in range(3):
#             coor.append(int(coord_node[i]))
#         coor = tuple(coor)
#         coord[node] = coor
#
#     return coord

FEATURE_SHEET_COLUMNS = [
    "condition",
    "duration",
    "soma uid",
    "coef_V_soma__V_convex_hull",
    "coef_axes_ellips_b__a",
    "coef_axes_ellips_c__a",
    "spherical_angles_eva",
    "spherical_angles_evb",
    #
    "N_nodes",
    "N_ext",
    "N_primary_ext",
    "N_sec_ext",
    "min_degree",
    "mean_degree",
    "median_degree",
    "max_degree",
    "std_degree",
    #
    "total_ext_length",
    "min_length",
    "mean_length",
    "median_length",
    "max_length",
    "std_lengths",
    "entropy_lengths",
    "hist_lengths",
    "min_thickness",
    "mean_thickness",
    "median_thickness",
    "max_thickness",
    "std_thickness",
    "entropy_thickness",
    "min_volume",
    "mean_volume",
    "median_volume",
    "max_volume",
    "std_volume",
    "entropy_volume",
    "min_curvature",
    "max_curvature",
    "mean_curvature",
    "median_curvature",
    "std_curvature",
    "entropy_curvature",
    "hist_curvature",
    #
    "total_ext_length_P",
    "min_length_P",
    "mean_length_P",
    "median_length_P",
    "max_length_P",
    "std_lengths_P",
    "entropy_lengths_P",
    "hist_lengths_P",
    "min_thickness_P",
    "mean_thickness_P",
    "median_thickness_P",
    "max_thickness_P",
    "std_thickness_P",
    "entropy_thickness_P",
    "min_volume_P",
    "mean_volume_P",
    "median_volume_P",
    "max_volume_P",
    "std_volume_P",
    "entropy_volume_P",
    "min_curvature_P",
    "max_curvature_P",
    "mean_curvature_P",
    "median_curvature_P",
    "std_curvature_P",
    "entropy_curvature_P",
    "hist_curvature_P",
    #
    "total_ext_length_S",
    "min_length_S",
    "mean_length_S",
    "median_length_S",
    "max_length_S",
    "std_lengths_S",
    "entropy_lengths_S",
    "hist_lengths_S",
    "min_thickness_S",
    "mean_thickness_S",
    "median_thickness_S",
    "max_thickness_S",
    "std_thickness_S",
    "entropy_thickness_S",
    "min_volume_S",
    "mean_volume_S",
    "median_volume_S",
    "max_volume_S",
    "std_volume_S",
    "entropy_volume_S",
    "min_curvature_S",
    "max_curvature_S",
    "mean_curvature_S",
    "median_curvature_S",
    "std_curvature_S",
    "entropy_curvature_S",
    "hist_curvature_S",
]


def ExtractFeaturesInDF(
    name_file,
    somas,
    voxel_size_in_micron: array_t,
    bins_length: array_t,
    bins_curvature: array_t,
    scale_map: array_t,
    decimals: int = 4,
    _=None,  # condition
    __=None,  # duration
):
    """
    Extract the features from somas and graphs.

    Store the condition and duration of the image
    if (condition is None) or (duration is None):
    Condition = re_.findall(r"[A-Z]{3}", name_file)[0]
    Duration = re_.findall(r"\dH", name_file)
    Find our whether the duration is in hours or in weeks
    if Duration.__len__() == 0:
        Duration = re_.findall(r"\dW", name_file)[0]
    else:
        Duration = Duration[0]

    Returns a pandas dataframe, without NaN.
    """
    somas_features_dict = {}  # Dict{soma 1: [features], soma 2: [features], ...}

    (
        Condition,
        Duration,
        min_degree,
        mean_degree,
        median_degree,
        max_degree,
        std_degree,
        total_ext_length_S,
        min_length_S,
        mean_length_S,
        median_length_S,
        max_length_S,
        std_lengths_S,
        entropy_lengths_S,
        hist_lengths_S,
        min_thickness_S,
        mean_thickness_S,
        median_thickness_S,
        max_thickness_S,
        std_thickness_S,
        entropy_thickness_S,
        min_volume_S,
        mean_volume_S,
        median_volume_S,
        max_volume_S,
        std_volume_S,
        entropy_volume_S,
        min_curvature_S,
        max_curvature_S,
        mean_curvature_S,
        median_curvature_S,
        std_curvature_S,
        entropy_curvature_S,
        hist_curvature_S,
    ) = 34 * (None,)

    for soma in somas:
        # -- Soma features

        # Axes of the best fitting ellipsoid: a > b > c
        (
            _,
            _,
            soma.axes_ellipsoid,
            _,
            spherical_coor,
            _,
            volume_convex_hull,
        ) = bf_.FindBestFittingEllipsoid3D(soma)

        # These ratios give info about the shape of the soma. ex: rather flat, rather patatoide, rather spherical...
        if type(soma.axes_ellipsoid[0]) is str:
            (
                Coef_axes_ellips_b__a,
                Coef_axes_ellips_c__a,
                spherical_angles_eva,
                spherical_angles_evb,
                soma.volume_soma_micron,
                Coef_V_soma__V_convex_hull,
            ) = 6 * (None,)
        else:
            Coef_axes_ellips_b__a = soma.axes_ellipsoid[0] / soma.axes_ellipsoid[2]
            Coef_axes_ellips_c__a = soma.axes_ellipsoid[1] / soma.axes_ellipsoid[2]

            # Spherical angles give the orientation of the somas in the 3D volume
            spherical_angles_eva = (spherical_coor[0][1], spherical_coor[0][2])
            spherical_angles_evb = (spherical_coor[1][1], spherical_coor[1][2])

            # Volume of the  in micron**3
            soma.volume_soma_micron = brick.task.unit.ToMicron(
                len(soma.sites[0]),
                voxel_size_in_micron,
                dimension=(0, 1, 2),
                decimals=2,
            )
            # Calculates volume of soma's convex hull in voxel volume
            # Take into account anisotropy of the 3D space ( volume = x * y * z with z > x=y)
            volume_convex_hull = (
                volume_convex_hull * voxel_size_in_micron[2] / voxel_size_in_micron[0]
            )

            # Volume of the soma / Volume of its convex hull gives the info about the convexity of the soma
            # If close to 0, the soma has a lot of invaginations, if close to 1, it is smooth and convex
            Coef_V_soma__V_convex_hull = len(soma.sites[0]) / round(
                volume_convex_hull + 0.5
            )

        # -- Extension features
        # Graph features

        # number of nodes except the constructed ones from node soma to the roots
        N_nodes = soma.skl_graph.n_nodes - len(soma.graph_roots)
        # number of edges except the constructed ones from node soma to the roots
        N_ext = soma.skl_graph.n_edges - len(soma.graph_roots)
        # number of primary edges = linked to the soma except the constructed ones from node soma to the roots
        N_primary_ext = len(soma.graph_roots)
        # number of secondary edges = not linked to the soma.
        N_sec_ext = N_ext - N_primary_ext

        LOGGER.info(
            f"Soma {soma.uid}\n"
            f"N nodes = {N_nodes}\n"
            f"N edges = {N_ext}\n"
            f"N primary extensions = {N_primary_ext}\n"
            f"N secondary extensions = {N_sec_ext}\n"
        )

        if N_primary_ext > 0:
            ext_lengths = [_elm[-1] for _elm in soma.skl_graph.lengths]
            for idx, length in enumerate(ext_lengths):
                ext_lengths[idx] = brick.task.unit.ToMicron(
                    length, voxel_size_in_micron, decimals=decimals
                )
            total_ext_length = brick.task.unit.ToMicron(
                soma.skl_graph.length, voxel_size_in_micron, decimals=decimals
            )

            (
                min_length,
                max_length,
                median_length,
                mean_length,
                std_lengths,
                hist_lengths,
                entropy_lengths,
            ) = _Statistics_mMdashe(ext_lengths, bins=bins_length)
            # hist_lengths = nmpy.histogram(ext_lengths, bins_length)[0]
            min_length = brick.task.unit.ToMicron(
                min_length, voxel_size_in_micron, decimals=decimals
            )
            mean_length = brick.task.unit.ToMicron(
                mean_length, voxel_size_in_micron, decimals=decimals
            )
            median_length = brick.task.unit.ToMicron(
                median_length, voxel_size_in_micron, decimals=decimals
            )
            max_length = brick.task.unit.ToMicron(
                max_length, voxel_size_in_micron, decimals=decimals
            )
            # std_lengths = nmpy.std(ext_lengths)
            # entropy_lengths = st_.entropy(hist_lengths)

            # Find the thickness of the extensions
            for *_, edge in soma.skl_graph.edges.data("details"):
                if edge is not None:
                    edge.widths = scale_map[edge.sites] * voxel_size_in_micron[1]
            mean_widths = soma.skl_graph.edge_reduced_widths()
            ext_thickness = nmpy.array(mean_widths) ** 2
            (
                min_thickness,
                max_thickness,
                median_thickness,
                mean_thickness,
                std_thickness,
                _,
                entropy_thickness,
            ) = _Statistics_mMdashe(ext_thickness)
            # min_thickness = min(ext_thickness)
            # mean_thickness = nmpy.mean(ext_thickness)
            # median_thickness = nmpy.median(ext_thickness)
            # max_thickness = max(ext_thickness)
            # std_thickness = nmpy.std(ext_thickness)
            # entropy_thickness = st_.entropy(nmpy.histogram(ext_thickness)[0])

            # Find the volume of the extensions
            ext_volume = nmpy.array(ext_lengths) * ext_thickness
            (
                min_volume,
                max_volume,
                median_volume,
                mean_volume,
                std_volume,
                _,
                entropy_volume,
            ) = _Statistics_mMdashe(ext_volume)
            # min_volume = min(ext_volume)
            # mean_volume = nmpy.mean(ext_volume)
            # median_volume = nmpy.median(ext_volume)
            # max_volume = max(ext_volume)
            # std_volume = nmpy.std(ext_volume)
            # entropy_volume = st_.entropy(nmpy.histogram(ext_volume)[0])

            curvatures = soma.skl_graph.curvature_and_torsion()
            (
                min_curvature,
                max_curvature,
                median_curvature,
                mean_curvature,
                std_curvature,
                hist_curvature,
                entropy_curvature,
            ) = _Statistics_mMdashe(curvatures, bins=bins_curvature)
            # hist_curvature = nmpy.histogram(curvatures, bins_curvature)[0]
            # min_curvature = min(curvatures)
            # max_curvature = max(curvatures)
            # mean_curvature = nmpy.mean(curvatures)
            # median_curvature = nmpy.median(curvatures)
            # std_curvature = nmpy.std(curvatures)
            # entropy_curvature = st_.entropy(hist_curvature)

            # PRIMARY extensions
            ext_lengths_P = list(soma.skl_graph.primary_edge_lengths(soma))
            for idx, length in enumerate(ext_lengths_P):
                ext_lengths_P[idx] = brick.task.unit.ToMicron(
                    length, voxel_size_in_micron, decimals=decimals
                )
            total_ext_length_P = sum(ext_lengths_P)
            (
                min_length_P,
                max_length_P,
                median_length_P,
                mean_length_P,
                std_lengths_P,
                hist_lengths_P,
                entropy_lengths_P,
            ) = _Statistics_mMdashe(ext_lengths_P, bins=bins_length)
            # hist_lengths_P = nmpy.histogram(ext_lengths_P, bins_length)[0]
            # min_length_P = min(ext_lengths_P)
            # mean_length_P = nmpy.mean(ext_lengths_P)
            # median_length_P = nmpy.median(ext_lengths_P)
            # max_length_P = max(ext_lengths_P)
            # std_lengths_P = nmpy.std(ext_lengths_P)
            # entropy_lengths_P = st_.entropy(hist_lengths_P)

            mean_widths_P = soma.skl_graph.P_edge_reduced_widths(soma)
            ext_thickness_P = nmpy.array(mean_widths_P) ** 2
            (
                min_thickness_P,
                max_thickness_P,
                median_thickness_P,
                mean_thickness_P,
                std_thickness_P,
                _,
                entropy_thickness_P,
            ) = _Statistics_mMdashe(ext_thickness_P)
            # min_thickness_P = min(ext_thickness_P)
            # mean_thickness_P = nmpy.mean(ext_thickness_P)
            # median_thickness_P = nmpy.median(ext_thickness_P)
            # max_thickness_P = max(ext_thickness_P)
            # std_thickness_P = nmpy.std(ext_thickness_P)
            # entropy_thickness_P = st_.entropy(nmpy.histogram(ext_thickness_P)[0])

            ext_volume_P = nmpy.array(ext_lengths_P) * ext_thickness_P
            (
                min_volume_P,
                max_volume_P,
                median_volume_P,
                mean_volume_P,
                std_volume_P,
                _,
                entropy_volume_P,
            ) = _Statistics_mMdashe(ext_volume_P)
            # min_volume_P = min(ext_volume_P)
            # mean_volume_P = nmpy.mean(ext_volume_P)
            # median_volume_P = nmpy.median(ext_volume_P)
            # max_volume_P = max(ext_volume_P)
            # std_volume_P = nmpy.std(ext_volume_P)
            # entropy_volume_P = st_.entropy(nmpy.histogram(ext_volume_P)[0])

            curvatures_P = soma.skl_graph.P_curvature_and_torsion(soma)
            (
                min_curvature_P,
                max_curvature_P,
                median_curvature_P,
                mean_curvature_P,
                std_curvature_P,
                hist_curvature_P,
                entropy_curvature_P,
            ) = _Statistics_mMdashe(curvatures_P, bins=bins_curvature)
            # hist_curvature_P = nmpy.histogram(curvatures_P, bins_curvature)[0]
            # min_curvature_P = min(curvatures_P)
            # max_curvature_P = max(curvatures_P)
            # mean_curvature_P = nmpy.mean(curvatures_P)
            # median_curvature_P = nmpy.median(curvatures_P)
            # std_curvature_P = nmpy.std(curvatures_P)
            # entropy_curvature_P = st_.entropy(hist_curvature_P)

            # Secondary extensions
            if N_sec_ext > 0:
                # min, mean, median, max and standard deviation of the degrees of non-leaves nodes
                min_degree = soma.skl_graph.min_degree_except_leaves_and_roots
                mean_degree = soma.skl_graph.mean_degree_except_leaves_and_roots
                median_degree = soma.skl_graph.median_degree_except_leaves_and_roots
                max_degree = soma.skl_graph.max_degree_except_leaves_an_roots
                std_degree = soma.skl_graph.std_degree_except_leaves_and_roots

                # SECONDARY extensions length
                ext_lengths_S = list(soma.skl_graph.secondary_edge_lengths(soma))
                for idx, length in enumerate(ext_lengths_S):
                    ext_lengths_S[idx] = brick.task.unit.ToMicron(
                        length, voxel_size_in_micron, decimals=decimals
                    )
                total_ext_length_S = sum(ext_lengths_S)

                (
                    min_length_S,
                    max_length_S,
                    median_length_S,
                    mean_length_S,
                    std_lengths_S,
                    hist_lengths_S,
                    entropy_lengths_S,
                ) = _Statistics_mMdashe(ext_lengths_S, bins=bins_length)
                # hist_lengths_S = nmpy.histogram(ext_lengths_S, bins_length)[0]
                # min_length_S = min(ext_lengths_S)
                # mean_length_S = nmpy.mean(ext_lengths_S)
                # median_length_S = nmpy.median(ext_lengths_S)
                # max_length_S = max(ext_lengths_S)
                # std_lengths_S = nmpy.std(ext_lengths_S)
                # entropy_lengths_S = st_.entropy(hist_lengths_S)

                mean_widths_S = soma.skl_graph.S_edge_reduced_widths(soma)
                ext_thickness_S = nmpy.array(mean_widths_S) ** 2
                (
                    min_thickness_S,
                    max_thickness_S,
                    median_thickness_S,
                    mean_thickness_S,
                    std_thickness_S,
                    _,
                    entropy_thickness_S,
                ) = _Statistics_mMdashe(ext_thickness_S)
                # min_thickness_S = min(ext_thickness_S)
                # mean_thickness_S = nmpy.mean(ext_thickness_S)
                # median_thickness_S = nmpy.median(ext_thickness_S)
                # max_thickness_S = max(ext_thickness_S)
                # std_thickness_S = nmpy.std(ext_thickness_S)
                # entropy_thickness_S = st_.entropy(nmpy.histogram(ext_thickness_S)[0])

                ext_volume_S = nmpy.array(ext_lengths_S) * ext_thickness_S
                (
                    min_volume_S,
                    max_volume_S,
                    median_volume_S,
                    mean_volume_S,
                    std_volume_S,
                    _,
                    entropy_volume_S,
                ) = _Statistics_mMdashe(ext_volume_S)
                # min_volume_S = min(ext_volume_S)
                # mean_volume_S = nmpy.mean(ext_volume_S)
                # median_volume_S = nmpy.median(ext_volume_S)
                # max_volume_S = max(ext_volume_S)
                # std_volume_S = nmpy.std(ext_volume_S)
                # entropy_volume_S = st_.entropy(nmpy.histogram(ext_volume_S)[0])

                curvatures_S = soma.skl_graph.S_curvature_and_torsion(soma)
                (
                    min_curvature_S,
                    max_curvature_S,
                    median_curvature_S,
                    mean_curvature_S,
                    std_curvature_S,
                    hist_curvature_S,
                    entropy_curvature_S,
                ) = _Statistics_mMdashe(curvatures_S, bins=bins_curvature)
                # hist_curvature_S = nmpy.histogram(curvatures_S, bins_curvature)[0]
                # min_curvature_S = min(curvatures_S)
                # max_curvature_S = max(curvatures_S)
                # mean_curvature_S = nmpy.mean(curvatures_S)
                # median_curvature_S = nmpy.median(curvatures_S)
                # std_curvature_S = nmpy.std(curvatures_S)
                # entropy_curvature_S = st_.entropy(hist_curvature_S)

            # If no secondary extensions, give certain value to parameters
            if N_sec_ext == 0:
                # min, mean, median, max and standard deviation of the degrees of non-leaves nodes
                min_degree = 1
                mean_degree = 1
                median_degree = 1
                max_degree = 1
                std_degree = 0

                total_ext_length_S = 0
                min_length_S = 0
                mean_length_S = 0
                median_length_S = 0
                max_length_S = 0
                std_lengths_S = 0
                entropy_lengths_S = 0
                hist_lengths_S = 0

                min_thickness_S = 0
                mean_thickness_S = 0
                median_thickness_S = 0
                max_thickness_S = 0
                std_thickness_S = 0
                entropy_thickness_S = 0

                min_volume_S = 0
                mean_volume_S = 0
                median_volume_S = 0
                max_volume_S = 0
                std_volume_S = 0
                entropy_volume_S = 0

                min_curvature_S = -1
                max_curvature_S = -1
                mean_curvature_S = -1
                median_curvature_S = -1
                std_curvature_S = 0
                entropy_curvature_S = 0
                hist_curvature_S = 0
        else:
            min_degree = 0
            mean_degree = 0
            median_degree = 0
            max_degree = 0
            std_degree = 0

            total_ext_length = 0
            min_length = 0
            mean_length = 0
            median_length = 0
            max_length = 0
            std_lengths = 0
            entropy_lengths = 0
            hist_lengths = 0

            min_thickness = 0
            mean_thickness = 0
            median_thickness = 0
            max_thickness = 0
            std_thickness = 0
            entropy_thickness = 0

            min_volume = 0
            mean_volume = 0
            median_volume = 0
            max_volume = 0
            std_volume = 0
            entropy_volume = 0

            min_curvature = -1
            max_curvature = -1
            mean_curvature = -1
            median_curvature = -1
            std_curvature = 0
            entropy_curvature = 0
            hist_curvature = 0

            total_ext_length_P = 0
            min_length_P = 0
            mean_length_P = 0
            median_length_P = 0
            max_length_P = 0
            std_lengths_P = 0
            entropy_lengths_P = 0
            hist_lengths_P = 0

            min_thickness_P = 0
            mean_thickness_P = 0
            median_thickness_P = 0
            max_thickness_P = 0
            std_thickness_P = 0
            entropy_thickness_P = 0

            min_volume_P = 0
            mean_volume_P = 0
            median_volume_P = 0
            max_volume_P = 0
            std_volume_P = 0
            entropy_volume_P = 0

            min_curvature_P = -1
            max_curvature_P = -1
            mean_curvature_P = -1
            median_curvature_P = -1
            std_curvature_P = 0
            entropy_curvature_P = 0
            hist_curvature_P = 0

            total_ext_length_S = 0
            min_length_S = 0
            mean_length_S = 0
            median_length_S = 0
            max_length_S = 0
            std_lengths_S = 0
            entropy_lengths_S = 0
            hist_lengths_S = 0

            min_thickness_S = 0
            mean_thickness_S = 0
            median_thickness_S = 0
            max_thickness_S = 0
            std_thickness_S = 0
            entropy_thickness_S = 0

            min_volume_S = 0
            mean_volume_S = 0
            median_volume_S = 0
            max_volume_S = 0
            std_volume_S = 0
            entropy_volume_S = 0

            min_curvature_S = -1
            max_curvature_S = -1
            mean_curvature_S = -1
            median_curvature_S = -1
            std_curvature_S = 0
            entropy_curvature_S = 0
            hist_curvature_S = 0

        # Create a dictionary with all the features for every somas
        somas_features_dict[name_file + f" soma {soma.uid}"] = [
            Condition,
            Duration,
            soma.uid,
            Coef_V_soma__V_convex_hull,
            Coef_axes_ellips_b__a,
            Coef_axes_ellips_c__a,
            spherical_angles_eva,
            spherical_angles_evb,
            N_nodes,
            N_ext,
            N_primary_ext,
            N_sec_ext,
            min_degree,
            mean_degree,
            median_degree,
            max_degree,
            std_degree,
            #
            total_ext_length,
            min_length,
            mean_length,
            median_length,
            max_length,
            std_lengths,
            entropy_lengths,
            hist_lengths,
            min_thickness,
            mean_thickness,
            median_thickness,
            max_thickness,
            std_thickness,
            entropy_thickness,
            min_volume,
            mean_volume,
            median_volume,
            max_volume,
            std_volume,
            entropy_volume,
            min_curvature,
            max_curvature,
            mean_curvature,
            median_curvature,
            std_curvature,
            entropy_curvature,
            hist_curvature,
            #
            total_ext_length_P,
            min_length_P,
            mean_length_P,
            median_length_P,
            max_length_P,
            std_lengths_P,
            entropy_lengths_P,
            hist_lengths_P,
            min_thickness_P,
            mean_thickness_P,
            median_thickness_P,
            max_thickness_P,
            std_thickness_P,
            entropy_thickness_P,
            min_volume_P,
            mean_volume_P,
            median_volume_P,
            max_volume_P,
            std_volume_P,
            entropy_volume_P,
            min_curvature_P,
            max_curvature_P,
            mean_curvature_P,
            median_curvature_P,
            std_curvature_P,
            entropy_curvature_P,
            hist_curvature_P,
            #
            total_ext_length_S,
            min_length_S,
            mean_length_S,
            median_length_S,
            max_length_S,
            std_lengths_S,
            entropy_lengths_S,
            hist_lengths_S,
            min_thickness_S,
            mean_thickness_S,
            median_thickness_S,
            max_thickness_S,
            std_thickness_S,
            entropy_thickness_S,
            min_volume_S,
            mean_volume_S,
            median_volume_S,
            max_volume_S,
            std_volume_S,
            entropy_volume_S,
            min_curvature_S,
            max_curvature_S,
            mean_curvature_S,
            median_curvature_S,
            std_curvature_S,
            entropy_curvature_S,
            hist_curvature_S,
        ]

    features_df = pd_.DataFrame.from_dict(
        somas_features_dict, orient="index", columns=FEATURE_SHEET_COLUMNS
    )

    return features_df


_Median = lambda _msr: nmpy.median(_msr).item()
_Mean = lambda _msr: nmpy.mean(_msr).item()
_Std = lambda _msr: nmpy.std(_msr).item()


def _Statistics_mMdashe(measures: Sequence, /, *, bins = None) -> tuple:
    """"""
    if bins is None:
        bins = {}
    else:
        bins = {"bins": bins}
    histogram = nmpy.histogram(measures, **bins)[0]
    histogram = tuple(histogram.tolist())
    entropy = st_.entropy(histogram).item()

    output = [
        _StatisticOf(measures) for _StatisticOf in (min, max, _Median, _Mean, _Std)
    ]
    output.extend((histogram, entropy))

    return tuple(output)