spacr 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

spacr/gui_utils.py

@@ -1,16 +1,11 @@
+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
 from tkinter.font import nametofont
-import matplotlib
-#matplotlib.use('TkAgg')
-matplotlib.use('Agg')
-import ctypes
-import ast
-import matplotlib.pyplot as plt
-import sys
-import io
-import traceback
-import spacr
+from torchvision import models
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
@@ -19,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
@@ -105,114 +120,132 @@ def check_mask_gui_settings(vars_dict):
             settings[key] = value
     return settings
 
-def check_measure_gui_settings_v1(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:
-            # Special handling for 'channels' to convert into a list of integers
-            if key == 'channels':
-                settings[key] = [int(chan) for chan in eval(value)] if value else []
+            if key in ['channels', 'png_dims']:
+                settings[key] = [int(chan) for chan in ast.literal_eval(value)] if value else []
                 
-            elif key == 'png_size':
-                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
-
             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 in ['pathogens', 'treatments', 'cells', 'crop_mode']:
-                settings[key] = eval(value) if value else None
+            elif key == 'normalize':
+                settings[key] = [int(num) for num in ast.literal_eval(value)] if value else []
 
-            elif key == 'timelapse_objects':
-                # Ensure it's a list of strings
-                settings[key] = eval(value) if value else []
+            # Directly assign string values for these specific keys
+            elif key in ['normalize_by', 'experiment', 'measurement', 'input_folder']:
+                settings[key] = value
 
-            # Handling for keys that should be treated as strings directly
-            elif key in ['normalize_by', 'experiment', 'measurement']:
-                settings[key] = str(value) if value else None
+            elif key == 'png_size':
+                settings[key] = [list(map(int, dim)) for dim in ast.literal_eval(value)] if value else []
+            
+            # 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)
-
-            else:
-                settings[key] = 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
 
-def check_measure_gui_settings(vars_dict):
+def check_classify_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
 
         try:
-            if key == 'channels' or key == 'png_dims':
-                # Converts string representation to a list of integers
-                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
-                
-            elif key == 'dialate_png_ratios':
-                settings[key] = [float(num) for num in eval(value)] if value else None
-
-            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
-
-            elif key == 'normalize_by':
-                # 'normalize_by' is a string, so directly assign the value
+            if key in ['src', 'measurement']:
+                # Directly assign string values
+                settings[key] = str(value)
+            elif key in ['cell_mask_dim', 'image_size', 'batch_size', 'epochs', 'gradient_accumulation_steps', 'num_workers']:
+                # Convert to integer
+                settings[key] = int(value)
+            elif key in ['val_split', 'learning_rate', 'weight_decay', 'dropout_rate']:
+                # Convert to float
+                settings[key] = float(value)
+            elif key == 'classes':
+                # Evaluate as list
+                settings[key] = ast.literal_eval(value)
+
+            elif key in ['model_type','optimizer_type','schedule','loss_type','train_mode']:
                 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...
-            
-            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 []
+            elif key in ['gradient_accumulation','normalize','save','plot', 'init_weights','amsgrad','use_checkpoint','intermedeate_save','pin_memory', 'num_workers','verbose']:
+                settings[key] = bool(value)
 
-            # 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
+        except SyntaxError as 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)}")
+            return None
 
-            # Handling for single values that are not strings (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
+    return settings
 
-            elif key == 'um_per_pixel':
-                settings[key] = float(value) if value else None
+def check_sim_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
 
-            # Direct handling of 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']:
+        try:
+            if key in ['src', 'name', 'variable']:
+                # Directly assign string values
+                settings[key] = str(value)
+            
+            elif key in ['nr_plates', 'number_of_genes','number_of_active_genes','avg_genes_per_well','avg_cells_per_well','avg_reads_per_gene']:
+                #generate list of integers from list
+                ls = [int(num) for num in ast.literal_eval(value)]
+                if len(ls) == 3 and ls[2] > 0:
+                    list_of_integers = list(range(ls[0], ls[1], ls[2]))
+                    list_of_integers = [num + 1 if num == 0 else num for num in list_of_integers]
+                else:
+                    list_of_integers = [ls[0]]
+                settings[key] = list_of_integers
+                
+            elif key in ['sequencing_error','well_ineq_coeff','gene_ineq_coeff', 'positive_mean']:
+                #generate list of floats from list
+                ls = [float(num) for num in ast.literal_eval(value)]
+                if len(ls) == 3 and ls[2] > 0:
+                    list_of_floats = np.linspace(ls[0], ls[1], ls[2])
+                    list_of_floats.tolist()
+                    list_of_floats = [x if x != 0.0 else x + 0.01 for x in list_of_floats]
+                else:
+                    list_of_floats = [ls[0]]
+                settings[key] = list_of_floats
+
+            elif key in ['plot', 'random_seed']:
+                # Evaluate as bool
                 settings[key] = bool(value)
