cellects 0.1.2__py3-none-any.whl → 0.2.6__py3-none-any.whl

cellects/core/script_based_run.py

@@ -4,57 +4,90 @@
 import logging
 import os
 from pathlib import Path
+from numpy.typing import NDArray
 import numpy as np
 import pandas as pd
 import cv2
 from cellects.core.program_organizer import ProgramOrganizer
 from cellects.utils.utilitarian import insensitive_glob
-from cellects.core.one_video_per_blob import OneVideoPerBlob
 from cellects.core.motion_analysis import MotionAnalysis
-from cellects.config.all_vars_dict import DefaultDicts
-from cellects.utils.load_display_save import show
-
-
-def load_one_folder(pathway, sample_number):
+from cellects.image_analysis.morphological_operations import create_ellipse
+from cellects.image_analysis.image_segmentation import convert_subtract_and_filter_video
+from cellects.utils.load_display_save import write_video_sets, readim, display_network_methods
+from cellects.image_analysis.network_functions import NetworkDetection
+
+def generate_colony_like_video():
+    ellipse = create_ellipse(7, 7).astype(np.uint8)
+    binary_video = np.zeros((20, 1000, 1000), dtype=np.uint8)
+    binary_video[0, np.random.randint(100, 900, 20), np.random.randint(100, 900, 20)] = 1
+    binary_video[0, ...] = cv2.dilate(binary_video[0, ...], ellipse)
+    for t in range(1, binary_video.shape[0]):
+        binary_video[t, ...] = cv2.dilate(binary_video[t - 1, ...], ellipse, iterations=1)
+    rgb_video = np.zeros((binary_video.shape[0], binary_video.shape[1], binary_video.shape[2], 3), dtype=np.uint8)
+    for c_ in range(3):
+        rgb_video[:, :, :, c_][binary_video > 0] = np.random.randint(150 + c_ * 20, 250 - c_ * 20, binary_video.sum())
+        rgb_video[:, :, :, c_][binary_video == 0] = np.random.randint(5 ,20 ,
+                                                               binary_video.size - binary_video.sum())
+    return rgb_video
+
+def load_data(rgb_video: NDArray=None, pathway: str='', sample_number:int=None, radical: str='', extension: str='', im_or_vid: int=0):
     po = ProgramOrganizer()
-    po.load_variable_dict()
-    # dd = DefaultDicts()
-    # po.all = dd.all
-    # po.vars = dd.vars
-    po.all['global_pathway'] = pathway
-    po.all['first_folder_sample_number'] = sample_number
-    # po.all['first_folder_sample_number'] = 6
-    # po.all['radical'] = "IMG"
-    # po.all['extension'] = ".jpg"
-    # po.all['im_or_vid'] = 0
-    po.look_for_data()
-    po.load_data_to_run_cellects_quickly()
+    if rgb_video is None:
+        if len(pathway) == 0:
+            pathway = Path(os.getcwd() + "/data/experiment")
+        po.all['global_pathway'] = pathway
+        po.all['first_folder_sample_number'] = sample_number
+        po.all['radical'] = radical
+        po.all['extension'] = extension
+        po.all['im_or_vid'] = im_or_vid
+        po.look_for_data()
+        po.load_data_to_run_cellects_quickly()
+        po.get_first_image()
+    else:
+        po.get_first_image(rgb_video[0,...])
+        po.analysis_instance = rgb_video
+        po.all['im_or_vid'] = 1
     return po
 
-def run_image_analysis(po):
+def run_image_analysis(po, PCA: bool=True, last_im:NDArray=None):
     if not po.first_exp_ready_to_run:
-        po.get_first_image()
-        po.fast_image_segmentation(True)
-        # po.first_image.find_first_im_csc(sample_number=po.sample_number,
-        #                                    several_blob_per_arena=None,
-        #                                    spot_shape=None, spot_size=None,
-        #                                    kmeans_clust_nb=2,
-        #                                    biomask=None, backmask=None,
-        #                                    color_space_dictionaries=None,
-        #                                    carefully=True)
+        if PCA:
+            po.fast_first_image_segmentation()
+        else:
+            po.first_image.find_first_im_csc()
         po.cropping(is_first_image=True)
         po.get_average_pixel_size()
         po.delineate_each_arena()
         po.get_background_to_subtract()
         po.get_origins_and_backgrounds_lists()
-        po.get_last_image()
-        po.fast_image_segmentation(is_first_image=False)
+        po.get_last_image(last_im)
+        po.fast_last_image_segmentation()
         po.find_if_lighter_background()
         po.extract_exif()
     else:
         print('Image analysis already done, run video analysis')
     return po
 
