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

spacr/gui_mask_app.py

@@ -1,15 +1,14 @@
-import spacr, sys, queue, ctypes, csv, matplotlib
+import spacr, sys, ctypes, csv, matplotlib
 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
-import matplotlib.pyplot as plt
 from matplotlib.figure import Figure
-from threading import Thread
 matplotlib.use('Agg')
-from threading import Thread
 from tkinter import filedialog
+from multiprocessing import Process, Queue, Value
+import traceback
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
@@ -17,112 +16,60 @@ except AttributeError:
     pass
 
 from .logger import log_function_call
-from .gui_utils import ScrollableFrame, StdoutRedirector, create_dark_mode, set_dark_style, set_default_font, mask_variables, generate_fields, check_mask_gui_settings, add_mask_gui_defaults
-from .gui_utils import safe_literal_eval
+from .gui_utils import ScrollableFrame, StdoutRedirector, safe_literal_eval, clear_canvas, main_thread_update_function, create_dark_mode, set_dark_style, set_default_font, generate_fields, process_stdout_stderr
+from .gui_utils import mask_variables, check_mask_gui_settings, preprocess_generate_masks_wrapper, read_settings_from_csv, update_settings_from_csv #, add_mask_gui_defaults
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
-class ScrollableFrame(ttk.Frame):
-    def __init__(self, container, *args, bg='#333333', **kwargs):
-        super().__init__(container, *args, **kwargs)
-        self.configure(style='TFrame')  # Ensure this uses the styled frame from dark mode
-        
-        canvas = tk.Canvas(self, bg=bg)  # Set canvas background to match dark mode
-        scrollbar = ttk.Scrollbar(self, orient="vertical", command=canvas.yview)
-        
-        self.scrollable_frame = ttk.Frame(canvas, style='TFrame')  # Ensure it uses the styled frame
-        self.scrollable_frame.bind(
-            "<Configure>",
-            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
-        )
-        
-        canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
-        canvas.configure(yscrollcommand=scrollbar.set)
-        
-        canvas.pack(side="left", fill="both", expand=True)
-        scrollbar.pack(side="right", fill="y")
-
-def clear_canvas():
-    global canvas
-    # Clear each plot (axes) in the figure
-    for ax in canvas.figure.get_axes():
-        ax.clear()  # Clears the axes, but keeps them visible for new plots
-
-    # Redraw the now empty canvas without changing its size
-    canvas.draw_idle()  # Using draw_idle for efficiency in redrawing
-        
+@log_function_call
 def initiate_abort():
-    global thread_control, q
-    thread_control["stop_requested"] = True
-    if thread_control["run_thread"] is not None:
-        thread_control["run_thread"].join(timeout=1)  # Timeout after 1 second
+    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():
-            q.put("Thread didn't terminate within timeout.")
+            thread_control["run_thread"].terminate()
         thread_control["run_thread"] = None
-    
-def preprocess_generate_masks_wrapper(*args, **kwargs):
-    global fig_queue
-    def my_show():
-        fig = plt.gcf()
-        fig_queue.put(fig)  # Put the figure into the queue
-        plt.close(fig)  # Close the figure to prevent it from being shown by plt.show()
-
-    original_show = plt.show
-    plt.show = my_show
-
-    try:
-        spacr.core.preprocess_generate_masks(*args, **kwargs)
-    except Exception as e:
-        pass
-    finally:
-        plt.show = original_show
         
-def run_mask_gui(q, fig_queue):
-    global vars_dict, thread_control
+@log_function_call
+def run_mask_gui(q, fig_queue, stop_requested):
+    global vars_dict
+    process_stdout_stderr(q)
     try:
-        while not thread_control["stop_requested"]:
-            settings = check_mask_gui_settings(vars_dict)
-            settings = add_mask_gui_defaults(settings)
-            preprocess_generate_masks_wrapper(settings['src'], settings=settings, advanced_settings={})
-            thread_control["stop_requested"] = True
+        settings = check_mask_gui_settings(vars_dict)
+        #settings = add_mask_gui_defaults(settings)
+        #for key in settings:
+        #    value = settings[key]
+        #    print(key, value, type(value))
+        preprocess_generate_masks_wrapper(settings, q, fig_queue)
     except Exception as e:
-        pass
-        #q.put(f"Error during processing: {e}")
+        q.put(f"Error during processing: {e}")
+        traceback.print_exc()
     finally:
-        # Ensure the thread is marked as not running anymore
-        thread_control["run_thread"] = None
-        # Reset the stop_requested flag for future operations
-        thread_control["stop_requested"] = False
-
-def start_thread(q, fig_queue):
+        stop_requested.value = 1
+    
+@log_function_call
+def start_process(q, fig_queue):
     global thread_control
-    thread_control["stop_requested"] = False  # Reset the stop signal
-    thread_control["run_thread"] = Thread(target=run_mask_gui, args=(q, fig_queue))
+    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_mask_gui, args=(q, fig_queue, stop_requested))
     thread_control["run_thread"].start()
     
 def import_settings(scrollable_frame):
