spacr 0.1.64__py3-none-any.whl → 0.1.75__py3-none-any.whl

spacr/core.py

@@ -971,7 +971,7 @@ def generate_dataset(src, file_metadata=None, experiment='TSG101_screen', sample
     shutil.rmtree(temp_dir)
     print(f"\nSaved {total_images} images to {tar_name}")
 
-def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=224, batch_size=64, normalize=True, preload='images', num_workers=10, threshold=0.5, verbose=False):
+def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=224, batch_size=64, normalize=True, preload='images', n_job=10, threshold=0.5, verbose=False):
     
     from .io import TarImageDataset
     from .utils import process_vision_results
@@ -994,7 +994,7 @@ def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=22
     model = torch.load(model_path)
     
     dataset = TarImageDataset(tar_path, transform=transform)
-    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=True)
+    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, n_job=n_job, pin_memory=True)
     
     model_name = os.path.splitext(os.path.basename(model_path))[0] 
     dataset_name = os.path.splitext(os.path.basename(tar_path))[0]  
@@ -1034,7 +1034,7 @@ def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=22
     torch.cuda.memory.empty_cache()
     return df
 
-def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True, num_workers=10):
+def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True, n_job=10):
     
     from .io import NoClassDataset
     
@@ -1055,7 +1055,7 @@ def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True,
     
     print(f'Loading dataset in {src} with {len(src)} images')
     dataset = NoClassDataset(data_dir=src, transform=transform, shuffle=True, load_to_memory=False)
-    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
+    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, n_job=n_job)
     print(f'Loaded {len(src)} images')
     
     result_loc = os.path.splitext(model_path)[0]+datetime.date.today().strftime('%y%m%d')+'_'+os.path.splitext(model_path)[1]+'_test_result.csv'
