batoolset 0.1.0__py3-none-any.whl

batoolset/ta/tracking/registration.py

@@ -0,0 +1,108 @@
+from skimage.registration import phase_cross_correlation # change in scipy 0.19
+# image = data.camera()
+from skimage import transform
+import numpy as np
+
+__DEBUG__ = False
+
+def apply_translation(img, y, x):
+    """
+    Applies translation to an image.
+
+    Args:
+        img (numpy.ndarray): The input image.
+        y (float): Translation along the y-axis.
+        x (float): Translation along the x-axis.
+
+    Returns:
+        numpy.ndarray: The translated image.
+    """
+    afine_tf = transform.AffineTransform(translation=(x, y))
+    translated = transform.warp(img, inverse_map=afine_tf, order=0, preserve_range=True)
+    return translated
+
+def pre_register_images(orig_t0, orig_t1, apply_to_orig_t0=False):
+    """
+    Performs pre-registration between two images.
+
+    Args:
+        orig_t0 (numpy.ndarray): The first image.
+        orig_t1 (numpy.ndarray): The second image.
+        apply_to_orig_t0 (bool, optional): Whether to apply the translation to orig_t0. Defaults to False.
+
+    Returns:
+        tuple or numpy.ndarray: If apply_to_orig_t0 is False, returns the global translations (gloabl_t0, gloabl_t1).
+        If apply_to_orig_t0 is True, returns the translated orig_t0 image.
+
+    Notes:
+        - The function uses phase cross-correlation to estimate the global translation between the two images.
+        - The global translation is then applied to either orig_t0 or both orig_t0 and orig_t1, depending on the
+          value of apply_to_orig_t0.
+    """
+    global_translation, error, diffphase = phase_cross_correlation(orig_t0, orig_t1)
+    gloabl_t0 = -global_translation[0]
+    gloabl_t1 = -global_translation[1]
+    if not apply_to_orig_t0:
+        return gloabl_t0, gloabl_t1
+    else:
+        return apply_translation(orig_t0, -gloabl_t0, -gloabl_t1)
+
+def get_pyramidal_registration(orig_t0, orig_t1, depth=2, threshold_translation=20):
+    """
+    Performs pyramidal registration between two images.
+
+    Args:
+        orig_t0 (numpy.ndarray): The first image.
+        orig_t1 (numpy.ndarray): The second image.
+        depth (int, optional): The depth of the pyramid. Defaults to 2.
+        threshold_translation (float, optional): The threshold for ignoring large translations. Defaults to 20.
+
+    Returns:
+        numpy.ndarray: The translation matrix representing the translations for each pixel.
+
+    Notes:
+        - The function applies pre-registration between orig_t0 and orig_t1.
+        - It then iteratively performs registration on blocks of decreasing size.
+        - Translations are accumulated in the translation matrix.
+    """
+
+    translation_matrix = np.zeros((*orig_t0.shape, 2))
+
+    gloabl_t0, gloabl_t1 = pre_register_images(orig_t0, orig_t1)
+
+    translation_matrix[..., 0] += gloabl_t0
+    translation_matrix[..., 1] += gloabl_t1
+
+    height = orig_t0.shape[0]
+    width = orig_t0.shape[1]
+
+    block_size = 256
+
+    for i in range(depth):
+        try:
+            tile_height = block_size // (i * 2)
+            tile_width = block_size // (i * 2)
+        except:
+            tile_height = block_size
+            tile_width = block_size
+
+        for y in range(0, height, tile_height):
+            for x in range(0, width, tile_width):
+                afine_tf = transform.AffineTransform(
+                    translation=(-translation_matrix[y, x, 1], -translation_matrix[y, x, 0]))
+                translated = transform.warp(orig_t0, inverse_map=afine_tf, order=0, preserve_range=True)
+
+                tile_t0 = translated[y:y + tile_height, x:x + tile_width]
+                tile_t1 = orig_t1[y:y + tile_height, x:x + tile_width]
+
+                shift, error, diffphase = phase_cross_correlation(tile_t0, tile_t1)
+                t0 = -shift[0]
+                t1 = -shift[1]
+
+                if abs(t0) > threshold_translation or abs(t1) > threshold_translation:
+                    continue
+
+                translation_matrix[y:y + tile_height, x:x + tile_width, 0] += t0
+                translation_matrix[y:y + tile_height, x:x + tile_width, 1] += t1
+
+    return translation_matrix

