small-fish-gui 1.3.4__tar.gz → 1.4.0__tar.gz

{small_fish_gui-1.3.4 → small_fish_gui-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: small_fish_gui
-Version: 1.3.4
+Version: 1.4.0
 Summary: Small Fish is a python application for the analysis of smFish images. It provides a ready to use graphical interface to combine famous python packages for cell analysis without any need for coding.
 Project-URL: Homepage, https://github.com/2Echoes/small_fish
 Project-URL: Issues, https://github.com/2Echoes/small_fish/issues

{small_fish_gui-1.3.4 → small_fish_gui-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "small_fish_gui"
-version = "1.3.4"
+version = "1.4.0"
 authors = [
   { name="Slimani Floric", email="floric.slimani@live.com" },
 ]

{small_fish_gui-1.3.4 → small_fish_gui-1.4.0}/src/small_fish_gui/__init__.py

@@ -38,4 +38,4 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 """
-__version__ = "1.3.4"
+__version__ = "1.4.0"

small_fish_gui-1.4.0/src/small_fish_gui/batch/__init__.py

@@ -0,0 +1,5 @@
+""""
+Module handling all batch processing interface; organised output and call to pipeline
+"""
+
+from .prompt import batch_promp

small_fish_gui-1.4.0/src/small_fish_gui/batch/input.py

@@ -0,0 +1,62 @@
+"""
+Submodule handling handling files and filenames in batch mode.
+"""
+
+import os
+import bigfish.stack as stack
+import czifile as czi
+import numpy as np
+from .integrity import check_file
+
+def open_image(filename:str) :
+
+    if filename.endswith('.czi') :
+        image = czi.imread(filename)
+    else :
+        image = stack.read_image(filename)
+
+    image = np.squeeze(image)
+
+    return image
+
+def get_images(filename:str) :
+    """returns filename if is image else return None"""
+
+    supported_types = ('.tiff', '.tif', '.png', '.czi')
+    if filename.endswith(supported_types) : 
+        return [filename]
+    else :
+        return None
+
+def get_files(path) :
+
+    filelist = os.listdir(path)
+    filelist = list(map(get_images,filelist))
+
+    while None in filelist : filelist.remove(None)
+
+    return filelist
+
+def extract_files(filenames: list) :
+    return sum(filenames,[])
+
+def load(
+        batch_folder:str,
+) :
+    if not os.path.isdir(batch_folder) :
+        print("Can't open {0}".format(batch_folder))
+        files_values = [[]]
+        last_shape = None
+        dim_number = 0
+    else :
+        files_values = get_files(batch_folder)
+        if len(files_values) == 0 :
+            last_shape = None
+            dim_number = 0
+        else :
+            first_filename = files_values[0][0]
+            last_shape = check_file(batch_folder + '/' + first_filename)
+            dim_number = len(last_shape)
+
+    
+    return files_values, last_shape, dim_number

small_fish_gui-1.4.0/src/small_fish_gui/batch/integrity.py

@@ -0,0 +1,158 @@
+"""
+Submodule handling all parameters check, asserting functions and pipeline will be able to run.
+"""
+
+import os
+import czifile as czi
+import bigfish.stack as stack
+import numpy as np
+import PySimpleGUI as sg
+
+from ..pipeline._preprocess import check_integrity, convert_parameters_types, ParameterInputError, _check_segmentation_parameters
+from ..pipeline._segmentation import _cast_segmentation_parameters
+
+def check_file(filename:str) :
+
+    if filename.endswith('.czi') :
+        image = czi.imread(filename)
+    else :
+        image = stack.read_image(filename)
+
+    image = np.squeeze(image)
+
+    return image.shape
+
+def sanity_check(
+        filename_list: list, 
+        batch_folder : str,
+        window : sg.Window, 
+        progress_bar: sg.ProgressBar,
+        ) :
+    
+    filenumber = len(filename_list)
+    if filenumber == 0 :
+        print("No file to check")
+        progress_bar.update(current_count= 0, bar_color=('gray','gray'))
+        return None
+    else :
+        print("{0} files to check".format(filenumber))
+        progress_bar.update(current_count=0, max= filenumber)
+        ref_shape = check_file(batch_folder + '/' + filename_list[0])
+
+        print("Starting sanity check. This could take some time...")
+        for i, file in enumerate(filename_list) :
+            progress_bar.update(current_count= i+1, bar_color=('green','gray'))
+            shape = check_file(batch_folder + '/' + file)
+
+            if len(shape) != len(ref_shape) : #then dimension missmatch
+                print("Different number of dimensions found : {0}, {1}".format(len(ref_shape), len(shape)))
+                progress_bar.update(current_count=filenumber, bar_color=('red','black'))
+                window= window.refresh()
+                break
+
+            window= window.refresh()
+
+        print("Sanity check completed.")
+        return None if len(shape) != len(ref_shape) else shape
+
+def check_channel_map_integrity(
+        maping:dict, 
+        shape: tuple,
+        expected_dim : int
+        ) :
+    
+    #Check integrity
+    channels_values = np.array(list(maping.values()), dtype= int)
+    total_channels = len(maping)
+    unique_channel = len(np.unique(channels_values))
+    res= True
+
+    if expected_dim != total_channels :
+        sg.popup("Image has {0} dimensions but {1} were mapped.".format(expected_dim, total_channels))
+        res = False
+    if total_channels != unique_channel :
+        sg.popup("{0} channel(s) are not uniquely mapped.".format(total_channels - unique_channel))
+        res = False
+    if not all(channels_values < len(shape)):
+        sg.popup("Channels values out of range for image dimensions.\nPlease select dimensions from {0}".format(list(range(len(shape)))))
+        res = False
+
+    return res
+
+def check_segmentation_parameters(
+        values,
+        shape,
+        is_multichannel,
+) :
+    values = _cast_segmentation_parameters(values=values)
+    try :
+        _check_segmentation_parameters(
+            user_parameters=values,
+            shape=shape,
+            is_multichannel=is_multichannel
+        )
+    except ParameterInputError as e: 
+        segmentation_is_ok = False
+        sg.popup_error(e)
+    else :
+        segmentation_is_ok = True
+    
+    return segmentation_is_ok, values
+
+def check_detection_parameters(
+        values,
+        do_dense_region_deconvolution,
+        do_clustering,
+        is_multichannel,
+        is_3D,
+        map,
+        shape
+) :
+    
+    values['dim'] = 3 if is_3D else 2
+    values = convert_parameters_types(values)
+    try :
+        check_integrity(
+            values=values,
+            do_dense_region_deconvolution=do_dense_region_deconvolution,
+            do_clustering=do_clustering,
+            multichannel=is_multichannel,
+            segmentation_done=None,
+            map=map,
+            shape=shape
+        )
+    except ParameterInputError as e: 
+        detection_is_ok = False
+        sg.popup_error(e)
+    else :
+        detection_is_ok = True
+    
+    return detection_is_ok, values
+
+def check_output_parameters(values) :
+    is_output_ok = True
+
+    #Output folder
+    output_folder = values.get('output_folder')
+    if not os.path.isdir(output_folder) :
+        sg.popup("Incorrect output folder selected")
+        is_output_ok=False
+
+    #Batch name
+    original_name = values['batch_name']
+    loop=1
+    values['batch_name'] = values['batch_name'].replace(' ','_')
+    while os.path.isdir(output_folder + '/' + values['batch_name']) :
+        values['batch_name'] = original_name + '_{0}'.format(loop)
+        loop+=1
+    if len(values['batch_name']) == 0 : is_output_ok = False
+
+    #extension
+    if values['csv'] or values['xlsx'] or values['feather'] :
+        pass
+    else :
+        sg.popup("Select at least one data format for output.")
+        is_output_ok=False
+
+
+    return is_output_ok, values

small_fish_gui-1.4.0/src/small_fish_gui/batch/pipeline.py

@@ -0,0 +1,218 @@
+"""
+Submodule keeping necessary calls from main pipeline for batch processing.
+"""
+
+import os
+import pandas as pd
+import PySimpleGUI as sg
+
+from .input import open_image
+from ..interface import write_results
+from ..pipeline import reorder_shape, reorder_image_stack, prepare_image_detection
+from ..pipeline import cell_segmentation, launch_detection, launch_features_computation
+from ..pipeline import launch_spots_extraction
+from ..pipeline import get_nucleus_signal
+from ..pipeline import _cast_segmentation_parameters, convert_parameters_types
+from ..pipeline import plot_segmentation, output_spot_tiffvisual
+from ..utils import get_datetime
+
+def window_print(window: sg.Window, *args) :
+    print(*args)
+    window.refresh()
+
+def batch_pipeline(
+        batch_window : sg.Window,
+        batch_progress_bar : sg.ProgressBar,
+        progress_count : sg.Text,
+        parameters : dict,
+        filenames_list : list,
+        do_segmentation : bool,
+        map : dict,
+        results_df : pd.DataFrame,
+        cell_results_df : pd.DataFrame,
+        is_3D,
+        last_acquisition_id=0,
+) :
+    
+    #Extracting parameters
+    input_path = parameters['Batch_folder']
+    output_path = parameters['output_folder']
+    batch_name = parameters['batch_name']
+    time = '_' + get_datetime()
+
+    #Preparing folder
+    window_print(batch_window,"Creating folders for output...")
+    main_dir = output_path + "/" + batch_name + time + "/"
+    os.makedirs(main_dir + "results/", exist_ok=True)
+    if parameters['save segmentation'] : os.makedirs(main_dir + "segmentation/", exist_ok=True)
+    if parameters['save detection'] : os.makedirs(main_dir + "detection/", exist_ok=True)
+    if parameters['extract spots'] : os.makedirs(main_dir + "results/spots_extraction", exist_ok=True)
+
+    #Setting spot detection dimension
+    parameters['dim'] = 3 if is_3D else 2
+
+    #Pipeline loop
+    window_print(batch_window,"Launching batch analysis...")
+    batch_progress_bar.update(max=len(filenames_list))
+    filenames_list.sort()
+    for acquisition_id, file in enumerate(filenames_list) :
+        
+        #GUI
+        window_print(batch_window,"\nNext file : {0}".format(file))
+        batch_progress_bar.update(current_count= acquisition_id, max= len(filenames_list))
+        progress_count.update(value=str(acquisition_id))
+        batch_window = batch_window.refresh()
+        
+        #0. Open image
+        image = open_image(input_path + '/' + file)
+        parameters['image'] = image
+        parameters['filename'] = file
+        for key_to_clean in [0,2] : 
+            if key_to_clean in parameters : del parameters[key_to_clean]
+
+        #1. Re-order shape
+        shape = image.shape
+        parameters['shape'] = shape
+        parameters['reordered_shape'] = reorder_shape(shape, map=map)
+
+        #2. Segmentation (opt)
+        if do_segmentation :
+            window_print(batch_window,"Segmenting cells...")
+            im_seg = reorder_image_stack(map, parameters)
+            parameters = _cast_segmentation_parameters(parameters)
+            cytoplasm_label, nucleus_label = cell_segmentation(
+                im_seg,
+                cyto_model_name= parameters['cyto_model_name'],
+                cyto_diameter= parameters['cytoplasm diameter'],
+                nucleus_model_name= parameters['nucleus_model_name'],
+                nucleus_diameter= parameters['nucleus diameter'],
+                channels=[parameters['cytoplasm channel'], parameters['nucleus channel']],
+                do_only_nuc=parameters['Segment only nuclei']
+                )
+            
+            if cytoplasm_label.max() == 0 : #No cell segmented
+                window_print(batch_window,"No cell was segmented, computing next image.")
+                continue
+            else : 
+                window_print(batch_window, "{0} cells segmented.".format(cytoplasm_label.max()))
+
+                if parameters['save segmentation'] :
+                    plot_segmentation(
+                        cyto_image=im_seg[parameters['cytoplasm channel']],
+                        cyto_label= cytoplasm_label,
+                        nuc_image= im_seg[parameters['nucleus channel']],
+                        nuc_label=nucleus_label,
+                        path= main_dir + "segmentation/" + file,
+                        do_only_nuc= parameters['Segment only nuclei'],
+                    )
+
+        else :
+            cytoplasm_label, nucleus_label = None,None
+
+        #3. Detection, deconvolution, clusterisation
+        window_print(batch_window,"Detecting spots...")
+        parameters = convert_parameters_types(parameters)
+        image, other_image = prepare_image_detection(map, parameters) 
+        nucleus_signal = get_nucleus_signal(image, other_image, parameters)
+        try : # Catch error raised if user enter a spot size too small compare to voxel size
+            parameters, frame_result, spots, clusters = launch_detection(
+                image,
+                other_image,
+                parameters,
+                cell_label=cytoplasm_label,
+                nucleus_label=nucleus_label,
+                hide_loading=True,
+            )
+
+        except ValueError as error :
+            if "The array should have an upper bound of 1" in str(error) :
+                window_print(batch_window,"Spot size too small for current voxel size.")
+                continue
+            else :
+                raise(error)
+        
+        if parameters['save detection'] :
+            if parameters['Cluster computation'] : spots_list = [spots, clusters[:,:parameters['dim']]]
+            else : spots_list = [spots]
+            output_spot_tiffvisual(
+                image,
+                spots_list= spots_list,
+                dot_size=2,
+                path_output= main_dir + "detection/" + file + "_spot_detection.tiff"
+            )
+
+        #4. Spots extraction
+        window_print(batch_window,"Extracting spots : ")
+        if parameters['extract spots'] :
+
+            #Setting parameter for call to lauch spot extraction
+            #Only spots have one file per image to avoir memory overload
+            parameters['do_spots_excel'] = parameters['xlsx']
+            parameters['do_spots_csv'] = parameters['csv']
+            parameters['do_spots_feather'] = parameters['feather']
+            parameters['spots_filename'] = "spots_extractions_{0}".format(file)
+            parameters['spots_extraction_folder'] = main_dir + "results/spots_extraction/"
+
+            launch_spots_extraction(
+                    acquisition_id=acquisition_id + last_acquisition_id,
+                    user_parameters=parameters,
+                    image=image,
+                    spots=spots,
+                    nucleus_label= nucleus_label,
+                    cell_label= cytoplasm_label,
+                )
+
+        #5. Features computation
+        window_print(batch_window,"computing features...")
+        new_results_df, new_cell_results_df = launch_features_computation(
+        acquisition_id=acquisition_id + last_acquisition_id,
+        image=image,
+        nucleus_signal = nucleus_signal,
+        spots=spots,
+        clusters=clusters,
+        nucleus_label = nucleus_label,
+        cell_label= cytoplasm_label,
+        user_parameters=parameters,
+        frame_results=frame_result,
+        )
+
+        results_df = pd.concat([
+            results_df.reset_index(drop=True), new_results_df.reset_index(drop=True)
+        ], axis=0)
+
+        cell_results_df = pd.concat([
+            cell_results_df.reset_index(drop=True), new_cell_results_df.reset_index(drop=True)
+        ], axis=0)
+
+
+        #6. Saving results
+        window_print(batch_window,"saving image_results...")
+        #1 file per batch + 1 file per batch if segmentation
+        acquisition_success = write_results(
+            results_df, 
+            path= main_dir + "results/", 
+            filename=batch_name, 
+            do_excel= parameters["xlsx"], 
+            do_feather= parameters["feather"], 
+            do_csv= parameters["csv"],
+            overwrite=True,
+            )
+        
+        if do_segmentation :
+            cell_success = write_results(
+                cell_results_df, 
+                path= main_dir + "results/", 
+                filename=batch_name + '_cell_result', 
+                do_excel= parameters["xlsx"], 
+                do_feather= parameters["feather"], 
+                do_csv= parameters["csv"],
+                overwrite=True,
+                )
+        
+        window_print(batch_window,"Sucessfully saved.")
+
+        
+    batch_progress_bar.update(current_count= acquisition_id+1, max= len(filenames_list))
+    progress_count.update(value=str(acquisition_id+1))
+    batch_window = batch_window.refresh()
+    return results_df, cell_results_df, acquisition_id