spacr 0.2.68__py3-none-any.whl → 0.3.0__py3-none-any.whl

spacr/gui_elements.py

@@ -670,25 +670,189 @@ class spacrProgressBar(ttk.Progressbar):
 
     def update_label(self):
         if self.label and self.progress_label:
-            # Update the progress label with current progress and additional info
+            # Start with the base progress information
             label_text = f"Processing: {self['value']}/{self['maximum']}"
+            
+            # Include the operation type if it exists
             if self.operation_type:
                 label_text += f", {self.operation_type}"
+            
+            # Handle additional info without adding newlines
             if hasattr(self, 'additional_info') and self.additional_info:
-                # Add a space between progress information and additional information
-                label_text += "\n\n"
-                # Split the additional_info into a list of items
+                # Join all additional info items with a space and ensure they're on the same line
                 items = self.additional_info.split(", ")
-                formatted_additional_info = ""
-                # Group the items in pairs, adding them to formatted_additional_info
-                for i in range(0, len(items), 2):
-                    if i + 1 < len(items):
-                        formatted_additional_info += f"{items[i]}, {items[i + 1]}\n\n"
-                    else:
-                        formatted_additional_info += f"{items[i]}\n\n"  # If there's an odd item out, add it alone
-                label_text += formatted_additional_info.strip()
+                formatted_additional_info = " ".join(items)
+
+                # Append the additional info to the label_text, ensuring it's all in one line
+                label_text += f" {formatted_additional_info.strip()}"
+
+            # Update the progress label
             self.progress_label.config(text=label_text)
 
