spacr 0.2.1__py3-none-any.whl → 0.2.21__py3-none-any.whl

spacr/get_alfafold_structures.py

@@ -1,72 +0,0 @@
-import csv
-import os
-import requests
-
-def download_alphafold_structures(tsv_location, dst, version="4"):
-    # Create the destination directory if it does not exist
-    dst_pdb = os.path.join(dst,'pdb')
-    dst_cif = os.path.join(dst,'cif')
-    dst_pae = os.path.join(dst,'pae')
-    
-    if not os.path.exists(dst):
-        os.makedirs(dst)
-    if not os.path.exists(dst_pdb):
-        os.makedirs(dst_pdb)
-    if not os.path.exists(dst_cif):
-        os.makedirs(dst_cif)
-    if not os.path.exists(dst_pae):
-        os.makedirs(dst_pae)
-
-    failed_downloads = []  # List to keep track of failed downloads
-
-    # Open the TSV file and read entries
-    with open(tsv_location, 'r') as tsv_file:
-        reader = csv.DictReader(tsv_file, delimiter='\t')
-        for row in reader:
-            entry = row['Entry']
-            af_link = f"https://alphafold.ebi.ac.uk/files/AF-{entry}-F1-model_v{version}.pdb"
-            cif_link = f"https://alphafold.ebi.ac.uk/files/AF-{entry}-F1-model_v{version}.cif"
-            pae_link = f"https://alphafold.ebi.ac.uk/files/AF-{entry}-F1-predicted_aligned_error_v{version}.json"
-
-            try:
-                response_pdb = requests.get(af_link, stream=True)
-                response_cif = requests.get(cif_link, stream=True)
-                response_pae = requests.get(pae_link, stream=True)
-                if response_pdb.status_code == 200:
-                    
-                    # Save the PDB file
-                    with open(os.path.join(dst_pdb, f"AF-{entry}-F1-model_v{version}.pdb"), 'wb') as pdb_file:
-                        pdb_file.write(response_pdb.content)
-                    print(f"Downloaded: AF-{entry}-F1-model_v{version}.pdb")
-                    
-                    # Save the CIF file
-                    with open(os.path.join(dst_cif, f"AF-{entry}-F1-model_v{version}.cif"), 'wb') as cif_file:
-                        cif_file.write(response_cif.content)
-                    print(f"Downloaded: AF-{entry}-F1-model_v{version}.cif")
-                    
-                    # Save the PAE file
-                    with open(os.path.join(dst_pae, f"AF-{entry}-F1-predicted_aligned_error_v{version}.json"), 'wb') as pdb_file:
-                        pdb_file.write(response_pae.content)
-                    print(f"Downloaded: AF-{entry}-F1-predicted_aligned_error_v{version}.json")
-                    
-                else:
-                    # If the file could not be downloaded, record the entry
-                    failed_downloads.append(entry)
-                    print(f"Failed to download structure for: {entry}")
-            except Exception as e:
-                print(f"Error downloading structure for {entry}: {e}")
-                failed_downloads.append(entry)
-
-    # Save the list of failed downloads to a CSV file in the destination folder
-    if failed_downloads:
-        with open(os.path.join(dst, 'failed_downloads.csv'), 'w', newline='') as failed_file:
-            writer = csv.writer(failed_file)
-            writer.writerow(['Entry'])
-            for entry in failed_downloads:
-                writer.writerow([entry])
-        print(f"Failed download entries saved to: {os.path.join(dst, 'failed_downloads.csv')}")
-
-# Example usage:
-#tsv_location = '/home/carruthers/Downloads/GT1_proteome/GT1_proteins_uniprot.tsv'  # Replace with the path to your TSV file containing a list of UniProt entries
-#dst_folder = '/home/carruthers/Downloads/GT1_proteome'  # Replace with your destination folder
-#download_alphafold_structures(tsv_location, dst_folder)

spacr/gui_2.py

