spacr 0.1.1__py3-none-any.whl → 0.1.7__py3-none-any.whl

spacr/app_mask.py

@@ -0,0 +1,8 @@
+from .gui import MainApp
+
+def start_mask_app():
+    app = MainApp(default_app="Mask")
+    app.mainloop()
+
+if __name__ == "__main__":
+    start_mask_app()

spacr/app_measure.py

@@ -0,0 +1,8 @@
+from .gui import MainApp
+
+def start_measure_app():
+    app = MainApp(default_app="Measure")
+    app.mainloop()
+
+if __name__ == "__main__":
+    start_measure_app()

spacr/app_sequencing.py

@@ -0,0 +1,8 @@
+from .gui import MainApp
+
+def start_seq_app():
+    app = MainApp(default_app="Sequencing")
+    app.mainloop()
+
+if __name__ == "__main__":
+    start_seq_app()

spacr/app_umap.py

@@ -0,0 +1,8 @@
+from .gui import MainApp
+
+def start_umap_app():
+    app = MainApp(default_app="Umap")
+    app.mainloop()
+
+if __name__ == "__main__":
+    start_umap_app()

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/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)
     
@@ -1668,7 +1668,7 @@ def preprocess_generate_masks(src, settings={}):
 
     from .io import preprocess_img_data, _load_and_concatenate_arrays
     from .plot import plot_merged, plot_arrays
-    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks, _merge_cells_based_on_parasite_overlap, process_masks
+    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks
     from .settings import set_default_settings_preprocess_generate_masks, set_default_plot_merge_settings
     
     settings = set_default_settings_preprocess_generate_masks(src, settings)
@@ -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)
@@ -3021,9 +3021,9 @@ def generate_image_umap(settings={}):
     """
  
     from .io import _read_and_join_tables
-    from .utils import get_db_paths, preprocess_data, reduction_and_clustering, remove_noise, generate_colors, correct_paths, plot_embedding, plot_clusters_grid, cluster_feature_analysis, generate_umap_from_images
-    from .settings import get_umap_image_settings
-    settings = get_umap_image_settings(settings)
+    from .utils import get_db_paths, preprocess_data, reduction_and_clustering, remove_noise, generate_colors, correct_paths, plot_embedding, plot_clusters_grid, cluster_feature_analysis #, generate_umap_from_images
+    from .settings import set_default_umap_image_settings
+    settings = set_default_umap_image_settings(settings)
 
     if isinstance(settings['src'], str):
         settings['src'] = [settings['src']]
@@ -3109,7 +3109,9 @@ def generate_image_umap(settings={}):
 
     else:
         if settings['resnet_features']:
-            numeric_data, embedding, labels = generate_umap_from_images(image_paths, settings['n_neighbors'], settings['min_dist'], settings['metric'], settings['clustering'], settings['eps'], settings['min_samples'], settings['n_jobs'], settings['verbose'])
+            # placeholder for resnet features, not implemented yet
+            pass
+            #numeric_data, embedding, labels = generate_umap_from_images(image_paths, settings['n_neighbors'], settings['min_dist'], settings['metric'], settings['clustering'], settings['eps'], settings['min_samples'], settings['n_jobs'], settings['verbose'])
         else:
             # Apply the trained reducer to the entire dataset
             numeric_data = preprocess_data(all_df, settings['filter_by'], settings['remove_highly_correlated'], settings['log_data'], settings['exclude'])
@@ -3205,9 +3207,9 @@ def reducer_hyperparameter_search(settings={}, reduction_params=None, dbscan_par
     
     from .io import _read_and_join_tables
     from .utils import get_db_paths, preprocess_data, search_reduction_and_clustering, generate_colors
-    from .settings import get_umap_image_settings
+    from .settings import set_default_umap_image_settings
 
-    settings = get_umap_image_settings(settings)
+    settings = set_default_umap_image_settings(settings)
     pointsize = settings['dot_size']
     if isinstance(dbscan_params, dict):
         dbscan_params = [dbscan_params]

spacr/deep_spacr.py

@@ -10,6 +10,9 @@ import matplotlib.pyplot as plt
 from PIL import Image
 
 from .logger import log_function_call
+from .utils import close_multiprocessing_processes, reset_mp
+#reset_mp()
+#close_multiprocessing_processes()
 
 def evaluate_model_core(model, loader, loader_name, epoch, loss_type):
     """
@@ -42,7 +45,6 @@ def evaluate_model_core(model, loader, loader_name, epoch, loss_type):
         for batch_idx, (data, target, _) in enumerate(loader, start=1):
             start_time = time.time()
             data, target = data.to(device), target.to(device).float()
-            #data, target = data.to(torch.float).to(device), target.to(device).float()
             output = model(data)
             loss += F.binary_cross_entropy_with_logits(output, target, reduction='sum').item()
             loss = calculate_loss(output, target, loss_type=loss_type)
@@ -228,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'],
@@ -253,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'],
@@ -274,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'],
@@ -313,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.
 
@@ -330,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'.
@@ -355,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

@@ -1,52 +1,67 @@
 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
+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):
+    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.geometry("1100x1500")
         self.configure(bg="black")
-        #self.attributes('-fullscreen', True)
-
         style = ttk.Style()
-        style_text_boxes(style)
+        set_dark_style(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"),
+            "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"),
-            "Classify": (initiate_classify_root, "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images.")
+            "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.")
         }
 
         self.selected_app = tk.StringVar()
         self.create_widgets()
 
+
+        if default_app == "Mask":
+            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
-        #create_menu_bar(self)
+        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 = 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()
 
@@ -59,10 +74,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=('Helvetica', 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=('Helvetica', 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 +87,11 @@ 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), font=('Helvetica', 12))
+            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', 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
@@ -98,7 +114,6 @@ class MainApp(tk.Tk):
 
         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.")
@@ -115,7 +130,9 @@ class MainApp(tk.Tk):
             print(f"An error occurred while loading the logo: {e}")
             return False
         try:
-            logo_image = logo_image.resize((800, 800), Image.Resampling.LANCZOS)
+            screen_height = frame.winfo_screenheight()
+            new_height = int(screen_height // 4)
+            logo_image = logo_image.resize((new_height, new_height), 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
@@ -125,13 +142,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 +160,5 @@ def gui_app():
     app.mainloop()
 
 if __name__ == "__main__":
+    set_start_method('spawn', force=True)
     gui_app()