spacr 0.3.1__py3-none-any.whl → 0.3.22__py3-none-any.whl

spacr/gui_core.py

@@ -1,9 +1,9 @@
-import traceback, ctypes, csv, re, platform, time
+import os, traceback, ctypes, csv, re, platform
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
 from multiprocessing import Process, Value, Queue, set_start_method
-from tkinter import ttk, scrolledtext
+from tkinter import ttk
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 import numpy as np
@@ -11,15 +11,13 @@ import psutil
 import GPUtil
 from collections import deque
 import tracemalloc
-from tkinter import Menu
-import io
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
 except AttributeError:
     pass
 
-from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu , spacrSlider, set_dark_style, standardize_figure
+from .gui_elements import spacrProgressBar, spacrButton, spacrFrame, spacrDropdownMenu , spacrSlider, set_dark_style
 
 # Define global variables
 q = None
@@ -35,6 +33,7 @@ figures = None
 figure_index = None
 progress_bar = None
 usage_bars = None
+index_control = None
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
@@ -170,39 +169,6 @@ def display_figure(fig):
             #flash_feedback("right")
             show_next_figure()
 
-    def zoom_v1(event):
-        nonlocal scale_factor
-
-        zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
-
-        # Adjust zoom factor based on the operating system and mouse event
-        if event.num == 4 or event.delta > 0:  # Scroll up
-            scale_factor *= (1 + zoom_speed)
-        elif event.num == 5 or event.delta < 0:  # Scroll down
-            scale_factor /= (1 + zoom_speed)
-
-        # Get mouse position relative to the figure
-        x_mouse, y_mouse = event.x, event.y
-        x_ratio = x_mouse / canvas_widget.winfo_width()
-        y_ratio = y_mouse / canvas_widget.winfo_height()
-
-        for ax in fig.get_axes():
-            xlim = ax.get_xlim()
-            ylim = ax.get_ylim()
-
-            # Calculate the new limits
-            x_center = xlim[0] + x_ratio * (xlim[1] - xlim[0])
-            y_center = ylim[0] + (1 - y_ratio) * (ylim[1] - ylim[0])
-
-            x_range = (xlim[1] - xlim[0]) * scale_factor
-            y_range = (ylim[1] - ylim[0]) * scale_factor
-
-            ax.set_xlim([x_center - x_range * x_ratio, x_center + x_range * (1 - x_ratio)])
-            ax.set_ylim([y_center - y_range * (1 - y_ratio), y_center + y_range * y_ratio])
-
-        # Redraw the figure
-        fig.canvas.draw_idle()
-
     def zoom(event):
         nonlocal scale_factor
 
@@ -282,7 +248,7 @@ def show_next_figure():
         figures.append(fig)
         figure_index += 1
         display_figure(fig)
-
+                       
 def process_fig_queue():
     global canvas, fig_queue, canvas_widget, parent_frame, uppdate_frequency, figures, figure_index, index_control
 
@@ -329,44 +295,60 @@ def update_figure(value):
     index_control.set_to(len(figures) - 1)
     index_control.set(figure_index)
 
-def setup_plot_section(vertical_container):
+def setup_plot_section(vertical_container, settings_type):
     global canvas, canvas_widget, figures, figure_index, index_control
+    from .gui_utils import display_media_in_plot_frame
+
+    style_out = set_dark_style(ttk.Style())
+    bg = style_out['bg_color']
+    fg = style_out['fg_color']
 
     # Initialize deque for storing figures and the current index
     figures = deque()
 
     # Create a frame for the plot section
     plot_frame = tk.Frame(vertical_container)
+    plot_frame.configure(bg=bg)
     vertical_container.add(plot_frame, stretch="always")
 
-    # Set up the plot
+    # Clear the plot_frame (optional, to handle cases where it may already have content)
+    for widget in plot_frame.winfo_children():
+        widget.destroy()
+
+    # Create a figure and plot
     figure = Figure(figsize=(30, 4), dpi=100)
     plot = figure.add_subplot(111)
     plot.plot([], [])
     plot.axis('off')
+
+    if settings_type == 'map_barcodes':
+        # Load and display GIF
+        current_dir = os.path.dirname(__file__)
+        resources_path = os.path.join(current_dir, 'resources', 'icons')
+        gif_path = os.path.join(resources_path, 'dna_matrix.mp4')
+
+        display_media_in_plot_frame(gif_path, plot_frame)
+        canvas = FigureCanvasTkAgg(figure, master=plot_frame)
+        canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
+        canvas_widget = canvas.get_tk_widget()
+        return canvas, canvas_widget
     
     canvas = FigureCanvasTkAgg(figure, master=plot_frame)
     canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
     canvas_widget = canvas.get_tk_widget()
     canvas_widget.grid(row=0, column=0, sticky="nsew")