+class spacrSlider(tk.Frame):
+    def __init__(self, master=None, length=None, thickness=2, knob_radius=10, position="center", from_=0, to=100, value=None, show_index=False, command=None, **kwargs):
+        super().__init__(master, **kwargs)
+
+        self.specified_length = length  # Store the specified length, if any
+        self.knob_radius = knob_radius
+        self.thickness = thickness
+        self.knob_position = knob_radius  # Start at the beginning of the slider
+        self.slider_line = None
+        self.knob = None
+        self.position = position.lower()  # Store the position option
+        self.offset = 0  # Initialize offset
+        self.from_ = from_  # Minimum value of the slider
+        self.to = to  # Maximum value of the slider
+        self.value = value if value is not None else from_  # Initial value of the slider
+        self.show_index = show_index  # Whether to show the index Entry widget
+        self.command = command  # Callback function to handle value changes
+
+        # Initialize the style and colors
+        style_out = set_dark_style(ttk.Style())
+        self.fg_color = style_out['fg_color']
+        self.bg_color = style_out['bg_color']
+        self.active_color = style_out['active_color']
+        self.inactive_color = style_out['inactive_color']
+
+        # Configure the frame's background color
+        self.configure(bg=self.bg_color)
+
+        # Create a frame for the slider and entry if needed
+        self.grid_columnconfigure(1, weight=1)
+
+        # Entry widget for showing and editing index, if enabled
+        if self.show_index:
+            self.index_var = tk.StringVar(value=str(int(self.value)))
+            self.index_entry = tk.Entry(self, textvariable=self.index_var, width=5, bg=self.bg_color, fg=self.fg_color, insertbackground=self.fg_color)
+            self.index_entry.grid(row=0, column=0, padx=5)
+            # Bind the entry to update the slider on change
+            self.index_entry.bind("<Return>", self.update_slider_from_entry)
+
+        # Create the slider canvas
+        self.canvas = tk.Canvas(self, height=knob_radius * 2, bg=self.bg_color, highlightthickness=0)
+        self.canvas.grid(row=0, column=1, sticky="ew")
+
+        # Set initial length to specified length or default value
+        self.length = self.specified_length if self.specified_length is not None else self.canvas.winfo_reqwidth()
+
+        # Calculate initial knob position based on the initial value
+        self.knob_position = self.value_to_position(self.value)
+
+        # Bind resize event to dynamically adjust the slider length if no length is specified
+        self.canvas.bind("<Configure>", self.resize_slider)
+
+        # Draw the slider components
+        self.draw_slider(inactive=True)
+
+        # Bind mouse events to the knob and slider
+        self.canvas.bind("<B1-Motion>", self.move_knob)
+        self.canvas.bind("<Button-1>", self.activate_knob)  # Activate knob on click
+        self.canvas.bind("<ButtonRelease-1>", self.release_knob)  # Trigger command on release
+
+    def resize_slider(self, event):
+        if self.specified_length is not None:
+            self.length = self.specified_length
+        else:
+            self.length = int(event.width * 0.9)  # 90% of the container width
+        
+        # Calculate the horizontal offset based on the position
+        if self.position == "center":
+            self.offset = (event.width - self.length) // 2
+        elif self.position == "right":
+            self.offset = event.width - self.length
+        else:  # position is "left"
+            self.offset = 0
+
+        # Update the knob position after resizing
+        self.knob_position = self.value_to_position(self.value)
+        self.draw_slider(inactive=True)
+
+    def value_to_position(self, value):
+        if self.to == self.from_:
+            return self.knob_radius
+        relative_value = (value - self.from_) / (self.to - self.from_)
+        return self.knob_radius + relative_value * (self.length - 2 * self.knob_radius)
+
+    def position_to_value(self, position):
+        if self.to == self.from_:
+            return self.from_
+        relative_position = (position - self.knob_radius) / (self.length - 2 * self.knob_radius)
+        return self.from_ + relative_position * (self.to - self.from_)
+
+    def draw_slider(self, inactive=False):
+        self.canvas.delete("all")
+
+        self.slider_line = self.canvas.create_line(
+            self.offset + self.knob_radius, 
+            self.knob_radius, 
+            self.offset + self.length - self.knob_radius, 
+            self.knob_radius, 
+            fill=self.fg_color, 
+            width=self.thickness
+        )
+
+        knob_color = self.inactive_color if inactive else self.active_color
+        self.knob = self.canvas.create_oval(
+            self.offset + self.knob_position - self.knob_radius, 
+            self.knob_radius - self.knob_radius, 
+            self.offset + self.knob_position + self.knob_radius, 
+            self.knob_radius + self.knob_radius, 
+            fill=knob_color, 
+            outline=""
+        )
+
+    def move_knob(self, event):
+        new_position = min(max(event.x - self.offset, self.knob_radius), self.length - self.knob_radius)
+        self.knob_position = new_position
+        self.value = self.position_to_value(self.knob_position)
+        self.canvas.coords(
+            self.knob, 
+            self.offset + self.knob_position - self.knob_radius, 
+            self.knob_radius - self.knob_radius, 
+            self.offset + self.knob_position + self.knob_radius, 
+            self.knob_radius + self.knob_radius
+        )
+        if self.show_index:
+            self.index_var.set(str(int(self.value)))
+
+    def activate_knob(self, event):
+        self.draw_slider(inactive=False)
+        self.move_knob(event)
+
+    def release_knob(self, event):
+        self.draw_slider(inactive=True)
+        if self.command:
+            self.command(self.value)  # Call the command with the final value when the knob is released
+
+    def set_to(self, new_to):
+        self.to = new_to
+        self.knob_position = self.value_to_position(self.value)
+        self.draw_slider(inactive=False)
+
+    def get(self):
+        return self.value
+
+    def set(self, value):
+        """Set the slider's value and update the knob position."""
+        self.value = max(self.from_, min(value, self.to))  # Ensure the value is within bounds
+        self.knob_position = self.value_to_position(self.value)
+        self.draw_slider(inactive=False)
+        if self.show_index:
+            self.index_var.set(str(int(self.value)))
+
+    def jump_to_click(self, event):
+        self.activate_knob(event)
+
+    def update_slider_from_entry(self, event):
+        """Update the slider's value from the entry."""
+        try:
+            index = int(self.index_var.get())
+            self.set(index)
+            if self.command:
+                self.command(self.value)
+        except ValueError:
+            pass
+
 def spacrScrollbarStyle(style, inactive_color, active_color):
     # Check if custom elements already exist to avoid duplication
     if not style.element_names().count('custom.Vertical.Scrollbar.trough'):
@@ -1987,6 +2151,11 @@ class AnnotateApp:
         style_out = set_dark_style(ttk.Style())
         self.font_loader = style_out['font_loader']
         self.font_size = style_out['font_size']
+        self.bg_color = style_out['bg_color']
+        self.fg_color = style_out['fg_color']
+        self.active_color = style_out['active_color']
+        self.inactive_color = style_out['inactive_color']
+
 
         if self.font_loader:
             self.font_style = self.font_loader.get_font(size=self.font_size)
@@ -2013,13 +2182,13 @@ class AnnotateApp:
         self.button_frame = Frame(root, bg=self.root.cget('bg'))
         self.button_frame.grid(row=2, column=1, padx=10, pady=10, sticky="se")
 
