spacr 0.0.17__py3-none-any.whl → 0.0.20__py3-none-any.whl

spacr/gui_sim_app.py

@@ -1,213 +0,0 @@
-import sys, ctypes, csv, matplotlib, traceback
-import tkinter as tk
-from tkinter import ttk, scrolledtext
-from ttkthemes import ThemedTk
-from matplotlib.figure import Figure
-from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
-from matplotlib.figure import Figure
-matplotlib.use('Agg')
-from tkinter import filedialog
-from multiprocessing import Process, Queue, Value
-
-try:
-    ctypes.windll.shcore.SetProcessDpiAwareness(True)
-except AttributeError:
-    pass
-
-from .logger import log_function_call
-
-from .gui_utils import ScrollableFrame, StdoutRedirector
-from .gui_utils import create_dark_mode, set_dark_style, set_default_font, generate_fields, process_stdout_stderr, safe_literal_eval, clear_canvas, main_thread_update_function
-from .gui_utils import sim_variables, check_sim_gui_settings, run_multiple_simulations_wrapper
-
-thread_control = {"run_thread": None, "stop_requested": False}
-
-@log_function_call
-def run_sim_gui(q, fig_queue, stop_requested):
-    global vars_dict
-    process_stdout_stderr(q)
-    try:
-        settings = check_sim_gui_settings(vars_dict)
-        for key in settings:
-            value = settings[key]
-            print(key, value, type(value))
-        run_multiple_simulations_wrapper(settings, q, fig_queue)
-    except Exception as e:
-        q.put(f"Error during processing: {e}")
-        traceback.print_exc()
-    finally:
-        stop_requested.value = 1
-
-@log_function_call
-def start_process(q, fig_queue):
-    global thread_control
-    if thread_control.get("run_thread") is not None:
-        initiate_abort()
-
-    stop_requested = Value('i', 0)  # multiprocessing shared value for inter-process communication
-    thread_control["stop_requested"] = stop_requested
-    thread_control["run_thread"] = Process(target=run_sim_gui, args=(q, fig_queue, stop_requested))
-    thread_control["run_thread"].start()
-
-@log_function_call
-def initiate_abort():
-    global thread_control
-    if thread_control.get("stop_requested") is not None:
-        thread_control["stop_requested"].value = 1
-
-    if thread_control.get("run_thread") is not None:
-        thread_control["run_thread"].join(timeout=5)
-        if thread_control["run_thread"].is_alive():
-            thread_control["run_thread"].terminate()
-        thread_control["run_thread"] = None
-
-def import_settings(scrollable_frame):
-    global vars_dict, original_variables_structure
-
-    csv_file_path = filedialog.askopenfilename(filetypes=[("CSV files", "*.csv")])
-    
-    if not csv_file_path:
-        return
-    
-    imported_variables = {}
-
-    with open(csv_file_path, newline='') as csvfile:
-        reader = csv.DictReader(csvfile)
-        for row in reader:
-            key = row['Key']
-            value = row['Value']
-            # Evaluate the value safely using safe_literal_eval
-            imported_variables[key] = safe_literal_eval(value)
-
-    # Track changed variables and apply the imported ones, printing changes as we go
-    for key, var in vars_dict.items():
-        if key in imported_variables and var.get() != imported_variables[key]:
-            print(f"Updating '{key}' from '{var.get()}' to '{imported_variables[key]}'")
-            var.set(imported_variables[key])
-    
-@log_function_call
-def initiate_sim_root(width, height):
-    global root, vars_dict, q, canvas, fig_queue, canvas_widget, thread_control
-        
-    theme = 'breeze'
-    
-    if theme in ['clam']:
-        root = tk.Tk()
-        style = ttk.Style(root)
-        style.theme_use(theme) #plastik, clearlooks, elegance, default was clam #alt, breeze, arc
-        set_dark_style(style)
-    elif theme in ['breeze']:
-        root = ThemedTk(theme="breeze")
-        style = ttk.Style(root)
-        set_dark_style(style)
-        
-    set_default_font(root, font_name="Arial", size=10)
-    #root.state('zoomed')  # For Windows to maximize the window
-    root.attributes('-fullscreen', True)
-    root.geometry(f"{width}x{height}")
-    root.title("SpaCer: Simulate screen")
-    fig_queue = Queue()
-            
-    def _process_fig_queue():
-        global canvas
-        try:
-            while not fig_queue.empty():
-                clear_canvas(canvas)
-                fig = fig_queue.get_nowait()
-                #set_fig_text_properties(fig, font_size=8)
-                for ax in fig.get_axes():
-                    ax.set_xticks([])  # Remove x-axis ticks
-                    ax.set_yticks([])  # Remove y-axis ticks
-                    ax.xaxis.set_visible(False)  # Hide the x-axis
-                    ax.yaxis.set_visible(False)  # Hide the y-axis
-                    #ax.title.set_fontsize(14) 
-                #disable_interactivity(fig)
-                fig.tight_layout()
-                fig.set_facecolor('#333333')
-                canvas.figure = fig
-                fig_width, fig_height = canvas_widget.winfo_width(), canvas_widget.winfo_height()
-                fig.set_size_inches(fig_width / fig.dpi, fig_height / fig.dpi, forward=True)
-                canvas.draw_idle() 
-        except Exception as e:
-            traceback.print_exc()
-            #pass
-        finally:
-            canvas_widget.after(100, _process_fig_queue)
-            
-    # Process queue for console output
-    def _process_console_queue():
-        while not q.empty():
-            message = q.get_nowait()
-            console_output.insert(tk.END, message)
-            console_output.see(tk.END)
-        console_output.after(100, _process_console_queue)
-        
-    # Vertical container for settings and console
-    vertical_container = tk.PanedWindow(root, orient=tk.HORIZONTAL) #VERTICAL
-    vertical_container.pack(fill=tk.BOTH, expand=True)
-
-    # Scrollable Frame for user settings
-    scrollable_frame = ScrollableFrame(vertical_container, bg='#333333')
-    vertical_container.add(scrollable_frame, stretch="always")
-
-    # Setup for user input fields (variables)
-    variables = sim_variables()
-    vars_dict = generate_fields(variables, scrollable_frame)
-    
-    # Horizontal container for Matplotlib figure and the vertical pane (for settings and console)
-    horizontal_container = tk.PanedWindow(vertical_container, orient=tk.VERTICAL) #HORIZONTAL
-    vertical_container.add(horizontal_container, stretch="always")
-
-    # Matplotlib figure setup
-    figure = Figure(figsize=(30, 4), dpi=100, facecolor='#333333')
-    plot = figure.add_subplot(111)
-    plot.plot([], [])  # This creates an empty plot.
-    plot.axis('off')
-
-    # Embedding the Matplotlib figure in the Tkinter window
-    canvas = FigureCanvasTkAgg(figure, master=horizontal_container)
-    canvas.get_tk_widget().configure(cursor='arrow', background='#333333', highlightthickness=0)
-    #canvas.get_tk_widget().configure(cursor='arrow')
-    canvas_widget = canvas.get_tk_widget()
-    horizontal_container.add(canvas_widget, stretch="always")
-    canvas.draw()
-    canvas.figure = figure
-
-    # Console output setup below the settings
-    console_output = scrolledtext.ScrolledText(vertical_container, height=10)
-    vertical_container.add(console_output, stretch="always")
-
-    # Queue and redirection setup for updating console output safely
-    q = Queue()
-    sys.stdout = StdoutRedirector(console_output)
-    sys.stderr = StdoutRedirector(console_output)
-    
-    # This is your GUI setup where you create the Run button
-    run_button = ttk.Button(scrollable_frame.scrollable_frame, text="Run",command=lambda: start_process(q, fig_queue))
-    run_button.grid(row=40, column=0, pady=10)
-    
-    abort_button = ttk.Button(scrollable_frame.scrollable_frame, text="Abort", command=initiate_abort)
-    abort_button.grid(row=40, column=1, pady=10)
-    
-    progress_label = ttk.Label(scrollable_frame.scrollable_frame, text="Processing: 0%", background="#333333", foreground="white")
-    progress_label.grid(row=41, column=0, columnspan=2, sticky="ew", pady=(5, 0))
-    
-    # Create the Import Settings button
-    import_btn = tk.Button(root, text="Import Settings", command=lambda: import_settings(scrollable_frame))
-    import_btn.pack(pady=20)
-    
-    _process_console_queue()
-    _process_fig_queue()
-    create_dark_mode(root, style, console_output)
-    
-    root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label))
-
-    return root, vars_dict
-
-def gui_sim():
-    global vars_dict, root
-    root, vars_dict = initiate_sim_root(1000, 1500)
-    root.mainloop()
-
-if __name__ == "__main__":
-    gui_sim()

