spacr 0.1.0__py3-none-any.whl → 0.1.11__py3-none-any.whl

spacr/annotate_app_v2.py

@@ -1,16 +1,18 @@
+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 .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):
@@ -509,3 +511,160 @@ 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):
+    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 = app.shutdown
+    root.next_app_func = None
+    root.next_app_args = ()
+
+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:
+        next_app_func(*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/classify_app.py

@@ -0,0 +1,201 @@
+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()

spacr/gui.py

@@ -9,10 +9,9 @@ import requests
 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_make_masks_app import initiate_mask_app_root
 from .gui_classify_app import initiate_classify_root
-
-from .gui_utils import CustomButton, style_text_boxes
+from .gui_utils import CustomButton, style_text_boxes, create_menu_bar
 
 class MainApp(tk.Tk):
     def __init__(self):
@@ -38,18 +37,24 @@ class MainApp(tk.Tk):
 
     def create_widgets(self):
         # Create the menu bar
-        #create_menu_bar(self)
+        self.gui_create_menu_bar()
+
         # 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 = tk.Canvas(self, bg="black", 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, 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 gui_create_menu_bar(self):
+        create_menu_bar(self)
+
     def create_startup_screen(self):
         self.clear_frame(self.content_frame)
 
@@ -59,10 +64,10 @@ class MainApp(tk.Tk):
 
         # Load the logo image
         if not self.load_logo(logo_frame):
-            tk.Label(logo_frame, text="Logo not found", bg="black", fg="white", font=('Arial', 24, tkFont.NORMAL)).pack(padx=10, pady=10)
+            tk.Label(logo_frame, text="Logo not found", bg="black", fg="white", font=('Helvetica', 24)).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=('Arial', 24, tkFont.NORMAL)).pack(padx=10, pady=10)
+        tk.Label(logo_frame, text="SpaCr", bg="black", fg="#008080", font=('Helvetica', 24)).pack(padx=10, pady=10)
 
         # Create a frame for the buttons and descriptions
         buttons_frame = tk.Frame(self.content_frame, bg="black")
@@ -72,10 +77,10 @@ class MainApp(tk.Tk):
             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))
+            button = CustomButton(buttons_frame, text=app_name, command=lambda app_name=app_name: self.load_app(app_name, app_func), 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=('Arial', 10, tkFont.NORMAL))
+            description_label = tk.Label(buttons_frame, text=app_desc, bg="black", fg="white", wraplength=800, justify="left", font=('Helvetica', 12))
             description_label.grid(row=i, column=1, pady=10, padx=10, sticky="w")
 
         # Ensure buttons have a fixed width
@@ -125,13 +130,14 @@ class MainApp(tk.Tk):
             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]
+    def load_app(self, app_name, app_func):
+        # Clear the current content frame
         self.clear_frame(self.content_frame)
 
+        # Initialize the selected app
         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())
+        app_func(app_frame)
 
     def clear_frame(self, frame):
         for widget in frame.winfo_children():
@@ -142,4 +148,4 @@ def gui_app():
     app.mainloop()
 
 if __name__ == "__main__":
-    gui_app()
+    gui_app()

spacr/gui_2.py

@@ -1,52 +1,93 @@
-import customtkinter as ctk
+import tkinter as tk
+from tkinter import ttk
+from tkinter import font as tkFont
 from PIL import Image, ImageTk
 import os
 import requests
 
-class MainApp(ctk.CTk):
+# 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("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.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):
-        self.content_frame = ctk.CTkFrame(self)
-        self.content_frame.pack(fill="both", expand=True, padx=20, pady=20)
+        # 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()
 
-        logo_frame = ctk.CTkFrame(self.content_frame)
+    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):
-            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)
+            tk.Label(logo_frame, text="Logo not found", bg="black", fg="white", font=('Helvetica', 24)).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)).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, app_func), 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', 12))
+            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()
+                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)
@@ -57,34 +98,63 @@ class MainApp(ctk.CTk):
 
         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((200, 200), Image.Resampling.LANCZOS)
+            logo_image = logo_image.resize((800, 800), Image.Resampling.LANCZOS)
             logo_photo = ImageTk.PhotoImage(logo_image)
-            logo_label = ctk.CTkLabel(frame, image=logo_photo)
+            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_mask_app(self):
-        print("Mask app loaded.")  # Placeholder for mask app loading function
+    def load_app_v1(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)
+
+    def load_app(root, app_name, app_func):
+        if hasattr(root, 'current_app_id'):
+            root.after_cancel(root.current_app_id)
+        root.current_app_id = None
+
+        # Clear the current content frame
+        for widget in root.content_frame.winfo_children():
+            widget.destroy()
+
+        # Initialize the selected app
+        app_frame = tk.Frame(root.content_frame, bg="black")
+        app_frame.pack(fill=tk.BOTH, expand=True)
+        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__":
-    gui_app()
+    gui_app()