-
     plot_frame.grid_rowconfigure(0, weight=1)
     plot_frame.grid_columnconfigure(0, weight=1)
-
     canvas.draw()
-    canvas.figure = figure  # Ensure that the figure is linked to the canvas
-    style_out = set_dark_style(ttk.Style())
-    bg = style_out['bg_color']
-    fg = style_out['fg_color']
-
+    canvas.figure = figure
     figure.patch.set_facecolor(bg)
     plot.set_facecolor(bg)
     containers = [plot_frame]
 
     # Create slider
-    control_frame = tk.Frame(plot_frame, height=15*2,  bg=bg)  # Fixed height based on knob_radius
+    control_frame = tk.Frame(plot_frame, height=15*2,  bg=bg)
     control_frame.grid(row=1, column=0, sticky="ew", padx=10, pady=5)
-    control_frame.grid_propagate(False)  # Prevent the frame from resizing
+    control_frame.grid_propagate(False) 
 
     # Pass the update_figure function as the command to spacrSlider
     index_control = spacrSlider(control_frame, from_=0, to=0, value=0, thickness=2, knob_radius=10, position="center", show_index=True, command=update_figure)
@@ -442,6 +424,8 @@ def import_settings(settings_type='mask'):
         settings = get_analyze_recruitment_default_settings(settings={})
     elif settings_type == 'analyze_plaques':
         settings = {}
+    elif settings_type == 'convert':
+        settings = {}
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     
@@ -452,7 +436,8 @@ def import_settings(settings_type='mask'):
 
 def setup_settings_panel(vertical_container, settings_type='mask'):
     global vars_dict, scrollable_frame
-    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings
+    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings
     from .gui_utils import convert_settings_dict_for_gui
     from .gui_elements import set_element_size
 
@@ -496,7 +481,9 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'recruitment':
         settings = get_analyze_recruitment_default_settings(settings={})
     elif settings_type == 'analyze_plaques':
-        settings = {}
+        settings = {'src':'path to images'}
+    elif settings_type == 'convert':
+        settings = {'src':'path to images'}
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
 
@@ -515,7 +502,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
 def setup_console(vertical_container):
     global console_output
     from .gui_elements import set_dark_style
-
+    
     # Apply dark style and get style output
     style = ttk.Style()
     style_out = set_dark_style(style)
@@ -546,9 +533,27 @@ def setup_console(vertical_container):
     def on_leave(event):
         top_border.config(bg=style_out['bg_color'])
 
+    #def on_enter_key(event):
+    #    user_input = console_output.get("1.0", "end-1c").strip()  # Get the user input from the console
+    #    if user_input:
+    #        # Print the user input with the (user) tag
+    #        console_output.insert("end", f"\n(user): {user_input}\n")
+    #        
+    #        # Get the AI response from the chatbot
+    #        response = chatbot.ask_question(user_input)
+    #        
+    #        # Print the AI response with the (ai) tag
+    #        console_output.insert("end", f"(ai): {response}\n")
+    #        
+    #        console_output.see("end")  # Scroll to the end
+    #        #console_output.delete("1.0", "end")  # Clear the input field
+    #    return "break"  # Prevent the default behavior of inserting a new line
+
     console_output.bind("<Enter>", on_enter)
     console_output.bind("<Leave>", on_leave)
 
+    #console_output.bind("<Return>", on_enter_key)
+
     return console_output, console_frame
 
 def setup_button_section(horizontal_container, settings_type='mask', run=True, abort=True, download=True, import_btn=True):
@@ -755,7 +760,7 @@ def initiate_abort():
 def start_process(q=None, fig_queue=None, settings_type='mask'):
     global thread_control, vars_dict, parent_frame
     from .settings import check_settings, expected_types
-    from .gui_utils import run_function_gui, set_high_priority, set_cpu_affinity, initialize_cuda
+    from .gui_utils import run_function_gui, set_cpu_affinity, initialize_cuda, display_gif_in_plot_frame, print_widget_structure
 
     if q is None:
         q = Queue()
@@ -778,16 +783,14 @@ def start_process(q=None, fig_queue=None, settings_type='mask'):
 
     process_args = (settings_type, settings, q, fig_queue, stop_requested)
     if settings_type in ['mask', 'umap', 'measure', 'simulation', 'sequencing', 'classify', 'analyze_plaques', 
-                         'cellpose_dataset', 'train_cellpose', 'ml_analyze', 'cellpose_masks', 'cellpose_all', 'map_barcodes', 
-                         'regression', 'recruitment', 'cellpose_compare', 'vision_scores', 'vision_dataset']:
+                         'cellpose_dataset', 'train_cellpose', 'ml_analyze', 'cellpose_masks', 'cellpose_all', 
+                         'map_barcodes', 'regression', 'recruitment', 'cellpose_compare', 'vision_scores', 
+                         'vision_dataset', 'convert']:
 
         # Start the process
         process = Process(target=run_function_gui, args=process_args)
         process.start()
 