spacr/gui_utils.py

@@ -1,6 +1,6 @@
-import spacr, inspect, traceback, io, sys, ast, ctypes, matplotlib
-matplotlib.use('Agg')
+import spacr, inspect, traceback, io, sys, ast, ctypes, matplotlib, re, csv
 import matplotlib.pyplot as plt
+matplotlib.use('Agg')
 import numpy as np
 import tkinter as tk
 from tkinter import ttk, messagebox
@@ -14,6 +14,26 @@ except AttributeError:
 
 from .logger import log_function_call
 
+def read_settings_from_csv(csv_file_path):
+    settings = {}
+    with open(csv_file_path, newline='') as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            key = row['Key']
+            value = row['Value']
+            settings[key] = value
+    return settings
+
+def update_settings_from_csv(variables, csv_settings):
+    new_settings = variables.copy()  # Start with a copy of the original settings
+    for key, value in csv_settings.items():
+        if key in new_settings:
+            # Get the variable type and options from the original settings
+            var_type, options, _ = new_settings[key]
+            # Update the default value with the CSV value, keeping the type and options unchanged
+            new_settings[key] = (var_type, options, value)
+    return new_settings
+
 def safe_literal_eval(value):
     try:
         # First, try to evaluate as a literal
@@ -103,62 +123,52 @@ def check_mask_gui_settings(vars_dict):
 def check_measure_gui_settings(vars_dict):
     settings = {}
     for key, var in vars_dict.items():