+def run_one_video_analysis(po, with_video_in_ram: bool=False):
+    i=0
+    show_seg= False
+    po.vars['frame_by_frame_segmentation'] = True
+    po.vars['do_threshold_segmentation'] = False
+    po.vars['do_slope_segmentation'] = False
+    if po.vars['convert_for_motion'] is None:
+        po.vars['convert_for_motion'] = po.vars['convert_for_origin']
+    videos_already_in_ram = None
+    if with_video_in_ram:
+        converted_video, _ = convert_subtract_and_filter_video(po.analysis_instance, po.vars['convert_for_motion'])
+        videos_already_in_ram = [po.analysis_instance, converted_video]
+    segment: bool = True
+    l = [i, i + 1, po.vars, segment, False, show_seg, videos_already_in_ram]
+    MA = MotionAnalysis(l)
+    MA.get_descriptors_from_binary()
+    # MA.detect_growth_transitions()
+    # MA.networks_analysis(show_seg)
+    # MA.study_cytoscillations(show_seg)
+    return MA
 
 def write_videos(po):
     po.update_output_list()
@@ -65,37 +98,17 @@ def write_videos(po):
     do_write_videos = not there_already_are_videos or (
             there_already_are_videos and po.all['overwrite_unaltered_videos'])
     if do_write_videos:
-        po.videos = OneVideoPerBlob(po.first_image, po.starting_blob_hsize_in_pixels, po.all['raw_images'])
-        po.videos.left = po.left
-        po.videos.right = po.right
-        po.videos.top = po.top
-        po.videos.bot = po.bot
-        po.videos.first_image.shape_number = po.sample_number
-        po.videos.write_videos_as_np_arrays(
-            po.data_list, po.vars['min_ram_free'], not po.vars['already_greyscale'], po.reduce_image_dim)
+        po.first_image.shape_number = po.sample_number
+        in_colors = not po.vars['already_greyscale']
+        bunch_nb, video_nb_per_bunch, sizes, video_bunch, vid_names, rom_memory_required, analysis_status, remaining, use_list_of_vid, is_landscape = po.prepare_video_writing(
+            po.data_list, po.vars['min_ram_free'], in_colors)
+        write_video_sets(po.data_list, sizes, vid_names, po.first_image.crop_coord,
+                         (po.top, po.bot, po.left, po.right), bunch_nb, video_nb_per_bunch,
+                         remaining, po.all["raw_images"], is_landscape, use_list_of_vid, in_colors, po.reduce_image_dim,
+                         pathway="")
     po.instantiate_tables()
     return po
 
-
-def run_one_video_analysis(po):
-    i=0
-    show_seg= False
-    # if os.path.isfile(f"coord_specimen{i + 1}_t720_y1475_x1477.npy"):
-    #     binary_coord = np.load(f"coord_specimen{i + 1}_t720_y1475_x1477.npy")
-    #     l = [i, i + 1, po.vars, False, False, show_seg, None]
-    #     MA = MotionAnalysis(l)
-    #     MA.binary = np.zeros((720, 1475, 1477), dtype=np.uint8)
-    #     MA.binary[binary_coord[0, :], binary_coord[1, :], binary_coord[2, :]] = 1
-    # else:
-    l = [i, i + 1, po.vars, True, False, show_seg, None]
-    MA = MotionAnalysis(l)
-    MA.get_descriptors_from_binary()
-    MA.detect_growth_transitions()
-    MA.networks_detection(show_seg)
-    MA.study_cytoscillations(show_seg)
-    return MA
-
-
 def run_all_arenas(po):
     po.instantiate_tables()
     for i, arena in enumerate(po.vars['analyzed_individuals']):
@@ -128,27 +141,18 @@ def run_all_arenas(po):
     cv2.imwrite(f"Analysis efficiency, {np.ceil(po.vars['img_number'] / 10).astype(np.uint64)}th image.jpg",
         po.first_image.bgr)
 
+def detect_network_in_one_image(im_path, save_path):
+    im = readim(im_path)
+    im = im[100:870, 200:1000]
+    greyscale_image = im.mean(axis=2)
+    net = NetworkDetection(greyscale_image, add_rolling_window=True)
+    net.get_best_network_detection_method()
+    display_network_methods(net, save_path)
+
 
 
 if __name__ == "__main__":
-    po = load_one_folder(Path("/data/experiment"), 1)
+    po = load_data(pathway=os.getcwd() + "/data/experiment", sample_number=1, extension='tif')
     po = run_image_analysis(po)
     po = write_videos(po)
-    # MA = run_one_video_analysis(po)
     run_all_arenas(po)
-
-    # MA.one_row_per_frame.to_csv(
-    #     "/Users/Directory/Scripts/python/Cellects/tests/data/experiment/motion_analysis_thresh.csv")
-
-    # path = Path("/Users/Directory/Scripts/python/Cellects/tests/data/experiment")
-    # po.load_variable_dict()
-    # run_image_analysis(po)
-    # os.chdir(path)
-    # from glob import glob
-    # from cellects.utils.load_display_save import readim
-    # im_names = np.sort(glob("*.JPG"))
-    # for i, im_name in enumerate(im_names): #  im_name = im_names[-1]
-    #     im = readim(im_name)
-    #     cv2.imwrite(f"image{i + 1}.tif", im[2925:3170, 1200:1500, :])
-    #
-    #     show(im[2925:3170,1200:1500, :])