-
+                
+            elif key in ['number_of_control_genes', 'replicates', 'max_workers']:
+                # Convert to integer
+                settings[key] = int(value)
+                
         except SyntaxError as e:
             messagebox.showerror("Error", f"Syntax error processing {key}: {str(e)}")
             return None
@@ -222,17 +255,44 @@ def check_measure_gui_settings(vars_dict):
 
     return settings
 
+def sim_variables():
+    variables = {
+        'name':('entry', None, 'plates_2_4_8'),
+        'variable':('entry', None, 'all'),
+        'src':('entry', None, '/home/olafsson/Desktop/simulations'),
+        'number_of_control_genes':('entry', None, 30),
+        'replicates':('entry', None, 4),
+        'max_workers':('entry', None, 1),
+        'plot':('check', None, True),
+        'random_seed':('check', None, True),
+        'nr_plates': ('entry', None, '[8,8,0]'),# '[2,2,8]'
+        'number_of_genes': ('entry', None, '[100, 100, 0]'), #[1384, 1384, 0]
+        'number_of_active_genes': ('entry', None, '[10,10,0]'),
+        'avg_genes_per_well': ('entry', None, '[2, 10, 2]'),
+        'avg_cells_per_well': ('entry', None, '[100, 100, 0]'),
+        'positive_mean': ('entry', None, '[0.8, 0.8, 0]'),
+        'avg_reads_per_gene': ('entry', None, '[1000,1000, 0]'),
+        'sequencing_error': ('entry', None, '[0.01, 0.01, 0]'),
+        'well_ineq_coeff': ('entry', None, '[0.3,0.3,0]'),
+        'gene_ineq_coeff': ('entry', None, '[0.8,0.8,0]'),
+    }
+    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),
-        'cytoplasm_min_size':('entry', None, 0),
         'save_png':('check', None, True),
         'crop_mode':('entry', None, '["cell"]'),
         'use_bounding_box':('check', None, True),
@@ -258,14 +318,56 @@ 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)
     }
     return variables
+
+def classify_variables():
+    
+    def get_torchvision_models():
+        # Fetch all public callable attributes from torchvision.models that are functions
+        model_names = [name for name, obj in inspect.getmembers(models) 
+                    if inspect.isfunction(obj) and not name.startswith("__")]
+        return model_names
+    
+    model_names = get_torchvision_models()
+    variables = {
+        'src':('entry', None, '/mnt/data/CellVoyager/40x/einar/mitotrackerHeLaToxoDsRed_20240224_123156/test_gui/merged'),
+        'cell_mask_dim':('entry', None, 4),
+        'classes':('entry', None, '["nc","pc"]'),
+        'measurement':('entry', None, 'mean_intensity'),
+        'model_type': ('combo', model_names, 'resnet50'),
+        'optimizer_type': ('combo', ['adamw','adam'], 'adamw'),
+        'schedule': ('combo', ['reduce_lr_on_plateau','step_lr'], 'reduce_lr_on_plateau'),
+        'loss_type': ('combo', ['focal_loss', 'binary_cross_entropy_with_logits'], 'focal_loss'),
+        'image_size': ('entry', None, 224),
+        'batch_size': ('entry', None, 12),
+        'epochs': ('entry', None, 2),
+        'val_split': ('entry', None, 0.1),
+        'train_mode': ('combo', ['erm', 'irm'], 'erm'),
+        'learning_rate': ('entry', None, 0.0001),
+        'weight_decay': ('entry', None, 0.00001),
+        'dropout_rate': ('entry', None, 0.1),
+        'gradient_accumulation': ('check', None, True),
+        'gradient_accumulation_steps': ('entry', None, 4),
+        'normalize': ('check', None, True),
+        'save': ('check', None, True), 
+        'plot': ('check', None, True),
+        'init_weights': ('check', None, True),
+        'amsgrad': ('check', None, True),
+        'use_checkpoint': ('check', None, True),
+        'intermedeate_save': ('check', None, True),
+        'pin_memory': ('check', None, True),
+        'num_workers': ('entry', None, 30),
+        'verbose': ('check', None, True),
+    }
+    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)
@@ -289,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 = {
@@ -314,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),
@@ -326,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),
@@ -401,29 +499,34 @@ 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 == "" or message == "\r":
+            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 clean_message.startswith("plot_cropped_arrays"):
+                pass
+            elif clean_message == "" or clean_message == "\r" or clean_message.strip() == "":
                 pass
             else:
