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

spacr/gui_2.py

@@ -0,0 +1,90 @@
+import customtkinter as ctk
+from PIL import Image, ImageTk
+import os
+import requests
+
+class MainApp(ctk.CTk):
+    def __init__(self):
+        super().__init__()
+        self.title("SpaCr GUI Collection")
+        self.geometry("1200x800")
+        ctk.set_appearance_mode("dark")  # Modes: "System" (standard), "Dark", "Light"
+        ctk.set_default_color_theme("dark-blue")  # Themes: "blue" (standard), "green", "dark-blue")
+        
+        # Set scaling factor for high DPI displays; use a floating-point value.
+        self.tk.call('tk', 'scaling', 1.5)
+        
+        self.create_widgets()
+
+    def create_widgets(self):
+        self.content_frame = ctk.CTkFrame(self)
+        self.content_frame.pack(fill="both", expand=True, padx=20, pady=20)
+
+        logo_frame = ctk.CTkFrame(self.content_frame)
+        logo_frame.pack(pady=20, expand=True)
+
+        if not self.load_logo(logo_frame):
+            ctk.CTkLabel(logo_frame, text="Logo not found", text_color="white", font=('Helvetica', 24)).pack(padx=10, pady=10)
+
+        ctk.CTkLabel(logo_frame, text="SpaCr", text_color="#00BFFF", font=('Helvetica', 36, "bold")).pack(padx=10, pady=10)
+
+        button = ctk.CTkButton(
+            self.content_frame,
+            text="Mask",
+            command=self.load_mask_app,
+            width=250,
+            height=60,
+            corner_radius=20,
+            fg_color="#1E90FF",
+            hover_color="#4682B4",
+            text_color="white",
+            font=("Helvetica", 18, "bold")
+        )
+        button.pack(pady=20)
+
+    def load_logo(self, frame):
+        def download_image(url, save_path):
+            try:
+                response = requests.get(url, stream=True)
+                response.raise_for_status()
+                with open(save_path, 'wb') as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        f.write(chunk)
+                return True
+            except requests.exceptions.RequestException as e:
+                print(f"Failed to download image from {url}: {e}")
+                return False
+
+        try:
+            img_path = os.path.join(os.path.dirname(__file__), 'logo_spacr.png')
+            logo_image = Image.open(img_path)
+        except (FileNotFoundError, Image.UnidentifiedImageError):
+            if download_image('https://raw.githubusercontent.com/EinarOlafsson/spacr/main/spacr/logo_spacr.png', img_path):
+                try:
+                    logo_image = Image.open(img_path)
+                except Image.UnidentifiedImageError as e:
+                    return False
+            else:
+                return False
+        except Exception as e:
+            return False
+
+        try:
+            logo_image = logo_image.resize((200, 200), Image.Resampling.LANCZOS)
+            logo_photo = ImageTk.PhotoImage(logo_image)
+            logo_label = ctk.CTkLabel(frame, image=logo_photo)
+            logo_label.image = logo_photo  # Keep a reference to avoid garbage collection
+            logo_label.pack()
+            return True
+        except Exception as e:
+            return False
+
+    def load_mask_app(self):
+        print("Mask app loaded.")  # Placeholder for mask app loading function
+
+def gui_app():
+    app = MainApp()
+    app.mainloop()
+
+if __name__ == "__main__":
+    gui_app()

spacr/gui_classify_app.py

