spacr 0.2.68__py3-none-any.whl → 0.2.81__py3-none-any.whl

spacr/core.py

@@ -1638,7 +1638,7 @@ def preprocess_generate_masks(src, settings={}):
     
     settings = set_default_settings_preprocess_generate_masks(src, settings)
     settings['src'] = src
-    save_settings(settings)
+    save_settings(settings, name='gen_mask')
 
     if not settings['pathogen_channel'] is None:
         custom_model_ls = ['toxo_pv_lumen','toxo_cyto']

spacr/gui_core.py

@@ -1,4 +1,4 @@
-import traceback, ctypes, csv, re
+import traceback, ctypes, csv, re, platform, time
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
@@ -19,7 +19,7 @@ try:
 except AttributeError:
     pass
 
-from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu , set_dark_style
+from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu , spacrSlider, set_dark_style, standardize_figure
 
 # Define global variables
 q = None
@@ -35,8 +35,6 @@ figures = None
 figure_index = None
 progress_bar = None
 usage_bars = None
-fig_memory_limit = None
-figure_current_memory_usage = None
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
@@ -80,35 +78,10 @@ def toggle_settings(button_scrollable_frame):
     category_dropdown.grid(row=0, column=4, sticky="ew", pady=2, padx=2)
     vars_dict = hide_all_settings(vars_dict, categories)
 
-def process_fig_queue():
-    global canvas, fig_queue, canvas_widget, parent_frame, uppdate_frequency, figures, figure_index
-
-    from .gui_elements import standardize_figure
-    try:
-        while not fig_queue.empty():
-            fig = fig_queue.get_nowait()
-
-            if fig is None:
-                print("Warning: Retrieved a None figure from fig_queue.")
-                continue  # Skip processing if the figure is None
-
-            # Standardize the figure appearance before adding it to the list
-            standardize_figure(fig)
-
-            figures.append(fig)
-            if figure_index == len(figures) - 2:
-                figure_index += 1
-                display_figure(fig)
-    except Exception as e:
-        traceback.print_exc()
-    finally:
-        after_id = canvas_widget.after(uppdate_frequency, process_fig_queue)
-        parent_frame.after_tasks.append(after_id)
-
 def display_figure(fig):
     global canvas, canvas_widget
 
-    from .gui_elements import modify_figure_properties, save_figure_as_format, modify_figure
+    from .gui_elements import save_figure_as_format, modify_figure
 
     # Apply the dark style to the context menu
     style_out = set_dark_style(ttk.Style())
@@ -197,7 +170,7 @@ def display_figure(fig):
             #flash_feedback("right")
             show_next_figure()
 
-    def zoom(event):
+    def zoom_v1(event):
         nonlocal scale_factor
 
         zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
@@ -230,16 +203,55 @@ def display_figure(fig):
         # Redraw the figure
         fig.canvas.draw_idle()
 
+    def zoom(event):
+        nonlocal scale_factor
+
+        zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
+
+        # Determine the zoom direction based on the scroll event
+        if event.num == 4 or event.delta > 0:  # Scroll up (zoom in)
+            scale_factor /= (1 + zoom_speed)  # Divide to zoom in
+        elif event.num == 5 or event.delta < 0:  # Scroll down (zoom out)
+            scale_factor *= (1 + zoom_speed)  # Multiply to zoom out
+
+        # Adjust the axes limits based on the new scale factor
+        for ax in canvas.figure.get_axes():
+            xlim = ax.get_xlim()
+            ylim = ax.get_ylim()
+
+            x_center = (xlim[1] + xlim[0]) / 2
+            y_center = (ylim[1] + ylim[0]) / 2
+
+            x_range = (xlim[1] - xlim[0]) * scale_factor
+            y_range = (ylim[1] - ylim[0]) * scale_factor
+
+            # Set the new limits
+            ax.set_xlim([x_center - x_range / 2, x_center + x_range / 2])
+            ax.set_ylim([y_center - y_range / 2, y_center + y_range / 2])
+
+        # Redraw the figure efficiently
+        canvas.draw_idle()
+
+
     # Bind events for hover, click interactions, and zoom
     canvas_widget.bind("<Motion>", on_hover)
     canvas_widget.bind("<Leave>", on_leave)
     canvas_widget.bind("<Button-1>", on_click)
     canvas_widget.bind("<Button-3>", on_right_click)
 