-                print(message)  # Or handle other messages differently
-                # For non-progress messages, you can still print them to the console or handle them as needed.
-
-        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))
-        
+
 def process_stdout_stderr(q):
     """
     Redirect stdout and stderr to the queue q.
@@ -453,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.
@@ -463,7 +565,7 @@ def measure_crop_wrapper(settings, q, fig_queue):
     - q: multiprocessing.Queue, Queue for logging messages to the GUI.
     - fig_queue: multiprocessing.Queue, Queue for sending figures to the GUI.
     """
-    
+
     def my_show():
         """
         Replacement for plt.show() that queues figures instead of displaying them.
@@ -477,12 +579,106 @@ def measure_crop_wrapper(settings, q, fig_queue):
     plt.show = my_show
 
     try:
-        # Assuming spacr.measure.measure_crop is your function that potentially generates matplotlib figures
-        # Pass settings as a named argument, along with any other needed arguments
+        print('start')
         spacr.measure.measure_crop(settings=settings, annotation_settings={}, advanced_settings={})
     except Exception as e:
         errorMessage = f"Error during processing: {e}"
         q.put(errorMessage)  # Send the error message to the GUI via the queue
         traceback.print_exc()
     finally:
-        plt.show = original_show  # Restore the original plt.show function
+        plt.show = original_show  # Restore the original plt.show function
+        
+@log_function_call
+def preprocess_generate_masks_wrapper(settings, q, fig_queue):
+    """
+    Wraps the measure_crop function to integrate with GUI processes.
+    
+    Parameters:
+    - settings: dict, The settings for the measure_crop function.
+    - q: multiprocessing.Queue, Queue for logging messages to the GUI.
+    - fig_queue: multiprocessing.Queue, Queue for sending figures to the GUI.
+    """
+
+    def my_show():
+        """
+        Replacement for plt.show() that queues figures instead of displaying them.
+        """
+        fig = plt.gcf()
+        fig_queue.put(fig)  # Queue the figure for GUI display
+        plt.close(fig)  # Prevent the figure from being shown by plt.show()
+
+    # Temporarily override plt.show
+    original_show = plt.show
+    plt.show = my_show
+
+    try:
+        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
+        traceback.print_exc()
+    finally:
+        plt.show = original_show  # Restore the original plt.show function
+
+def train_test_model_wrapper(settings, q, fig_queue):
+    """
+    Wraps the measure_crop function to integrate with GUI processes.
+    
+    Parameters:
+    - settings: dict, The settings for the measure_crop function.
+    - q: multiprocessing.Queue, Queue for logging messages to the GUI.
+    - fig_queue: multiprocessing.Queue, Queue for sending figures to the GUI.
+    """
+
+    def my_show():
+        """
+        Replacement for plt.show() that queues figures instead of displaying them.
+        """
+        fig = plt.gcf()
+        fig_queue.put(fig)  # Queue the figure for GUI display
+        plt.close(fig)  # Prevent the figure from being shown by plt.show()
+
+    # Temporarily override plt.show
+    original_show = plt.show
+    plt.show = my_show
+
+    try:
+        spacr.core.train_test_model(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
+        traceback.print_exc()
+    finally:
+        plt.show = original_show  # Restore the original plt.show function
+        
+        
+def run_multiple_simulations_wrapper(settings, q, fig_queue):
+    """
+    Wraps the run_multiple_simulations function to integrate with GUI processes.
+    
+    Parameters:
+    - settings: dict, The settings for the run_multiple_simulations function.
+    - q: multiprocessing.Queue, Queue for logging messages to the GUI.
+    - fig_queue: multiprocessing.Queue, Queue for sending figures to the GUI.
+    """
+
+    def my_show():
+        """
+        Replacement for plt.show() that queues figures instead of displaying them.
+        """
+        fig = plt.gcf()
+        fig_queue.put(fig)  # Queue the figure for GUI display
+        plt.close(fig)  # Prevent the figure from being shown by plt.show()
+
+    # Temporarily override plt.show
+    original_show = plt.show
+    plt.show = my_show
+
+    try:
+        spacr.sim.run_multiple_simulations(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
+        traceback.print_exc()
+    finally:
+        plt.show = original_show  # Restore the original plt.show function