-        value = var.get()  # This retrieves the string representation for entries or the actual value for checkboxes and combos
+        value = var.get()  # Retrieves the string representation for entries or the actual value for checkboxes and combos.
 
         try:
-            if key == 'channels' or key == 'png_dims':
-                # Converts string representation to a list of integers
+            if key in ['channels', 'png_dims']:
                 settings[key] = [int(chan) for chan in ast.literal_eval(value)] if value else []
                 
             elif key in ['cell_loc', 'pathogen_loc', 'treatment_loc']:
-                settings[key] = ast.literal_eval(value) if value else None
-                
+                # Convert to a list of lists of strings, ensuring all structures are lists.
+                settings[key] = [list(map(str, sublist)) for sublist in ast.literal_eval(value)] if value else []
+
             elif key == 'dialate_png_ratios':
-                settings[key] = [float(num) for num in eval(value)] if value else None
+                settings[key] = [float(num) for num in ast.literal_eval(value)] if value else []
 
             elif key == 'normalize':
-                # Converts 'normalize' into a list of two integers
-                settings[key] = [int(num) for num in ast.literal_eval(value)] if value else None
+                settings[key] = [int(num) for num in ast.literal_eval(value)] if value else []
 
-            elif key == 'normalize_by':
-                # 'normalize_by' is a string, so directly assign the value
+            # Directly assign string values for these specific keys
+            elif key in ['normalize_by', 'experiment', 'measurement', 'input_folder']:
                 settings[key] = value
 
             elif key == 'png_size':
-                # Converts string representation into a list of lists of integers
-                temp_val = ast.literal_eval(value) if value else []
-                settings[key] = [list(map(int, dim)) for dim in temp_val] if temp_val else None
-
-            # Handling for other keys as in your original function...
+                settings[key] = [list(map(int, dim)) for dim in ast.literal_eval(value)] if value else []
             
-            elif key in ['pathogens', 'treatments', 'cells', 'crop_mode', 'timelapse_objects']:
-                # Ensuring these are evaluated correctly as lists or other structures
-                settings[key] = ast.literal_eval(value) if value else None
-
-            elif key == 'timelapse_objects':
-                # Ensure it's a list of strings
-                settings[key] = eval(value) if value else []
-
-            # Handling for keys that should be treated as strings directly
-            elif key in ['normalize_by', 'experiment', 'measurement', 'input_folder']:
-                settings[key] = str(value) if value else None
+            # Ensure these are lists of strings, converting from tuples if necessary
+            elif key in ['timelapse_objects', 'crop_mode', 'cells', 'pathogens', 'treatments']:
+                eval_value = ast.literal_eval(value) if value else []
+                settings[key] = list(map(str, eval_value)) if isinstance(eval_value, (list, tuple)) else [str(eval_value)]
 
