spacr 0.0.21__tar.gz → 0.0.35__tar.gz

{spacr-0.0.21/spacr.egg-info → spacr-0.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.0.21
+Version: 0.0.35
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson

{spacr-0.0.21 → spacr-0.0.35}/setup.py

@@ -35,7 +35,7 @@ dependencies = [
 
 setup(
     name="spacr",
-    version="0.0.21",
+    version="0.0.35",
     author="Einar Birnir Olafsson",
     author_email="olafsson@med.umich.com",
     description="Spatial phenotype analysis of crisp screens (SpaCr)",
@@ -45,12 +45,13 @@ setup(
     install_requires=dependencies,
     entry_points={
         'console_scripts': [
-            'gui_mask=spacr.gui_mask_app:gui_mask',
-            'gui_measure=spacr.gui_measure_app:gui_measure',
-            'gui_make_masks=spacr.mask_app:gui_make_masks',
-            'gui_annotation=spacr.annotate_app:gui_annotation',
-            'gui_classify=spacr.gui_classify_app:gui_classify',
-            'gui_sim=spacr.gui_sim_app:gui_sim',
+            'mask=spacr.gui_mask_app:gui_mask',
+            'measure=spacr.gui_measure_app:gui_measure',
+            'make_masks=spacr.mask_app:gui_make_masks',
+            'annotate=spacr.annotate_app:gui_annotation',
+            'classify=spacr.gui_classify_app:gui_classify',
+            'sim=spacr.gui_sim_app:gui_sim',
+            'gui=spacr.gui:gui_app',
         ],
     },
     extras_require={

{spacr-0.0.21 → spacr-0.0.35}/spacr/annotate_app.py

@@ -13,7 +13,7 @@ from ttkthemes import ThemedTk
 
 from .logger import log_function_call
 
-from .gui_utils import ScrollableFrame, set_default_font, set_dark_style, create_dark_mode
+from .gui_utils import ScrollableFrame, set_default_font, set_dark_style, create_dark_mode, style_text_boxes, create_menu_bar
 
 class ImageApp:
     """
@@ -425,7 +425,8 @@ def initiate_annotation_app_root(width, height):
     root = ThemedTk(theme=theme)
     style = ttk.Style(root)
     set_dark_style(style)
-    set_default_font(root, font_name="Arial", size=10)
+    style_text_boxes(style)
+    set_default_font(root, font_name="Arial", size=8)
     root.geometry(f"{width}x{height}")
     root.title("Annotation App")
 
@@ -473,6 +474,7 @@ def initiate_annotation_app_root(width, height):
         new_root = tk.Tk()
         new_root.geometry(f"{width}x{height}")
         new_root.title("Mask Application")
+        
 
         # Start the annotation application in the new root window
         app_instance = annotate(db, image_type, channels, annotation_column, geom, img_size, rows, columns)
@@ -482,7 +484,7 @@ def initiate_annotation_app_root(width, height):
     create_dark_mode(root, style, console_output=None)
 
     run_button = ttk.Button(scrollable_frame.scrollable_frame, text="Run", command=run_app)
-    run_button.grid(row=row, column=0, columnspan=2, pady=10)
+    run_button.grid(row=row, column=0, columnspan=2, pady=10, padx=10)
 
     return root
 

spacr-0.0.35/spacr/chris.py

@@ -0,0 +1,50 @@
+import pandas as pd 
+import numpy as np
+from .core import _permutation_importance, _shap_analysis
+
+def join_measurments_and_annotation(src, tables = ['cell', 'nucleus', 'pathogen','cytoplasm']):
+    
+    from .io import _read_and_merge_data, _read_db
+    
+    db_loc = [src+'/measurements/measurements.db']
+    loc = src+'/measurements/measurements.db'
+    df, _ = _read_and_merge_data(db_loc, 
+                                 tables, 
+                                 verbose=True, 
+                                 include_multinucleated=True, 
+                                 include_multiinfected=True, 
+                                 include_noninfected=True)
+    
+    paths_df = _read_db(loc, tables=['png_list'])
+
+    merged_df = pd.merge(df, paths_df[0], on='prcfo', how='left')
+
+    return merged_df
+
+def plate_heatmap(src, model_type='xgboost', variable='predictions', grouping='mean', min_max='allq', cmap='viridis', channel_of_interest=3, min_count=25, n_estimators=100, col_to_compare='col', pos='c1', neg='c2', exclude=None, n_repeats=10, clean=True, nr_to_plot=20, verbose=False, n_jobs=-1):
+    from .io import _read_and_merge_data
+    from .plot import _plot_plates
+
+    db_loc = [src+'/measurements/measurements.db']
+    tables = ['cell', 'nucleus', 'pathogen','cytoplasm']
+    include_multinucleated, include_multiinfected, include_noninfected = True, 2.0, True
+    
+    df = join_measurments_and_annotation(src, tables=['cell', 'nucleus', 'pathogen', 'cytoplasm'])
+        
+    if not channel_of_interest is None:
+        df['recruitment'] = df[f'pathogen_channel_{channel_of_interest}_mean_intensity']/df[f'cytoplasm_channel_{channel_of_interest}_mean_intensity']
+        feature_string = f'channel_{channel_of_interest}'
+    else:
+        feature_string = None
+    
+    output = _permutation_importance(df, feature_string, col_to_compare, pos, neg, exclude, n_repeats, clean, nr_to_plot, n_estimators=n_estimators, random_state=42, model_type=model_type, n_jobs=n_jobs)
+    
+    _shap_analysis(output[3], output[4], output[5])
+
+    features = output[0].select_dtypes(include=[np.number]).columns.tolist()
+
+    if not variable in features:
+        raise ValueError(f"Variable {variable} not found in the dataframe. Please choose one of the following: {features}")
+    
+    plate_heatmap = _plot_plates(output[0], variable, grouping, min_max, cmap, min_count)
+    return [output, plate_heatmap]

spacr-0.0.35/spacr/gui.py

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

{spacr-0.0.21 → spacr-0.0.35}/spacr/gui_classify_app.py

@@ -16,8 +16,8 @@ except AttributeError:
     pass
 
 from .logger import log_function_call
-from .gui_utils import ScrollableFrame, StdoutRedirector, create_dark_mode, set_dark_style, set_default_font, generate_fields, process_stdout_stderr, safe_literal_eval, 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  
+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}
 
@@ -70,128 +70,119 @@ def import_settings(scrollable_frame):
     vars_dict = generate_fields(new_settings, scrollable_frame)
 
 @log_function_call
-def initiate_classify_root(width, height):
-    global root, vars_dict, q, canvas, fig_queue, canvas_widget, thread_control
-        
-    theme = 'breeze'
+def initiate_classify_root(parent_frame, width, height):
+    global vars_dict, q, canvas, fig_queue, canvas_widget, thread_control
     
-    if theme in ['clam']:
-        root = tk.Tk()
-        style = ttk.Style(root)
-        style.theme_use(theme) #plastik, clearlooks, elegance, default was clam #alt, breeze, arc
-        set_dark_style(style)
-    elif theme in ['breeze']:
-        root = ThemedTk(theme="breeze")
-        style = ttk.Style(root)
-        set_dark_style(style)
-        
-    set_default_font(root, font_name="Arial", size=10)
-    #root.state('zoomed')  # For Windows to maximize the window
-    root.attributes('-fullscreen', True)
-    root.geometry(f"{width}x{height}")
-    root.title("SpaCer: generate masks")
+    style = ttk.Style(parent_frame)
+    set_dark_style(style)
+    style_text_boxes(style)
+    set_default_font(parent_frame, font_name="Open Sans", 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()
-                #set_fig_text_properties(fig, font_size=8)
                 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
-                    #ax.title.set_fontsize(14) 
-                #disable_interactivity(fig)
                 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() 
+                canvas.draw_idle()
         except Exception as e:
             traceback.print_exc()
-            #pass
         finally:
             canvas_widget.after(100, _process_fig_queue)
-            
-    # Process queue for console output
+
     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 for settings and console
-    vertical_container = tk.PanedWindow(root, orient=tk.HORIZONTAL) #VERTICAL
-    vertical_container.pack(fill=tk.BOTH, expand=True)
 
-    # Scrollable Frame for user settings
-    scrollable_frame = ScrollableFrame(vertical_container, bg='#333333')
-    vertical_container.add(scrollable_frame, stretch="always")
+    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)
-    
-    # Horizontal container for Matplotlib figure and the vertical pane (for settings and console)
-    horizontal_container = tk.PanedWindow(vertical_container, orient=tk.VERTICAL) #HORIZONTAL
-    vertical_container.add(horizontal_container, stretch="always")
 
-    # Matplotlib figure setup
+    # Button section
+    import_btn = CustomButton(scrollable_frame.scrollable_frame, text="Import Settings", command=lambda: import_settings(scrollable_frame))
+    import_btn.grid(row=47, column=0, pady=20, padx=20)
+    run_button = CustomButton(scrollable_frame.scrollable_frame, text="Run", command=lambda: start_process(q, fig_queue))
+    run_button.grid(row=45, column=0, pady=20, padx=20)
+    abort_button = CustomButton(scrollable_frame.scrollable_frame, text="Abort", command=initiate_abort)
+    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([], [])  # This creates an empty plot.
+    plot.plot([], [])
     plot.axis('off')
-
-    # Embedding the Matplotlib figure in the Tkinter window
-    canvas = FigureCanvasTkAgg(figure, master=horizontal_container)
+    canvas = FigureCanvasTkAgg(figure, master=plot_frame)
     canvas.get_tk_widget().configure(cursor='arrow', background='#333333', highlightthickness=0)
-    #canvas.get_tk_widget().configure(cursor='arrow')
     canvas_widget = canvas.get_tk_widget()
-    horizontal_container.add(canvas_widget, stretch="always")
+    plot_frame.add(canvas_widget, stretch="always")
     canvas.draw()
     canvas.figure = figure
 
-    # Console output setup below the settings
-    console_output = scrolledtext.ScrolledText(vertical_container, height=10)
-    vertical_container.add(console_output, stretch="always")
+    # 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)
 
-    # Queue and redirection setup for updating console output safely
     q = Queue()
     sys.stdout = StdoutRedirector(console_output)
     sys.stderr = StdoutRedirector(console_output)
-    
-    # This is your GUI setup where you create the Run button
-    run_button = ttk.Button(scrollable_frame.scrollable_frame, text="Run",command=lambda: start_process(q, fig_queue))
-    run_button.grid(row=40, column=0, pady=10)
-    
-    abort_button = ttk.Button(scrollable_frame.scrollable_frame, text="Abort", command=initiate_abort)
-    abort_button.grid(row=40, column=1, pady=10)
-    
-    progress_label = ttk.Label(scrollable_frame.scrollable_frame, text="Processing: 0%", background="#333333", foreground="white")
-    progress_label.grid(row=41, column=0, columnspan=2, sticky="ew", pady=(5, 0))
-    
-    # Create the Import Settings button
-    import_btn = tk.Button(root, text="Import Settings", command=lambda: import_settings(scrollable_frame))
-    import_btn.pack(pady=20)
-    
+
     _process_console_queue()
     _process_fig_queue()
-    create_dark_mode(root, style, console_output)
-    
-    root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label))
-    
-    return root, vars_dict
+
+    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():
-    global vars_dict, root
-    root, vars_dict = initiate_classify_root(1000, 1500)
+    root = tk.Tk()
+    root.geometry("1000x800")
+    root.title("SpaCer: generate masks")
+    initiate_classify_root(root, 1000, 800)
+    create_menu_bar(root)
     root.mainloop()
 
 if __name__ == "__main__":
-    gui_classify()
+    gui_classify()