-        self.next_button = Button(self.button_frame, text="Next", command=self.next_page, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.next_button = Button(self.button_frame, text="Next", command=self.next_page, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color, highlightcolor=self.fg_color, highlightthickness=1)
         self.next_button.pack(side="right", padx=5)
 
-        self.previous_button = Button(self.button_frame, text="Back", command=self.previous_page, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.previous_button = Button(self.button_frame, text="Back", command=self.previous_page, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color, highlightcolor=self.fg_color, highlightthickness=1)
         self.previous_button.pack(side="right", padx=5)
 
-        self.exit_button = Button(self.button_frame, text="Exit", command=self.shutdown, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.exit_button = Button(self.button_frame, text="Exit", command=self.shutdown, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color, highlightcolor=self.fg_color, highlightthickness=1)
         self.exit_button.pack(side="right", padx=5)
 
         # Calculate grid rows and columns based on the root window size and image size
@@ -2169,7 +2338,7 @@ class AnnotateApp:
 
         for i, (img, annotation) in enumerate(loaded_images):
             if annotation:
-                border_color = 'teal' if annotation == 1 else 'red'
+                border_color = self.active_color if annotation == 1 else 'red'
                 img = self.add_colored_border(img, border_width=5, border_color=border_color)
 
             photo = ImageTk.PhotoImage(img)
@@ -2215,7 +2384,7 @@ class AnnotateApp:
         left_border = Image.new('RGB', (border_width, img.height), color=border_color)
         right_border = Image.new('RGB', (border_width, img.height), color=border_color)
 
-        bordered_img = Image.new('RGB', (img.width + 2 * border_width, img.height + 2 * border_width), color='white')
+        bordered_img = Image.new('RGB', (img.width + 2 * border_width, img.height + 2 * border_width), color=self.fg_color)
         bordered_img.paste(top_border, (border_width, 0))
         bordered_img.paste(bottom_border, (border_width, img.height + border_width))
         bordered_img.paste(left_border, (0, border_width))
@@ -2255,7 +2424,7 @@ class AnnotateApp:
             print(f"Image {os.path.split(path)[1]} annotated: {new_annotation}")
             
             img_ = img.crop((5, 5, img.width-5, img.height-5))
-            border_fill = 'teal' if new_annotation == 1 else ('red' if new_annotation == 2 else None)
+            border_fill = self.active_color if new_annotation == 1 else ('red' if new_annotation == 2 else None)
             img_ = ImageOps.expand(img_, border=5, fill=border_fill) if border_fill else img_
 
             photo = ImageTk.PhotoImage(img_)
@@ -2400,6 +2569,7 @@ def standardize_figure(fig):
     - Line width: 1
     - Line color: from style
     """
+    
 
     for ax in fig.get_axes():
         # Set font properties for title and labels
@@ -2448,6 +2618,8 @@ def standardize_figure(fig):
 
     fig.canvas.draw_idle()
 
+    return fig
+
 def modify_figure_properties(fig, scale_x=None, scale_y=None, line_width=None, font_size=None, x_lim=None, y_lim=None, grid=False, legend=None, title=None, x_label_rotation=None, remove_axes=False, bg_color=None, text_color=None, line_color=None):
     """
     Modifies the properties of the figure, including scaling, line widths, font sizes, axis limits, x-axis label rotation, background color, text color, line color, and other common options.

spacr/gui_utils.py

@@ -486,7 +486,7 @@ def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imp
 def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     
     from .gui_utils import process_stdout_stderr
-    from .core import generate_image_umap, preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, compare_cellpose_masks, analyze_plaques, generate_dataset, apply_model_to_tar
+    from .core import generate_image_umap, preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, analyze_plaques, compare_cellpose_masks, generate_dataset, apply_model_to_tar
     from .io import generate_cellpose_train_test
     from .measure import measure_crop
     from .sim import run_multiple_simulations
@@ -532,6 +532,9 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     elif settings_type == 'umap':
         function = generate_image_umap
         imports = 1
+    elif settings_type == 'analyze_plaques':
+        function = analyze_plaques
+        imports = 1
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     try:

spacr/io.py

@@ -26,7 +26,7 @@ import atexit
 
 from .logger import log_function_call
 
-def _load_images_and_labels(image_files, label_files, circular=False, invert=False, image_extension="*.tif", label_extension="*.tif"):
+def _load_images_and_labels(image_files, label_files, circular=False, invert=False):
     
     from .utils import invert_image, apply_mask
     

spacr/measure.py

@@ -998,10 +998,10 @@ def measure_crop(settings):
         src_fldr = os.path.join(src_fldr, 'merged')
         print(f"Changed source folder to: {src_fldr}")
 
-    if settings['save_measurements']:
-        source_folder = os.path.dirname(settings['src'])
-        os.makedirs(source_folder+'/measurements', exist_ok=True)
-        _create_database(source_folder+'/measurements/measurements.db')
+    #if settings['save_measurements']:
+        #source_folder = os.path.dirname(settings['src'])
+        #os.makedirs(source_folder+'/measurements', exist_ok=True)
+        #_create_database(source_folder+'/measurements/measurements.db')
     
     if settings['cell_mask_dim'] is None:
         settings['include_uninfected'] = True