@@ -1302,7 +1302,7 @@ def generate_training_dataset(src, mode='annotation', annotation_column='test',
     
     return
 
-def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_size=32, classes=['nc','pc'], num_workers=None, validation_split=0.0, max_show=2, pin_memory=False, normalize=False, channels=[1, 2, 3], augment=False, verbose=False):
+def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_size=32, classes=['nc','pc'], n_job=None, validation_split=0.0, max_show=2, pin_memory=False, normalize=False, channels=[1, 2, 3], augment=False, verbose=False):
     
     """
     Generate data loaders for training and validation/test datasets.
@@ -1314,7 +1314,7 @@ def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_
     - image_size (int): The size of the input images.
     - batch_size (int): The batch size for the data loaders.
     - classes (list): The list of classes to consider.
-    - num_workers (int): The number of worker threads for data loading.
+    - n_job (int): The number of worker threads for data loading.
     - validation_split (float): The fraction of data to use for validation when train_mode is 'erm'.
     - max_show (int): The maximum number of images to show when verbose is True.
     - pin_memory (bool): Whether to pin memory for faster data transfer.
@@ -1404,10 +1404,10 @@ def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_
                 #val_dataset = augment_dataset(val_dataset, is_grayscale=(len(channels) == 1))
                 print(f'Data after augmentation: Train: {len(train_dataset)}')#, Validataion:{len(val_dataset)}')
 
-            train_loaders = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
-            val_loaders = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+            train_loaders = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
+            val_loaders = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
         else:
-            train_loaders = DataLoader(data, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+            train_loaders = DataLoader(data, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
         
     elif train_mode == 'irm':
         data = MyDataset(data_dir, classes, transform=transform, shuffle=shuffle, pin_memory=pin_memory)
@@ -1436,13 +1436,13 @@ def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_
                     #val_dataset = augment_dataset(val_dataset, is_grayscale=(len(channels) == 1))
                     print(f'Data after augmentation: Train: {len(train_dataset)}')#, Validataion:{len(val_dataset)}')
 
-                train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
-                val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+                train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
+                val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
 
                 train_loaders.append(train_loader)
                 val_loaders.append(val_loader)
             else:
-                train_loader = DataLoader(plate_data, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+                train_loader = DataLoader(plate_data, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
                 train_loaders.append(train_loader)
                 val_loaders.append(None)
     
@@ -2078,11 +2078,11 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
                             else:
                                 radius = 100
 
-                            workers = os.cpu_count()-2
-                            if workers < 1:
-                                workers = 1
+                            n_job = os.cpu_count()-2
+                            if n_job < 1:
+                                n_job = 1
 
-                            mask_stack = _btrack_track_cells(src, name, batch_filenames, object_type, plot, save, masks_3D=masks, mode=timelapse_mode, timelapse_remove_transient=timelapse_remove_transient, radius=radius, workers=workers)
+                            mask_stack = _btrack_track_cells(src, name, batch_filenames, object_type, plot, save, masks_3D=masks, mode=timelapse_mode, timelapse_remove_transient=timelapse_remove_transient, radius=radius, n_job=n_job)
                         if timelapse_mode == 'trackpy':
                             mask_stack = _trackpy_track_cells(src, name, batch_filenames, object_type, masks, timelapse_displacement, timelapse_memory, timelapse_remove_transient, plot, save, timelapse_mode)
                             
@@ -2303,9 +2303,9 @@ def generate_cellpose_masks(src, settings, object_type):
                         else:
                             radius = 100
 
-                        workers = os.cpu_count()-2
-                        if workers < 1:
-                            workers = 1
+                        n_job = os.cpu_count()-2
+                        if n_job < 1:
+                            n_job = 1
 
                         mask_stack = _btrack_track_cells(src=src,
                                                          name=name,
@@ -2317,7 +2317,7 @@ def generate_cellpose_masks(src, settings, object_type):
                                                          mode=timelapse_mode,
                                                          timelapse_remove_transient=timelapse_remove_transient,
                                                          radius=radius,
-                                                         workers=workers)
+                                                         n_job=n_job)
                     if timelapse_mode == 'trackpy':
                         mask_stack = _trackpy_track_cells(src=src,
                                                           name=name,
@@ -2551,7 +2551,7 @@ def compare_cellpose_masks(src, verbose=False, processes=None, save=True):
         common_files.intersection_update(os.listdir(d))
     common_files = list(common_files)
 
-    # Create a pool of workers
+    # Create a pool of n_job
     with Pool(processes=processes) as pool:
         args = [(src, filename, dirs, conditions) for filename in common_files]
         results = pool.map(compare_mask, args)

spacr/deep_spacr.py

@@ -230,7 +230,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                                                     image_size=settings['image_size'],
                                                     batch_size=settings['batch_size'], 
                                                     classes=settings['classes'], 
-                                                    num_workers=settings['num_workers'],
+                                                    n_job=settings['n_job'],
                                                     validation_split=settings['val_split'],
                                                     pin_memory=settings['pin_memory'],
                                                     normalize=settings['normalize'],
@@ -255,7 +255,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                             optimizer_type = settings['optimizer_type'], 
                             use_checkpoint = settings['use_checkpoint'], 
                             dropout_rate = settings['dropout_rate'], 
-                            num_workers = settings['num_workers'], 
+                            n_job = settings['n_job'], 
                             val_loaders = val, 
                             test_loaders = None, 
                             intermedeate_save = settings['intermedeate_save'],
@@ -276,7 +276,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                                                      image_size=settings['image_size'],
                                                      batch_size=settings['batch_size'], 
                                                      classes=settings['classes'], 
-                                                     num_workers=settings['num_workers'],
+                                                     n_job=settings['n_job'],
                                                      validation_split=0.0,
                                                      pin_memory=settings['pin_memory'],
                                                      normalize=settings['normalize'],
@@ -315,7 +315,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
     torch.cuda.memory.empty_cache()
     gc.collect()
     
-def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='erm', epochs=100, learning_rate=0.0001, weight_decay=0.05, amsgrad=False, optimizer_type='adamw', use_checkpoint=False, dropout_rate=0, num_workers=20, val_loaders=None, test_loaders=None, init_weights='imagenet', intermedeate_save=None, chan_dict=None, schedule = None, loss_type='binary_cross_entropy_with_logits', gradient_accumulation=False, gradient_accumulation_steps=4, channels=['r','g','b']):
+def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='erm', epochs=100, learning_rate=0.0001, weight_decay=0.05, amsgrad=False, optimizer_type='adamw', use_checkpoint=False, dropout_rate=0, n_job=20, val_loaders=None, test_loaders=None, init_weights='imagenet', intermedeate_save=None, chan_dict=None, schedule = None, loss_type='binary_cross_entropy_with_logits', gradient_accumulation=False, gradient_accumulation_steps=4, channels=['r','g','b']):
     """
     Trains a model using the specified parameters.
 
