spacr 0.2.53__py3-none-any.whl → 0.2.56__py3-none-any.whl

spacr/gui_core.py

@@ -15,7 +15,7 @@ try:
 except AttributeError:
     pass
 
-from .settings import set_default_train_test_model, get_measure_crop_settings, set_default_settings_preprocess_generate_masks, get_analyze_reads_default_settings, set_default_umap_image_settings
+from .settings import set_default_train_test_model, get_measure_crop_settings, set_default_settings_preprocess_generate_masks, set_default_generate_barecode_mapping, set_default_umap_image_settings
 from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style
 
 # Define global variables
@@ -122,7 +122,7 @@ def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var,
 def import_settings(settings_type='mask'):
     from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
     global vars_dict, scrollable_frame, button_scrollable_frame
-    from .settings import generate_fields
+    from .settings import generate_fields, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model, set_default_generate_barecode_mapping, set_default_umap_image_settings
 
     def read_settings_from_csv(csv_file_path):
         settings = {}
@@ -158,7 +158,7 @@ def import_settings(settings_type='mask'):
     elif settings_type == 'classify':
         settings = set_default_train_test_model(settings={})
     elif settings_type == 'sequencing':
-        settings = get_analyze_reads_default_settings(settings={})
+        settings = set_default_generate_barecode_mapping(settings={})
     elif settings_type == 'umap':
         settings = set_default_umap_image_settings(settings={})
     else:
@@ -171,7 +171,7 @@ def import_settings(settings_type='mask'):
 
 def setup_settings_panel(vertical_container, settings_type='mask'):
     global vars_dict, scrollable_frame
-    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model, get_analyze_reads_default_settings, set_default_umap_image_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
     from .gui_utils import convert_settings_dict_for_gui
     from .gui_elements import set_element_size
 
@@ -197,9 +197,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'measure':
         settings = get_measure_crop_settings(settings={})
     elif settings_type == 'classify':
-        settings = set_default_train_test_model(settings={})
-    elif settings_type == 'sequencing':
-        settings = get_analyze_reads_default_settings(settings={})
+        settings = deep_spacr_defaults(settings={})
     elif settings_type == 'umap':
         settings = set_default_umap_image_settings(settings={})
     elif settings_type == 'train_cellpose':
@@ -211,7 +209,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'cellpose_all':
         settings = get_check_cellpose_models_default_settings(settings={})
     elif settings_type == 'map_barcodes':
-        settings = get_map_barcodes_default_settings(settings={})
+        settings = set_default_generate_barecode_mapping(settings={})
     elif settings_type == 'regression':
         settings = get_perform_regression_default_settings(settings={})
     elif settings_type == 'recruitment':