-            # Handling for single values that are not strings (int, float, bool)
+            # Handling for single non-string values (int, float, bool)
             elif key in ['cell_mask_dim', 'cell_min_size', 'nucleus_mask_dim', 'nucleus_min_size', 'pathogen_mask_dim', 'pathogen_min_size', 'cytoplasm_min_size', 'max_workers', 'channel_of_interest', 'nr_imgs']:
                 settings[key] = int(value) if value else None
 
             elif key == 'um_per_pixel':
                 settings[key] = float(value) if value else None
 
-            # Direct handling of boolean values based on checkboxes
+            # Handling boolean values based on checkboxes
             elif key in ['save_png', 'use_bounding_box', 'save_measurements', 'plot', 'plot_filtration', 'include_uninfected', 'dialate_pngs', 'timelapse', 'representative_images']:
-                settings[key] = bool(value)
+                settings[key] = var.get()
 
         except SyntaxError as e:
-            messagebox.showerror("Error", f"Syntax error processing {key}: {str(e)}")
+            print(f"Syntax error processing {key}: {str(e)}")
+            #messagebox.showerror("Error", f"Syntax error processing {key}: {str(e)}")
             return None
         except Exception as e:
-            messagebox.showerror("Error", f"Error processing {key}: {str(e)}")
+            print(f"Error processing {key}: {str(e)}")
+            #messagebox.showerror("Error", f"Error processing {key}: {str(e)}")
             return None
 
     return settings
@@ -268,11 +278,21 @@ def sim_variables():
     }
     return variables
 