@@ -0,0 +1,187 @@
+import sys, ctypes, matplotlib
+import tkinter as tk
+from tkinter import ttk, scrolledtext
+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
+import traceback
+
+try:
+    ctypes.windll.shcore.SetProcessDpiAwareness(True)
+except AttributeError:
+    pass
+
+from .logger import log_function_call
+from .gui_utils import ScrollableFrame, StdoutRedirector, CustomButton, set_dark_style, set_default_font, generate_fields, process_stdout_stderr, clear_canvas, main_thread_update_function
+from .gui_utils import classify_variables, check_classify_gui_settings, train_test_model_wrapper, read_settings_from_csv, update_settings_from_csv, style_text_boxes, create_menu_bar
+
+thread_control = {"run_thread": None, "stop_requested": False}
+
+#@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
+        
+#@log_function_call
+def run_classify_gui(q, fig_queue, stop_requested):
+    global vars_dict
+    process_stdout_stderr(q)
+    try:
+        settings = check_classify_gui_settings(vars_dict)
+        for key in settings:
+            value = settings[key]
+            print(key, value, type(value))
+        train_test_model_wrapper(settings['src'], settings)
+    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_classify_gui, args=(q, fig_queue, stop_requested))
+    thread_control["run_thread"].start()
+    
+def import_settings(scrollable_frame):
+    global vars_dict
+
+    csv_file_path = filedialog.askopenfilename(filetypes=[("CSV files", "*.csv")])
+    csv_settings = read_settings_from_csv(csv_file_path)
+    variables = classify_variables()
+    new_settings = update_settings_from_csv(variables, csv_settings)
+    vars_dict = generate_fields(new_settings, scrollable_frame)
+
+#@log_function_call
+def initiate_classify_root(parent_frame):#, width, height):
+    global vars_dict, q, canvas, fig_queue, canvas_widget, thread_control
+    
+    style = ttk.Style(parent_frame)
+    set_dark_style(style)
+    style_text_boxes(style)
+    set_default_font(parent_frame, font_name="Arial", size=8)
+
+    parent_frame.configure(bg='#333333')
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_columnconfigure(0, weight=1)
+    fig_queue = Queue()
+
+    def _process_fig_queue():
+        global canvas
+        try:
+            while not fig_queue.empty():
+                clear_canvas(canvas)
+                fig = fig_queue.get_nowait()
+                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
+                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()
+        finally:
+            canvas_widget.after(100, _process_fig_queue)
+
+    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 = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL)
+    vertical_container.grid(row=0, column=0, sticky=tk.NSEW)
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_columnconfigure(0, weight=1)
+
+    # Settings Section
+    settings_frame = tk.Frame(vertical_container, bg='#333333')
+    vertical_container.add(settings_frame, stretch="always")
+    settings_label = ttk.Label(settings_frame, text="Settings", background="#333333", foreground="white")
+    settings_label.grid(row=0, column=0, pady=10, padx=10)
+    scrollable_frame = ScrollableFrame(settings_frame, width=500)
+    scrollable_frame.grid(row=1, column=0, sticky="nsew")
+    settings_frame.grid_rowconfigure(1, weight=1)
+    settings_frame.grid_columnconfigure(0, weight=1)
+
+    # Setup for user input fields (variables)
+    variables = classify_variables()
+    vars_dict = generate_fields(variables, scrollable_frame)
+
+    # Button section
+    import_btn = CustomButton(scrollable_frame.scrollable_frame, text="Import Settings", command=lambda: import_settings(scrollable_frame))
+    import_btn.grid(row=47, column=0, pady=20, padx=20)
+    run_button = CustomButton(scrollable_frame.scrollable_frame, text="Run", command=lambda: start_process(q, fig_queue))
+    run_button.grid(row=45, column=0, pady=20, padx=20)
+    abort_button = CustomButton(scrollable_frame.scrollable_frame, text="Abort", command=initiate_abort)
+    abort_button.grid(row=45, column=1, pady=20, padx=20)
+    progress_label = ttk.Label(scrollable_frame.scrollable_frame, text="Processing: 0%", background="black", foreground="white") # Create progress field
+    progress_label.grid(row=50, column=0, columnspan=2, sticky="ew", pady=(5, 0), padx=10)
+
+    # Plot Canvas Section
+    plot_frame = tk.PanedWindow(vertical_container, orient=tk.VERTICAL)
+    vertical_container.add(plot_frame, stretch="always")
+    figure = Figure(figsize=(30, 4), dpi=100, facecolor='#333333')
+    plot = figure.add_subplot(111)
+    plot.plot([], [])
+    plot.axis('off')
+    canvas = FigureCanvasTkAgg(figure, master=plot_frame)
+    canvas.get_tk_widget().configure(cursor='arrow', background='#333333', highlightthickness=0)
+    canvas_widget = canvas.get_tk_widget()
+    plot_frame.add(canvas_widget, stretch="always")
+    canvas.draw()
+    canvas.figure = figure
+
+    # Console Section
+    console_frame = tk.Frame(vertical_container, bg='#333333')
+    vertical_container.add(console_frame, stretch="always")
+    console_label = ttk.Label(console_frame, text="Console", background="#333333", foreground="white")
+    console_label.grid(row=0, column=0, pady=10, padx=10)
+    console_output = scrolledtext.ScrolledText(console_frame, height=10, bg='#333333', fg='white', insertbackground='white')
+    console_output.grid(row=1, column=0, sticky="nsew")
+    console_frame.grid_rowconfigure(1, weight=1)
+    console_frame.grid_columnconfigure(0, weight=1)
+
+    q = Queue()
+    sys.stdout = StdoutRedirector(console_output)
+    sys.stderr = StdoutRedirector(console_output)
+
+    _process_console_queue()
+    _process_fig_queue()
+
+    parent_frame.after(100, lambda: main_thread_update_function(parent_frame, q, fig_queue, canvas_widget, progress_label))
+
+    return parent_frame, vars_dict
+
+def gui_classify():
+    root = tk.Tk()
+    root.geometry("1000x800")
+    root.title("SpaCer: generate masks")
+    initiate_classify_root(root, 1000, 800)
+    create_menu_bar(root)
+    root.mainloop()
+
+if __name__ == "__main__":
+    gui_classify()

