spacr 0.4.1__py3-none-any.whl → 0.4.2__py3-none-any.whl

spacr/core.py

@@ -9,12 +9,11 @@ warnings.filterwarnings("ignore", message="3D stack used, but stitch_threshold=0
 
 def preprocess_generate_masks(settings):
 
-    from .io import preprocess_img_data, _load_and_concatenate_arrays
+    from .io import preprocess_img_data, _load_and_concatenate_arrays, convert_to_yokogawa
     from .plot import plot_image_mask_overlay, plot_arrays
-    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks, print_progress, save_settings, delete_intermedeate_files
+    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks, print_progress, save_settings, delete_intermedeate_files, format_path_for_system, normalize_src_path
     from .settings import set_default_settings_preprocess_generate_masks
     
-    
     if 'src' in settings:
         if not isinstance(settings['src'], (str, list)):
             ValueError(f'src must be a string or a list of strings')
@@ -23,6 +22,8 @@ def preprocess_generate_masks(settings):
         ValueError(f'src is a required parameter')
         return
     
+    settings['src'] = normalize_src_path(settings['src'])
+    
     if isinstance(settings['src'], str):
         settings['src'] = [settings['src']]
 
@@ -30,9 +31,19 @@ def preprocess_generate_masks(settings):
         source_folders = settings['src']
         for source_folder in source_folders:
             print(f'Processing folder: {source_folder}')
+            
+            if settings['metadata_type'] == 'auto':
+                convert_to_yokogawa(folder=source_folder)
+            
+            source_folder = format_path_for_system(source_folder)            
             settings['src'] = source_folder
             src = source_folder
             settings = set_default_settings_preprocess_generate_masks(settings)
+            
+            if settings['cell_channel'] is None and settings['nucleus_channel'] is None and settings['pathogen_channel'] is None:
+                print(f'Error: At least one of cell_channel, nucleus_channel or pathogen_channel must be defined')
+                return
+
             save_settings(settings, name='gen_mask_settings')
 
             if not settings['pathogen_channel'] is None:

spacr/gui_core.py

@@ -170,49 +170,22 @@ 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
-
-        # Determine the zoom direction based on the scroll event
-        if event.num == 4 or event.delta > 0:  # Scroll up (zoom in)
-            scale_factor /= (1 + zoom_speed)  # Divide to zoom in
-        elif event.num == 5 or event.delta < 0:  # Scroll down (zoom out)
-            scale_factor *= (1 + zoom_speed)  # Multiply to zoom out
-
-        # Adjust the axes limits based on the new scale factor
-        for ax in canvas.figure.get_axes():
-            xlim = ax.get_xlim()
-            ylim = ax.get_ylim()
-
-            x_center = (xlim[1] + xlim[0]) / 2
-            y_center = (ylim[1] + ylim[0]) / 2
-
-            x_range = (xlim[1] - xlim[0]) * scale_factor
-            y_range = (ylim[1] - ylim[0]) * scale_factor
-
-            # Set the new limits
-            ax.set_xlim([x_center - x_range / 2, x_center + x_range / 2])
-            ax.set_ylim([y_center - y_range / 2, y_center + y_range / 2])
-
-        # Redraw the figure efficiently
-        canvas.draw_idle()
-        
     def zoom_test(event):
         if event.num == 4:  # Scroll up
             print("zoom in")
         elif event.num == 5: # Scroll down
             print("zoom out")
-            
-    def zoom_2(event):
-        zoom_speed = 0.1  # Change this to control how fast you zoom
+        
+    def zoom_v1(event):
+        # Fixed zoom factors (adjust these if you want faster or slower zoom)
+        zoom_in_factor = 0.9   # When zooming in, ranges shrink by 10%
+        zoom_out_factor = 1.1  # When zooming out, ranges increase by 10%
 
         # Determine the zoom direction based on the scroll event
         if event.num == 4 or (hasattr(event, 'delta') and event.delta > 0):  # Scroll up = zoom in
-            factor = 1 - zoom_speed
+            factor = zoom_in_factor
         elif event.num == 5 or (hasattr(event, 'delta') and event.delta < 0): # Scroll down = zoom out
-            factor = 1 + zoom_speed
+            factor = zoom_out_factor
         else:
             return  # No recognized scroll direction
 
@@ -247,23 +220,28 @@ def display_figure(fig):
             return  # No recognized scroll direction
 
         for ax in canvas.figure.get_axes():
+            # Get the current mouse position in pixel coordinates
+            mouse_x, mouse_y = event.x, event.y
+
+            # Convert pixel coordinates to data coordinates
+            inv = ax.transData.inverted()
+            data_x, data_y = inv.transform((mouse_x, mouse_y))
+
+            # Get the current axis limits
             xlim = ax.get_xlim()
             ylim = ax.get_ylim()
 
-            x_center = (xlim[1] + xlim[0]) / 2
-            y_center = (ylim[1] + ylim[0]) / 2
-
+            # Calculate the zooming range around the cursor position
             x_range = (xlim[1] - xlim[0]) * factor
             y_range = (ylim[1] - ylim[0]) * factor
 
-            # Set the new limits
-            ax.set_xlim([x_center - x_range / 2, x_center + x_range / 2])
-            ax.set_ylim([y_center - y_range / 2, y_center + y_range / 2])
+            # Adjust the limits while keeping the mouse position fixed
+            ax.set_xlim([data_x - (data_x - xlim[0]) * factor, data_x + (xlim[1] - data_x) * factor])
+            ax.set_ylim([data_y - (data_y - ylim[0]) * factor, data_y + (ylim[1] - data_y) * factor])
 
         # Redraw the figure efficiently
         canvas.draw_idle()
 
-
     # Bind events for hover, click interactions, and zoom
     canvas_widget.bind("<Motion>", on_hover)
     canvas_widget.bind("<Leave>", on_leave)
@@ -854,7 +832,7 @@ def initiate_abort():
     global thread_control, q, parent_frame
     if thread_control.get("run_thread") is not None:
         try:
-            q.put("Aborting processes...")
+            #q.put("Aborting processes...")
             thread_control.get("run_thread").terminate()
             thread_control["run_thread"] = None
             q.put("Processes aborted.")
@@ -862,22 +840,136 @@ def initiate_abort():
             q.put(f"Error aborting process: {e}")
 
     thread_control = {"run_thread": None, "stop_requested": False}
+    
+def check_src_folders_files(settings, settings_type, q):
+    """
+    Checks if 'src' is a key in the settings dictionary and if it exists as a valid path.
+    If 'src' is a list, iterates through the list and checks each path.
+    If any path is missing, prompts the user to edit or remove invalid paths.
+    """
+
+    request_stop = False
+        
+    def _folder_has_images(folder_path, image_extensions = {".png", ".jpg", ".jpeg", ".bmp", ".gif", ".tiff", ".tif", ".webp", ".npy", ".npz", "nd2", "czi", "lif"}):
+        """Check if a folder contains any image files."""
+        return any(file.lower().endswith(tuple(image_extensions)) for file in os.listdir(folder_path))
+
+    def _has_folder(parent_folder, sub_folder="measure"):
+        """Check if a specific sub-folder exists inside the given folder."""
+        return os.path.isdir(os.path.join(parent_folder, sub_folder))
+    
+    from .utils import normalize_src_path
+    
+    settings['src'] = normalize_src_path(settings['src'])
+
+    src_value = settings.get("src")
+
+    # **Skip if 'src' is missing**
+    if src_value is None:
+        return request_stop
+
+    # Convert single string src to a list for uniform handling
+    if isinstance(src_value, str):
+        src_list = [src_value]
+    elif isinstance(src_value, list):
+        src_list = src_value
+    else:
+        request_stop = True
+        return request_stop  # Ensure early exit
+
+    # Identify missing paths
+    missing_paths = {i: path for i, path in enumerate(src_list) if not os.path.exists(path)}
+
+    if missing_paths:
+        q.put(f'Error: The following paths are missing: {missing_paths}')
+        request_stop = True
+        return request_stop  # Ensure early exit
+
+    conditions = [True]  # Initialize conditions list
+
+    for path in src_list:  # Fixed: Use src_list instead of src_value
+        if settings_type == 'mask':
+            pictures_continue = _folder_has_images(path)
+            folder_chan_continue = _has_folder(path, "1")
+            folder_stack_continue = _has_folder(path, "stack")
+            folder_npz_continue = _has_folder(path, "norm_channel_stack")
+            
+            if not pictures_continue:
+                if not any([folder_chan_continue, folder_stack_continue, folder_npz_continue]):
+                    if not folder_chan_continue:
+                        q.put(f"Error: Missing channel folder in folder: {path}")
+                        
+                    if not folder_stack_continue:
+                        q.put(f"Error: Missing stack folder in folder: {path}")
+                        
+                    if not folder_npz_continue:
+                        q.put(f"Error: Missing norm_channel_stack folder in folder: {path}")
+                    else:
+                        q.put(f"Error: No images in folder: {path}")
+            
+            #q.put(f"path:{path}")
+            #q.put(f"pictures_continue:{pictures_continue}, folder_chan_continue:{folder_chan_continue}, folder_stack_continue:{folder_stack_continue}, folder_npz_continue:{folder_npz_continue}")
+
+            conditions = [pictures_continue, folder_chan_continue, folder_stack_continue, folder_npz_continue]
+            
+        if settings_type == 'measure':
+            npy_continue = _folder_has_images(path, image_extensions={".npy"})
+            conditions = [npy_continue]
+            
+        if settings_type == 'recruitment':
+            db_continue = _folder_has_images(path, image_extensions={".db"})
+            conditions = [db_continue]
+            
+        if settings_type == 'umap':
+            db_continue = _folder_has_images(path, image_extensions={".db"})
+            conditions = [db_continue]
+            
+        if settings_type == 'analyze_plaques':
+            conditions = [True]
+        
+        if settings_type == 'map_barcodes':
+            conditions = [True]
+        
+        if settings_type == 'regression':
+            db_continue = _folder_has_images(path, image_extensions={".db"})
+            conditions = [db_continue]
+            
+        if settings_type == 'classify':
+            db_continue = _folder_has_images(path, image_extensions={".db"})
+            conditions = [db_continue]
+            
+        if settings_type == 'analyze_plaques':
+            db_continue = _folder_has_images(path, image_extensions={".db"})
+            conditions = [db_continue]
+            
+    if not any(conditions):
+        q.put(f"Error: The following path(s) is missing images or folders: {path}")
+        request_stop = True
+            
+    return request_stop
 
 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_cpu_affinity, initialize_cuda, display_gif_in_plot_frame, print_widget_structure
-
+        
     if q is None:
         q = Queue()
     if fig_queue is None:
         fig_queue = Queue()
     try:
-        settings = check_settings(vars_dict, expected_types, q)
+        settings, errors = check_settings(vars_dict, expected_types, q)
+        
+        if len(errors) > 0:
+            return
+        
+        if check_src_folders_files(settings, settings_type, q):
+            return
+    
     except ValueError as e:
         q.put(f"Error: {e}")
         return
-
+        
     if isinstance(thread_control, dict) and thread_control.get("run_thread") is not None:
         initiate_abort()
     
@@ -902,13 +994,176 @@ def start_process(q=None, fig_queue=None, settings_type='mask'):
 
         # Store the process in thread_control for future reference
         thread_control["run_thread"] = process
+        
     else:
         q.put(f"Error: Unknown settings type '{settings_type}'")
         return
-
+    
 def process_console_queue():
     global q, console_output, parent_frame, progress_bar, process_console_queue
 
+    # Initialize function attribute if it doesn't exist
+    if not hasattr(process_console_queue, "completed_tasks"):
+        process_console_queue.completed_tasks = []
+    if not hasattr(process_console_queue, "current_maximum"):
+        process_console_queue.current_maximum = None
+
+    ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
+    
+    spacing = 5
+
+    # **Configure styles for different message types**
+    console_output.tag_configure("error", foreground="red", spacing3 = spacing)
+    console_output.tag_configure("warning", foreground="orange", spacing3 = spacing)
+    console_output.tag_configure("normal", foreground="white", spacing3 = spacing)
+
+    while not q.empty():
+        message = q.get_nowait()
+        clean_message = ansi_escape_pattern.sub('', message)
+
+        # **Detect Error Messages (Red)**
+        if clean_message.startswith("Error:"):
+            console_output.insert(tk.END, clean_message + "\n", "error")
+            console_output.see(tk.END)
+            #print("Run aborted due to error:", clean_message)  # Debug message
+            #return  # **Exit immediately to stop further execution**
+
+        # **Detect Warning Messages (Orange)**
+        elif clean_message.startswith("Warning:"):
+            console_output.insert(tk.END, clean_message + "\n", "warning")
+        
+        # **Process Progress Messages Normally**
+        elif clean_message.startswith("Progress:"):
+            try:
+                # Extract the progress information
+                match = re.search(r'Progress: (\d+)/(\d+), operation_type: ([\w\s]*),(.*)', clean_message)
+
+                if match:
+                    current_progress = int(match.group(1))
+                    total_progress = int(match.group(2))
+                    operation_type = match.group(3).strip()
+                    additional_info = match.group(4).strip()  # Capture everything after operation_type
+                    
+                    # Check if the maximum value has changed
+                    if process_console_queue.current_maximum != total_progress:
+                        process_console_queue.current_maximum = total_progress
+                        process_console_queue.completed_tasks = []
+
+                    # Add the task to the completed set
+                    process_console_queue.completed_tasks.append(current_progress)
+                    
+                    # Calculate the unique progress count
+                    unique_progress_count = len(np.unique(process_console_queue.completed_tasks))
+
+                    # Update the progress bar
+                    if progress_bar:
+                        progress_bar['maximum'] = total_progress
+                        progress_bar['value'] = unique_progress_count
+
+                    # Store operation type and additional info
+                    if operation_type:
+                        progress_bar.operation_type = operation_type
+                        progress_bar.additional_info = additional_info
+
+                    # Update the progress label
+                    if progress_bar.progress_label:
+                        progress_bar.update_label()
+
+                    # Clear completed tasks when progress is complete
+                    if unique_progress_count >= total_progress:
+                        process_console_queue.completed_tasks.clear()
+
+            except Exception as e:
+                print(f"Error parsing progress message: {e}")
+
+        # **Insert Normal Messages with Extra Line Spacing**
+        else:
+            console_output.insert(tk.END, clean_message + "\n", "normal")
+
+        console_output.see(tk.END)
+
+    # **Continue processing if no error was detected**
+    after_id = console_output.after(uppdate_frequency, process_console_queue)
+    parent_frame.after_tasks.append(after_id)
+    
+def process_console_queue_v2():
+    global q, console_output, parent_frame, progress_bar, process_console_queue
+
+    # Initialize function attribute if it doesn't exist
+    if not hasattr(process_console_queue, "completed_tasks"):
+        process_console_queue.completed_tasks = []
+    if not hasattr(process_console_queue, "current_maximum"):
+        process_console_queue.current_maximum = None
+
+    ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
+
+    while not q.empty():
+        message = q.get_nowait()
+        clean_message = ansi_escape_pattern.sub('', message)
+
+        # **Abort Execution if an Error Message is Detected**
+        if clean_message.startswith("Error:"):
+            console_output.insert(tk.END, clean_message + "\n", "error")
+            console_output.see(tk.END)
+            print("Run aborted due to error:", clean_message)  # Debug message
+            return  # **Exit immediately to stop further execution**
+
+        # Check if the message contains progress information
+        if clean_message.startswith("Progress:"):
+            try:
+                # Extract the progress information
+                match = re.search(r'Progress: (\d+)/(\d+), operation_type: ([\w\s]*),(.*)', clean_message)
+
+                if match:
+                    current_progress = int(match.group(1))
+                    total_progress = int(match.group(2))
+                    operation_type = match.group(3).strip()
+                    additional_info = match.group(4).strip()  # Capture everything after operation_type
+                    
+                    # Check if the maximum value has changed
+                    if process_console_queue.current_maximum != total_progress:
+                        process_console_queue.current_maximum = total_progress
+                        process_console_queue.completed_tasks = []
+
+                    # Add the task to the completed set
+                    process_console_queue.completed_tasks.append(current_progress)
+                    
+                    # Calculate the unique progress count
+                    unique_progress_count = len(np.unique(process_console_queue.completed_tasks))
+
+                    # Update the progress bar
+                    if progress_bar:
+                        progress_bar['maximum'] = total_progress
+                        progress_bar['value'] = unique_progress_count
+
+                    # Store operation type and additional info
+                    if operation_type:
+                        progress_bar.operation_type = operation_type
+                        progress_bar.additional_info = additional_info
+
+                    # Update the progress label
+                    if progress_bar.progress_label:
+                        progress_bar.update_label()
+
+                    # Clear completed tasks when progress is complete
+                    if unique_progress_count >= total_progress:
+                        process_console_queue.completed_tasks.clear()
+
+            except Exception as e:
+                print(f"Error parsing progress message: {e}")
+
+        else:
+            # Insert non-progress messages into the console
+            console_output.insert(tk.END, clean_message + "\n")
+            console_output.see(tk.END)
+
+    # **Continue processing if no error was detected**
+    after_id = console_output.after(uppdate_frequency, process_console_queue)
+    parent_frame.after_tasks.append(after_id)
+
+def process_console_queue_v1():
+    global q, console_output, parent_frame, progress_bar, process_console_queue
+
     # Initialize function attribute if it doesn't exist
     if not hasattr(process_console_queue, "completed_tasks"):
         process_console_queue.completed_tasks = []

spacr/gui_elements.py

@@ -2285,6 +2285,9 @@ class AnnotateApp:
         
         self.train_button = Button(self.button_frame,text="orig.",command=self.swich_back_annotation_column,bg=self.bg_color,fg=self.fg_color,highlightbackground=self.fg_color,highlightcolor=self.fg_color,highlightthickness=1)
         self.train_button.pack(side="right", padx=5)
+        
+        self.settings_button = Button(self.button_frame, text="Settings", command=self.open_settings_window, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color,highlightcolor=self.fg_color,highlightthickness=1)
+        self.settings_button.pack(side="right", padx=5)
 
         # Calculate grid rows and columns based on the root window size and image size
         self.calculate_grid_dimensions()
@@ -2308,6 +2311,134 @@ class AnnotateApp:
         for col in range(self.grid_cols):
             self.grid_frame.grid_columnconfigure(col, weight=1)
             
+    def open_settings_window(self):
+        from .gui_utils import generate_annotate_fields, convert_to_number
+
+        # Create settings window
+        settings_window = tk.Toplevel(self.root)
+        settings_window.title("Modify Annotation Settings")
+
+        style_out = set_dark_style(ttk.Style())
+        settings_window.configure(bg=style_out['bg_color'])
+        
+        settings_frame = tk.Frame(settings_window, bg=style_out['bg_color'])
+        settings_frame.pack(fill=tk.BOTH, expand=True)
+
+        # Generate fields with current settings pre-filled
+        vars_dict = generate_annotate_fields(settings_frame)
+
+        # Pre-fill the current settings into vars_dict
+        current_settings = {
+            'image_type': self.image_type or '',
+            'channels': ','.join(self.channels) if self.channels else '',
+            'img_size': f"{self.image_size[0]},{self.image_size[1]}",
+            'annotation_column': self.annotation_column or '',
+            'normalize': str(self.normalize),
+            'percentiles': ','.join(map(str, self.percentiles)),
+            'measurement': ','.join(self.measurement) if self.measurement else '',
+            'threshold': str(self.threshold) if self.threshold is not None else '',
+            'normalize_channels': ','.join(self.normalize_channels) if self.normalize_channels else ''
+        }
+
+        for key, data in vars_dict.items():
+            if key in current_settings:
+                data['entry'].delete(0, tk.END)
+                data['entry'].insert(0, current_settings[key])
+
+        def apply_new_settings():
+            settings = {key: data['entry'].get() for key, data in vars_dict.items()}
+            
+            # Process settings exactly as your original initiation function does
+            settings['channels'] = settings['channels'].split(',') if settings['channels'] else None
+            settings['img_size'] = list(map(int, settings['img_size'].split(',')))
+            settings['percentiles'] = list(map(convert_to_number, settings['percentiles'].split(','))) if settings['percentiles'] else [1, 99]
+            settings['normalize'] = settings['normalize'].lower() == 'true'
+            settings['normalize_channels'] = settings['normalize_channels'].split(',') if settings['normalize_channels'] else None
+
+            try:
+                settings['measurement'] = settings['measurement'].split(',') if settings['measurement'] else None
+                settings['threshold'] = None if settings['threshold'].lower() == 'none' else int(settings['threshold'])
+            except:
+                settings['measurement'] = None
+                settings['threshold'] = None
+
+            # Convert empty strings to None
+            for key, value in settings.items():
+                if isinstance(value, list):
+                    settings[key] = [v if v != '' else None for v in value]
+                elif value == '':
+                    settings[key] = None
+
+            # Apply these settings dynamically using update_settings method
+            self.update_settings(**{
+                'image_type': settings.get('image_type'),
+                'channels': settings.get('channels'),
+                'image_size': settings.get('img_size'),
+                'annotation_column': settings.get('annotation_column'),
+                'normalize': settings.get('normalize'),
+                'percentiles': settings.get('percentiles'),
+                'measurement': settings.get('measurement'),
+                'threshold': settings.get('threshold'),
+                'normalize_channels': settings.get('normalize_channels')
+            })
+
+            settings_window.destroy()
+
+        apply_button = spacrButton(settings_window, text="Apply Settings", command=apply_new_settings,show_text=False)
+        apply_button.pack(pady=10)
+        
+    def update_settings(self, **kwargs):
+        allowed_attributes = {
+            'image_type', 'channels', 'image_size', 'annotation_column',
+            'normalize', 'percentiles', 'measurement', 'threshold', 'normalize_channels'
+        }
+
+        updated = False
+
+        for attr, value in kwargs.items():
+            if attr in allowed_attributes and value is not None:
+                setattr(self, attr, value)
+                updated = True
+
+        if 'image_size' in kwargs:
+            if isinstance(self.image_size, list):
+                self.image_size = (int(self.image_size[0]), int(self.image_size[0]))
+            elif isinstance(self.image_size, int):
+                self.image_size = (self.image_size, self.image_size)
+            else:
+                raise ValueError("Invalid image size")
+
+            self.calculate_grid_dimensions()
+            self.recreate_image_grid()
+
+        if updated:
+            current_index = self.index  # Retain current index
+            self.prefilter_paths_annotations()
+
+            # Ensure the retained index is still valid (not out of bounds)
+            max_index = len(self.filtered_paths_annotations) - 1
+            self.index = min(current_index, max_index := max(0, max(0, max(len(self.filtered_paths_annotations) - self.grid_rows * self.grid_cols, 0))))
+            self.load_images()
+
+    def recreate_image_grid(self):
+        # Remove current labels
+        for label in self.labels:
+            label.destroy()
+        self.labels.clear()
+
+        # Recreate the labels grid with updated dimensions
+        for i in range(self.grid_rows * self.grid_cols):
+            label = Label(self.grid_frame, bg=self.root.cget('bg'))
+            label.grid(row=i // self.grid_cols, column=i % self.grid_cols, padx=2, pady=2, sticky="nsew")
+            self.labels.append(label)
+
+        # Reconfigure grid weights
+        for row in range(self.grid_rows):
+            self.grid_frame.grid_rowconfigure(row, weight=1)
+        for col in range(self.grid_cols):
+            self.grid_frame.grid_columnconfigure(col, weight=1)
+
+            
     def swich_back_annotation_column(self):
         self.annotation_column = self.orig_annotation_columns
         self.prefilter_paths_annotations()