-    # Bind mouse wheel for zooming (cross-platform)
-    canvas_widget.bind("<MouseWheel>", zoom)  # Windows
-    canvas_widget.bind("<Button-4>", zoom)  # Linux/macOS Scroll Up
-    canvas_widget.bind("<Button-5>", zoom)  # Linux/macOS Scroll Down
+
+    # Detect the operating system and bind the appropriate mouse wheel events
+    current_os = platform.system()
+
+    if current_os == "Windows":
+        canvas_widget.bind("<MouseWheel>", zoom)  # Windows
+    elif current_os == "Darwin":  # macOS
+        canvas_widget.bind("<MouseWheel>", zoom)
+        canvas_widget.bind("<Button-4>", zoom)  # Scroll up
+        canvas_widget.bind("<Button-5>", zoom)  # Scroll down
+    elif current_os == "Linux":
+        canvas_widget.bind("<Button-4>", zoom)  # Linux Scroll up
+        canvas_widget.bind("<Button-5>", zoom)  # Linux Scroll down
 
 def clear_unused_figures():
     global figures, figure_index
@@ -253,6 +265,7 @@ def clear_unused_figures():
 
 def show_previous_figure():
     global figure_index, figures, fig_queue
+    
     if figure_index is not None and figure_index > 0:
         figure_index -= 1
         display_figure(figures[figure_index])
@@ -270,8 +283,104 @@ def show_next_figure():
         figure_index += 1
         display_figure(fig)
 