@@ -332,7 +332,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
         optimizer_type (str, optional): The type of optimizer to use. Defaults to 'adamw'.
         use_checkpoint (bool, optional): Whether to use checkpointing during training. Defaults to False.
         dropout_rate (float, optional): The dropout rate for the model. Defaults to 0.
-        num_workers (int, optional): The number of workers for data loading. Defaults to 20.
+        n_job (int, optional): The number of n_job for data loading. Defaults to 20.
         val_loaders (list, optional): A list of validation data loaders. Defaults to None.
         test_loaders (list, optional): A list of test data loaders. Defaults to None.
         init_weights (str, optional): The initialization weights for the model. Defaults to 'imagenet'.
@@ -357,7 +357,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
         
     use_cuda = torch.cuda.is_available()
     device = torch.device("cuda" if use_cuda else "cpu")
-    kwargs = {'num_workers': num_workers, 'pin_memory': True} if use_cuda else {}
+    kwargs = {'n_job': n_job, 'pin_memory': True} if use_cuda else {}
     
     for idx, (images, labels, filenames) in enumerate(train_loaders):
         batch, chans, height, width = images.shape

spacr/gui.py

@@ -5,8 +5,6 @@ import os, requests
 from multiprocessing import set_start_method
 from .gui_elements import spacrButton, create_menu_bar, set_dark_style
 from .gui_core import initiate_root
-from .app_annotate import initiate_annotation_app_root
-from .app_make_masks import initiate_mask_app_root
 
 class MainApp(tk.Tk):
     def __init__(self, default_app=None):
@@ -22,8 +20,8 @@ class MainApp(tk.Tk):
         self.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": (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"),
+            "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."),
             "Sequencing": (lambda frame: initiate_root(frame, 'sequencing'), "Analyze sequensing data."),
             "Umap": (lambda frame: initiate_root(frame, 'umap'), "Generate UMAP embedings with datapoints represented as images.")
@@ -32,21 +30,8 @@ class MainApp(tk.Tk):
         self.selected_app = tk.StringVar()
         self.create_widgets()
 
-
-        if default_app == "Mask":
+        if default_app in self.gui_apps:
             self.load_app(default_app, self.gui_apps[default_app][0])
-        elif default_app == "Measure":
-            self.load_app(default_app, self.gui_apps[default_app][1])
-        elif default_app == "Annotate":
-            self.load_app(default_app, self.gui_apps[default_app][2])
-        elif default_app == "Make Masks":
-            self.load_app(default_app, self.gui_apps[default_app][3])
-        elif default_app == "Classify":
-            self.load_app(default_app, self.gui_apps[default_app][4])
-        elif default_app == "Sequencing":
-            self.load_app(default_app, self.gui_apps[default_app][5])
-        elif default_app == "Umap":
-            self.load_app(default_app, self.gui_apps[default_app][6])
 
     def create_widgets(self):
         # Create the menu bar
@@ -88,7 +73,6 @@ class MainApp(tk.Tk):
 
             # Create custom button with text
             button = spacrButton(buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), font=('Helvetica', 12))
-            #button = ttk.Button(buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), style='Custom.TButton')
             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))
@@ -161,4 +145,4 @@ def gui_app():
 
 if __name__ == "__main__":
     set_start_method('spawn', force=True)
-    gui_app()
+    gui_app()

spacr/gui_core.py

@@ -1,11 +1,11 @@
-import os, traceback, ctypes, matplotlib, requests, csv, re
+import os, traceback, ctypes, matplotlib, requests, csv
 matplotlib.use('Agg')
 import tkinter as tk
 from tkinter import ttk
-import tkinter.font as tkFont
 from tkinter import filedialog
-from tkinter import font as tkFont
-from multiprocessing import Process, Value, Queue, Manager, set_start_method
+from multiprocessing import Process, Value, Queue
+from multiprocessing.sharedctypes import Synchronized
+from multiprocessing import set_start_method
 from tkinter import ttk, scrolledtext
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
@@ -14,7 +14,7 @@ import requests
 from huggingface_hub import list_repo_files
 
 from .settings import set_default_train_test_model, get_measure_crop_settings, set_default_settings_preprocess_generate_masks, get_analyze_reads_default_settings, set_default_umap_image_settings
