cellects 0.1.0.dev1__py3-none-any.whl

cellects/image_analysis/cell_leaving_detection.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Contains the function: cell_leaving_detection
+This function considers the pixel intensity curve of each covered pixel and assesesed whether a covered pixel retrieved
+-partially at least- its initial intensity.
+"""
+import cv2
+import numpy as np
+from cellects.image_analysis.morphological_operations import cross_33
+
+
+def cell_leaving_detection(new_shape, covering_intensity, previous_binary, greyscale_image, fading_coefficient, lighter_background, several_blob_per_arena, erodila_disk, protect_from_fading=None, add_to_fading=None):
+    # To look for fading pixels, only consider the internal contour of the shape at t-1
+    fading = cv2.erode(previous_binary, erodila_disk)
+    fading = previous_binary - fading
+    # If the origin state is considered constant: origin pixels will never be fading
+    if protect_from_fading is not None:
+        fading *= (1 - protect_from_fading)
+    if add_to_fading is not None:
+        if protect_from_fading is not None:
+            add_to_fading[np.nonzero(protect_from_fading)] = 0
+        add_to_fading_coord = np.nonzero(add_to_fading)
+        fading[add_to_fading_coord] = 1
+        if lighter_background:
+            covering_intensity[add_to_fading_coord] = 1 / (1 - fading_coefficient)  # 0.9 * covering_intensity[add_to_fading_coord]  #
+        else:
+            covering_intensity[add_to_fading_coord] = 255  # 1.1 * covering_intensity[add_to_fading_coord]
+    # With a lighter background, fading them if their intensity gets higher than the covering intensity
+    if lighter_background:
+        fading = fading * np.greater((greyscale_image), (1 - fading_coefficient) * covering_intensity).astype(np.uint8)
+    else:
+        fading = fading * np.less((greyscale_image), (1 + fading_coefficient) * covering_intensity).astype(np.uint8)
+
+    if np.any(fading):
+        fading = cv2.morphologyEx(fading, cv2.MORPH_CLOSE, cross_33, iterations=1)
+        if not several_blob_per_arena:
+            # Check if uncov_potentials does not break the shape into several components
+            uncov_nb, uncov_shapes = cv2.connectedComponents(fading, ltype=cv2.CV_16U)
+            nb, garbage_img = cv2.connectedComponents(new_shape, ltype=cv2.CV_16U)
+            i = 0
+            while i <= uncov_nb:
+                i += 1
+                prev_nb = nb
+                new_shape[np.nonzero(uncov_shapes == i)] = 0
+                nb, garbage_img = cv2.connectedComponents(new_shape, ltype=cv2.CV_16U)
+                if nb > prev_nb:
+                    new_shape[np.nonzero(uncov_shapes == i)] = 1
+                    nb, garbage_img = cv2.connectedComponents(new_shape, ltype=cv2.CV_16U)
+            uncov_shapes = None
+        else:
+            new_shape[np.nonzero(fading)] = 0
+        new_shape = cv2.morphologyEx(new_shape, cv2.MORPH_OPEN, cross_33, iterations=0)
+        new_shape = cv2.morphologyEx(new_shape, cv2.MORPH_CLOSE, cross_33)
+
+    return new_shape, covering_intensity

cellects/image_analysis/cluster_flux_study.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+This script contains the class for studying oscillating clusters on videos in 2D
+"""
+import cv2
+import numpy as np
+from numpy import (
+    append, float32, sum, mean, zeros, empty, array, nonzero, unique,
+    isin, logical_or, logical_not, greater, uint8,
+    uint32, min, any, zeros)
+from cellects.image_analysis.morphological_operations import cross_33, get_minimal_distance_between_2_shapes
+
+
+class ClusterFluxStudy:
+    """
+
+    """
+    def __init__(self, dims):
+        self.dims = dims
+
+        self.pixels_data = np.empty((4, 0), dtype=np.uint32)
+        self.clusters_id = np.zeros(self.dims[1:], dtype=np.uint32)
+        # self.alive_clusters_in_flux = np.empty(0, dtype=np.uint32)#list()
+        self.cluster_total_number = 0
+
+    def update_flux(self, t, contours, current_flux, period_tracking, clusters_final_data):
+        # Save the data from pixels that are not anymore in efflux
+        lost = np.greater(self.clusters_id > 0, current_flux > 0)
+        # Some pixels of that cluster faded, save their data
+        lost_data = np.nonzero(lost)
+        lost_data = np.array((period_tracking[lost],  # lost_coord[0], lost_coord[1],
+                      self.clusters_id[lost], lost_data[0], lost_data[1]), dtype=np.uint32)
+        # Add this to the array containing the data of each cluster that are still alive
+        self.pixels_data = np.append(self.pixels_data, lost_data, axis=1)
+        # Stop considering these pixels in period_tracking because they switched
+        period_tracking[lost] = 0
+        current_period_tracking = np.zeros(self.dims[1:], dtype=bool)
+        for curr_clust_id in np.unique(current_flux)[1:]:
+            # Get all pixels that were in the same flux previously
+            curr_clust = current_flux == curr_clust_id
+            already = self.clusters_id * curr_clust
+            new = np.greater(curr_clust, self.clusters_id > 0)
+
+            if not np.any(already):
+                # It is an entirely new cluster:
+                cluster_pixels = new
+                self.cluster_total_number += 1
+                cluster_name = self.cluster_total_number
+            else:
+                # Check whether parts of that cluster correspond to several clusters in clusters_id
+                cluster_names = np.unique(already)[1:]
+                # keep only one cluster name to gather clusters that just became connected
+                cluster_name = np.min(cluster_names)
+                # Put the same cluster name for new ones and every pixels that were
+                # a part of a cluster touching the current cluster
+                cluster_pixels = np.logical_or(np.isin(self.clusters_id, cluster_names), new)
+                # If they are more than one,
+                if len(cluster_names) > 1:
+                    # Update these cluster names in pixels_data
+                    self.pixels_data[1, np.isin(self.pixels_data[1, :], cluster_names)] = cluster_name
+            # Update clusters_id
+            self.clusters_id[cluster_pixels] = cluster_name
+            # Update period_tracking
+            current_period_tracking[curr_clust] = True
+
+        period_tracking[current_period_tracking] += 1
+        # Remove lost pixels from clusters_id
+        self.clusters_id[lost] = 0
+        # Find out which clusters are still alive or not
+        still_alive_clusters = np.isin(self.pixels_data[1, :], np.unique(self.clusters_id))
+        clusters_to_archive = np.unique(self.pixels_data[1, np.logical_not(still_alive_clusters)])
+        # store their data in clusters_final_data
+        clusters_data = np.zeros((len(clusters_to_archive), 6), dtype=np.float32)
+        for clust_i, cluster in enumerate(clusters_to_archive):
+            cluster_bool = self.pixels_data[1, :] == cluster
+            cluster_size = np.sum(cluster_bool)
+            cluster_img = np.zeros(self.dims[1:], dtype=np.uint8)
+            cluster_img[self.pixels_data[2, cluster_bool], self.pixels_data[3, cluster_bool]] = 1
+            nb, im, stats, centro = cv2.connectedComponentsWithStats(cluster_img)
+            if np.any(cv2.dilate(cluster_img, kernel=cross_33, borderType=cv2.BORDER_CONSTANT, borderValue=0) * contours):
+                minimal_distance = 1
+            else:
+                if cluster_size > 200:
+
+                    eroded_cluster_img = cv2.erode(cluster_img, cross_33)
+                    cluster_img = np.nonzero(cluster_img - eroded_cluster_img)
+                    contours[cluster_img] = 2
+                else:
+                    contours[self.pixels_data[2, cluster_bool], self.pixels_data[3, cluster_bool]] = 2
+                # Get the minimal distance between the border of the cell(s) (noted 1 in contours)
+                # and the border of the cluster in the cell(s) (now noted 2 in contours)
+                minimal_distance = get_minimal_distance_between_2_shapes(contours)
+            data_to_save = np.array([[np.mean(self.pixels_data[0, cluster_bool]), t,
+                                   cluster_size, minimal_distance, centro[1, 0], centro[1, 1]]], dtype=np.float32)
+            clusters_data[clust_i,:] = data_to_save
+        # and remove their data from pixels_data
+        clusters_final_data = np.append(clusters_final_data, clusters_data, axis=0)
+        self.pixels_data = self.pixels_data[:, still_alive_clusters]
+
+        return period_tracking, clusters_final_data
+
+