-def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var, vars_dict_var, canvas_var, canvas_widget_var, scrollable_frame_var, fig_queue_var, figures_var, figure_index_var, progress_bar_var, usage_bars_var, fig_memory_limit_var, figure_current_memory_usage_var):
-    global thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, progress_bar, usage_bars, fig_memory_limit, figure_current_memory_usage
+def process_fig_queue():
+    global canvas, fig_queue, canvas_widget, parent_frame, uppdate_frequency, figures, figure_index, index_control
+
+    from .gui_elements import standardize_figure
+    try:
+        while not fig_queue.empty():
+            fig = fig_queue.get_nowait()
+
+            if fig is None:
+                print("Warning: Retrieved a None figure from fig_queue.")
+                continue  # Skip processing if the figure is None
+
+            # Standardize the figure appearance before adding it to the list
+            fig = standardize_figure(fig)
+
+            figures.append(fig)
+
+            # Update the slider range and set the value to the latest figure index
+            index_control.set_to(len(figures) - 1)
+
+            if figure_index == -1:
+                figure_index += 1
+                display_figure(figures[figure_index])
+                index_control.set(figure_index)
+            
+    except Exception as e:
+        traceback.print_exc()
+    finally:
+        after_id = canvas_widget.after(uppdate_frequency, process_fig_queue)
+        parent_frame.after_tasks.append(after_id)
+
+def update_figure(value):
+    global figure_index, figures
+
+    # Convert the value to an integer
+    index = int(value)
+    
+    # Check if the index is valid
+    if 0 <= index < len(figures):
+        figure_index = index
+        display_figure(figures[figure_index])
+
+    # Update the index control widget's range and value
+    index_control.set_to(len(figures) - 1)
+    index_control.set(figure_index)
+
+def setup_plot_section(vertical_container):
+    global canvas, canvas_widget, figures, figure_index, index_control
+
+    # Initialize deque for storing figures and the current index
+    figures = deque()
+
+    # Create a frame for the plot section
+    plot_frame = tk.Frame(vertical_container)
+    vertical_container.add(plot_frame, stretch="always")
+
+    # Set up the plot
+    figure = Figure(figsize=(30, 4), dpi=100)
+    plot = figure.add_subplot(111)
+    plot.plot([], [])
+    plot.axis('off')
+    
+    canvas = FigureCanvasTkAgg(figure, master=plot_frame)
+    canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
+    canvas_widget = canvas.get_tk_widget()
+    canvas_widget.grid(row=0, column=0, sticky="nsew")
+
+    plot_frame.grid_rowconfigure(0, weight=1)
+    plot_frame.grid_columnconfigure(0, weight=1)
+
+    canvas.draw()
+    canvas.figure = figure  # Ensure that the figure is linked to the canvas
+    style_out = set_dark_style(ttk.Style())
+    bg = style_out['bg_color']
+    fg = style_out['fg_color']
+
+    figure.patch.set_facecolor(bg)
+    plot.set_facecolor(bg)
+    containers = [plot_frame]
+
+    # Create slider
+    control_frame = tk.Frame(plot_frame, height=15*2,  bg=bg)  # Fixed height based on knob_radius
+    control_frame.grid(row=1, column=0, sticky="ew", padx=10, pady=5)
+    control_frame.grid_propagate(False)  # Prevent the frame from resizing
+
+    # Pass the update_figure function as the command to spacrSlider
+    index_control = spacrSlider(control_frame, from_=0, to=0, value=0, thickness=2, knob_radius=10, position="center", show_index=True, command=update_figure)
+    index_control.grid(row=0, column=0, sticky="ew")
+    control_frame.grid_columnconfigure(0, weight=1)
+
+    widgets = [canvas_widget, index_control]
+    style = ttk.Style(vertical_container)
+    _ = set_dark_style(style, containers=containers, widgets=widgets)
+
+    return canvas, canvas_widget
+
+def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var, vars_dict_var, canvas_var, canvas_widget_var, scrollable_frame_var, fig_queue_var, figures_var, figure_index_var, index_control_var, progress_bar_var, usage_bars_var):
+    global thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, progress_bar, usage_bars, index_control
     thread_control = thread_control_var
     q = q_var
     console_output = console_output_var
@@ -285,8 +394,7 @@ def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var,
     figure_index = figure_index_var
     progress_bar = progress_bar_var
     usage_bars = usage_bars_var
-    fig_memory_limit = fig_memory_limit_var
-    figure_current_memory_usage = figure_current_memory_usage_var
+    index_control = index_control_var
 
 def import_settings(settings_type='mask'):
     from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
@@ -400,46 +508,6 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     print("Settings panel setup complete")
     return scrollable_frame, vars_dict
 
-def setup_plot_section(vertical_container):
-    global canvas, canvas_widget, figures, figure_index
-
-    from .gui_elements import set_element_size
-
-    # Initialize deque for storing figures and the current index
-    figures = deque()
-    figure_index = -1
-
-    # Create a frame for the plot section
-    plot_frame = tk.Frame(vertical_container)
-    vertical_container.add(plot_frame, stretch="always")
-
-    # Set up the plot
-    figure = Figure(figsize=(30, 4), dpi=100)
-    plot = figure.add_subplot(111)
-    plot.plot([], [])
-    plot.axis('off')
-    
-    canvas = FigureCanvasTkAgg(figure, master=plot_frame)
-    canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
-    canvas_widget = canvas.get_tk_widget()
-    canvas_widget.grid(row=0, column=0, sticky="nsew")
-
-    plot_frame.grid_rowconfigure(0, weight=1)
-    plot_frame.grid_columnconfigure(0, weight=1)
-
-    canvas.draw()
-    canvas.figure = figure  # Ensure that the figure is linked to the canvas
-    style_out = set_dark_style(ttk.Style())
-
-    figure.patch.set_facecolor(style_out['bg_color'])
-    plot.set_facecolor(style_out['bg_color'])
-    containers = [plot_frame]
-    widgets = [canvas_widget]
-    style = ttk.Style(vertical_container)
-    _ = set_dark_style(style, containers=containers, widgets=widgets)
-    
-    return canvas, canvas_widget
-
 def setup_console(vertical_container):
     global console_output
     from .gui_elements import set_dark_style