-from .gui_elements import create_menu_bar, spacrButton, spacrLabel, spacrFrame, spacrCheckbutton, spacrDropdownMenu ,set_dark_style, set_default_font
+from .gui_elements import create_menu_bar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style, set_default_font
 from . gui_run import run_mask_gui, run_measure_gui, run_classify_gui, run_sequencing_gui, run_umap_gui
 
 try:
@@ -37,21 +37,18 @@ thread_control = {"run_thread": None, "stop_requested": False}
 
 def initiate_abort():
     global thread_control
-    if thread_control.get("stop_requested") is not None:
-        if isinstance(thread_control["stop_requested"], Value):
-            thread_control["stop_requested"].value = 1
-
+    if isinstance(thread_control.get("stop_requested"), Synchronized):
+        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"].terminate()
+        thread_control["run_thread"].join()
         thread_control["run_thread"] = None
 
-def start_process(q, fig_queue, settings_type='mask'):
+def start_process_v1(q, fig_queue, settings_type='mask'):
     global thread_control, vars_dict
-    from .settings import check_settings
+    from .settings import check_settings, expected_types
 
-    settings = check_settings(vars_dict)
+    settings = check_settings(vars_dict, expected_types, q)
     if thread_control.get("run_thread") is not None:
         initiate_abort()
     stop_requested = Value('i', 0)  # multiprocessing shared value for inter-process communication
@@ -68,9 +65,47 @@ def start_process(q, fig_queue, settings_type='mask'):
         thread_control["run_thread"] = Process(target=run_umap_gui, args=(settings, q, fig_queue, stop_requested))
     thread_control["run_thread"].start()
 
-def import_settings(settings_type='mask'):
+def start_process(q=None, fig_queue=None, settings_type='mask'):
+    global thread_control, vars_dict
+    from .settings import check_settings, expected_types
 
-    global vars_dict, scrollable_frame
+    if q is None:
+        q = Queue()
+    if fig_queue is None:
+        fig_queue = Queue()
+
+    try:
+        settings = check_settings(vars_dict, expected_types, q)
+    except ValueError as e:
+        q.put(f"Error: {e}")
+        return
+
+    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
+
+    process_args = (settings, q, fig_queue, stop_requested)
+
+    if settings_type == 'mask':
+        thread_control["run_thread"] = Process(target=run_mask_gui, args=process_args)
+    elif settings_type == 'measure':
+        thread_control["run_thread"] = Process(target=run_measure_gui, args=process_args)
+    elif settings_type == 'classify':
+        thread_control["run_thread"] = Process(target=run_classify_gui, args=process_args)
+    elif settings_type == 'sequencing':
+        thread_control["run_thread"] = Process(target=run_sequencing_gui, args=process_args)
+    elif settings_type == 'umap':
+        thread_control["run_thread"] = Process(target=run_umap_gui, args=process_args)
+    else:
+        q.put(f"Error: Unknown settings type '{settings_type}'")
+        return
+
+    thread_control["run_thread"].start()
+
+def import_settings(settings_type='mask'):
+    global vars_dict, scrollable_frame, button_scrollable_frame
     from .settings import generate_fields
 
     def read_settings_from_csv(csv_file_path):
@@ -98,6 +133,7 @@ def import_settings(settings_type='mask'):
     if not csv_file_path:  # If no file is selected, return early
         return
     
+    #vars_dict = hide_all_settings(vars_dict, categories=None)
     csv_settings = read_settings_from_csv(csv_file_path)
     if settings_type == 'mask':
         settings = set_default_settings_preprocess_generate_masks(src='path', settings={})
@@ -115,6 +151,7 @@ def import_settings(settings_type='mask'):
     variables = convert_settings_dict_for_gui(settings)
     new_settings = update_settings_from_csv(variables, csv_settings)
     vars_dict = generate_fields(new_settings, scrollable_frame)
+    vars_dict = hide_all_settings(vars_dict, categories=None)
 
 def convert_settings_dict_for_gui(settings):
     variables = {}