+def add_measure_gui_defaults(settings):
+    settings['compartments'] = ['pathogen', 'cytoplasm']
+    return settings
+
 def measure_variables():
     variables = {
         'input_folder':('entry', None, '/mnt/data/CellVoyager/40x/einar/mitotrackerHeLaToxoDsRed_20240224_123156/test_gui/merged'),
         'channels': ('combo', ['[0,1,2,3]','[0,1,2]','[0,1]','[0]'], '[0,1,2,3]'),
         'cell_mask_dim':('entry', None, 4),
+        'cell_min_size':('entry', None, 0),
+        'cytoplasm_min_size':('entry', None, 0),
+        'nucleus_mask_dim':('entry', None, 5),
+        'nucleus_min_size':('entry', None, 0),
+        'pathogen_mask_dim':('entry', None, 6),
+        'pathogen_min_size':('entry', None, 0),
         'save_png':('check', None, True),
         'crop_mode':('entry', None, '["cell"]'),
         'use_bounding_box':('check', None, True),
@@ -298,6 +318,7 @@ def measure_variables():
         'treatments': ('entry', None, '["cm","lovastatin_20uM"]'),
         'treatment_loc': ('entry', None, '[["c1","c2"], ["c3","c4"]]'),
         'channel_of_interest':('entry', None, 3),
+        'compartments':('entry', None, '["pathogen","cytoplasm"]'),
         'measurement':('entry', None, 'mean_intensity'),
         'nr_imgs':('entry', None, 32),
         'um_per_pixel':('entry', None, 0.1)
@@ -346,7 +367,7 @@ def classify_variables():
     return variables
     
 
-@log_function_call
+#@log_function_call
 def create_input_field(frame, label_text, row, var_type='entry', options=None, default_value=None):
     label = ttk.Label(frame, text=label_text, style='TLabel')  # Assuming you have a dark mode style for labels too
     label.grid(column=0, row=row, sticky=tk.W, padx=5, pady=5)
@@ -370,10 +391,6 @@ def create_input_field(frame, label_text, row, var_type='entry', options=None, d
         var = None  # Placeholder in case of an undefined var_type
     
     return var
-
-def add_measure_gui_defaults(settings):
-    settings['compartments'] = ['pathogen', 'cytoplasm']
-    return settings
     
 def mask_variables():
     variables = {
@@ -395,10 +412,10 @@ def mask_variables():
         'pathogen_background': ('entry', None, 100),
         'pathogen_Signal_to_noise': ('entry', None, 3),
         'pathogen_CP_prob': ('entry', None, 0),
-        #'preprocess': ('check', None, True),
-        #'masks': ('check', None, True),
-        #'examples_to_plot': ('entry', None, 1),
-        #'randomize': ('check', None, True),
+        'preprocess': ('check', None, True),
+        'masks': ('check', None, True),
+        'examples_to_plot': ('entry', None, 1),
+        'randomize': ('check', None, True),
         'batch_size': ('entry', None, 50),
         'timelapse': ('check', None, False),
         'timelapse_displacement': ('entry', None, None),
@@ -407,14 +424,14 @@ def mask_variables():
         'timelapse_remove_transient': ('check', None, True),
         'timelapse_mode': ('combo',  ['trackpy', 'btrack'], 'trackpy'),
         'timelapse_objects': ('combo', ['cell','nucleus','pathogen','cytoplasm', None], None),
-        #'fps': ('entry', None, 2),
-        #'remove_background': ('check', None, True),
+        'fps': ('entry', None, 2),
+        'remove_background': ('check', None, True),
         'lower_quantile': ('entry', None, 0.01),
-        #'merge': ('check', None, False),
-        #'normalize_plots': ('check', None, True),
-        #'all_to_mip': ('check', None, False),
-        #'pick_slice': ('check', None, False),
-        #'skip_mode': ('entry', None, None),
+        'merge': ('check', None, False),
+        'normalize_plots': ('check', None, True),
+        'all_to_mip': ('check', None, False),
+        'pick_slice': ('check', None, False),
+        'skip_mode': ('entry', None, None),
         'save': ('check', None, True),
         'plot': ('check', None, True),
         'workers': ('entry', None, 30),
@@ -482,30 +499,31 @@ def set_dark_style(style):
     style.configure('TEntry', background='#333333', foreground='white')
     style.configure('TCheckbutton', background='#333333', foreground='white')
 
-@log_function_call   
+#@log_function_call   
 def main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label):
     try:
+        ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
         while not q.empty():
             message = q.get_nowait()
-            if message.startswith("Progress"):
-                progress_label.config(text=message)
-            elif message.startswith("Processing"):
-                progress_label.config(text=message)
-            elif message == "" or message == "\r":
-                pass
-            elif message.startswith("/"):
+            clean_message = ansi_escape_pattern.sub('', message)
+            if clean_message.startswith("Progress"):
+                progress_label.config(text=clean_message)
+            if clean_message.startswith("\rProgress"):
+                progress_label.config(text=clean_message)
+            elif clean_message.startswith("Successfully"):
+                progress_label.config(text=clean_message)
+            elif clean_message.startswith("Processing"):
+                progress_label.config(text=clean_message)
+            elif clean_message.startswith("scale"):
                 pass
-            elif message.startswith("\\"):
+            elif clean_message.startswith("plot_cropped_arrays"):
                 pass
-            elif message.startswith(""):
+            elif clean_message == "" or clean_message == "\r" or clean_message.strip() == "":
                 pass
             else:
-                print(message)  # Or handle other messages differently
-        while not fig_queue.empty():
-            fig = fig_queue.get_nowait()
-            clear_canvas(canvas_widget)
+                print(clean_message)
     except Exception as e:
-        print(f"Error updating GUI: {e}")
+        print(f"Error updating GUI canvas: {e}")
     finally:
         root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label))
 
@@ -538,7 +556,6 @@ def clear_canvas(canvas):
     # Redraw the now empty canvas without changing its size
     canvas.draw_idle()
     
-@log_function_call
 def measure_crop_wrapper(settings, q, fig_queue):
     """
     Wraps the measure_crop function to integrate with GUI processes.
@@ -562,6 +579,7 @@ def measure_crop_wrapper(settings, q, fig_queue):
     plt.show = my_show
 
     try:
+        print('start')
         spacr.measure.measure_crop(settings=settings, annotation_settings={}, advanced_settings={})
     except Exception as e:
         errorMessage = f"Error during processing: {e}"
@@ -594,7 +612,7 @@ def preprocess_generate_masks_wrapper(settings, q, fig_queue):
     plt.show = my_show
 
     try:
-        spacr.core.preprocess_generate_masks(settings['src'], settings=settings, advanced_settings={})
+        spacr.core.preprocess_generate_masks(settings['src'], settings=settings)
     except Exception as e:
         errorMessage = f"Error during processing: {e}"
         q.put(errorMessage)  # Send the error message to the GUI via the queue