@@ -479,27 +547,6 @@ def setup_console(vertical_container):
 
     return console_output, console_frame
 
-def setup_progress_frame(vertical_container):
-    global progress_output
-    style_out = set_dark_style(ttk.Style())
-    font_loader = style_out['font_loader']
-    font_size = style_out['font_size']
-    progress_frame = tk.Frame(vertical_container)
-    vertical_container.add(progress_frame, stretch="always")
-    label_frame = tk.Frame(progress_frame)
-    label_frame.grid(row=0, column=0, sticky="ew", pady=(5, 0), padx=10)
-    progress_label = spacrLabel(label_frame, text="Processing: 0%", font=font_loader.get_font(size=font_size), anchor='w', justify='left', align="left")
-    progress_label.grid(row=0, column=0, sticky="w")
-    progress_output = scrolledtext.ScrolledText(progress_frame, height=10)
-    progress_output.grid(row=1, column=0, sticky="nsew")
-    progress_frame.grid_rowconfigure(1, weight=1)
-    progress_frame.grid_columnconfigure(0, weight=1)
-    containers = [progress_frame, label_frame]
-    widgets = [progress_label, progress_output]
-    style = ttk.Style(vertical_container)
-    _ = set_dark_style(style, containers=containers, widgets=widgets)
-    return progress_output
-
 def setup_button_section(horizontal_container, settings_type='mask', run=True, abort=True, download=True, import_btn=True):
     global thread_control, parent_frame, button_frame, button_scrollable_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict, progress_bar
     from .gui_utils import download_hug_dataset