@@ -350,7 +348,7 @@ def setup_button_section(horizontal_container, settings_type='mask', run=True, a
         widgets.append(run_button)
         btn_col += 1
 
-    if abort and settings_type in ['mask', 'measure', 'classify', 'sequencing', 'umap']:
+    if abort and settings_type in ['mask', 'measure', 'classify', 'sequencing', 'umap', 'map_barcodes']:
         abort_button = spacrButton(button_scrollable_frame.scrollable_frame, text="abort", command=lambda: initiate_abort(), show_text=False, size=size_dict['btn_size'], animation=False)
         abort_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
         widgets.append(abort_button)
@@ -551,7 +549,7 @@ def start_process(q=None, fig_queue=None, settings_type='mask'):
 
     process_args = (settings_type, settings, q, fig_queue, stop_requested)
     if settings_type in [
-        'mask', 'measure', 'simulation', 'sequencing', 'classify', 'cellpose_dataset', 
+        'mask', 'umap', 'measure', 'simulation', 'sequencing', 'classify', 'cellpose_dataset', 
         'train_cellpose', 'ml_analyze', 'cellpose_masks', 'cellpose_all', 'map_barcodes', 
         'regression', 'recruitment', 'plaques', 'cellpose_compare', 'vision_scores', 
         'vision_dataset'

spacr/gui_elements.py

@@ -603,6 +603,76 @@ class spacrCheckbutton(ttk.Checkbutton):
         _ = set_dark_style(style, widgets=[self])
 
 class spacrProgressBar(ttk.Progressbar):
+    def __init__(self, parent, label=True, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+
+        # Get the style colors
+        style_out = set_dark_style(ttk.Style())
+
+        self.fg_color = style_out['fg_color']
+        self.bg_color = style_out['bg_color']
+        self.active_color = style_out['active_color']
+        self.inactive_color = style_out['inactive_color']
+
+        # Configure the style for the progress bar
+        self.style = ttk.Style()
+        self.style.configure(
+            "spacr.Horizontal.TProgressbar",
+            troughcolor=self.bg_color,
+            background=self.active_color,
+            thickness=20,
+            troughrelief='flat',
+            borderwidth=0
+        )
+        self.configure(style="spacr.Horizontal.TProgressbar")
+
+        # Set initial value to 0
+        self['value'] = 0
+
+        # Track whether to show the progress label
+        self.label = label
+
+        # Create the progress label with text wrapping
+        if self.label:
+            self.progress_label = tk.Label(
+                parent,
+                text="Processing: 0/0",
+                anchor='w',
+                justify='left',
+                bg=self.inactive_color,
+                fg=self.fg_color,
+                wraplength=300  # Adjust the wraplength as needed
+            )
+            self.progress_label.grid_forget()  # Temporarily hide it
+
+        # Initialize attributes for time and operation
+        self.operation_type = None
+        self.time_image = None
+        self.time_batch = None
+        self.time_left = None
+
+    def set_label_position(self):
+        if self.label and self.progress_label:
+            row_info = self.grid_info().get('row', 0)
+            col_info = self.grid_info().get('column', 0)
+            col_span = self.grid_info().get('columnspan', 1)
+            self.progress_label.grid(row=row_info + 1, column=col_info, columnspan=col_span, pady=5, padx=5, sticky='ew')
+
+    def update_label(self):
+        if self.label and self.progress_label:
+            # Update the progress label with current progress and additional info
+            label_text = f"Processing: {self['value']}/{self['maximum']}"
+            if self.operation_type:
+                label_text += f", {self.operation_type}"
+            if self.time_image:
+                label_text += f", Time/image: {self.time_image:.3f} sec"
+            if self.time_batch:
+                label_text += f", Time/batch: {self.time_batch:.3f} sec"
+            if self.time_left:
+                label_text += f", Time_left: {self.time_left:.3f} min"
+            self.progress_label.config(text=label_text)
+
+class spacrProgressBar_v1(ttk.Progressbar):
     def __init__(self, parent, label=True, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
 

spacr/gui_utils.py

@@ -44,7 +44,7 @@ def load_app(root, app_name, app_func):
     else:
         proceed_with_app(root, app_name, app_func)
     
-def parse_list(value):
+def parse_list_v1(value):
     try:
         parsed_value = ast.literal_eval(value)
         if isinstance(parsed_value, list):
@@ -54,6 +54,22 @@ def parse_list(value):
     except (ValueError, SyntaxError) as e:
         raise ValueError(f"Invalid format for list: {value}. Error: {e}")
     
+def parse_list(value):
+    try:
+        parsed_value = ast.literal_eval(value)
+        if isinstance(parsed_value, list):
+            # Check if the list elements are homogeneous (all int or all str)
+            if all(isinstance(item, int) for item in parsed_value):
+                return parsed_value
+            elif all(isinstance(item, str) for item in parsed_value):
+                return parsed_value
+            else:
+                raise ValueError("List contains mixed types or unsupported types")
+        else:
+            raise ValueError(f"Expected a list but got {type(parsed_value).__name__}")
+    except (ValueError, SyntaxError) as e:
+        raise ValueError(f"Invalid format for list: {value}. Error: {e}")
+
 # Usage example in your create_input_field function
 def create_input_field(frame, label_text, row, var_type='entry', options=None, default_value=None):
     from .gui_elements import set_dark_style, set_element_size
@@ -323,7 +339,9 @@ def convert_settings_dict_for_gui(settings):
     special_cases = {
         'metadata_type': ('combo', ['cellvoyager', 'cq1', 'nikon', 'zeis', 'custom'], 'cellvoyager'),
         'channels': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'train_channels': ('combo', ["['r','g','b']", "['r','g']", "['r','b']", "['g','b']", "['r']", "['g']", "['b']"], "['r','g','b']"),
         'channel_dims': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'annotate'),
         'cell_mask_dim': ('combo', chans, None),
         'cell_chann_dim': ('combo', chans, None),
         'nucleus_mask_dim': ('combo', chans, None),
@@ -369,6 +387,7 @@ def convert_settings_dict_for_gui(settings):
             variables[key] = ('entry', None, str(value))
         else:
             variables[key] = ('entry', None, str(value))
+    
     return variables
 
 
@@ -413,13 +432,14 @@ def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imp
         plt.show = original_show
 
 def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
+    
     from .gui_utils import process_stdout_stderr
-    from .core import preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, compare_cellpose_masks, analyze_plaques, generate_dataset, apply_model_to_tar
+    from .core import generate_image_umap, preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, compare_cellpose_masks, analyze_plaques, generate_dataset, apply_model_to_tar
     from .io import generate_cellpose_train_test
     from .measure import measure_crop
     from .sim import run_multiple_simulations
-    from .deep_spacr import train_test_model
-    from .sequencing import analyze_reads, map_barcodes_folder, perform_regression
+    from .deep_spacr import deep_spacr
+    from .sequencing import generate_barecode_mapping, perform_regression
     process_stdout_stderr(q)
 
     print(f'run_function_gui settings_type: {settings_type}') 
@@ -433,12 +453,9 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     elif settings_type == 'simulation':
         function = run_multiple_simulations
         imports = 1
-    elif settings_type == 'sequencing':
-        function = analyze_reads
-        imports = 1
     elif settings_type == 'classify':
-        function = train_test_model
-        imports = 2
+        function = deep_spacr
+        imports = 1
     elif settings_type == 'train_cellpose':
         function = train_cellpose
         imports = 1
@@ -452,7 +469,7 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
         function = check_cellpose_models
         imports = 1
     elif settings_type == 'map_barcodes':
-        function = map_barcodes_folder
+        function = generate_barecode_mapping
         imports = 1
     elif settings_type == 'regression':
         function = perform_regression
@@ -460,6 +477,9 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     elif settings_type == 'recruitment':
         function = analyze_recruitment
         imports = 2
+    elif settings_type == 'umap':
+        function = generate_image_umap
+        imports = 1
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     try:

spacr/io.py

@@ -2293,15 +2293,23 @@ def _save_model(model, model_type, results_df, dst, epoch, epochs, intermedeate_
     def save_model_at_threshold(threshold, epoch, suffix=""):
         percentile = str(threshold * 100)
         print(f'\rfound: {percentile}% accurate model')#, end='\r', flush=True)
-        torch.save(model, f'{dst}/{model_type}_epoch_{str(epoch)}{suffix}_acc_{percentile}_channels_{channels_str}.pth')
+        model_path = f'{dst}/{model_type}_epoch_{str(epoch)}{suffix}_acc_{percentile}_channels_{channels_str}.pth'
+        torch.save(model, model_path)
+        return model_path
 
     if epoch % 100 == 0 or epoch == epochs:
-        torch.save(model, f'{dst}/{model_type}_epoch_{str(epoch)}_channels_{channels_str}.pth')
+        model_path = f'{dst}/{model_type}_epoch_{str(epoch)}_channels_{channels_str}.pth'
+        torch.save(model, model_path)
+        return model_path
 
     for threshold in intermedeate_save:
         if results_df['neg_accuracy'].dropna().mean() >= threshold and results_df['pos_accuracy'].dropna().mean() >= threshold:
-            save_model_at_threshold(threshold, epoch)
-            break  # Ensure we only save for the highest matching threshold
+            model_path = save_model_at_threshold(threshold, epoch)
+            break
+        else:
+            model_path = None
+    
+    return model_path
 
 def _save_progress(dst, results_df, train_metrics_df, epoch, epochs):
     """