batoolset/ta/tracking/swap_detector_and_fixer.py

@@ -0,0 +1,296 @@
+from batoolset.img import int24_to_RGB, RGB_to_int24
+from timeit import default_timer as timer
+import numpy as np
+from batoolset.img import Img
+# really very good --> now make it recursive then done --> extract the cell from there and continue
+from natsort import natsorted
+import os
+
+# parameters
+from batoolset.utils.loadlist import loadlist
+from batoolset.ta.tracking.rapid_detection_of_vertices import associate_vertices_to_cells, detect_vertices_and_bonds
+
+__DEBUG__ = False
+
+
+
+def _fix_swapping_internal(tracked_cells_t0, tracked_cells_t1, vertices_t0=None, vertices_t1=None, MIN_CUT_OFF_SWAPPING=None):
+    """
+    Fixes swapping of cells between two time steps.
+
+    Args:
+        tracked_cells_t0 (numpy.ndarray): Array of tracked cells at time t0.
+        tracked_cells_t1 (numpy.ndarray): Array of tracked cells at time t1.
+        vertices_t0 (numpy.ndarray, optional): Array of vertices at time t0. Defaults to None.
+        vertices_t1 (numpy.ndarray, optional): Array of vertices at time t1. Defaults to None.
+        MIN_CUT_OFF_SWAPPING (float, optional): Minimum cutoff score for swapping. Defaults to None.
+
+    Returns:
+        numpy.ndarray: Updated array of tracked cells at time t1.
+
+    """
+    if __DEBUG__:
+        cell_to_check = 0x29d785  # 0x976494 #0x29d785  # 0x746502 #0x96c9ef #0x542358  # 0xf36619 #0x496bbd #0x1bf38f
+        # map           9921684   2742149   7628034  9882095   5514072   15951385   4811709
+        print('cell to check', cell_to_check, format(cell_to_check, 'x'))
+
+
+    # inner_time = timer()
+    if vertices_t0 is None:
+        vertices_t0 = detect_vertices_and_bonds(tracked_cells_t0)
+        vertices_t0 = np.where(vertices_t0 == 255)
+    if vertices_t1 is None:
+        vertices_t1 = detect_vertices_and_bonds(tracked_cells_t1)
+        vertices_t1 = np.where(vertices_t1 == 255)
+    # print('current time0', timer() - inner_time)
+
+    # inner_time = timer()
+    t0_cells_n_vertices = associate_vertices_to_cells(tracked_cells_t0, vertices_t0,
+                                                      forbidden_colors=(0, 0xFFFFFF),
+                                                      output_cells_and_their_neighbors=True)
+    t1_cells_n_vertices = associate_vertices_to_cells(tracked_cells_t1, vertices_t1,
+                                                      forbidden_colors=(0, 0xFFFFFF),
+                                                      output_cells_and_their_neighbors=True)
+
+
+    if __DEBUG__:
+        print('t0_cells_n_vertices', t0_cells_n_vertices)
+        print('t1_cells_n_vertices', t1_cells_n_vertices)
+
+    # inner_time = timer()
+    best_pairs = {}  # dict that contains pairs -->  a good idea
+    best_pairs_score = {}
+
+    for key, value in t0_cells_n_vertices.items():
+        max_match = 0.
+        best_match = 0
+        neighs_at_t0 = t0_cells_n_vertices[key]
+        best_pair_size = 0
+
+        for key2, value2 in t1_cells_n_vertices.items():
+            neighs_at_t1 = t1_cells_n_vertices[key2]
+            common_neighs = set(neighs_at_t1).intersection(neighs_at_t0)
+
+            # if two are equal --> try to take the best --> find a way to do it smartly
+            if len(common_neighs) > 0 and len(
+                    common_neighs) >= max_match:  # if found twice --> find a way to select which cells to take
+                # max_match = len(common_neighs) / ((len(neighs_at_t1)+len(neighs_at_t0))/2)
+
+                conti = True
+                if len(common_neighs) == max_match:
+                    if len(neighs_at_t1) == best_pair_size:
+                        if key == key2:
+                            # do favor identity as much as possible
+                            conti = True
+                        # find a trick or random
+                        elif key2 in neighs_at_t0:  # not sure this is very smart but give it a try NB recursion may fix bugs
+                            conti = False
+                    elif len(neighs_at_t1) > best_pair_size:
+                        conti = False
+                    # si les 2 font la meme taille --> pb à nouveau --> y a t'il une astuce...
+
+                if conti:
+                    max_match = len(common_neighs)  # / ((len(neighs_at_t1)+len(neighs_at_t0))/2)
+                    best_match = key2
+                    best_pair_size = len(neighs_at_t1)
+                    if __DEBUG__:
+                        if key == cell_to_check:
+                            hex_list_0 = [format(x, 'x') for x in neighs_at_t0]
+                            hex_list_1 = [format(x, 'x') for x in neighs_at_t1]
+                            print('pairs for a test', neighs_at_t0, neighs_at_t1, len(common_neighs), max_match,
+                                  format(key, 'x'), format(key2, 'x'), key, key2, hex_list_0,
+                                  hex_list_1)  # that works --> so indeed the best match is found but then cells are lost and swapped --> why is that --> I still miss a ctrl somewhere --> or a secondary swap that is less good somehow --> check that or a coding error!!
+                else:
+                    if __DEBUG__:
+                        if key == cell_to_check:
+                            hex_list_0 = [format(x, 'x') for x in neighs_at_t0]
+                            hex_list_1 = [format(x, 'x') for x in neighs_at_t1]
+                            print('discarded pairs for a test', neighs_at_t0, neighs_at_t1, len(common_neighs),
+                                  max_match,
+                                  format(key, 'x'), format(key2, 'x'), key, key2, hex_list_0,
+                                  hex_list_1)
+        if __DEBUG__:
+            if key == cell_to_check:
+                print('final match', max_match, cell_to_check, best_match, format(cell_to_check, 'x'),
+                      format(best_match, 'x'))
+        # or best --> compare to its current match and if better then take it otherwise ignore  --> maybe
+
+        # in fact I take all here but is that really worth ??? --> maybe take one but only if the cell has just one neighbor ???? --> shall I start with 2 ??? that would dramatically reduce the nb of cells I guess --> think about it
+        if max_match >= 0.5:  # take all cells that have at least half of their neighbs --> 40--> maybe ok
+
+            # compare neighbors of current match versus those in the previous
+            best_pairs[key] = best_match
+            best_pairs_score[key] = max_match  # will be used later to avoid issues
+
+    # remove cells that did not change much
+    if MIN_CUT_OFF_SWAPPING is not None and MIN_CUT_OFF_SWAPPING>0:
+        pairs_to_ignore = [k for k, v in best_pairs_score.items() if v <= MIN_CUT_OFF_SWAPPING]
+        for ids in pairs_to_ignore:
+            del best_pairs[ids]
+
+    # finding duplicate values
+    # from dictionary using set
+    rev_dict = {}
+    for key, value in best_pairs.items():
+        rev_dict.setdefault(value, set()).add(key)
+
+    dupes_matches_to_be_removed = []
+    for key, value in rev_dict.items():
+
+        if __DEBUG__:
+            if key == cell_to_check:
+                print('MEGA THERE######')
+
+        if len(value) > 1:
+            best_match = 0
+            max_match = 0
+            # keep only best and remove all others from the table
+            for iii, val in enumerate(value):
+                if __DEBUG__:
+                    if key == cell_to_check:
+                        print(iii, val, best_pairs_score[val])
+
+                if best_pairs_score[val] == max_match:
+                    if val == key:
+                        max_match = best_pairs_score[val]
+                        best_match = val
+                elif best_pairs_score[val] > max_match:
+                    max_match = best_pairs_score[val]
+                    best_match = val
+
+            if __DEBUG__:
+                if key == cell_to_check:
+                    print(value, val, max_match)
+
+            value.remove(best_match)
+            # I do have a bug here but I don't get it in fact but ok for now
+            dupes_matches_to_be_removed.extend(
+                value)  # not a good idea --> just need to remove it from the value not from everywhere... is that correct ???? remove it only if present again in duplicates in final stuff after cleaning
+
+    if __DEBUG__:
+        print('dupes_matches_to_be_removed', dupes_matches_to_be_removed,
+              [format(x, 'x') for x in dupes_matches_to_be_removed])
+
+    for key in dupes_matches_to_be_removed:
+        if key in best_pairs:
+            del best_pairs[key]
+
+    def swap(pairs_of_cells_to_swap,
+             tracked_cells_t1):  # this is super slow and would benefit from recoding it in C --> this takes most of the time of the function
+        # inner_time = timer()
+        clone_tracks = np.array(tracked_cells_t1, copy=True)
+        # print('current time', timer() - inner_time)
+
+        for cell1, cell2 in pairs_of_cells_to_swap.items():
+            if cell1 == cell2: # remove identity cause it slows down a lot the process
+                continue
+
+            # if cell2 not in pairs_of_cells_to_swap.keys(): # very slow --> find a way to make that faster
+            clone_tracks[tracked_cells_t1 == cell1] = cell2
+            clone_tracks[tracked_cells_t1 == cell2] = cell1
+
+            if __DEBUG__:
+                print('converting', cell2, '--> ', cell1, format(cell2, 'x'), '-->', format(cell1, 'x'))
+
+            # find a way todo things and to not duplicate stuff
+
+            # pb --> this creates duplications but otherwise it does swap correct cells --> find a way to prevent this --> I need to order swaps and other stuff
+        # print('current time2', timer() - inner_time)
+        return clone_tracks
+
+    # inner_time = timer()
+    tracked_cells_t1 = swap(best_pairs,
+                            tracked_cells_t1)  # c'est ce truc qui est super lent --> plus de la moitié du temps --> try improve that
+
+    if __DEBUG__:
+        print('best_pairs', len(best_pairs), best_pairs)  # maybe best ratio versus its own size
+    # TODO maybe save swapped cells --> only show those and blacken all the rest
+
+    return tracked_cells_t1
+
+
+if __name__ == '__main__':
+
+    swap_fix_recursions = 3
+
+    # pb is because after translation the cell is also present in both --> skipped by my stuff --> need detect those cells and chose to get only one in fact
+    # pb is because after translation the cell is also present in both --> skipped by my stuff --> need detect those cells and chose to get only one in fact
+    # or first do the
+
+    start_all = timer()
+
+    # path = '/E/Sample_images/tracking_test/leg_uncropped'  # quick test of the tracking algo
+    # path = '/E/Sample_images/tracking_test/leg_cropped'  # quick test of the tracking algo
+    path = '/E/Sample_images/tracking_test/test_uncropped'  # quick test of the tracking algo
+    # path = '/E/Sample_images/tracking_test/test_cropped'  # quick test of the tracking algo
+
+    if not path.lower().endswith('.txt') and not path.lower().endswith('.lst'):
+        images_to_analyze = os.listdir(path)
+        images_to_analyze = [os.path.join(path, f) for f in images_to_analyze if
+                             os.path.isfile(os.path.join(path, f))]  # list only files and only if they end by tif
+        images_to_analyze = natsorted(images_to_analyze)
+    else:
+        images_to_analyze = loadlist(path)
+
+    # get current and next in fact and map next
+
+    # process first image directly then move on to next
+    # images_to_analyze = []
+
+    # for image 0 --> just randomly fill it with colors --> make sure no dupe and that's it
+
+    # TODO --> do the first
+
+    print(images_to_analyze)
+
+    for l in range(len(images_to_analyze) - 1):
+
+        start_loop = timer()
+
+        file_path_0 = images_to_analyze[l]
+        file_path_1 = images_to_analyze[l + 1]
+
+        print('files', file_path_1, file_path_0)
+
+        if not file_path_1.endswith('.tif') or not file_path_0.endswith('.tif'):
+            continue
+
+        # print('files', file_path_1, file_path_0)
+
+        filename0_without_ext = os.path.splitext(file_path_0)[0]
+        filename1_without_ext = os.path.splitext(file_path_1)[0]
+
+        tracked_cells_t0 = Img(os.path.join(filename0_without_ext, 'tracked_cells_resized.tif'))
+        tracked_cells_t1 = Img(os.path.join(filename1_without_ext, 'tracked_cells_resized.tif'))
+
+    vertices_t0 = detect_vertices_and_bonds(RGB_to_int24(tracked_cells_t0))
+    vertices_t0 = np.where(vertices_t0==255)
+    vertices_t1 = detect_vertices_and_bonds(RGB_to_int24(tracked_cells_t1))
+    vertices_t1 = np.where(vertices_t1 == 255)
+
+    # time is always increasing but why is that is some set not reset
+    for fix in range(swap_fix_recursions):
+        print('swapping fix recursion #', fix)
+        begin_loop = timer()
+        tracked_cells_t1 = _fix_swapping_internal(tracked_cells_t0, tracked_cells_t1, vertices_t0=vertices_t0, vertices_t1=vertices_t1)
+        # tracked_cells_t1 = _fix_swapping_internal(tracked_cells_t0, tracked_cells_t1)
+        print('current time', timer() - begin_loop)
+        # Img(tracked_cells_t1).save(os.path.join(filename0_without_ext, 'track_after_swap_correction'+ str(fix)+ '.tif'), mode='raw')
+
+    # example of swapped cells
+    print('total time', timer() - start_all)  # --> 47 secs --> un peu lent qd meme
+
+    Img(int24_to_RGB(tracked_cells_t1)).save(os.path.join(filename0_without_ext, 'track_after_swap_correction.tif'), mode='raw')
+
+    # puis je la faire dynamiquement pr eviter les swaps en live
+    # --> void aussi si rentable ou pas
+
+    # TODO -->
+    # this now seems ok and could be done recursively...
+    # could also use neighbor cells to reassign most likely cell --> cell that matches most of the surrounding IDs
+
+    # pas mal --> see how many recursions might be needed to get the stuff to work --> might be time consuming to do plenty of recursion... --> maybe just update the map so that not everything needs be calculated again
+
+    # if a cell is unsure try reassign it by its neighborood...
+
+    # TODO --> reidentify cells by neighborhood --> simply use the vertices to detect the neighbors --> split the code