@@ -836,7 +883,7 @@ def initiate_root(parent, settings_type='mask'):
         tuple: A tuple containing the parent frame and the dictionary of variables used in the GUI.
     """
     
-    global q, fig_queue, thread_control, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar, uppdate_frequency, figures, figure_index, fig_memory_limit, figure_current_memory_usage
+    global q, fig_queue, thread_control, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar, uppdate_frequency, figures, figure_index, index_control, usage_bars
     
     from .gui_utils import setup_frame
     from .settings import descriptions
@@ -853,8 +900,6 @@ def initiate_root(parent, settings_type='mask'):
     # Initialize global variables
     figures = deque()
     figure_index = -1
-    fig_memory_limit = 200 * 1024 * 1024  # 200 MB limit
-    figure_current_memory_usage = 0
 
     parent_frame = parent
 
@@ -886,7 +931,7 @@ def initiate_root(parent, settings_type='mask'):
         button_scrollable_frame, btn_col = setup_button_section(horizontal_container, settings_type)
         _, usage_bars, btn_col = setup_usage_panel(horizontal_container, btn_col, uppdate_frequency)
 
-        set_globals(thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, progress_bar, usage_bars, fig_memory_limit, figure_current_memory_usage)
+        set_globals(thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, index_control, progress_bar, usage_bars)
         description_text = descriptions.get(settings_type, "No description available for this module.")
         
         q.put(f"Console")
@@ -899,4 +944,6 @@ def initiate_root(parent, settings_type='mask'):
         parent_window.after_tasks.append(after_id)
 
     print("Root initialization complete")
-    return parent_frame, vars_dict
+    return parent_frame, vars_dict
+
+

spacr/gui_elements.py

@@ -670,25 +670,189 @@ class spacrProgressBar(ttk.Progressbar):
 
     def update_label(self):
         if self.label and self.progress_label:
-            # Update the progress label with current progress and additional info
+            # Start with the base progress information
             label_text = f"Processing: {self['value']}/{self['maximum']}"
+            
+            # Include the operation type if it exists
             if self.operation_type:
                 label_text += f", {self.operation_type}"
+            
+            # Handle additional info without adding newlines
             if hasattr(self, 'additional_info') and self.additional_info:
-                # Add a space between progress information and additional information
-                label_text += "\n\n"
-                # Split the additional_info into a list of items
+                # Join all additional info items with a space and ensure they're on the same line
                 items = self.additional_info.split(", ")
-                formatted_additional_info = ""
-                # Group the items in pairs, adding them to formatted_additional_info
-                for i in range(0, len(items), 2):
-                    if i + 1 < len(items):
-                        formatted_additional_info += f"{items[i]}, {items[i + 1]}\n\n"
-                    else:
-                        formatted_additional_info += f"{items[i]}\n\n"  # If there's an odd item out, add it alone
-                label_text += formatted_additional_info.strip()
+                formatted_additional_info = " ".join(items)
+
+                # Append the additional info to the label_text, ensuring it's all in one line
+                label_text += f" {formatted_additional_info.strip()}"
+
+            # Update the progress label
             self.progress_label.config(text=label_text)
 
+class spacrSlider(tk.Frame):
+    def __init__(self, master=None, length=None, thickness=2, knob_radius=10, position="center", from_=0, to=100, value=None, show_index=False, command=None, **kwargs):
+        super().__init__(master, **kwargs)
+
+        self.specified_length = length  # Store the specified length, if any
+        self.knob_radius = knob_radius
+        self.thickness = thickness
+        self.knob_position = knob_radius  # Start at the beginning of the slider
+        self.slider_line = None
+        self.knob = None
+        self.position = position.lower()  # Store the position option
+        self.offset = 0  # Initialize offset
+        self.from_ = from_  # Minimum value of the slider
+        self.to = to  # Maximum value of the slider
+        self.value = value if value is not None else from_  # Initial value of the slider
+        self.show_index = show_index  # Whether to show the index Entry widget
+        self.command = command  # Callback function to handle value changes
+
+        # Initialize the style and colors
+        style_out = set_dark_style(ttk.Style())
+        self.fg_color = style_out['fg_color']
+        self.bg_color = style_out['bg_color']
+        self.active_color = style_out['active_color']
+        self.inactive_color = style_out['inactive_color']
+
+        # Configure the frame's background color
+        self.configure(bg=self.bg_color)
+
+        # Create a frame for the slider and entry if needed
+        self.grid_columnconfigure(1, weight=1)
+
+        # Entry widget for showing and editing index, if enabled
+        if self.show_index:
+            self.index_var = tk.StringVar(value=str(int(self.value)))
+            self.index_entry = tk.Entry(self, textvariable=self.index_var, width=5, bg=self.bg_color, fg=self.fg_color, insertbackground=self.fg_color)
+            self.index_entry.grid(row=0, column=0, padx=5)
+            # Bind the entry to update the slider on change
+            self.index_entry.bind("<Return>", self.update_slider_from_entry)
+
+        # Create the slider canvas
+        self.canvas = tk.Canvas(self, height=knob_radius * 2, bg=self.bg_color, highlightthickness=0)
+        self.canvas.grid(row=0, column=1, sticky="ew")
+
+        # Set initial length to specified length or default value
+        self.length = self.specified_length if self.specified_length is not None else self.canvas.winfo_reqwidth()
+
+        # Calculate initial knob position based on the initial value
+        self.knob_position = self.value_to_position(self.value)
+
+        # Bind resize event to dynamically adjust the slider length if no length is specified
+        self.canvas.bind("<Configure>", self.resize_slider)
+
+        # Draw the slider components
+        self.draw_slider(inactive=True)
+
+        # Bind mouse events to the knob and slider
+        self.canvas.bind("<B1-Motion>", self.move_knob)
+        self.canvas.bind("<Button-1>", self.activate_knob)  # Activate knob on click
+        self.canvas.bind("<ButtonRelease-1>", self.release_knob)  # Trigger command on release
+
+    def resize_slider(self, event):
+        if self.specified_length is not None:
+            self.length = self.specified_length
+        else:
+            self.length = int(event.width * 0.9)  # 90% of the container width
+        
+        # Calculate the horizontal offset based on the position
+        if self.position == "center":
+            self.offset = (event.width - self.length) // 2
+        elif self.position == "right":
+            self.offset = event.width - self.length
+        else:  # position is "left"
+            self.offset = 0
+
+        # Update the knob position after resizing
+        self.knob_position = self.value_to_position(self.value)
+        self.draw_slider(inactive=True)
+
+    def value_to_position(self, value):
+        if self.to == self.from_:
+            return self.knob_radius
+        relative_value = (value - self.from_) / (self.to - self.from_)
+        return self.knob_radius + relative_value * (self.length - 2 * self.knob_radius)
+
+    def position_to_value(self, position):
+        if self.to == self.from_:
+            return self.from_
+        relative_position = (position - self.knob_radius) / (self.length - 2 * self.knob_radius)
+        return self.from_ + relative_position * (self.to - self.from_)
+
+    def draw_slider(self, inactive=False):
+        self.canvas.delete("all")
+
+        self.slider_line = self.canvas.create_line(
+            self.offset + self.knob_radius, 
+            self.knob_radius, 
+            self.offset + self.length - self.knob_radius, 
+            self.knob_radius, 
+            fill=self.fg_color, 
+            width=self.thickness
+        )
+
+        knob_color = self.inactive_color if inactive else self.active_color
+        self.knob = self.canvas.create_oval(
+            self.offset + self.knob_position - self.knob_radius, 
+            self.knob_radius - self.knob_radius, 
+            self.offset + self.knob_position + self.knob_radius, 
+            self.knob_radius + self.knob_radius, 
+            fill=knob_color, 
+            outline=""
+        )
+
+    def move_knob(self, event):
+        new_position = min(max(event.x - self.offset, self.knob_radius), self.length - self.knob_radius)
+        self.knob_position = new_position
+        self.value = self.position_to_value(self.knob_position)
+        self.canvas.coords(
+            self.knob, 
+            self.offset + self.knob_position - self.knob_radius, 
+            self.knob_radius - self.knob_radius, 
+            self.offset + self.knob_position + self.knob_radius, 
+            self.knob_radius + self.knob_radius
+        )
+        if self.show_index:
+            self.index_var.set(str(int(self.value)))
+
+    def activate_knob(self, event):
+        self.draw_slider(inactive=False)
+        self.move_knob(event)
+
+    def release_knob(self, event):
+        self.draw_slider(inactive=True)
+        if self.command:
+            self.command(self.value)  # Call the command with the final value when the knob is released
+
+    def set_to(self, new_to):
+        self.to = new_to
+        self.knob_position = self.value_to_position(self.value)
+        self.draw_slider(inactive=False)
+
+    def get(self):
+        return self.value
+
+    def set(self, value):
+        """Set the slider's value and update the knob position."""
+        self.value = max(self.from_, min(value, self.to))  # Ensure the value is within bounds
+        self.knob_position = self.value_to_position(self.value)
+        self.draw_slider(inactive=False)
+        if self.show_index:
+            self.index_var.set(str(int(self.value)))
+
+    def jump_to_click(self, event):
+        self.activate_knob(event)
+
+    def update_slider_from_entry(self, event):
+        """Update the slider's value from the entry."""
+        try:
+            index = int(self.index_var.get())
+            self.set(index)
+            if self.command:
+                self.command(self.value)
+        except ValueError:
+            pass
+
 def spacrScrollbarStyle(style, inactive_color, active_color):
     # Check if custom elements already exist to avoid duplication
     if not style.element_names().count('custom.Vertical.Scrollbar.trough'):
