cellects 0.1.0.dev1__py3-none-any.whl

cellects/image_analysis/one_image_analysis_threads.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+"""
+This script contains 2 classes used by the OneImageAnalysis class
+They are threads to process the first image and save the selected combinations simultaneously
+"""
+import threading
+import logging
+from copy import deepcopy
+import numpy as np
+import cv2
+from cellects.image_analysis.image_segmentation import otsu_thresholding, combine_color_spaces
+
+
+class ProcessFirstImage:
+    def __init__(self, l):
+        self.start_processing(l)
+
+    def start_processing(self, l):
+        """
+        Wil process the first image according to rules and parameters in l
+        :param l: list containing the necessary data to process the first image
+        """
+        self.parent = l[0]
+        get_one_channel_result = l[1]
+        combine_channels = l[2]
+        self.all_c_spaces = self.parent.all_c_spaces
+        self.several_blob_per_arena = l[4]
+        self.sample_number = l[5]
+        self.spot_size = l[6]
+        kmeans_clust_nb = l[7]
+        self.biomask = l[8]
+        self.backmask = l[9]
+        if get_one_channel_result:
+            self.csc_dict = l[3]
+            self.image = combine_color_spaces(self.csc_dict, self.all_c_spaces)
+            if kmeans_clust_nb is None:
+                self.binary_image = otsu_thresholding(self.image)
+            else:
+                self.kmeans(kmeans_clust_nb, self.biomask, self.backmask)
+                # self.parent.image = self.image
+                # self.parent.kmeans(kmeans_clust_nb, self.biomask, self.backmask)
+                # self.binary_image = self.parent.binary_image
+            self.unaltered_concomp_nb, shapes = cv2.connectedComponents(self.binary_image)
+            if 1 < self.unaltered_concomp_nb < 10000:
+                self.total_area = np.sum(self.binary_image)
+                if 100 < self.total_area < self.binary_image.size * 0.75:
+                    self.process_binary_image()
+                    self.parent.save_combination_features(self)
+                    # except RuntimeWarning:
+                    #     logging.info("Make sure that scaling and spot size are correct")
+        if combine_channels:
+            i = l[3]
+            possibilities = l[10]
+            saved_color_space_list = self.parent.saved_color_space_list
+            combination_features = self.parent.combination_features
+            self.csc_dict = saved_color_space_list[i]
+            previous_shape_number = combination_features[i, 4]
+            previous_sum = combination_features[i, 5]
+            for j in possibilities[::-1]:
+                csc_dict2 = saved_color_space_list[j]
+                csc_dict = deepcopy(self.csc_dict)
+                keys = list(csc_dict.keys())
+
+                k2 = list(csc_dict2.keys())[0]
+                v2 = csc_dict2[k2]
+                if np.isin(k2, keys) and np.sum(v2 * csc_dict[k2]) != 0:
+                    break
+                for factor in [2, 1]:
+                    if np.isin(k2, keys):
+                        csc_dict[k2] += v2 * factor
+                    else:
+                        csc_dict[k2] = v2 * factor
+                    self.image = combine_color_spaces(csc_dict, self.all_c_spaces)
+                    if kmeans_clust_nb is None:
+                        self.binary_image = otsu_thresholding(self.image)
+                    else:
+                        self.kmeans(kmeans_clust_nb, self.biomask, self.backmask)
+                    self.process_binary_image()
+                    self.total_area = self.validated_shapes.sum()
+                    if previous_shape_number >= self.shape_number and self.total_area > previous_sum * 0.9:
+                        previous_shape_number = self.shape_number
+                        previous_sum = self.total_area
+                        self.csc_dict = deepcopy(csc_dict)
+                        self.unaltered_concomp_nb = combination_features[i, 3]
+                        self.parent.save_combination_features(self)
+                        logging.info(str(saved_color_space_list[i]) + "-->" + str(self.csc_dict ))
+
+    def shape_selection(self, horizontal_size, shape, confint, do_not_delete=None):
+        """
+        This method use the statistics of the connected components of a binary image to make shape selection
+        :param horizontal_size: the average horizontal size of one shape in pixels
+        :param shape: the geometry of the shape: circle or rectangle
+        :param confint: confidence interval for horizontal size and shape detection
+        :param do_not_delete: binary image with 1 in area drawn by the user as "Cell"
+        :return: A binary matrix of the resulting validated shapes and the number of shapes detected
+        """
+        # counter+=1;horizontal_size = self.spot_size; shape = self.parent.spot_shapes[counter];confint = self.parent.spot_size_confints[::-1][counter]
+        # stats columns contain in that order:
+        # - x leftmost coordinate of boundingbox
+        # - y topmost coordinate of boundingbox
+        # - The horizontal size of the bounding box.
+        # - The vertical size of the bounding box.
+        # - The total area (in pixels) of the connected component.
+
+        # First, remove each stain which horizontal size varies too much from reference
+        size_interval = [horizontal_size * (1 - confint), horizontal_size * (1 + confint)]
+        cc_to_remove = np.argwhere(np.logical_or(self.stats[:, 2] < size_interval[0], self.stats[:, 2] > size_interval[1]))
+
+        if do_not_delete is None:
+            self.shapes2[np.isin(self.shapes2, cc_to_remove)] = 0
+        else:
+            self.shapes2[np.logical_and(np.isin(self.shapes2, cc_to_remove), np.logical_not(np.isin(self.shapes2, do_not_delete)))] = 0
+
+        # Second, determine the shape of each stain to only keep the ones corresponding to the reference shape
+        shapes = np.zeros(self.binary_image.shape, dtype=np.uint8)
+        shapes[self.shapes2 > 0] = 1
+        nb_components, self.shapes2, self.stats, self.centroids = cv2.connectedComponentsWithStats(shapes,
+                                                                                   connectivity=8)
+        if nb_components > 1:
+            if shape == 'circle':
+                surf_interval = [np.pi * np.square(horizontal_size // 2) * (1 - confint), np.pi * np.square(horizontal_size // 2) * (1 + confint)]
+                cc_to_remove = np.argwhere(np.logical_or(self.stats[:, 4] < surf_interval[0], self.stats[:, 4] > surf_interval[1]))
+            elif shape == 'rectangle':
+                # If the smaller side is the horizontal one, use the user provided horizontal side
+                if np.argmin((np.mean(self.stats[1:, 2]), np.mean(self.stats[1:, 3]))) == 0:
+                    surf_interval = [np.square(horizontal_size) * (1 - confint), np.square(horizontal_size) * (1 + confint)]
+                    cc_to_remove = np.argwhere(np.logical_or(self.stats[:, 4] < surf_interval[0], self.stats[:, 4] > surf_interval[1]))
+                # If the smaller side is the vertical one, use the median vertical length shape
+                else:
+                    surf_interval = [np.square(np.median(self.stats[1:, 3])) * (1 - confint), np.square(np.median(self.stats[1:, 3])) * (1 + confint)]
+                    cc_to_remove = np.argwhere(np.logical_or(self.stats[:, 4] < surf_interval[0], self.stats[:, 4] > surf_interval[1]))
+            else:
+                logging.info("Original blob shape not well written")
+
+            if do_not_delete is None:
+                self.shapes2[np.isin(self.shapes2, cc_to_remove)] = 0
+            else:
+                self.shapes2[np.logical_and(np.isin(self.shapes2, cc_to_remove),
+                                            np.logical_not(np.isin(self.shapes2, do_not_delete)))] = 0
+            # There was only that before:
+            shapes = np.zeros(self.binary_image.shape, dtype=np.uint8)
+            shapes[np.nonzero(self.shapes2)] = 1
+
+            nb_components, self.shapes2, self.stats, self.centroids = cv2.connectedComponentsWithStats(shapes, connectivity=8)
+        self.validated_shapes = shapes
+        self.shape_number = nb_components - 1
+
+    def kmeans(self, cluster_number, biomask=None, backmask=None, bio_label=None):
+        """
+        Use of Kmeans to detect the Cell(s) after having segmented the grayscale image into two or more categories
+        :param cluster_number: the number of categories to find
+        :param biomask: the mask of pixels marked as Cell(s) by the user
+        :param backmask: the mask of pixels marked as Background by the user
+        :param bio_label:
+        :return:
+        """
+        image = self.image.reshape((-1, 1))
+        image = np.float32(image)
+        criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
+        compactness, label, center = cv2.kmeans(image, cluster_number, None, criteria, attempts=10, flags=cv2.KMEANS_RANDOM_CENTERS)
+        kmeans_image = np.uint8(label.flatten().reshape(self.image.shape[:2]))
+        sum_per_label = np.zeros(cluster_number)
+        self.binary_image = np.zeros(self.image.shape[:2], np.uint8)
+        if bio_label is not None:
+            self.binary_image[np.nonzero(kmeans_image == bio_label)] = 1
+            self.bio_label = bio_label
+        else:
+            if biomask is not None:
+                all_labels = kmeans_image[biomask[0], biomask[1]]
+                for i in range(cluster_number):
+                    sum_per_label[i] = (all_labels == i).sum()
+                self.bio_label = np.nonzero(sum_per_label == np.max(sum_per_label))
+            elif backmask is not None:
+                all_labels = kmeans_image[backmask[0], backmask[1]]
+                for i in range(cluster_number):
+                    sum_per_label[i] = (all_labels == i).sum()
+                self.bio_label = np.nonzero(sum_per_label == np.min(sum_per_label))
+            else:
+                for i in range(cluster_number):
+                    sum_per_label[i] = (kmeans_image == i).sum()
+                self.bio_label = np.nonzero(sum_per_label == np.min(sum_per_label))
+            self.binary_image[np.nonzero(kmeans_image == self.bio_label)] = 1
+
+    def process_binary_image(self, use_bio_and_back_masks=False):
+        """
+        Process the binary image to get the final validated shapes
+        Starts by computin connected components, then remove the background pixels marked by the user,
+        then, if there are not several blob per arena, select spot according to their sizes
+        :param use_bio_and_back_masks: if true, will use the cell(s) and background matked by the user
+        :return:
+        """
+        self.shape_number, self.shapes, self.stats, self.centroids = cv2.connectedComponentsWithStats(
+            self.binary_image, connectivity=8)
+        do_not_delete = None
+        if use_bio_and_back_masks:
+            if self.backmask is not None:
+                if np.any(self.shapes[self.backmask]):
+                    self.shapes[np.isin(self.shapes, np.unique(self.shapes[self.backmask]))] = 0
+                    self.shape_number, self.shapes, self.stats, self.centroids = cv2.connectedComponentsWithStats(
+                        (self.shapes > 0).astype(np.uint8), connectivity=8)
+            self.shape_number -= 1
+            if self.biomask is not None:
+                if np.any(self.shapes[self.biomask]):
+                    do_not_delete = np.unique(self.shapes[self.biomask])
+                    do_not_delete = do_not_delete[do_not_delete != 0]
+        if not self.several_blob_per_arena and self.spot_size is not None:
+            counter = 0
+            self.shapes2 = deepcopy(self.shapes)
+            while self.shape_number != self.sample_number and counter < len(self.parent.spot_size_confints):
+                self.shape_selection(horizontal_size=self.spot_size, shape=self.parent.spot_shapes[counter],
+                                     confint=self.parent.spot_size_confints[counter], do_not_delete=do_not_delete)
+                logging.info(f"Shape selection algorithm found {self.shape_number} disconnected shapes")
+                counter += 1
+            if self.shape_number == self.sample_number:
+                self.shapes = self.shapes2
+        if self.shape_number == self.sample_number:
+            self.validated_shapes = np.zeros(self.shapes.shape, dtype=np.uint8)
+            self.validated_shapes[self.shapes > 0] = 1
+        else:
+            max_size = self.binary_image.size * 0.75
+            min_size = 10
+            cc_to_remove = np.argwhere(np.logical_or(self.stats[1:, 4] < min_size, self.stats[1:, 4] > max_size)) + 1
+            self.shapes[np.isin(self.shapes, cc_to_remove)] = 0
+            self.validated_shapes = np.zeros(self.shapes.shape, dtype=np.uint8)
+            self.validated_shapes[self.shapes > 0] = 1
+            self.shape_number, self.shapes, self.stats, self.centroids = cv2.connectedComponentsWithStats(
+                self.validated_shapes,
+                connectivity=8)
+            if not self.several_blob_per_arena and self.sample_number is not None and self.shape_number > self.sample_number:
+                # Sort shapes by size and compare the largest with the second largest
+                # If the difference is too large, remove that largest shape.
+                cc_to_remove = np.array([], dtype=np.uint8)
+                to_remove = np.array([], dtype=np.uint8)
+                self.stats = self.stats[1:, :]
+                while self.stats.shape[0] > self.sample_number and to_remove is not None:
+                    # 1) rank by height
+                    sorted_height = np.argsort(self.stats[:, 2])
+                    # and only consider the number of shapes we want to detect
+                    standard_error = np.std(self.stats[sorted_height, 2][-self.sample_number:])
+                    differences = np.diff(self.stats[sorted_height, 2])
+                    # Look for very big changes from one height to the next
+                    if differences.any() and np.max(differences) > 2 * standard_error:
+                        # Within these, remove shapes that are too large
+                        to_remove = sorted_height[np.argmax(differences)]
+                        cc_to_remove = np.append(cc_to_remove, to_remove + 1)
+                        self.stats = np.delete(self.stats, to_remove, 0)
+
+                    else:
+                        to_remove = None
+                self.shapes[np.isin(self.shapes, cc_to_remove)] = 0
+                self.validated_shapes = np.zeros(self.shapes.shape, dtype=np.uint8)
+                self.validated_shapes[self.shapes > 0] = 1
+                self.shape_number, self.shapes, self.stats, self.centroids = cv2.connectedComponentsWithStats(
+                    self.validated_shapes,
+                    connectivity=8)
+
+            self.shape_number -= 1
+
+
+class SaveCombinationThread(threading.Thread):
+    def __init__(self, parent=None):
+        # super(SaveCombinationThread, self).__init__()
+        threading.Thread.__init__(self)
+        self.parent = parent
+
+    def run(self):
+        """
+        Save the current process_i data into the combination_features list
+        :return:
+        """
+        logging.info(f"Saving results from the color space combination: {self.process_i.csc_dict}. {self.process_i.shape_number} distinct spots detected.")
+        self.parent.saved_images_list.append(self.process_i.validated_shapes)
+        self.parent.converted_images_list.append(np.round(self.process_i.image).astype(np.uint8))
+        self.parent.saved_color_space_list.append(self.process_i.csc_dict)
+        self.parent.combination_features[self.parent.saved_csc_nb, :3] = list(self.process_i.csc_dict.values())[0]
+        self.parent.combination_features[self.parent.saved_csc_nb, 3] = self.process_i.unaltered_concomp_nb - 1  # unaltered_cc_nb
+        self.parent.combination_features[self.parent.saved_csc_nb, 4] = self.process_i.shape_number  # cc_nb
+        self.parent.combination_features[self.parent.saved_csc_nb, 5] = self.process_i.total_area  # area
+        self.parent.combination_features[self.parent.saved_csc_nb, 6] = np.std(self.process_i.stats[1:, 2])  # width_std
+        self.parent.combination_features[self.parent.saved_csc_nb, 7] = np.std(self.process_i.stats[1:, 3])  # height_std
+        self.parent.combination_features[self.parent.saved_csc_nb, 8] = np.std(self.process_i.stats[1:, 4])  # area_std
+        if self.process_i.biomask is not None:
+            self.parent.combination_features[self.parent.saved_csc_nb, 9] = np.sum(
+                self.process_i.validated_shapes[self.process_i.biomask[0], self.process_i.biomask[1]])
+        if self.process_i.backmask is not None:
+            self.parent.combination_features[self.parent.saved_csc_nb, 10] = np.sum(
+                (1 - self.process_i.validated_shapes)[self.process_i.backmask[0], self.process_i.backmask[1]])
+        self.parent.saved_csc_nb += 1
+        logging.info("end")

cellects/image_analysis/progressively_add_distant_shapes.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""Contains the class: ProgressivelyAddDistantShapes"""
+from copy import deepcopy
+import numpy as np
+import cv2
+from cellects.image_analysis.morphological_operations import cross_33, make_gravity_field, CompareNeighborsWithValue, get_radius_distance_against_time, cc, Ellipse
+
+
+
+class ProgressivelyAddDistantShapes:
+    def __init__(self, new_potentials, previous_shape, max_distance):
+        """
+        This class check new potential shapes sizes and distance to a main
+        (first called previous) shape.
+        If these sizes and distance match requirements,
+        create a bridge between these and the main shape
+        Then, the modify_past_analysis method progressively grows that bridge
+        in a binary video. Bridge growth speed depends on neighboring growth speed
+
+        :param new_potentials: A binary image of all shapes detected at t
+        :param previous_shape: A binary image of the main shape (1) at t - 1
+        :param min_shape_size: The minimal size for a shape from new_potentials to get bridged
+        :param max_shape_size: The maximal size for a shape from new_potentials to get bridged
+        :param max_distance: The maximal distance for a shape from new_potentials to get bridged
+        :param cross_33: A binary crux
+        """
+        self.new_order = np.logical_or(new_potentials, previous_shape).astype(np.uint8)
+        self.new_order, self.stats, centers = cc(self.new_order)
+        self.main_shape = np.zeros(self.new_order.shape, np.uint8)
+        self.max_distance = max_distance
+        self.check_main_shape_label(previous_shape)
+
+    def check_main_shape_label(self, previous_shape):
+
+        if np.any(self.new_order > 1):
+            # If there is at least one pixel of the previous shape that is not among pixels labelled 1,
+            # clarify who's main shape
+            main_shape_label = np.unique(previous_shape * self.new_order)
+            main_shape_label = main_shape_label[main_shape_label != 0]
+
+            # If the main shape is not labelled 1 in main_shape:
+            if not np.isin(1, main_shape_label):
+                # If it is not 1, find which label correspond to the previous shape
+                if len(main_shape_label) > 1:
+                    pixel_sum_per_label = np.zeros(len(main_shape_label), dtype =np.uint64)
+                    # Find out the label corresponding to the largest shape
+                    for li, label in enumerate(main_shape_label):
+                        pixel_sum_per_label[li] = self.new_order[self.new_order == label].sum()
+                    main_shape_label = main_shape_label[np.argmax(pixel_sum_per_label)]
+                # Attribute the correct main shape
+                self.main_shape[self.new_order == main_shape_label] = 1
+                # Exchange the 1 and the main shape label in new_order image
+                not_one_idx = np.nonzero(self.new_order == main_shape_label)
+                one_idx = np.nonzero(self.new_order == 1)
+                self.new_order[not_one_idx[0], not_one_idx[1]] = 1
+                self.new_order[one_idx[0], one_idx[1]] = main_shape_label
+                # Do the same for stats
+                not_one_stats = deepcopy(self.stats[main_shape_label, :])
+                self.stats[main_shape_label, :] = self.stats[1, :]
+                self.stats[1, :] = not_one_stats
+            else:
+            #if np.any(previous_shape * (self.new_order == 1)):
+                # Create an image of the principal shape
+                self.main_shape[self.new_order == 1] = 1
+        else:
+            self.main_shape[np.nonzero(self.new_order)] = 1
+
+    def consider_shapes_sizes(self, min_shape_size=None, max_shape_size=None):
+        if self.max_distance != 0:
+            # Eliminate too small and too large shapes
+            if min_shape_size is not None or max_shape_size is not None:
+                if min_shape_size is not None:
+                    small_shapes = self.stats[:, 4] < min_shape_size
+                    extreme_shapes = deepcopy(small_shapes)
+                if max_shape_size is not None:
+                    large_shapes = self.stats[:, 4] > max_shape_size
+                    extreme_shapes = deepcopy(large_shapes)
+                if min_shape_size is not None and max_shape_size is not None:
+                    extreme_shapes = np.nonzero(np.logical_or(small_shapes, large_shapes))[0]
+                is_main_in_it = np.isin(extreme_shapes, 1)
+                if np.any(is_main_in_it):
+                    extreme_shapes = np.delete(extreme_shapes, is_main_in_it)
+                for extreme_shape in extreme_shapes:
+                    self.new_order[self.new_order == extreme_shape] = 0
+        else:
+            self.expanded_shape = self.main_shape
+
+    def connect_shapes(self, only_keep_connected_shapes, rank_connecting_pixels, intensity_valley=None):
+        # If there are distant shapes of the good size, run the following:
+        if self.max_distance != 0 and np.any(self.new_order > 1):
+            # The intensity valley method does not work yet, don't use it
+            if intensity_valley is not None:
+                self.gravity_field = intensity_valley # make sure that the values correspond to the coord
+            else:
+                # 1) faire un champ gravitationnel autour de la forme principale
+                self.gravity_field = make_gravity_field(self.main_shape, max_distance=self.max_distance, with_erosion=1)
+
+                # If there are near enough shapes, run the following
+                # 2) Dilate other shapes toward the main according to the gradient
+            other_shapes, max_field_feelings = self.expand_smalls_toward_main()
+
+
+            # plt.imshow(other_shapes)
+            # If there are shapes within gravity field range
+            if np.any(max_field_feelings > 0):
+                self.expanded_shape = np.zeros(self.main_shape.shape, np.uint8)
+                self.expanded_shape[np.nonzero(self.main_shape + other_shapes)] = 1
+                if only_keep_connected_shapes:
+                    # Make sure that only shapes connected with the main one remain on the final image
+                    self.keep_connected_shapes()
+                    if rank_connecting_pixels:
+                        # Rate the extension of small shapes according to the distance between the small and the main shapes
+                        self.distance_ranking_of_connecting_pixels()
+                #self.expanded_shape
+                # plt.imshow(self.expanded_shape)
+            else:
+                self.expanded_shape = self.main_shape
+        # Otherwise, end by putting the main shape as output
+        else:
+            self.expanded_shape = self.main_shape
+
+    def expand_smalls_toward_main(self):
+
+        other_shapes = np.zeros(self.main_shape.shape, np.uint8)
+        other_shapes[self.new_order > 1] = 1
+        simple_disk = cross_33
+        kernel = Ellipse((5, 5)).create().astype(np.uint8)
+        # Dilate the main shape, progressively to infer in what order other shapes should be expanded toward it
+        main_shape = deepcopy(self.main_shape)
+        new_order = deepcopy(self.new_order)
+        order_of_shapes_to_expand = np.empty(0, dtype=np.uint32)
+        nb = 3
+        while nb > 2:
+            main_shape = cv2.dilate(main_shape, kernel)
+            connections = deepcopy(main_shape)
+            connections *= new_order
+            new_connections = np.unique(connections)[2:]
+            new_order[np.isin(new_order, new_connections)] = 1
+            order_of_shapes_to_expand = np.append(order_of_shapes_to_expand, new_connections)
+            connections[main_shape > 0] = 1
+            connections[other_shapes > 0] = 1
+            nb, connections = cv2.connectedComponents(connections)
+
+        expanded_main = deepcopy(self.main_shape)
+        max_field_feelings = np.empty(0, dtype=np.uint32)
+        max_field_feeling = 0
+        # Loop over each shape to connect, from the nearest to the furthest to the main shape
+        for shape_i in order_of_shapes_to_expand:#  np.unique(self.new_order)[2:]:
+            current_shape = np.zeros(self.main_shape.shape, np.uint8)
+            current_shape[self.new_order == shape_i] = 1
+            dil = 0
+            # Dilate that shape until it overlaps the main shape
+            while np.logical_and(dil <= self.max_distance, not np.any(current_shape * expanded_main)):
+                dil += 1
+                rings = cv2.dilate(current_shape, simple_disk, iterations=1, borderType=cv2.BORDER_CONSTANT,
+                               borderValue=0)
+
+                rings = self.gravity_field * (rings - current_shape)
+                max_field_feeling = np.max(rings) # np.min(rings[rings>0])
+                max_field_feelings = np.append(max_field_feeling, max_field_feelings)
+                if max_field_feeling > 0:  # If there is no shape within max_distance range, quit the loop
+
+                    if dil == 1:
+                        initial_pixel_number = np.sum(rings == max_field_feeling)
+                    while np.sum(rings == max_field_feeling) > initial_pixel_number:
+                        shrinking_stick = CompareNeighborsWithValue(rings, 8, np.uint32)
+                        shrinking_stick.is_equal(max_field_feeling, True)
+                        rings[shrinking_stick.equal_neighbor_nb < 2] = 0
+                    current_shape[rings == max_field_feeling] = 1
+                else:
+                    break
+
+            expanded_main[current_shape != 0] = 1
+        return expanded_main, max_field_feelings
+
+
+    def keep_connected_shapes(self):
+        number, order = cv2.connectedComponents(self.expanded_shape, ltype=cv2.CV_16U)
+        if number > 2:
+            for i in np.arange(1, number):
+                expanded_shape_test = np.zeros(order.shape, np.uint8)
+                expanded_shape_test[order == i] = 1
+                if np.any(expanded_shape_test * self.main_shape):
+                    break
+            self.expanded_shape = expanded_shape_test
+        # else:
+        #     self.expanded_shape = other_shapes + self.main_shape
+        # self.expanded_shape[self.expanded_shape > 1] = 1
+
+    def distance_ranking_of_connecting_pixels(self):
+        rated_extension = np.zeros(self.main_shape.shape, np.uint8)
+        rated_extension[(self.main_shape - self.expanded_shape) == 255] = 1
+        rated_extension = rated_extension * self.gravity_field
+        if np.any(rated_extension):
+            rated_extension[np.nonzero(rated_extension)] -= np.min(
+                rated_extension[np.nonzero(rated_extension)]) - 1
+        self.expanded_shape += rated_extension
+
+    #binary_video = self.binary[(self.step // 2):(self.t + 1), :, :]
+    #draft_seg = self.segmentation[(self.step // 2):(self.t + 1), :, :]
+    def modify_past_analysis(self, binary_video, draft_seg):
+        self.binary_video = binary_video
+        self.draft_seg = draft_seg
+        self.expanded_shape[self.expanded_shape == 1] = 0
+        # Find the time at which the shape became connected to the expanded shape
+        # (i.e. the time to start looking for a growth)
+        distance_against_time, time_start, time_end = self.find_expansion_timings()
+
+        # Use that vector to progressively fill pixels at the same speed as shape grows
+        for t in np.arange(len(distance_against_time)):
+            image_garbage = (self.expanded_shape >= distance_against_time[t]).astype(np.uint8)
+            new_order, stats, centers = cc(image_garbage)
+            for comp_i in np.arange(1, stats.shape[0]):
+                past_image = deepcopy(self.binary_video[time_start + t, :, :])
+                with_new_comp = new_order == comp_i
+                past_image[with_new_comp] = 1
+                nb_comp, image_garbage = cv2.connectedComponents(past_image)
+                if nb_comp == 2:
+                    self.binary_video[time_start + t, :, :][with_new_comp] = 1
+        #self.expanded_shape[self.expanded_shape > 0] = 1
+        #self.binary_video[time_end:, :, :] += self.expanded_shape
+        for t in np.arange(time_end, self.binary_video.shape[0]):
+            self.binary_video[t, :, :][np.nonzero(self.expanded_shape)] = 1
+        last_image = self.binary_video[t, :, :] + self.binary_video[t - 1, :, :]
+        last_image[last_image > 0] = 1
+        self.binary_video[-1, :, :] = last_image
+        return self.binary_video
+
+    def find_expansion_timings(self):
+        max_t = self.binary_video.shape[0] - 1
+        dilated_one = cv2.dilate(self.expanded_shape, cross_33)
+        # Find the time at which the nearest pixel of the expanded_shape si reached by the main shape
+        closest_pixels = np.zeros(self.main_shape.shape, dtype=np.uint8)
+        closest_pixels[self.expanded_shape == np.max(dilated_one)] = 1
+        expand_start = max_t
+        # Loop until there is no overlap between the dilated added shape and the original shape
+        # Stop one frame before in order to obtain the exact reaching moment.
+        while np.any(self.binary_video[expand_start - 1, :, :] * closest_pixels):
+            expand_start -= 1
+
+        # Find the relationship between distance and time
+        distance_against_time, time_start, time_end = get_radius_distance_against_time(
+            self.draft_seg[expand_start:(max_t + 1), :, :], dilated_one)
+        time_start += expand_start
+        time_end += expand_start
+        return distance_against_time, time_start, time_end