spacr 0.1.1__tar.gz → 0.1.12__tar.gz

{spacr-0.1.1/spacr.egg-info → spacr-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.1.1
+Version: 0.1.12
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -40,6 +40,10 @@ Requires-Dist: ttf_opensans>=2020.10.30
 Requires-Dist: customtkinter<6.0,>=5.2.2
 Requires-Dist: biopython<2.0,>=1.80
 Requires-Dist: lxml<6.0,>=5.1.0
+Requires-Dist: qtpy<2.5,>=2.4.1
+Requires-Dist: superqt<0.7,>=0.6.7
+Requires-Dist: pyqt6<6.8,>=6.7.1
+Requires-Dist: pyqtgraph<0.14,>=0.13.7
 Provides-Extra: dev
 Requires-Dist: pytest>=3.9; extra == "dev"
 Provides-Extra: headless

{spacr-0.1.1 → spacr-0.1.12}/setup.py

@@ -52,12 +52,16 @@ dependencies = [
     'ttf_opensans>=2020.10.30',
     'customtkinter>=5.2.2,<6.0', 
     'biopython>=1.80,<2.0',
-    'lxml>=5.1.0,<6.0'
+    'lxml>=5.1.0,<6.0', 
+    'qtpy>=2.4.1,<2.5',
+    'superqt>=0.6.7,<0.7',
+    'pyqt6>=6.7.1,<6.8',
+    'pyqtgraph>=0.13.7,<0.14'
 ]
 
 setup(
     name="spacr",
-    version="0.1.01",
+    version="0.1.12",
     author="Einar Birnir Olafsson",
     author_email="olafsson@med.umich.com",
     description="Spatial phenotype analysis of crisp screens (SpaCr)",
@@ -71,12 +75,12 @@ setup(
         'console_scripts': [
             'mask=spacr.gui_mask_app:gui_mask',
             'measure=spacr.gui_measure_app:gui_measure',
-            'make_masks=spacr.mask_app:gui_make_masks',
-            'annotate=spacr.annotate_app:gui_annotation',
+            'make_masks=spacr.gui_make_mask_app:gui_make_masks',
+            'make_masks2=spacr.gui_make_mask_app_v2:gui_make_masks',
+            'annotate=spacr.annotate_app_v2:gui_annotate',
             'classify=spacr.gui_classify_app:gui_classify',
             'sim=spacr.gui_sim_app:gui_sim',
             'gui=spacr.gui:gui_app',
-            'gui2=spacr.gui_2:gui_app',
         ],
     },
     extras_require={

{spacr-0.1.1 → spacr-0.1.12}/spacr/__init__.py

@@ -12,13 +12,13 @@ from . import sim
 from . import sequencing
 from . import timelapse
 from . import deep_spacr
-from . import annotate_app
-from . import annotate_app_v2
+from . import app_annotate
 from . import gui_utils
-from . import mask_app
-from . import gui_mask_app
-from . import gui_measure_app
-from . import gui_classify_app
+from . import app_make_masks
+from . import app_make_masks_v2
+from . import app_mask
+from . import app_measure
+from . import app_classify
 from . import logger
 
 
@@ -33,13 +33,13 @@ __all__ = [
     "sequencing"
     "timelapse",
     "deep_spacr",
-    "annotate_app",
-    "annotate_app_v2",
+    "app_annotate",
     "gui_utils",
-    "mask_app",
-    "gui_mask_app",
-    "gui_measure_app",
-    "gui_classify_app",
+    "app_make_masks",
+    "app_make_masks_v2",
+    "app_mask",
+    "app_measure",
+    "app_classify",
     "logger"
 ]
 

spacr-0.1.1/spacr/annotate_app_v2.py → spacr-0.1.12/spacr/app_annotate.py

@@ -1,37 +1,22 @@
+import sqlite3
 from queue import Queue
-from tkinter import Label, Entry, Button
+from tkinter import Label
 import tkinter as tk
+from tkinter import ttk
 import os, threading, time, sqlite3
 import numpy as np
 from PIL import Image, ImageOps
 from concurrent.futures import ThreadPoolExecutor
 from PIL import ImageTk
-import pandas as pd
 from skimage.exposure import rescale_intensity
-import cv2
-import matplotlib.pyplot as plt
 from IPython.display import display, HTML
+from tkinter import font as tkFont
+from tkinter import TclError
+
+from .gui_utils import ScrollableFrame, CustomButton, set_dark_style, set_default_font, style_text_boxes, create_menu_bar
 
 class ImageApp:
     def __init__(self, root, db_path, src, image_type=None, channels=None, grid_rows=None, grid_cols=None, image_size=(200, 200), annotation_column='annotate', normalize=False, percentiles=(1,99), measurement=None, threshold=None):
-        """
-        Initializes an instance of the ImageApp class.
-
-        Parameters:
-        - root (tkinter.Tk): The root window of the application.
-        - db_path (str): The path to the SQLite database.
-        - src (str): The source directory that should be upstream of 'data' in the paths.
-        - image_type (str): The type of images to display.
-        - channels (list): The channels to filter in the images.
-        - grid_rows (int): The number of rows in the image grid.
-        - grid_cols (int): The number of columns in the image grid.
-        - image_size (tuple): The size of the displayed images.
-        - annotation_column (str): The column name for image annotations in the database.
-        - normalize (bool): Whether to normalize images to their 2nd and 98th percentiles. Defaults to False.
-        - measurement (str): The measurement column to filter by.
-        - threshold (float): The threshold value for filtering the measurement column.
-        """
-
         self.root = root
         self.db_path = db_path
         self.src = src
@@ -67,9 +52,6 @@ class ImageApp:
             self.labels.append(label)
 
     def prefilter_paths_annotations(self):
-        """
-        Pre-filters the paths and annotations based on the specified measurement and threshold.
-        """
         from .io import _read_and_join_tables
         from .utils import is_list_of_lists
 
@@ -157,21 +139,6 @@ class ImageApp:
             conn.close()
 
     def load_images(self):
-        """
-        Loads and displays images with annotations.
-
-        This method retrieves image paths and annotations from a pre-filtered list,
-        loads the images using a ThreadPoolExecutor for parallel processing,
-        adds colored borders to images based on their annotations,
-        and displays the images in the corresponding labels.
-
-        Args:
-            None
-
-        Returns:
-            None
-        """
-
         for label in self.labels:
             label.config(image='')
 
@@ -211,16 +178,6 @@ class ImageApp:
         self.root.update()
 
     def load_single_image(self, path_annotation_tuple):
-        """
-        Loads a single image from the given path and annotation tuple.
-
-        Args:
-            path_annotation_tuple (tuple): A tuple containing the image path and its annotation.
-
-        Returns:
-            img (PIL.Image.Image): The loaded image.
-            annotation: The annotation associated with the image.
-        """
         path, annotation = path_annotation_tuple
         img = Image.open(path)
         img = self.normalize_image(img, self.normalize, self.percentiles)
@@ -231,18 +188,6 @@ class ImageApp:
 
     @staticmethod
     def normalize_image(img, normalize=False, percentiles=(1, 99)):
-        """
-        Normalize the pixel values of an image based on the 2nd and 98th percentiles or the image min and max values,
-        and ensure the image is exported as 8-bit.
-
-        Parameters:
-        - img: PIL.Image.Image. The input image to be normalized.
-        - normalize: bool. Whether to normalize based on the 2nd and 98th percentiles.
-        - percentiles: tuple. The percentiles to use for normalization.
-
-        Returns:
-        - PIL.Image.Image. The normalized and 8-bit converted image.
-        """
         img_array = np.array(img)
 
         if normalize:
@@ -259,17 +204,6 @@ class ImageApp:
         return Image.fromarray(img_array)
     
     def add_colored_border(self, img, border_width, border_color):
-        """
-        Adds a colored border to an image.
-
-        Args:
-            img (PIL.Image.Image): The input image.
-            border_width (int): The width of the border in pixels.
-            border_color (str): The color of the border in RGB format.
-
-        Returns:
-            PIL.Image.Image: The image with the colored border.
-        """
         top_border = Image.new('RGB', (img.width, border_width), color=border_color)
         bottom_border = Image.new('RGB', (img.width, border_width), color=border_color)
         left_border = Image.new('RGB', (border_width, img.height), color=border_color)
@@ -285,15 +219,6 @@ class ImageApp:
         return bordered_img
     
     def filter_channels(self, img):
-        """
-        Filters the channels of an image based on the specified channels.
-
-        Args:
-            img (PIL.Image.Image): The input image.
-
-        Returns:
-            PIL.Image.Image: The filtered image.
-        """
         r, g, b = img.split()
         if self.channels:
             if 'r' not in self.channels:
@@ -310,17 +235,6 @@ class ImageApp:
         return Image.merge("RGB", (r, g, b))
 
     def get_on_image_click(self, path, label, img):
-        """
-        Returns a callback function that handles the click event on an image.
-
-        Parameters:
-        path (str): The path of the image file.
-        label (tkinter.Label): The label widget to update with the annotated image.
-        img (PIL.Image.Image): The image object.
-
-        Returns:
-        function: The callback function for the image click event.
-        """
         def on_image_click(event):
             new_annotation = 1 if event.num == 1 else (2 if event.num == 3 else None)
             
@@ -354,11 +268,6 @@ class ImageApp:
         """))
 
     def update_database_worker(self):
-        """
-        Worker function that continuously updates the database with pending updates from the update queue.
-        It retrieves the pending updates from the queue, updates the corresponding records in the database,
-        and resets the text in the HTML and status label.
-        """
         conn = sqlite3.connect(self.db_path)
         c = conn.cursor()
 
@@ -381,51 +290,24 @@ class ImageApp:
                         c.execute(f'UPDATE png_list SET {self.annotation_column} = ? WHERE png_path = ?', (new_annotation, path))
                 conn.commit()
 
-                # Reset the text
                 ImageApp.update_html('')
                 self.status_label.config(text='')
                 self.root.update()
             time.sleep(0.1)
 
     def update_gui_text(self, text):
-        """
-        Update the text of the status label in the GUI.
-
-        Args:
-            text (str): The new text to be displayed in the status label.
-
-        Returns:
-            None
-        """
         self.status_label.config(text=text)
         self.root.update()
 
     def next_page(self):
-        """
-        Moves to the next page of images in the grid.
-
-        If there are pending updates in the dictionary, they are added to the update queue.
-        The pending updates dictionary is then cleared.
-        The index is incremented by the number of rows multiplied by the number of columns in the grid.
-        Finally, the images are loaded for the new page.
-        """
-        if self.pending_updates:  # Check if the dictionary is not empty
+        if self.pending_updates:
             self.update_queue.put(self.pending_updates.copy())
         self.pending_updates.clear()
         self.index += self.grid_rows * self.grid_cols
         self.load_images()
 
     def previous_page(self):
-        """
-        Move to the previous page in the grid.
-
-        If there are pending updates in the dictionary, they are added to the update queue.
-        The dictionary of pending updates is then cleared.
-        The index is decremented by the number of rows multiplied by the number of columns in the grid.
-        If the index becomes negative, it is set to 0.
-        Finally, the images are loaded for the new page.
-        """
-        if self.pending_updates:  # Check if the dictionary is not empty
+        if self.pending_updates:
             self.update_queue.put(self.pending_updates.copy())
         self.pending_updates.clear()
         self.index -= self.grid_rows * self.grid_cols
@@ -434,23 +316,15 @@ class ImageApp:
         self.load_images()
 
     def shutdown(self):
-        """
-        Shuts down the application.
-
-        This method sets the terminate flag to True, clears the pending updates,
-        updates the database, and quits the application.
-
-        """
-        self.terminate = True  # Set terminate first
+        self.terminate = True
         self.update_queue.put(self.pending_updates.copy())
         self.pending_updates.clear()
-        self.db_update_thread.join()  # Join the thread to make sure database is updated
+        self.db_update_thread.join()
         self.root.quit()
         self.root.destroy()
         print(f'Quit application')
 
 def get_annotate_default_settings(settings):
-
     settings.setdefault('image_type', 'cell_png')
     settings.setdefault('channels', ['r', 'g', 'b'])
     settings.setdefault('geom', "3200x2000")
@@ -466,24 +340,6 @@ def get_annotate_default_settings(settings):
     return settings
 
 def annotate(settings):
-    """
-    Annotates images in a database using a graphical user interface.
-
-    Args:
-        db (str): The path to the SQLite database.
-        src (str): The source directory that should be upstream of 'data' in the paths.
-        image_type (str, optional): The type of images to load from the database. Defaults to None.
-        channels (str, optional): The channels of the images to load from the database. Defaults to None.
-        geom (str, optional): The geometry of the GUI window. Defaults to "1000x1100".
-        img_size (tuple, optional): The size of the images to display in the GUI. Defaults to (200, 200).
-        rows (int, optional): The number of rows in the image grid. Defaults to 5.
-        columns (int, optional): The number of columns in the image grid. Defaults to 5.
-        annotation_column (str, optional): The name of the annotation column in the database table. Defaults to 'annotate'.
-        normalize (bool, optional): Whether to normalize images to their 2nd and 98th percentiles. Defaults to False.
-        measurement (str, optional): The measurement column to filter by.
-        threshold (float, optional): The threshold value for filtering the measurement column.
-    """
-
     settings = get_annotate_default_settings(settings)
     src  = settings['src']
 
@@ -509,3 +365,175 @@ def annotate(settings):
     
     app.load_images()
     root.mainloop()
+
+# Global list to keep references to PhotoImage objects
+global_image_refs = []
+
+def initiate_annotation_app_root(parent_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')
+    
+    container = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL, bg='black')
+    container.pack(fill=tk.BOTH, expand=True)
+
+    scrollable_frame = ScrollableFrame(container, bg='black')
+    container.add(scrollable_frame, stretch="always")
+
+    # Setup input fields
+    vars_dict = {
+        'src': ttk.Entry(scrollable_frame.scrollable_frame),
+        'image_type': ttk.Entry(scrollable_frame.scrollable_frame),
+        'channels': ttk.Entry(scrollable_frame.scrollable_frame),
+        'geom': ttk.Entry(scrollable_frame.scrollable_frame),
+        'img_size': ttk.Entry(scrollable_frame.scrollable_frame),
+        'rows': ttk.Entry(scrollable_frame.scrollable_frame),
+        'columns': ttk.Entry(scrollable_frame.scrollable_frame),
+        'annotation_column': ttk.Entry(scrollable_frame.scrollable_frame),
+        'normalize': ttk.Entry(scrollable_frame.scrollable_frame),
+        'percentiles': ttk.Entry(scrollable_frame.scrollable_frame),
+        'measurement': ttk.Entry(scrollable_frame.scrollable_frame),
+        'threshold': ttk.Entry(scrollable_frame.scrollable_frame),
+    }
+
+    default_settings = {
+        'src': 'path',
+        'image_type': 'cell_png',
+        'channels': 'r,g,b',
+        'geom': "3200x2000",
+        'img_size': '(200, 200)',
+        'rows': '10',
+        'columns': '18',
+        'annotation_column': 'recruited_test',
+        'normalize': 'False',
+        'percentiles': '(2,98)',
+        'measurement': 'None',
+        'threshold': 'None'
+    }
+
+    # Arrange input fields and labels
+    row = 0
+    for name, entry in vars_dict.items():
+        ttk.Label(scrollable_frame.scrollable_frame, text=f"{name.replace('_', ' ').capitalize()}:",
+                  background="black", foreground="white").grid(row=row, column=0)
+        entry.insert(0, default_settings[name])
+        entry.grid(row=row, column=1)
+        row += 1
+
+    # Function to be called when "Run" button is clicked
+    def run_app():
+        settings = {key: entry.get() for key, entry in vars_dict.items()}
+        settings['channels'] = settings['channels'].split(',')
+        settings['img_size'] = tuple(map(int, settings['img_size'][1:-1].split(',')))
+        settings['percentiles'] = tuple(map(int, settings['percentiles'][1:-1].split(',')))
+        settings['normalize'] = settings['normalize'].lower() == 'true'
+        settings['rows'] = int(settings['rows'])
+        settings['columns'] = int(settings['columns'])
+        if settings['measurement'].lower() == 'none':
+            settings['measurement'] = None
+        if settings['threshold'].lower() == 'none':
+            settings['threshold'] = None
+        
+        # Clear previous content instead of destroying the root
+        if hasattr(parent_frame, 'winfo_children'):
+            for widget in parent_frame.winfo_children():
+                widget.destroy()
+        
+        # Start the annotate application in the same root window
+        annotate_app(parent_frame, settings)
+        
+    run_button = CustomButton(scrollable_frame.scrollable_frame, text="Run", command=run_app,
+                              font=tkFont.Font(family="Arial", size=12, weight=tkFont.NORMAL))
+    run_button.grid(row=row, column=0, columnspan=2, pady=10, padx=10)
+
+    return parent_frame
+
+def annotate_app(parent_frame, settings):
+    global global_image_refs
+    global_image_refs.clear()
+    root = parent_frame.winfo_toplevel()
+    annotate_with_image_refs(settings, root, lambda: load_next_app(root))
+
+def annotate_with_image_refs(settings, root, shutdown_callback):
+    from .gui_utils import proceed_with_app
+    from .gui import gui_app
+
+    settings = get_annotate_default_settings(settings)
+    src = settings['src']
+
+    db = os.path.join(src, 'measurements/measurements.db')
+    conn = sqlite3.connect(db)
+    c = conn.cursor()
+    c.execute('PRAGMA table_info(png_list)')
+    cols = c.fetchall()
+    if settings['annotation_column'] not in [col[1] for col in cols]:
+        c.execute(f"ALTER TABLE png_list ADD COLUMN {settings['annotation_column']} integer")
+    conn.commit()
+    conn.close()
+
+    app = ImageApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], grid_rows=settings['rows'], grid_cols=settings['columns'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'])
+
+    # Set the canvas background to black
+    root.configure(bg='black')
+
+    next_button = tk.Button(root, text="Next", command=app.next_page, background='black', foreground='white')
+    next_button.grid(row=app.grid_rows, column=app.grid_cols - 1)
+    back_button = tk.Button(root, text="Back", command=app.previous_page, background='black', foreground='white')
+    back_button.grid(row=app.grid_rows, column=app.grid_cols - 2)
+    exit_button = tk.Button(root, text="Exit", command=lambda: [app.shutdown(), shutdown_callback()], background='black', foreground='white')
+    exit_button.grid(row=app.grid_rows, column=app.grid_cols - 3)
+
+    app.load_images()
+
+    # Store the shutdown function and next app details in the root
+    root.current_app_exit_func = lambda: [app.shutdown(), shutdown_callback()]
+    root.next_app_func = proceed_with_app
+    root.next_app_args = ("Main App", gui_app)  # Specify the main app function
+
+def load_next_app(root):
+    # Get the next app function and arguments
+    next_app_func = root.next_app_func
+    next_app_args = root.next_app_args
+
+    if next_app_func:
+        try:
+            if not root.winfo_exists():
+                raise tk.TclError
+            next_app_func(root, *next_app_args)
+        except tk.TclError:
+            # Reinitialize root if it has been destroyed
+            new_root = tk.Tk()
+            width = new_root.winfo_screenwidth()
+            height = new_root.winfo_screenheight()
+            new_root.geometry(f"{width}x{height}")
+            new_root.title("SpaCr Application")
+            next_app_func(new_root, *next_app_args)
+
+
+def gui_annotate():
+    root = tk.Tk()
+    width = root.winfo_screenwidth()
+    height = root.winfo_screenheight()
+    root.geometry(f"{width}x{height}")
+    root.title("Annotate Application")
+    
+    # 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_annotation_app_root(root.content_frame)
+    create_menu_bar(root)
+    root.mainloop()
+
+if __name__ == "__main__":
+    gui_annotate()

spacr-0.1.1/spacr/gui_classify_app.py → spacr-0.1.12/spacr/app_classify.py

@@ -77,7 +77,7 @@ def initiate_classify_root(parent_frame):
     style_text_boxes(style)
     set_default_font(parent_frame, font_name="Helvetica", size=8)
 
-    parent_frame.configure(bg='#333333')
+    parent_frame.configure(bg='black')
     parent_frame.grid_rowconfigure(0, weight=1)
     parent_frame.grid_columnconfigure(0, weight=1)
     fig_queue = Queue()
@@ -94,7 +94,7 @@ def initiate_classify_root(parent_frame):
                     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')
+                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)
@@ -117,9 +117,9 @@ def initiate_classify_root(parent_frame):
     parent_frame.grid_columnconfigure(0, weight=1)
 
     # Settings Section
-    settings_frame = tk.Frame(vertical_container, bg='#333333')
+    settings_frame = tk.Frame(vertical_container, bg='black')
     vertical_container.add(settings_frame, stretch="always")
-    settings_label = ttk.Label(settings_frame, text="Settings", background="#333333", foreground="white")
+    settings_label = ttk.Label(settings_frame, text="Settings", background="black", 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")
@@ -131,11 +131,11 @@ def initiate_classify_root(parent_frame):
     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 = 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))
+    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)
+    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)
@@ -143,23 +143,23 @@ def initiate_classify_root(parent_frame):
     # 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')
+    figure = Figure(figsize=(30, 4), dpi=100, facecolor='black')
     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.get_tk_widget().configure(cursor='arrow', background='black', 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')
+    console_frame = tk.Frame(vertical_container, bg='black')
     vertical_container.add(console_frame, stretch="always")
-    console_label = ttk.Label(console_frame, text="Console", background="#333333", foreground="white")
+    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='#333333', fg='white', insertbackground='white')
+    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)
@@ -177,9 +177,23 @@ def initiate_classify_root(parent_frame):
 
 def gui_classify():
     root = tk.Tk()
-    root.geometry("1000x800")
-    root.title("SpaCer: generate masks")
-    initiate_classify_root(root),
+    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()