@@ -1987,6 +2151,11 @@ class AnnotateApp:
         style_out = set_dark_style(ttk.Style())
         self.font_loader = style_out['font_loader']
         self.font_size = style_out['font_size']
+        self.bg_color = style_out['bg_color']
+        self.fg_color = style_out['fg_color']
+        self.active_color = style_out['active_color']
+        self.inactive_color = style_out['inactive_color']
+
 
         if self.font_loader:
             self.font_style = self.font_loader.get_font(size=self.font_size)
@@ -2013,13 +2182,13 @@ class AnnotateApp:
         self.button_frame = Frame(root, bg=self.root.cget('bg'))
         self.button_frame.grid(row=2, column=1, padx=10, pady=10, sticky="se")
 
-        self.next_button = Button(self.button_frame, text="Next", command=self.next_page, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.next_button = Button(self.button_frame, text="Next", command=self.next_page, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color, highlightcolor=self.fg_color, highlightthickness=1)
         self.next_button.pack(side="right", padx=5)
 
-        self.previous_button = Button(self.button_frame, text="Back", command=self.previous_page, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.previous_button = Button(self.button_frame, text="Back", command=self.previous_page, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color, highlightcolor=self.fg_color, highlightthickness=1)
         self.previous_button.pack(side="right", padx=5)
 
-        self.exit_button = Button(self.button_frame, text="Exit", command=self.shutdown, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.exit_button = Button(self.button_frame, text="Exit", command=self.shutdown, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color, highlightcolor=self.fg_color, highlightthickness=1)
         self.exit_button.pack(side="right", padx=5)
 
         # Calculate grid rows and columns based on the root window size and image size
@@ -2169,7 +2338,7 @@ class AnnotateApp:
 
         for i, (img, annotation) in enumerate(loaded_images):
             if annotation:
-                border_color = 'teal' if annotation == 1 else 'red'
+                border_color = self.active_color if annotation == 1 else 'red'
                 img = self.add_colored_border(img, border_width=5, border_color=border_color)
 
             photo = ImageTk.PhotoImage(img)
@@ -2215,7 +2384,7 @@ class AnnotateApp:
         left_border = Image.new('RGB', (border_width, img.height), color=border_color)
         right_border = Image.new('RGB', (border_width, img.height), color=border_color)
 
-        bordered_img = Image.new('RGB', (img.width + 2 * border_width, img.height + 2 * border_width), color='white')
+        bordered_img = Image.new('RGB', (img.width + 2 * border_width, img.height + 2 * border_width), color=self.fg_color)
         bordered_img.paste(top_border, (border_width, 0))
         bordered_img.paste(bottom_border, (border_width, img.height + border_width))
         bordered_img.paste(left_border, (0, border_width))
@@ -2255,7 +2424,7 @@ class AnnotateApp:
             print(f"Image {os.path.split(path)[1]} annotated: {new_annotation}")
             
             img_ = img.crop((5, 5, img.width-5, img.height-5))
-            border_fill = 'teal' if new_annotation == 1 else ('red' if new_annotation == 2 else None)
+            border_fill = self.active_color if new_annotation == 1 else ('red' if new_annotation == 2 else None)
             img_ = ImageOps.expand(img_, border=5, fill=border_fill) if border_fill else img_
 
             photo = ImageTk.PhotoImage(img_)
@@ -2400,6 +2569,7 @@ def standardize_figure(fig):
     - Line width: 1
     - Line color: from style
     """
+    
 
     for ax in fig.get_axes():
         # Set font properties for title and labels
@@ -2448,6 +2618,8 @@ def standardize_figure(fig):
 
     fig.canvas.draw_idle()
 
+    return fig
+
 def modify_figure_properties(fig, scale_x=None, scale_y=None, line_width=None, font_size=None, x_lim=None, y_lim=None, grid=False, legend=None, title=None, x_label_rotation=None, remove_axes=False, bg_color=None, text_color=None, line_color=None):
     """
     Modifies the properties of the figure, including scaling, line widths, font sizes, axis limits, x-axis label rotation, background color, text color, line color, and other common options.