@@ -1,157 +0,0 @@
-import tkinter as tk
-from tkinter import ttk
-from PIL import Image, ImageTk, ImageDraw
-import os
-from multiprocessing import set_start_method
-from .gui_elements import spacrButton, create_menu_bar, set_dark_style
-from .gui_core import initiate_root
-
-class MainApp(tk.Tk):
-    def __init__(self, default_app=None):
-        super().__init__()
-        width = self.winfo_screenwidth()
-        height = self.winfo_screenheight()
-        self.geometry(f"{width}x{height}")
-        self.title("SpaCr GUI Collection")
-        self.configure(bg='#333333')  # Set window background to dark gray
-
-        # Initialize style and apply dark style to the main window
-        style = ttk.Style()
-        self.color_settings = set_dark_style(style, parent_frame=self)
-        self.main_buttons = {}  # Initialize main_buttons dictionary here
-        self.additional_buttons = {}  # Initialize additional_buttons dictionary here
-
-        self.main_gui_apps = {
-            "Mask": (lambda frame: initiate_root(frame, 'mask'), "Generate cellpose masks for cells, nuclei and pathogen images."),
-            "Measure": (lambda frame: initiate_root(frame, 'measure'), "Measure single object intensity and morphological feature. Crop and save single object image"),
-            "Annotate": (lambda frame: initiate_root(frame, 'annotate'), "Annotation single object images on a grid. Annotations are saved to database."),
-            "Make Masks": (lambda frame: initiate_root(frame, 'make_masks'), "Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
-            "Classify": (lambda frame: initiate_root(frame, 'classify'), "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images."),
-        }
-
-        self.additional_gui_apps = {
-            "Sequencing": (lambda frame: initiate_root(frame, 'sequencing'), "Analyze sequencing data."),
-            "Umap": (lambda frame: initiate_root(frame, 'umap'), "Generate UMAP embeddings with datapoints represented as images."),
-            "Train Cellpose": (lambda frame: initiate_root(frame, 'train_cellpose'), "Train custom Cellpose models."),
-            "ML Analyze": (lambda frame: initiate_root(frame, 'ml_analyze'), "Machine learning analysis of data."),
-            "Cellpose Masks": (lambda frame: initiate_root(frame, 'cellpose_masks'), "Generate Cellpose masks."),
-            "Cellpose All": (lambda frame: initiate_root(frame, 'cellpose_all'), "Run Cellpose on all images."),
-            "Map Barcodes": (lambda frame: initiate_root(frame, 'map_barcodes'), "Map barcodes to data."),
-            "Regression": (lambda frame: initiate_root(frame, 'regression'), "Perform regression analysis."),
-            "Recruitment": (lambda frame: initiate_root(frame, 'recruitment'), "Analyze recruitment data.")
-        }
-
-        self.selected_app = tk.StringVar()
-        self.create_widgets()
-
-        if default_app in self.main_gui_apps:
-            self.load_app(default_app, self.main_gui_apps[default_app][0])
-        elif default_app in self.additional_gui_apps:
-            self.load_app(default_app, self.additional_gui_apps[default_app][0])
-
-    def create_widgets(self):
-        # Create the menu bar
-        create_menu_bar(self)
-
-        # Create a canvas to hold the selected app and other elements
-        self.canvas = tk.Canvas(self, highlightthickness=0)
-        self.canvas.grid(row=0, column=0, sticky="nsew")
-        self.grid_rowconfigure(0, weight=1)
-        self.grid_columnconfigure(0, weight=1)
-
-        # Create a frame inside the canvas to hold the main content
-        self.content_frame = tk.Frame(self.canvas)
-        self.content_frame.grid(row=0, column=0, sticky="nsew")
-
-        # Center the content frame within the canvas
-        self.canvas.create_window((self.winfo_screenwidth() // 2, self.winfo_screenheight() // 2), window=self.content_frame, anchor="center")
-
-        # Apply dark style to canvas and content_frame
-        set_dark_style(ttk.Style(), containers=[self.canvas, self.content_frame])
-
-        # Create startup screen with buttons for each main GUI app and drop-down for additional apps
-        self.create_startup_screen()
-
-    def create_startup_screen(self):
-        self.clear_frame(self.content_frame)
-
-        # Create frames for the grids
-        main_buttons_frame = tk.Frame(self.content_frame)
-        main_buttons_frame.pack(pady=10)
-        set_dark_style(ttk.Style(), containers=[main_buttons_frame])
-
-        additional_buttons_frame = tk.Frame(self.content_frame)
-        additional_buttons_frame.pack(pady=10)
-        set_dark_style(ttk.Style(), containers=[additional_buttons_frame])
-
-        # Create a frame for the description below the icon grids
-        description_frame = tk.Frame(self.content_frame, height=50)
-        description_frame.pack(fill=tk.X, pady=10)
-        description_frame.pack_propagate(False)  # Prevent the frame from resizing based on its content
-        set_dark_style(ttk.Style(), containers=[description_frame])
-
-        # Use a Label widget to display descriptions
-        self.description_label = tk.Label(description_frame, text="", wraplength=800, justify="center", font=('Helvetica', 12), fg=self.color_settings['fg_color'], bg=self.color_settings['bg_color'])
-        self.description_label.pack(fill=tk.BOTH, pady=10)
-
-        # Load the logo image and place it in the main apps row
-        logo_button = spacrButton(main_buttons_frame, text="SpaCr", command=lambda: self.load_app("logo_spacr", initiate_root), icon_name="logo_spacr", size=100, show_text=False)
-        logo_button.grid(row=0, column=0, padx=5, pady=5)
-        self.main_buttons[logo_button] = "SpaCr: An advanced application suite for cellpose masks, measurements, annotations, and more."
-
-        # Create icon buttons for the main apps
-        for i, (app_name, app_data) in enumerate(self.main_gui_apps.items()):
-            app_func, app_desc = app_data
-            button = spacrButton(main_buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), icon_name=app_name.lower(), size=100, show_text=False)
-            button.grid(row=0, column=i + 1, padx=5, pady=5)
-            self.main_buttons[button] = app_desc
-
-        # Create icon buttons for the additional apps
-        for i, (app_name, app_data) in enumerate(self.additional_gui_apps.items()):
-            app_func, app_desc = app_data
-            button = spacrButton(additional_buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), icon_name=app_name.lower(), size=75, show_text=False)
-            button.grid(row=0, column=i, padx=5, pady=5)
-            self.additional_buttons[button] = app_desc
-
-        # Update description initially
-        self.update_description()
-
-    def update_description(self):
-        # Check all buttons and update description if any has the active color
-        for button, desc in {**self.main_buttons, **self.additional_buttons}.items():
-            if button.canvas.itemcget(button.button_bg, "fill") == self.color_settings['active_color']:
-                self.show_description(desc)
-                return
-        self.clear_description()
-
-    def show_description(self, description):
-        if self.description_label.winfo_exists():
-            self.description_label.config(text=description)
-            self.description_label.update_idletasks()  # Ensure the label updates immediately
-
-    def clear_description(self):
-        if self.description_label.winfo_exists():
-            self.description_label.config(text="")
-            self.description_label.update_idletasks()  # Ensure the label updates immediately
-
-    def load_app(self, app_name, app_func):
-        # Clear the current content frame
-        self.clear_frame(self.canvas)
-
-        # Initialize the selected app
-        app_frame = tk.Frame(self.canvas)
-        app_frame.pack(fill=tk.BOTH, expand=True)
-        set_dark_style(ttk.Style(), containers=[app_frame])
-        app_func(app_frame)
-
-    def clear_frame(self, frame):
-        for widget in frame.winfo_children():
-            widget.destroy()
-
-def gui_app():
-    app = MainApp()
-    app.mainloop()
-
-if __name__ == "__main__":
-    set_start_method('spawn', force=True)
-    gui_app()

spacr/gui_annotate.py

@@ -1,145 +0,0 @@
-import tkinter as tk
-from tkinter import ttk
-from tkinter import font as tkFont
-from PIL import Image, ImageTk
-import os
-import requests
-
-# Import your GUI apps
-from .gui_mask_app import initiate_mask_root
-from .gui_measure_app import initiate_measure_root
-from .annotate_app import initiate_annotation_app_root
-from .mask_app import initiate_mask_app_root
-from .gui_classify_app import initiate_classify_root
-
-from .gui_utils import CustomButton, style_text_boxes
-
-class MainApp(tk.Tk):
-    def __init__(self):
-        super().__init__()
-        self.title("SpaCr GUI Collection")
-        self.geometry("1100x1500")
-        self.configure(bg="black")
-        #self.attributes('-fullscreen', True)
-
-        style = ttk.Style()
-        style_text_boxes(style)
-
-        self.gui_apps = {
-            "Mask": (initiate_mask_root, "Generate cellpose masks for cells, nuclei and pathogen images."),
-            "Measure": (initiate_measure_root, "Measure single object intensity and morphological feature. Crop and save single object image"),
-            "Annotate": (initiate_annotation_app_root, "Annotation single object images on a grid. Annotations are saved to database."),
-            "Make Masks": (initiate_mask_app_root, "Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
-            "Classify": (initiate_classify_root, "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images.")
-        }
-
-        self.selected_app = tk.StringVar()
-        self.create_widgets()
-
-    def create_widgets(self):
-        # Create the menu bar
-        #create_menu_bar(self)
-        # Create a canvas to hold the selected app and other elements
-        self.canvas = tk.Canvas(self, bg="black", highlightthickness=0, width=4000, height=4000)
-        self.canvas.grid(row=0, column=0, sticky="nsew")
-        self.grid_rowconfigure(0, weight=1)
-        self.grid_columnconfigure(0, weight=1)
-        # Create a frame inside the canvas to hold the main content
-        self.content_frame = tk.Frame(self.canvas, bg="black")
-        self.content_frame.pack(fill=tk.BOTH, expand=True)
-        # Create startup screen with buttons for each GUI app
-        self.create_startup_screen()
-
-    def create_startup_screen(self):
-        self.clear_frame(self.content_frame)
-
-        # Create a frame for the logo and description
-        logo_frame = tk.Frame(self.content_frame, bg="black")
-        logo_frame.pack(pady=20, expand=True)
-
-        # Load the logo image
-        if not self.load_logo(logo_frame):
-            tk.Label(logo_frame, text="Logo not found", bg="black", fg="white", font=('Helvetica', 24, tkFont.NORMAL)).pack(padx=10, pady=10)
-
-        # Add SpaCr text below the logo with padding for sharper text
-        tk.Label(logo_frame, text="SpaCr", bg="black", fg="#008080", font=('Helvetica', 24, tkFont.NORMAL)).pack(padx=10, pady=10)
-
-        # Create a frame for the buttons and descriptions
-        buttons_frame = tk.Frame(self.content_frame, bg="black")
-        buttons_frame.pack(pady=10, expand=True, padx=10)
-
-        for i, (app_name, app_data) in enumerate(self.gui_apps.items()):
-            app_func, app_desc = app_data
-
-            # Create custom button with text
-            button = CustomButton(buttons_frame, text=app_name, command=lambda app_name=app_name: self.load_app(app_name), font=('Helvetica', 12))
-            button.grid(row=i, column=0, pady=10, padx=10, sticky="w")
-
-            description_label = tk.Label(buttons_frame, text=app_desc, bg="black", fg="white", wraplength=800, justify="left", font=('Helvetica', 10, tkFont.NORMAL))
-            description_label.grid(row=i, column=1, pady=10, padx=10, sticky="w")
-
-        # Ensure buttons have a fixed width
-        buttons_frame.grid_columnconfigure(0, minsize=150)
-        # Ensure descriptions expand as needed
-        buttons_frame.grid_columnconfigure(1, weight=1)
-
-    def load_logo(self, frame):
-        def download_image(url, save_path):
-            try:
-                response = requests.get(url, stream=True)
-                response.raise_for_status()  # Raise an HTTPError for bad responses
-                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')
-            print(f"Trying to load logo from {img_path}")
-            logo_image = Image.open(img_path)
-        except (FileNotFoundError, Image.UnidentifiedImageError):
-            print(f"File {img_path} not found or is not a valid image. Attempting to download from GitHub.")
-            if download_image('https://raw.githubusercontent.com/EinarOlafsson/spacr/main/spacr/logo_spacr.png', img_path):
-                try:
-                    print(f"Downloaded file size: {os.path.getsize(img_path)} bytes")
-                    logo_image = Image.open(img_path)
-                except Image.UnidentifiedImageError as e:
-                    print(f"Downloaded file is not a valid image: {e}")
-                    return False
-            else:
-                return False
-        except Exception as e:
-            print(f"An error occurred while loading the logo: {e}")
-            return False
-        try:
-            logo_image = logo_image.resize((800, 800), Image.Resampling.LANCZOS)
-            logo_photo = ImageTk.PhotoImage(logo_image)
-            logo_label = tk.Label(frame, image=logo_photo, bg="black")
-            logo_label.image = logo_photo  # Keep a reference to avoid garbage collection
-            logo_label.pack()
-            return True
-        except Exception as e:
-            print(f"An error occurred while processing the logo image: {e}")
-            return False
-
-    def load_app(self, app_name):
-        selected_app_func, _ = self.gui_apps[app_name]
-        self.clear_frame(self.content_frame)
-
-        app_frame = tk.Frame(self.content_frame, bg="black")
-        app_frame.pack(fill=tk.BOTH, expand=True)
-        selected_app_func(app_frame)#, self.winfo_width(), self.winfo_height())
-
-    def clear_frame(self, frame):
-        for widget in frame.winfo_children():
-            widget.destroy()
-
-def gui_app():
-    app = MainApp()
-    app.mainloop()
-
-if __name__ == "__main__":
-    gui_app()

spacr/gui_classify_app.py

@@ -1,201 +0,0 @@
-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):
-    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="Helvetica", 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", command=lambda: import_settings(scrollable_frame), font=('Helvetica', 10))
-    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), font=('Helvetica', 10))
-    run_button.grid(row=45, column=0, pady=20, padx=20)
-    abort_button = CustomButton(scrollable_frame.scrollable_frame, text="Abort", command=initiate_abort, font=('Helvetica', 10))
-    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()
-    width = root.winfo_screenwidth()
-    height = root.winfo_screenheight()
-    root.geometry(f"{width}x{height}") 
-    root.title("SpaCr: classify objects")
-    
-    # Clear previous content if any
-    if hasattr(root, 'content_frame'):
-        for widget in root.content_frame.winfo_children():
-            widget.destroy()
-        root.content_frame.grid_forget()
-    else:
-        root.content_frame = tk.Frame(root)
-        root.content_frame.grid(row=1, column=0, sticky="nsew")
-        root.grid_rowconfigure(1, weight=1)
-        root.grid_columnconfigure(0, weight=1)
-    
-    initiate_classify_root(root.content_frame)
-    create_menu_bar(root)
-    root.mainloop()
-
-if __name__ == "__main__":
-    gui_classify()