spacr/gui_mask_app.py

@@ -1,15 +1,14 @@
-import spacr, sys, queue, ctypes, csv, matplotlib
+#import customtkinter as ctk
+
+import sys, ctypes, 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,230 +16,206 @@ 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, ToggleSwitch, CustomButton, ToolTip
+from .gui_utils import clear_canvas, main_thread_update_function, set_dark_style, generate_fields, process_stdout_stderr, set_default_font, style_text_boxes
+from .gui_utils import mask_variables, check_mask_gui_settings, preprocess_generate_masks_wrapper, read_settings_from_csv, update_settings_from_csv, create_menu_bar
 
 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
-        
+def toggle_test_mode():
+    global vars_dict
+    current_state = vars_dict['test_mode'][2].get()
+    new_state = not current_state
+    vars_dict['test_mode'][2].set(new_state)
+    if new_state:
+        test_mode_button.config(bg="blue")
+    else:
+        test_mode_button.config(bg="gray")
+
+def toggle_advanced_settings():
+    global vars_dict
+
+    timelapse_settings = ['timelapse', 'timelapse_memory', 'timelapse_remove_transient', 'timelapse_mode', 'timelapse_objects', 'timelapse_displacement', 'timelapse_frame_limits', 'fps']
+    misc_settings = ['examples_to_plot', 'all_to_mip', 'pick_slice', 'skip_mode']
+    opperational_settings = ['preprocess', 'masks', 'randomize', 'batch_size', 'custom_regex', 'merge', 'normalize_plots', 'workers', 'plot', 'remove_background', 'lower_quantile']
+
+    advanced_settings = timelapse_settings+misc_settings+opperational_settings
+
+    # Toggle visibility of advanced settings
+    for setting in advanced_settings:
+        label, widget, var = vars_dict[setting]
+        if advanced_var.get() is False:
+            label.grid_remove()  # Hide the label
+            widget.grid_remove()  # Hide the widget
+        else:
+            label.grid()  # Show the label
+            widget.grid()  # Show the widget
+
+#@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)
+        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
+        stop_requested.value = 1
 
-def start_thread(q, fig_queue):
+#@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")])
+    csv_settings = read_settings_from_csv(csv_file_path)
+    variables = mask_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(parent_frame, width, height):
+    global vars_dict, q, canvas, fig_queue, canvas_widget, thread_control, advanced_var, scrollable_frame
+
+    style = ttk.Style(parent_frame)
+    set_dark_style(style)
+    style_text_boxes(style)
+    set_default_font(parent_frame, font_name="Arial", size=8)
+    parent_frame.configure(bg='black')
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_columnconfigure(0, weight=1)
     
-    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_mask_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: 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():
                     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')
+                fig.set_facecolor('black')
                 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 queue.Empty:
-            pass
+                canvas.draw_idle()
         except Exception as e:
-            pass
+            traceback.print_exc()
         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)