batoolset/ta/tracking/track_correction.py

@@ -0,0 +1,238 @@
+# zut le code est pas finalisé...
+
+# USE a track object to store the click and its content...
+
+
+# do a code to do smart track correction that avoids creating dupes
+# checks for dupes, etc...
+# can connect tracks and or swap tracks
+
+# si les deux couleurs existent dans les deux images alors c'est du swap et faut swapper à partir de la dernière image sinon
+# si chaque couleur existe dans une image et pas dans l'autre alors faire un connect track. Si le connect risque de dupliquer une cellule alors il faut faire un swap de la cellule puis connecter la track afin de ne pas dupliquer les cellules
+# reflechir mais ça devrait etre bon
+# existe t'il un moyen perenne de restaurer les tracks corrected ???? si oui lequel pr que le job ne soit pas perdu
+# peut etre simplement faire un truc du genre update tracks et rajouter les cellules perdues de maniere aleatoire ? pas si simple en fait
+# puis je aussi swapper plusieurs cellules en même temps ??? peut etre mais pas si simple
+# comment faire un algo de swap intelligent
+
+
+# need to store cell id or centroid or centre of area and the frame --> should be sufficient to do everything --> the most robust then detect the color of the other
+
+# offer apply to all or just before or after the current image
+# do the codes for that
+
+# aussi faire un code pour reappliquer les tracks
+
+
+from batoolset.img import RGB_to_int24, int24_to_RGB
+from timeit import default_timer as timer
+import matplotlib.pyplot as plt
+from batoolset.img import Img
+from batoolset.utils.loadlist import loadlist
+from batoolset.files.tools import smart_name_parser
+from batoolset.tools.logger import TA_logger  # logging
+
+logger = TA_logger()
+
+
+def swap(img, id1, id2):
+    """
+    Swaps the pixel values of two IDs in the image.
+
+    Args:
+        img (numpy.ndarray): The input image.
+        id1: The first ID to swap.
+        id2: The second ID to swap.
+
+    Returns:
+        numpy.ndarray: The modified image with swapped IDs.
+
+    """
+    idcs1 = img == id1
+    idcs2 = img == id2
+    img[idcs1], img[idcs2] = id2, id1
+    return img
+
+
+def assign_id(img, old_id, new_id):
+    """
+    Assigns a new ID to all pixels with the specified old ID in the image.
+
+    Args:
+        img (numpy.ndarray): The input image.
+        old_id: The ID to be replaced.
+        new_id: The new ID to assign.
+
+    Returns:
+        numpy.ndarray: The modified image with updated IDs.
+
+    """
+    img[img == old_id] = new_id
+    return img
+
+
+def swap_tracks(lst, frame_of_first_connection, id_t0, id_t1, __preview_only=False):
+    """
+    Swaps the IDs of two tracks in a list of tracks.
+
+    Args:
+        lst (list): The list of tracks.
+        frame_of_first_connection: The frame at which the first connection occurs.
+        id_t0: The ID of the first track.
+        id_t1: The ID of the second track.
+        __preview_only (bool, optional): Whether to only preview the swap. Defaults to False.
+
+    """
+    correct_track(lst, frame_of_first_connection, id_t0, id_t1, correction_mode='swap', __preview_only=__preview_only)
+
+
+def connect_tracks(lst, frame_of_first_connection, id_t0, id_t1, __preview_only=False):
+    """
+    Connects two tracks in a list of tracks.
+
+    Args:
+        lst (list): The list of tracks.
+        frame_of_first_connection: The frame at which the first connection occurs.
+        id_t0: The ID of the first track.
+        id_t1: The ID of the second track.
+        __preview_only (bool, optional): Whether to only preview the connection. Defaults to False.
+
+    """
+    correct_track(lst, frame_of_first_connection, id_t0, id_t1, correction_mode='connect', __preview_only=__preview_only)
+
+def correct_track(lst, frame_of_first_connection, id_t0, id_t1, correction_mode='connect', __preview_only=False, early_stop=True):
+    """
+    Corrects a track in a list of tracks based on the specified correction mode.
+
+    Args:
+        lst (list): The list of tracks.
+        frame_of_first_connection: The frame at which the first connection occurs.
+        id_t0: The ID of the first track.
+        id_t1: The ID of the second track.
+        correction_mode (str, optional): The correction mode. Defaults to 'connect'.
+        __preview_only (bool, optional): Whether to only preview the correction. Defaults to False.
+        early_stop (bool, optional): Whether to stop the correction process early. Defaults to True.
+
+    """
+    if frame_of_first_connection >= len(lst):
+        logger.error('error wrong connection frame nb')
+        return
+
+    for l in range(frame_of_first_connection, len(lst)):
+        tracked_cell_path = smart_name_parser(lst[l], ordered_output='tracked_cells_resized.tif')
+        tracked_cells_t0 = RGB_to_int24(Img(tracked_cell_path))
+
+        cellpos_1 = id_t0 in tracked_cells_t0
+        cellpos_2 = id_t1 in tracked_cells_t0
+
+        if not cellpos_1 and not cellpos_2:
+            logger.info('cells not found --> ignoring track correction')
+            continue
+
+        if cellpos_1 and cellpos_2 and correction_mode == 'connect':
+            logger.info('IDs are both present in the same image, to avoid track ID duplication the desired change will be ignored, please ensure the selected cells are not simply swapped in the image')
+            break
+
+        if not cellpos_1 and cellpos_2 or not cellpos_2 and cellpos_1 and correction_mode == 'swap':
+            logger.info('missing cell at frame ' + str(l) + ' swapping ignored')
+            if early_stop:
+                logger.info('quitting track edition')
+                break
+            else:
+                continue
+
+        if cellpos_1 and cellpos_2 and correction_mode == 'swap':
+            logger.info('swapped cell ids: ' + str(id_t0) + ' and ' + str(id_t1))
+            tracked_cells_t0 = swap(tracked_cells_t0, id_t0, id_t1)
+            if __preview_only:
+                plt.imshow(int24_to_RGB(tracked_cells_t0))
+                plt.show()
+            else:
+                Img(int24_to_RGB(tracked_cells_t0), dimensions='hwc').save(tracked_cell_path, mode='raw')
+        else:
+            if cellpos_1:
+                logger.info('changed id ' + str(id_t0) + ' to ' + str(id_t1))
+                tracked_cells_t0 = assign_id(tracked_cells_t0, id_t0, id_t1)
+            elif cellpos_2:
+                logger.info('changed id ' + str(id_t1) + ' to ' + str(id_t0))
+                tracked_cells_t0 = assign_id(tracked_cells_t0, id_t1, id_t0)
+            if __preview_only:
+                plt.imshow(int24_to_RGB(tracked_cells_t0))
+                plt.show()
+            else:
+                Img(int24_to_RGB(tracked_cells_t0), dimensions='hwc').save(tracked_cell_path, mode='raw')
+
+if __name__ == "__main__":
+    start_all = timer()
+
+    # path = '/E/Sample_images/tracking_test'
+    path = '/E/Sample_images/sample_images_PA/mini10_fake_swaps/liste.lst'
+    # path = '/E/Sample_images/test_tracking_with_shift' # quick test of the algo
+    #
+    # images_to_analyze = os.listdir(path)
+    # images_to_analyze = [os.path.join(path, f) for f in images_to_analyze if
+    #                      os.path.isfile(os.path.join(path, f))]  # list only files and only if they end by tif
+    # images_to_analyze = natsorted(images_to_analyze)
+
+    images_to_analyze = loadlist(path)
+
+    # then do amrutha's code watershed  imagendarray (2-D, 3-D, …) of integers--> cool --> will also work for 3D --> then need segmentation in 3D
+    #
+    #
+    # for l in range(len(images_to_analyze)):
+    #     # in fact I don't even need to reopen the mask file because the track file should suffice ???
+    #
+    #     file_path_0 = images_to_analyze[l]
+    #     if not file_path_0.endswith('.tif'):
+    #         continue
+    #
+    #
+    #     # print('files', file_path_1, file_path_0)
+    #
+    #     filename0_without_ext = os.path.splitext(file_path_0)[0]
+    #
+    #     tracked_cells_t0 = Img(os.path.join(filename0_without_ext,        'tracked_cells_resized.tif')) # 455:455 + 128, 435:435 + 128 #455:455 + 256, 435:435 + 290 #768:1024,0:256 #0:128, 0:128 #500:500+128, 500:500+128
+    #
+    #
+    #
+    #
+    #     # TODO always get the mask instead of any other files in order to have the minimal nb of files available
+    #     # mask_t0 = Img(os.path.join(filename0_without_ext, 'handCorrection.tif'))[
+    #     #     ..., 0]  # 455:455 + 128, 435:435 + 128 #455:455 + 256, 435:435 + 290 #768:1024,0:256 #0:128, 0:128 #500:500+128, 500:500+128
+    #
+    #
+    #     # labels_t0 = measure.label(mask_t0, connectivity=1,
+    #     #                           background=255)  # FOUR_CONNECTED # use bg = 255 to avoid having to invert the image --> a gain of time I think and could be applied more generally
+    #
+    #     height = tracked_cells_t0.shape[0]
+    #     width = tracked_cells_t0.shape[1]
+    #
+    #
+    #     # could maybe store the ID of duplicate cell as a reseed --> can be a pb with extruding cells but should most often be ok though
+    #     #
+    #
+    #     labels_tracking_t0 = measure.label(tracked_cells_t0[..., 0], connectivity=1, background=255)
+    #     rps_t0 = regionprops(labels_tracking_t0)
+    #
+    #
+    #     centroids_t0 = []
+    #     for region in rps_t0:
+    #         # take regions with large enough areas
+    #         centroids_t0.append(region.centroid)
+
+    # try create a dupe to see if it fails -> it will and I should really avoid that
+
+    # swap_tracks(images_to_analyze, 1, 0x0ef5dd, 0xa28ad6, __preview_only=True)  # both cells exist
+
+
+    swap_tracks(images_to_analyze, 0, 0x0ef5dd, 0xFAFAFF, __preview_only=True)  # one cells exist
+
+    # ça marche mais reflechir que je ne puisse pas creer des pbs avec ça
+    # connect_tracks(images_to_analyze, 0, 0xffdd5d, 0x3b2cdb, __preview_only=True)  # both cells exist
+    # connect_tracks(images_to_analyze, 0, 0xffdd5d, 0x0ef5dd, __preview_only=True)  # create a duplicate cell # --> breaking
+
+    # codes are the same --> just keep one and
+
+    # tt a l'air de marcher --> maybe add a flag for recursive --> in fact not...
+
+    print('total time', timer() - start_all)