-    global vars_dict, original_variables_structure
+    global vars_dict
 
     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])
+    csv_settings = read_settings_from_csv(csv_file_path)
+    variables = mask_variables()
+    #variables = add_mask_gui_defaults(variables)
+    new_settings = update_settings_from_csv(variables, csv_settings)
+    vars_dict = generate_fields(new_settings, scrollable_frame)
     
 @log_function_call
 def initiate_mask_root(width, height):
@@ -145,13 +92,13 @@ def initiate_mask_root(width, height):
     root.attributes('-fullscreen', True)
     root.geometry(f"{width}x{height}")
     root.title("SpaCer: generate masks")
-    fig_queue = queue.Queue()
-    
+    fig_queue = Queue()
+            
     def _process_fig_queue():
         global canvas
         try:
             while not fig_queue.empty():
-                clear_canvas()
+                clear_canvas(canvas)
                 fig = fig_queue.get_nowait()
                 #set_fig_text_properties(fig, font_size=8)
                 for ax in fig.get_axes():
@@ -167,13 +114,12 @@ def initiate_mask_root(width, height):
                 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 queue.Empty:
-            pass
         except Exception as e:
-            pass
+            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():
@@ -211,22 +157,26 @@ def initiate_mask_root(width, height):
     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.Queue()
+    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_thread(q, fig_queue))
-    run_button.grid(row=40, column=0, pady=10)
+    run_button = ttk.Button(scrollable_frame.scrollable_frame, text="Run",command=lambda: start_process(q, fig_queue))
+    run_button.grid(row=45, 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)
+    abort_button.grid(row=45, 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))
@@ -236,12 +186,14 @@ def initiate_mask_root(width, height):
     _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_mask():
     global vars_dict, root
     root, vars_dict = initiate_mask_root(1000, 1500)
     root.mainloop()
-
+    
 if __name__ == "__main__":
     gui_mask()

spacr/gui_measure_app.py

@@ -7,7 +7,7 @@ import matplotlib.pyplot as plt
 matplotlib.use('Agg')  # Use the non-GUI Agg backend
 from multiprocessing import Process, Queue, Value
 from ttkthemes import ThemedTk
-from tkinter import filedialog
+from tkinter import filedialog, StringVar, BooleanVar, IntVar, DoubleVar, Tk
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
@@ -15,19 +15,18 @@ except AttributeError:
     pass
 
 from .logger import log_function_call
-from .gui_utils import ScrollableFrame, StdoutRedirector, set_dark_style, set_default_font, measure_variables, generate_fields, create_dark_mode, check_measure_gui_settings, add_measure_gui_defaults, main_thread_update_function
-from .gui_utils import process_stdout_stderr, measure_crop_wrapper, clear_canvas, safe_literal_eval
+from .gui_utils import ScrollableFrame, StdoutRedirector, process_stdout_stderr, set_dark_style, set_default_font, generate_fields, create_dark_mode, main_thread_update_function
+from .gui_utils import measure_variables, measure_crop_wrapper, clear_canvas, safe_literal_eval, check_measure_gui_settings, read_settings_from_csv, update_settings_from_csv
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
-
 @log_function_call
 def run_measure_gui(q, fig_queue, stop_requested):
     global vars_dict
     process_stdout_stderr(q)
     try:
+        print('hello')
         settings = check_measure_gui_settings(vars_dict)
-        settings = add_measure_gui_defaults(settings)
         #for key in settings:
         #    value = settings[key]
         #    print(key, value, type(value))
@@ -61,29 +60,15 @@ def initiate_abort():
             thread_control["run_thread"].terminate()
         thread_control["run_thread"] = None
 
+@log_function_call
 def import_settings(scrollable_frame):
-    global vars_dict, original_variables_structure
+    global vars_dict
 
     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])
+    csv_settings = read_settings_from_csv(csv_file_path)
+    variables = measure_variables()
+    new_settings = update_settings_from_csv(variables, csv_settings)
+    vars_dict = generate_fields(new_settings, scrollable_frame)
 
 @log_function_call
 def initiate_measure_root(width, height):
@@ -135,7 +120,7 @@ def initiate_measure_root(width, height):
             #pass
         finally:
             canvas_widget.after(100, _process_fig_queue)
-    
+            
     # Process queue for console output
     def _process_console_queue():
         while not q.empty():
@@ -173,6 +158,7 @@ def initiate_measure_root(width, height):
     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)
@@ -190,7 +176,7 @@ def initiate_measure_root(width, height):
     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="Progress: 0%", background="#333333", foreground="white")
+    progress_label = ttk.Label(scrollable_frame.scrollable_frame, text="Progress: ", background="#333333", foreground="white")
     progress_label.grid(row=41, column=0, columnspan=2, sticky="ew", pady=(5, 0))
     
     # Create the Import Settings button
@@ -201,7 +187,7 @@ def initiate_measure_root(width, height):
     _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))
+    #root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label))
     
     return root, vars_dict