cellects/image_analysis/extract_exif.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""ADD DETAIL OF THE MODULE"""
+
+"""
+
+dir(my_image)
+['<unknown EXIF tag 59932>', '<unknown EXIF tag 59933>', '_exif_ifd_pointer', '_gps_ifd_pointer', '_segments', 'aperture
+_value', 'brightness_value', 'color_space', 'components_configuration', 'compression', 'datetime', 'datetime_digitized',
+'datetime_original', 'exif_version', 'exposure_bias_value', 'exposure_mode', 'exposure_program', 'exposure_time', 'f_
+number', 'flash', 'flashpix_version', 'focal_length', 'focal_length_in_35mm_film', 'get', 'get_file', 'get_thumbnail',
+'gps_altitude', 'gps_altitude_ref', 'gps_datestamp', 'gps_dest_bearing', 'gps_dest_bearing_ref', 'gps_horizontal_
+positioning_error', 'gps_img_direction', 'gps_img_direction_ref', 'gps_latitude', 'gps_latitude_ref', 'gps_longitude',
+'gps_longitude_ref', 'gps_speed', 'gps_speed_ref', 'gps_timestamp', 'has_exif', 'jpeg_interchange_format', 'jpeg_
+interchange_format_length', 'lens_make', 'lens_model', 'lens_specification', 'make', 'maker_note', 'metering_mode',
+'model', 'orientation', 'photographic_sensitivity', 'pixel_x_dimension', 'pixel_y_dimension', 'resolution_unit',
+'scene_capture_type', 'scene_type', 'sensing_method', 'shutter_speed_value', 'software', 'subject_area', 'subsec_time_
+digitized', 'subsec_time_original', 'white_balance', 'x_resolution', 'y_and_c_positioning', 'y_resolution']
+
+"""
+import numpy as np
+
+def extract_time(image_list, pathway="", raw_images=False):
+    from numpy import min, max, any, zeros, arange, all, int64, repeat
+    nb = len(image_list)
+    timings = np.zeros((nb, 6), dtype=np.int64)
+    if raw_images:
+        import exifread
+        for i in np.arange(nb):
+            with open(pathway + image_list[i], 'rb') as image_file:
+                my_image = exifread.process_file(image_file, details=False, stop_tag='DateTimeOriginal')
+                datetime = my_image["EXIF DateTimeOriginal"]
+            datetime = datetime.values[:10] + ':' + datetime.values[11:]
+            timings[i, :] = datetime.split(':')
+    else:
+        from exif import Image
+        for i in np.arange(nb):
+            with open(pathway + image_list[i], 'rb') as image_file:
+                my_image = Image(image_file)
+                if my_image.has_exif:
+                    datetime = my_image.datetime
+                    datetime = datetime[:10] + ':' + datetime[11:]
+                    timings[i, :] = datetime.split(':')
+
+    if np.all(timings[:, 0] == timings[0, 0]):
+        if np.all(timings[:, 1] == timings[0, 1]):
+            if np.all(timings[:, 2] == timings[0, 2]):
+                time = timings[:, 3] * 3600 + timings[:, 4] * 60 + timings[:, 5]
+            else:
+                time = timings[:, 2] * 86400 + timings[:, 3] * 3600 + timings[:, 4] * 60 + timings[:, 5]
+        else:
+            days_per_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
+            for j in np.arange(nb):
+                month_number = timings[j, 1]#int(timings[j, 1])
+                timings[j, 1] = days_per_month[month_number] * month_number
+            time = (timings[:, 1] + timings[:, 2]) * 86400 + timings[:, 3] * 3600 + timings[:, 4] * 60 + timings[:, 5]
+        #time = int(time)
+    else:
+        time = np.repeat(0, nb)#arange(1, nb * 60, 60)#"Do not experiment the 31th of december!!!"
+    if time.sum() == 0:
+        time = np.repeat(0, nb)#arange(1, nb * 60, 60)
+    return time

cellects/image_analysis/fractal_analysis.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+This script contains the class for analyzing fractals out of a binary image
+"""
+
+
+import os
+from pickletools import uint8
+from copy import deepcopy
+import numpy as np
+import cv2
+from scipy.optimize import curve_fit
+from scipy.stats import linregress
+from cellects.utils.formulas import linear_model
+from cellects.core.cellects_paths import DATA_DIR
+from cellects.image_analysis.morphological_operations import cross_33
+
+
+def prepare_box_counting(binary_image, side_threshold=128, zoom_step=0, contours=True):
+    side_lengths = None
+    zoomed_binary = binary_image
+    binary_idx = np.nonzero(binary_image)
+    if binary_idx[0].size:
+        min_y = np.min(binary_idx[0])
+        min_y = np.max((min_y - 1, 0))
+
+        min_x = np.min(binary_idx[1])
+        min_x = np.max((min_x - 1, 0))
+
+        max_y = np.max(binary_idx[0])
+        max_y = np.min((max_y + 1, binary_image.shape[0] - 1))
+
+        max_x = np.max(binary_idx[1])
+        max_x = np.min((max_x + 1, binary_image.shape[1] - 1))
+
+        zoomed_binary = deepcopy(binary_image[min_y:(max_y + 1), min_x: (max_x + 1)])
+        min_side = np.min(zoomed_binary.shape)
+        if min_side >= side_threshold:
+            if contours:
+                eroded_zoomed_binary = cv2.erode(zoomed_binary, cross_33)
+                zoomed_binary = zoomed_binary - eroded_zoomed_binary
+            if zoom_step == 0:
+                max_power = int(np.floor(np.log2(min_side)))  # Largest integer power of 2
+                side_lengths = 2 ** np.arange(max_power, -1, -1)
+            else:
+                side_lengths = np.arange(1, min_side, zoom_step)
+    return zoomed_binary, side_lengths
+
+
+def box_counting(zoomed_binary, side_lengths):
+    """
+    Let us take:
+    - s: the side lengths of many boxes
+    - N(s): the number of pixels belonging to the shape contained in a box of side length s.
+    - c: a constant
+    - D: the fractal dimension
+
+    N(s) = C(1/s)^D
+    log(N(s)) = D*log(1/s) + log(C)
+
+    box_counting_dimension = log(N)/log(1/s)
+    The line of y=log(N(r)) vs x=log(1/r) has a slope equal to the box_counting_dimension
+    :param zoomed_binary:
+    :return:
+    """
+    box_counting_dimension:float = 0.
+    r_value:float = 0.
+    box_nb:float = 0.
+    if side_lengths is not None:
+        box_counts = np.zeros(len(side_lengths), dtype=np.uint64)
+        # Loop through side_lengths and compute block counts
+        for idx, side_length in enumerate(side_lengths):
+            S = np.add.reduceat(
+                np.add.reduceat(zoomed_binary, np.arange(0, zoomed_binary.shape[0], side_length), axis=0),
+                np.arange(0, zoomed_binary.shape[1], side_length),
+                axis=1
+            )
+            box_counts[idx] = len(np.where(S > 0)[0])
+
+        valid_indices = box_counts > 0
+        if valid_indices.sum() >= 2:
+            log_box_counts = np.log(box_counts)
+            log_reciprocal_lengths = np.log(1 / side_lengths)
+            slope, intercept, r_value, p_value, stderr = linregress(log_reciprocal_lengths, log_box_counts)
+            # coefficients = np.polyfit(log_reciprocal_lengths, log_box_counts, 1)
+            box_counting_dimension = slope
+            box_nb = len(side_lengths)
+
+    return box_counting_dimension, r_value, box_nb
+
+
+class FractalAnalysis:
+    def __init__(self, binary_image):
+        """
+        Initialize FractalAnalysis class
+        :param binary_image: A 2D binary image. The two first dims are coordinates.
+        :type binary_image: uint8
+        """
+        self.binary_image = binary_image
+        self.fractal_contours = []
+        self.fractal_box_lengths = []
+        self.fractal_box_widths = []
+        self.minkowski_dimension = None
+
+    def detect_fractal(self, threshold=100):
+        """
+        Find the contours of the fractal
+        :param threshold:
+        :type threshold: int
+        :return:
+        """
+        contours, _ = cv2.findContours(self.binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        for contour in contours:
+            area = cv2.contourArea(contour)
+            if area > threshold:
+                self.fractal_contours.append(contour)
+
+    def extract_fractal(self, image):
+        """
+        Draw the fractal mesh on a colored image
+        :param image: 3D matrix of a bgr image. The two first dims are coordinates, le last is color.
+        :type image: uint8
+        :return:
+        """
+        # Créer un masque pour extraire la fractale
+        self.fractal_mesh = np.zeros(self.binary_image.shape, dtype=np.uint8)
+
+        for contour in self.fractal_contours:
+            # i=0
+            # i+=1
+            # contour = self.fractal_contours[i]
+            # cv2.drawContours(self.fractal_mesh, [contour], 0, 1, thickness=cv2.FILLED)
+            cont = np.reshape(contour, (len(contour), 2))
+            cont = np.transpose(cont)
+            self.fractal_mesh[cont[1], cont[0]] = 1
+
+            x, y, w, h = cv2.boundingRect(contour)
+            self.fractal_box_lengths.append(np.max((w, h)))
+            self.fractal_box_widths.append(np.min((w, h)))
+
+    def get_dimension(self):
+        """
+        Compute the minkowski dimension of the binary image
+        :return: Minkowski dimension
+        :rtype: =np.float64
+        """
+        if np.any(self.fractal_mesh):
+            fractal_mask = deepcopy(self.fractal_mesh[:, :])
+            # fractal_mask = (self.fractal_mesh[:, :] > 0).astype(np.uint8)
+            size = np.min(fractal_mask.shape)
+            scales = np.arange(1, int(np.log2(size)) + 1)
+
+            Ns = []
+            for scale in scales:
+                # i=0
+                # i+=1
+                # scale = scales[i]
+
+                box_size = 2 ** scale
+                boxes = np.add.reduceat(
+                    np.add.reduceat(fractal_mask, np.arange(0, fractal_mask.shape[0], box_size), axis=0),
+                    np.arange(0, fractal_mask.shape[1], box_size),
+                    axis=1,
+                )
+
+                Ns.append(np.sum(boxes > 0))
+
+            scales_inv = 1 / np.array(scales, dtype=np.float32)
+            coeffs, _ = curve_fit(linear_model, scales_inv, np.log(np.array(Ns, dtype=np.float32)))
+            self.minkowski_dimension = coeffs[1]
+        else:
+            self.minkowski_dimension = 0
+
+    def save_fractal_mesh(self, image_save_path):
+        """
+        Save an image representing the fractal mesh
+        :param image_save_path: path where to save the image
+        :type image_save_path: str
+        :return:
+        """
+        cv2.imwrite(image_save_path, self.fractal_mesh)
+
+
+

cellects/image_analysis/fractal_functions.py

@@ -0,0 +1,108 @@
+
+import os
+from pickletools import uint8
+from copy import deepcopy
+
+# import matplotlib
+# matplotlib.use('QtAgg')
+import matplotlib.pyplot as plt
+import numpy as np
+import cv2
+from scipy.optimize import curve_fit
+from scipy.stats import linregress
+from cellects.utils.formulas import (linear_model)
+from cellects.image_analysis.morphological_operations import cross_33
+
+
+def display_boxes(binary_image, box_diameter):
+    plt.imshow(binary_image, cmap='gray')
+    height, width = binary_image.shape
+    for x in range(0, width + 1, box_diameter):
+        plt.axvline(x=x, color='white', linewidth=1)
+    for y in range(0, height + 1, box_diameter):
+        plt.axhline(y=y, color='white', linewidth=1)
+    plt.show()
+
+
+def prepare_box_counting(binary_image, min_im_side=128, min_mesh_side=8, zoom_step=0, contours=True):
+    side_lengths = None
+    zoomed_binary = binary_image
+    binary_idx = np.nonzero(binary_image)
+    if binary_idx[0].size:
+        min_y = np.min(binary_idx[0])
+        min_y = np.max((min_y - 1, 0))
+
+        min_x = np.min(binary_idx[1])
+        min_x = np.max((min_x - 1, 0))
+
+        max_y = np.max(binary_idx[0])
+        max_y = np.min((max_y + 1, binary_image.shape[0] - 1))
+
+        max_x = np.max(binary_idx[1])
+        max_x = np.min((max_x + 1, binary_image.shape[1] - 1))
+
+        zoomed_binary = deepcopy(binary_image[min_y:(max_y + 1), min_x: (max_x + 1)])
+        min_side = np.min(zoomed_binary.shape)
+        if min_side >= min_im_side:
+            if contours:
+                eroded_zoomed_binary = cv2.erode(zoomed_binary, cross_33)
+                zoomed_binary = zoomed_binary - eroded_zoomed_binary
+            if zoom_step == 0:
+                max_power = int(np.floor(np.log2(min_side)))  # Largest integer power of 2
+                side_lengths = 2 ** np.arange(max_power, int(np.log2(min_mesh_side // 2)), -1)
+            else:
+                side_lengths = np.arange(min_mesh_side, min_side, zoom_step)
+    return zoomed_binary, side_lengths
+
+
+def box_counting(zoomed_binary, side_lengths, display=False):
+    """
+    Let us take:
+    - s: the side lengths of many boxes
+    - N(s): the number of pixels belonging to the shape contained in a box of side length s.
+    - c: a constant
+    - D: the fractal dimension
+
+    N(s) = C(1/s)^D
+    log(N(s)) = D*log(1/s) + log(C)
+
+    box_counting_dimension = log(N)/log(1/s)
+    The line of y=log(N(r)) vs x=log(1/r) has a slope equal to the box_counting_dimension
+    :param zoomed_binary:
+    :return:
+    """
+    box_counting_dimension:float = 0.
+    r_value:float = 0.
+    box_nb:float = 0.
+    if side_lengths is not None:
+        box_counts = np.zeros(len(side_lengths), dtype=np.uint64)
+        # Loop through side_lengths and compute block counts
+        for idx, side_length in enumerate(side_lengths):
+            S = np.add.reduceat(
+                np.add.reduceat(zoomed_binary, np.arange(0, zoomed_binary.shape[0], side_length), axis=0),
+                np.arange(0, zoomed_binary.shape[1], side_length),
+                axis=1
+            )
+            box_counts[idx] = len(np.where(S > 0)[0])
+
+        valid_indices = box_counts > 0
+        if valid_indices.sum() >= 2:
+            log_box_counts = np.log(box_counts)
+            log_reciprocal_lengths = np.log(1 / side_lengths)
+            slope, intercept, r_value, p_value, stderr = linregress(log_reciprocal_lengths, log_box_counts)
+            # coefficients = np.polyfit(log_reciprocal_lengths, log_box_counts, 1)
+            box_counting_dimension = slope
+            box_nb = len(side_lengths)
+            if display:
+                plt.scatter(log_reciprocal_lengths, log_box_counts, label="Box counting")
+                plt.plot([0, log_reciprocal_lengths.min()], [intercept, intercept + slope * log_reciprocal_lengths.min()], label="Linear regression")
+                plt.plot([], [], ' ', label=f"D = {slope:.2f}")
+                plt.plot([], [], ' ', label=f"R2 = {r_value:.6f}")
+                plt.plot([], [], ' ', label=f"p-value = {p_value:.2e}")
+                plt.legend(loc='best')
+                plt.xlabel(f"log(1/Diameter) | Diameter ⊆ [{side_lengths[0]}:{side_lengths[-1]}] (n={box_nb})")
+                plt.ylabel(f"log(Box number) | Box number ⊆ [{box_counts[0]}:{box_counts[-1]}]")
+                plt.show()
+                # plt.close()
+
+    return box_counting_dimension, r_value, box_nb