# 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 __future__ import annotations
from brick.component.glial_cmp import glial_cmp_t
import brick.processing.map_labeling as ml_
from brick.general.type import array_t, py_array_picker_h, site_h
from collections import namedtuple as namedtuple_t
import sys as sy_
from typing import Optional, Sequence, Tuple
import numpy as np_
import scipy.ndimage as im_
import skimage.filters as fl_
import skimage.measure as ms_
import skimage.morphology as mp_
som_ext_path_t = namedtuple_t("som_ext_path_t", "extension length path idx")
class soma_t(glial_cmp_t):
#
__slots__ = ("contour_points", "centroid", "skl_graph", "ext_roots", "graph_roots")
def __init__(self):
#
super().__init__()
for slot in self.__class__.__slots__:
setattr(self, slot, None)
self.ext_roots = []
@classmethod
def FromMap(cls, lmp: array_t, uid: int) -> soma_t:
#
instance = cls()
bmp = lmp == uid
instance.InitializeFromMap(bmp, uid)
contour_map = cls.ContourMap(bmp)
instance.contour_points = tuple(zip(*contour_map.nonzero()))
instance.centroid = np_.array([np_.median(instance.sites[i]) for i in range(3)])
return instance
def Extensions(self, max_level: int = sy_.maxsize) -> Tuple[glial_cmp_t]:
#
# max_level=1: directly connected extensions
# ...
soma_ext = self.extensions.copy()
current_level_idx = 0
for level in range(2, max_level + 1):
next_level_idx = soma_ext.__len__()
if next_level_idx == current_level_idx:
break
for extension in soma_ext[current_level_idx:]:
soma_ext.extend(extension.extensions)
current_level_idx = next_level_idx
return tuple(soma_ext)
def ContourPointsCloseTo(
self, point: site_h, max_distance: float
) -> Tuple[Optional[Tuple[site_h, ...]], Optional[py_array_picker_h]]:
#
points = tuple(
contour_point
for contour_point in self.contour_points
if (np_.subtract(point, contour_point) ** 2).sum() <= max_distance
)
return __PointsCloseTo__(points)
def ExtensionPointsCloseTo(
self, point: site_h, max_distance: float
) -> Tuple[Optional[Tuple[site_h, ...]], Optional[py_array_picker_h]]:
#
# Leave connection paths apart because only detected extension pieces
# (as opposed to invented=connection paths) are considered valid connection targets
#
points = []
for extension in self.Extensions():
ext_sites = tuple(zip(*extension.sites))
points.extend(
ext_point
for ext_point in ext_sites
if (np_.subtract(point, ext_point) ** 2).sum() <= max_distance
)
return __PointsCloseTo__(tuple(points))
def BackReferenceSoma(self, glial_cmp: glial_cmp_t) -> None:
#
raise NotImplementedError("Soma do not need to back-reference a soma")
def __str__(self) -> str:
#
if self.extensions is None:
n_extensions = 0
else:
n_extensions = self.extensions.__len__()
return (
f"Soma.{self.uid}, "
f"area={self.sites[0].__len__()}, "
f"contour points={self.contour_points.__len__()}, "
f"extensions={n_extensions}"
)
@staticmethod
def Map(image: array_t, low: float, high: float, selem: array_t) -> array_t:
#
# low = 10 #0.15
# high = 67.4 # 0.7126
#
max_image = image.max()
nonzero_sites = image.nonzero()
nonzero_values = image[nonzero_sites]
min_image = nonzero_values.min()
low = low * (max_image - min_image) + min_image
high = high * (max_image - min_image) + min_image
result = fl_.apply_hysteresis_threshold(image, low, high)
result = result.astype(np_.int8, copy=False)
for dep in range(image.shape[0]):
result[dep, :, :] = mp_.closing(result[dep, :, :], selem)
result[dep, :, :] = mp_.opening(result[dep, :, :], selem)
return result
@staticmethod
def FilteredMap(map_: array_t, min_area: int) -> array_t:
result = map_.copy()
lmp = ms_.label(map_) # label the image region by measuring the connectivity
for region in ms_.regionprops(lmp): # Measure properties of labeled image regions
if region.area <= min_area:
region_sites = (lmp == region.label).nonzero()
result[region_sites] = 0
lmp[region_sites] = 0
return result, lmp
@staticmethod
def ContourMap(map_: array_t) -> array_t:
#
part_map = ml_.PartLMap(map_)
# Works because the background is labeled with 27
result = part_map < 26
return result.astype(np_.int8)
@staticmethod
def InfluenceMaps(map_: array_t) -> Tuple[array_t, array_t]:
background = (map_ == 0).astype(np_.int8)
dist_map, idx_map = im_.morphology.distance_transform_edt(
background, return_indices=True
)
# obj_map = np_.empty_like(map_)
# for row in range(0, obj_map.shape[0]):
# for col in range(0, obj_map.shape[1]):
# for dep in range(0, obj_map.shape[2]):
# obj_map[row, col, dep] = map_[
# idx_map[0, row, col, dep],
# idx_map[1, row, col, dep],
# idx_map[2, row, col, dep],
# ]
return dist_map, np_.array(map_[tuple(idx_map)])
@staticmethod
def SomasLMap(somas: Sequence[soma_t], with_extensions: bool = True) -> array_t:
#
shape = somas[0].img_shape
result = np_.zeros(shape, dtype=np_.int64)
for soma in somas:
result[soma.sites] = soma.uid
if with_extensions:
for connection_path in filter(
lambda path: path is not None, soma.connection_path.values()
):
result[connection_path] = soma.uid
for extension in soma.Extensions():
for connection_path in filter(
lambda path: path is not None,
extension.connection_path.values(),
):
result[connection_path] = soma.uid
result[extension.sites] = soma.uid
return result
def __PointsCloseTo__(
points: Tuple[site_h, ...]
) -> Tuple[Optional[Tuple[site_h, ...]], Optional[py_array_picker_h]]:
#
if points.__len__() > 0:
points_as_picker = tuple(zip(*points))
else:
points = None
points_as_picker = None
return points, points_as_picker