@@ -314,9 +351,8 @@ def download_dataset(repo_id, subfolder, local_dir=None, retries=5, delay=5):
 
     raise Exception("Failed to download files after multiple attempts.")
 
-
 def setup_button_section(horizontal_container, settings_type='mask', settings_row=5, run=True, abort=True, download=True, import_btn=True):
-    global button_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict
+    global button_frame, button_scrollable_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict
 
     button_frame = tk.Frame(horizontal_container, bg='black')
     horizontal_container.add(button_frame, stretch="always", sticky="nsew")
@@ -357,60 +393,29 @@ def setup_button_section(horizontal_container, settings_type='mask', settings_ro
         toggle_settings(button_scrollable_frame)
     return button_scrollable_frame
 
-def toggle_settings_v1(button_scrollable_frame):
-    global vars_dict
-    from .settings import categories
-
-    if vars_dict is None:
-        raise ValueError("vars_dict is not initialized.")
+def hide_all_settings(vars_dict, categories):
+    """
+    Function to initially hide all settings in the GUI.
 
-    def toggle_category(settings, var):
-        for setting in settings:
-            if setting in vars_dict:
-                label, widget, _ = vars_dict[setting]
-                if var.get() == 0:
-                    label.grid_remove()
-                    widget.grid_remove()
-                else:
-                    label.grid()
-                    widget.grid()
+    Parameters:
+    - categories: dict, The categories of settings with their corresponding settings.
+    - vars_dict: dict, The dictionary containing the settings and their corresponding widgets.
+    """
 
-    row = 1
-    col = 3 
-    category_idx = 0
+    if categories is None:
+        from .settings import categories
 
     for category, settings in categories.items():
         if any(setting in vars_dict for setting in settings):
-            category_var = tk.IntVar(value=0)
-            vars_dict[category] = (None, None, category_var)
-            toggle = spacrCheckbutton(
-                button_scrollable_frame.scrollable_frame, 
-                text=category, 
-                variable=category_var, 
-                command=lambda cat=settings, var=category_var: toggle_category(cat, var)
-            )
-            # Directly set the style
-            style = ttk.Style()
-            font_style = tkFont.Font(family="Helvetica", size=12, weight="bold")
-            style.configure('Spacr.TCheckbutton', font=font_style, background='black', foreground='#ffffff', indicatoron=False, relief='flat')
-            style.map('Spacr.TCheckbutton', background=[('selected', 'black'), ('active', 'black')], foreground=[('selected', '#ffffff'), ('active', '#ffffff')])
-            toggle.configure(style='Spacr.TCheckbutton')
-            toggle.grid(row=row, column=col, sticky="w", pady=2, padx=2)
-            #row += 1
-            col += 1
-            category_idx += 1
-
-            if category_idx % 4 == 0:  
-                row += 1
-                col = 2
-
-    for settings in categories.values():
-        for setting in settings:
-            if setting in vars_dict:
-                label, widget, _ = vars_dict[setting]
-                label.grid_remove()
-                widget.grid_remove()
-
+            vars_dict[category] = (None, None, tk.IntVar(value=0))
+            
+            # Initially hide all settings
+            for setting in settings:
+                if setting in vars_dict:
+                    label, widget, _ = vars_dict[setting]
+                    label.grid_remove()
+                    widget.grid_remove()
+    return vars_dict
 
 def toggle_settings(button_scrollable_frame):
     global vars_dict
@@ -449,16 +454,7 @@ def toggle_settings(button_scrollable_frame):
     non_empty_categories = [category for category, settings in categories.items() if any(setting in vars_dict for setting in settings)]
     category_dropdown = spacrDropdownMenu(button_scrollable_frame.scrollable_frame, category_var, non_empty_categories, command=on_category_select)
     category_dropdown.grid(row=1, column=3, sticky="ew", pady=2, padx=2)
-
-    for category, settings in categories.items():
-        if any(setting in vars_dict for setting in settings):
-            vars_dict[category] = (None, None, tk.IntVar(value=0))
-            # Initially hide all settings
-            for setting in settings:
-                if setting in vars_dict:
-                    label, widget, _ = vars_dict[setting]
-                    label.grid_remove()
-                    widget.grid_remove()
+    vars_dict = hide_all_settings(vars_dict, categories)
 
 def process_fig_queue():
     global canvas, fig_queue, canvas_widget, parent_frame
@@ -531,66 +527,55 @@ def setup_frame(parent_frame):
     return parent_frame, vertical_container, horizontal_container
 
 def initiate_root(parent, settings_type='mask'):
-
-    def main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label):
-        try:
-            ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
-            while not q.empty():
-                message = q.get_nowait()
-                clean_message = ansi_escape_pattern.sub('', message)
-                if clean_message.startswith("Progress"):
-                    progress_label.config(text=clean_message)
-                if clean_message.startswith("\rProgress"):
-                    progress_label.config(text=clean_message)
-                elif clean_message.startswith("Successfully"):
-                    progress_label.config(text=clean_message)
-                elif clean_message.startswith("Processing"):
-                    progress_label.config(text=clean_message)
-                elif clean_message.startswith("scale"):
-                    pass
-                elif clean_message.startswith("plot_cropped_arrays"):
-                    pass
-                elif clean_message == "" or clean_message == "\r" or clean_message.strip() == "":
-                    pass
-                else:
-                    print(clean_message)
-        except Exception as e:
-            print(f"Error updating GUI canvas: {e}")
-        finally:
-            root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label))
-
     global q, fig_queue, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, progress_label, button_scrollable_frame