+    vertical_container = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL)
+    vertical_container.grid(row=0, column=0, sticky=tk.NSEW)
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_columnconfigure(0, weight=1)
+
+    # Settings Section
+    settings_frame = tk.Frame(vertical_container, bg='black')
+    vertical_container.add(settings_frame, stretch="always")
+    settings_label = ttk.Label(settings_frame, text="Settings", style="Custom.TLabel")
+    settings_label.grid(row=0, column=0, pady=10, padx=10)
+    scrollable_frame = ScrollableFrame(settings_frame, width=600)
+    scrollable_frame.grid(row=1, column=0, sticky="nsew")
+    settings_frame.grid_rowconfigure(1, weight=1)
+    settings_frame.grid_columnconfigure(0, weight=1)
+    
+    # Create advanced settings checkbox
+    advanced_var = tk.BooleanVar(value=False)
+    advanced_Toggle = ToggleSwitch(scrollable_frame.scrollable_frame, text="Advanced Settings", variable=advanced_var, command=toggle_advanced_settings)
+    advanced_Toggle.grid(row=48, column=0, pady=10, padx=10)
     variables = mask_variables()
     vars_dict = generate_fields(variables, scrollable_frame)
+    toggle_advanced_settings()
+    vars_dict['Test mode'] = (None, None, tk.BooleanVar(value=False))
     
-    # 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')
+    # Button section
+    test_mode_button = CustomButton(scrollable_frame.scrollable_frame, text="Test Mode", command=toggle_test_mode)
+    test_mode_button.grid(row=47, column=1, pady=10, padx=10)
+    import_btn = CustomButton(scrollable_frame.scrollable_frame, text="Import", command=lambda: import_settings(scrollable_frame))
+    import_btn.grid(row=47, column=0, pady=10, padx=10)
+    run_button = CustomButton(scrollable_frame.scrollable_frame, text="Run", command=lambda: start_process(q, fig_queue))
+    run_button.grid(row=45, column=0, pady=10, padx=10)
+    abort_button = CustomButton(scrollable_frame.scrollable_frame, text="Abort", command=initiate_abort)
+    abort_button.grid(row=45, column=1, pady=10, padx=10)
+    progress_label = ttk.Label(scrollable_frame.scrollable_frame, text="Processing: 0%", background="black", foreground="white") # Create progress field
+    progress_label.grid(row=50, column=0, columnspan=2, sticky="ew", pady=(5, 0), padx=10)
+
+    # Plot Canvas Section
+    plot_frame = tk.PanedWindow(vertical_container, orient=tk.VERTICAL) # Horizontal container for Matplotlib figure and the vertical pane (for settings and console)
+    vertical_container.add(plot_frame, stretch="always")
+    figure = Figure(figsize=(30, 4), dpi=100, facecolor='black') # Matplotlib figure setup
     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 = FigureCanvasTkAgg(figure, master=plot_frame) # Embedd Matplotlib figure in Tkinter window
+    canvas.get_tk_widget().configure(cursor='arrow', background='black', highlightthickness=0)
     canvas_widget = canvas.get_tk_widget()
-    horizontal_container.add(canvas_widget, stretch="always")
+    plot_frame.add(canvas_widget, stretch="always")
     canvas.draw()
-
-    # 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()
+    canvas.figure = figure
+
+    # Console Section
+    console_frame = tk.Frame(vertical_container, bg='black')
+    vertical_container.add(console_frame, stretch="always")
+    console_label = ttk.Label(console_frame, text="Console", background="black", foreground="white")
+    console_label.grid(row=0, column=0, pady=10, padx=10)
+    console_output = scrolledtext.ScrolledText(console_frame, height=10, bg='black', fg='white', insertbackground='white')
+    console_output.grid(row=1, column=0, sticky="nsew")
+    console_frame.grid_rowconfigure(1, weight=1)
+    console_frame.grid_columnconfigure(0, weight=1)
+
+    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)
-    
-    abort_button = ttk.Button(scrollable_frame.scrollable_frame, text="Abort", command=initiate_abort)
-    abort_button.grid(row=40, column=1, pady=10)
-    
-    # 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)
     
-    return root, vars_dict
+    parent_frame.after(100, lambda: main_thread_update_function(parent_frame, q, fig_queue, canvas_widget, progress_label))
+
+    return parent_frame, vars_dict
 
 def gui_mask():
-    global vars_dict, root
-    root, vars_dict = initiate_mask_root(1000, 1500)
+    root = tk.Tk()
+    root.geometry("1000x800")
+    root.title("SpaCer: generate masks")
+    initiate_mask_root(root, 1000, 800)
+    create_menu_bar(root)
     root.mainloop()
 
 if __name__ == "__main__":