-        # Set high priority for the process
-        #set_high_priority(process)
-
         # Set CPU affinity if necessary
         set_cpu_affinity(process)
 
@@ -889,10 +892,14 @@ def initiate_root(parent, settings_type='mask'):
     
     global q, fig_queue, thread_control, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar, uppdate_frequency, figures, figure_index, index_control, usage_bars
     
-    from .gui_utils import setup_frame
+    from .gui_utils import setup_frame, get_screen_dimensions
     from .settings import descriptions
+    #from .openai import Chatbot
 
     uppdate_frequency = 500
+    num_cores = os.cpu_count()
+
+    #chatbot = Chatbot(api_key="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")
 
     # Start tracemalloc and initialize global variables
     tracemalloc.start()
@@ -930,10 +937,14 @@ def initiate_root(parent, settings_type='mask'):
     else:
         scrollable_frame, vars_dict = setup_settings_panel(settings_container, settings_type)
         print('setup_settings_panel')
-        canvas, canvas_widget = setup_plot_section(vertical_container)
-        console_output, _ = setup_console(vertical_container)
+        canvas, canvas_widget = setup_plot_section(vertical_container, settings_type)
+        console_output, _ = setup_console(vertical_container) #, chatbot)
         button_scrollable_frame, btn_col = setup_button_section(horizontal_container, settings_type)
-        _, usage_bars, btn_col = setup_usage_panel(horizontal_container, btn_col, uppdate_frequency)
+        
+        if num_cores > 12:
+            _, usage_bars, btn_col = setup_usage_panel(horizontal_container, btn_col, uppdate_frequency)
+        else:
+            usage_bars = []
 
         set_globals(thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, index_control, progress_bar, usage_bars)
         description_text = descriptions.get(settings_type, "No description available for this module.")

spacr/gui_elements.py

@@ -1,4 +1,4 @@
-import os, threading, time, sqlite3, webbrowser, pyautogui
+import os, threading, time, sqlite3, webbrowser, pyautogui, random, cv2
 import tkinter as tk
 from tkinter import ttk
 import tkinter.font as tkFont
@@ -7,7 +7,7 @@ from tkinter import font
 from queue import Queue
 from tkinter import Label, Frame, Button
 import numpy as np
-from PIL import Image, ImageOps, ImageTk
+from PIL import Image, ImageOps, ImageTk, ImageDraw, ImageFont, ImageEnhance
 from concurrent.futures import ThreadPoolExecutor
 from skimage.exposure import rescale_intensity
 from IPython.display import display, HTML
@@ -16,7 +16,8 @@ from collections import deque
 from skimage.draw import polygon, line
 from skimage.transform import resize
 from scipy.ndimage import binary_fill_holes, label
-from tkinter import ttk, scrolledtext
+from tkinter import ttk, scrolledtext 
+
 fig = None
 
 def set_element_size():
@@ -2512,7 +2513,6 @@ def create_menu_bar(root):
         "Annotate": lambda: initiate_root(root, settings_type='annotate'),
         "Make Masks": lambda: initiate_root(root, settings_type='make_masks'),
         "Classify": lambda: initiate_root(root, settings_type='classify'),
-        "Sequencing": lambda: initiate_root(root, settings_type='sequencing'),
         "Umap": lambda: initiate_root(root, settings_type='umap'),
         "Train Cellpose": lambda: initiate_root(root, settings_type='train_cellpose'),
         "ML Analyze": lambda: initiate_root(root, settings_type='ml_analyze'),
@@ -2842,4 +2842,109 @@ def modify_figure(fig):
 
     # Apply button
     apply_button = tk.Button(modify_window, text="Apply", command=apply_modifications, bg="#2E2E2E", fg="white")