+    from .gui_utils import main_thread_update_function
+    from .gui import gui_app
+    set_start_method('spawn', force=True)
+    
     print("Initializing root with settings_type:", settings_type)
     parent_frame = parent
 
     if not hasattr(parent_frame, 'after_tasks'):
         parent_frame.after_tasks = []
 
+    # Clear previous content instead of destroying the root
     for widget in parent_frame.winfo_children():
-        if widget.winfo_exists():
-            try:
-                widget.destroy()
-            except tk.TclError as e:
-                print(f"Error destroying widget: {e}")
+        try:
+            widget.destroy()
+        except tk.TclError as e:
+            print(f"Error destroying widget: {e}")
 
     q = Queue()
     fig_queue = Queue()
     parent_frame, vertical_container, horizontal_container = setup_frame(parent_frame)
-    scrollable_frame, vars_dict = setup_settings_panel(horizontal_container, settings_type)  # Adjust height and width as needed
-    button_scrollable_frame = setup_button_section(horizontal_container, settings_type)
-    canvas, canvas_widget = setup_plot_section(vertical_container)
-    console_output = setup_console(vertical_container)
 
-    if settings_type in ['mask', 'measure', 'classify', 'sequencing']:
-        progress_output = setup_progress_frame(vertical_container)
+    if settings_type == 'annotate':
+        from .app_annotate import initiate_annotation_app
+        initiate_annotation_app(horizontal_container)
+    elif settings_type == 'make_masks':
+        from .app_make_masks import initiate_make_mask_app
+        initiate_make_mask_app(horizontal_container)
+    elif settings_type is None:
+        #parent.quit()
+        parent_frame.destroy()
+        gui_app()
     else:
-        progress_output = None
+        scrollable_frame, vars_dict = setup_settings_panel(horizontal_container, settings_type)
+        button_scrollable_frame = setup_button_section(horizontal_container, settings_type)
+        canvas, canvas_widget = setup_plot_section(vertical_container)
+        console_output = setup_console(vertical_container)
+
+        if settings_type in ['mask', 'measure', 'classify', 'sequencing']:
+            progress_output = setup_progress_frame(vertical_container)
+        else:
+            progress_output = None
+
+        set_globals(q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, progress_label, fig_queue)
+        process_console_queue()
+        process_fig_queue()
+        after_id = parent_frame.after(100, lambda: main_thread_update_function(parent_frame, q, fig_queue, canvas_widget, progress_label))
+        parent_frame.after_tasks.append(after_id)
 
-    set_globals(q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, progress_label, fig_queue)
-    process_console_queue()
-    process_fig_queue()
-    after_id = parent_frame.after(100, lambda: main_thread_update_function(parent_frame, q, fig_queue, canvas_widget, progress_label))
-    parent_frame.after_tasks.append(after_id)
     print("Root initialization complete")
     return parent_frame, vars_dict