-    apply_button.grid(row=len(options) + len(checkboxes), column=0, columnspan=2, pady=10)
+    apply_button.grid(row=len(options) + len(checkboxes), column=0, columnspan=2, pady=10)
+
+def generate_dna_matrix(output_path='dna_matrix.gif', canvas_width=1500, canvas_height=1000, duration=30, fps=20, base_size=20, transition_frames=30, font_type='arial.ttf', enhance=[1.1, 1.5, 1.2, 1.5], lowercase_prob=0.3):
+    """
+    Generate a DNA matrix animation and save it as GIF, MP4, or AVI using OpenCV for videos.
+    """
+
+    def save_output(frames, output_path, fps, output_format):
+        """Save the animation based on output format."""
+        if output_format in ['.mp4', '.avi']:
+            images = [np.array(img.convert('RGB')) for img in frames]
+            fourcc = cv2.VideoWriter_fourcc(*('mp4v' if output_format == '.mp4' else 'XVID'))
+            out = cv2.VideoWriter(output_path, fourcc, fps, (canvas_width, canvas_height))
+            for img in images:
+                out.write(cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
+            out.release()
+        elif output_format == '.gif':
+            frames[0].save(output_path, save_all=True, append_images=frames[1:], duration=int(1000/fps), loop=0)
+
+    def draw_base(draw, col_idx, base_position, base, font, alpha=255, fill_color=None):
+        """Draws a DNA base at the specified position."""
+        draw.text((col_idx * base_size, base_position * base_size), base, fill=(*fill_color, alpha), font=font)
+
+    # Setup variables
+    num_frames = duration * fps
+    num_columns = canvas_width // base_size
+    bases = ['A', 'T', 'C', 'G']
+    active_color = (155, 55, 155)
+    color = (255, 255, 255)
+    base_colors = {'A': color, 'T': color, 'C': color, 'G': color}
+
+    _, output_format = os.path.splitext(output_path)
+    
+    # Initialize font
+    try:
+        font = ImageFont.truetype(font_type, base_size)
+    except IOError:
+        font = ImageFont.load_default()
+
+    # DNA string and positions
+    string_lengths = [random.randint(10, 100) for _ in range(num_columns)]
+    visible_bases = [0] * num_columns
+    base_positions = [random.randint(-canvas_height // base_size, 0) for _ in range(num_columns)]
+    column_strings = [[''] * 100 for _ in range(num_columns)]
+    random_white_sequences = [None] * num_columns
+
+    frames = []
+    end_frame_start = int(num_frames * 0.8)
+
+    for frame_idx in range(num_frames):
+        img = Image.new('RGBA', (canvas_width, canvas_height), color=(0, 0, 0, 255))
+        draw = ImageDraw.Draw(img)
+
+        for col_idx in range(num_columns):
+            if base_positions[col_idx] >= canvas_height // base_size and frame_idx < end_frame_start:
+                string_lengths[col_idx] = random.randint(10, 100)
+                base_positions[col_idx] = -string_lengths[col_idx]
+                visible_bases[col_idx] = 0
+                # Randomly choose whether to make each base lowercase
+                column_strings[col_idx] = [
+                    random.choice([base.lower(), base]) if random.random() < lowercase_prob else base
+                    for base in [random.choice(bases) for _ in range(string_lengths[col_idx])]
+                ]
+                if string_lengths[col_idx] > 8:
+                    random_start = random.randint(0, string_lengths[col_idx] - 8)
+                    random_white_sequences[col_idx] = range(random_start, random_start + 8)
+
+            last_10_percent_start = max(0, int(string_lengths[col_idx] * 0.9))
+            
+            for row_idx in range(min(visible_bases[col_idx], string_lengths[col_idx])):
+                base_position = base_positions[col_idx] + row_idx
+                if 0 <= base_position * base_size < canvas_height:
+                    base = column_strings[col_idx][row_idx]
+                    if base:
+                        if row_idx == visible_bases[col_idx] - 1:
+                            draw_base(draw, col_idx, base_position, base, font, fill_color=active_color)
+                        elif row_idx >= last_10_percent_start:
+                            alpha = 255 - int(((row_idx - last_10_percent_start) / (string_lengths[col_idx] - last_10_percent_start)) * 127)
+                            draw_base(draw, col_idx, base_position, base, font, alpha=alpha, fill_color=base_colors[base.upper()])
+                        elif random_white_sequences[col_idx] and row_idx in random_white_sequences[col_idx]:
+                            draw_base(draw, col_idx, base_position, base, font, fill_color=active_color)
+                        else:
+                            draw_base(draw, col_idx, base_position, base, font, fill_color=base_colors[base.upper()])
+
+            if visible_bases[col_idx] < string_lengths[col_idx]:
+                visible_bases[col_idx] += 1
+            base_positions[col_idx] += 2
+
+        # Convert the image to numpy array to check unique pixel values
+        img_array = np.array(img)
+        if len(np.unique(img_array)) > 2:  # Only append frames with more than two unique pixel values (avoid black frames)
+            # Enhance contrast and saturation
+            if enhance:
+                img = ImageEnhance.Brightness(img).enhance(enhance[0])   # Slightly increase brightness
+                img = ImageEnhance.Sharpness(img).enhance(enhance[1])    # Sharpen the image
+                img = ImageEnhance.Contrast(img).enhance(enhance[2])     # Enhance contrast
+                img = ImageEnhance.Color(img).enhance(enhance[3])        # Boost color saturation 
+
+            frames.append(img)
+
+    for i in range(transition_frames):
+        alpha = i / float(transition_frames)
+        transition_frame = Image.blend(frames[-1], frames[0], alpha)
+        frames.append(transition_frame)
+
+    save_output(frames, output_path, fps, output_format)