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

spacr/__init__.py

@@ -27,7 +27,7 @@ from . import openai
 from . import ml
 from . import toxo
 from . import cellpose
-from . import stats
+from . import sp_stats
 from . import logger
 
 __all__ = [
@@ -58,7 +58,7 @@ __all__ = [
     "ml",
     "toxo",
     "cellpose",
-    "stats",
+    "sp_stats",
     "logger"
 ]
 

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/deep_spacr.py

@@ -938,67 +938,8 @@ def deep_spacr(settings={}):
         if os.path.exists(settings['model_path']):
             apply_model_to_tar(settings)
             
-def model_knowledge_transfer(
-    teacher_paths,
-    student_save_path,
-    data_loader,                 # A DataLoader with (images, labels)
-    device='cpu',
-    student_model_name='maxvit_t',
-    pretrained=True,
-    dropout_rate=None,
-    use_checkpoint=False,
-    alpha=0.5,
-    temperature=2.0,
-    lr=1e-4,
-    epochs=10
-):
-    """
-    Performs multi-teacher knowledge distillation on a new labeled dataset,
-    producing a single student TorchModel that combines (distills) the 
-    teachers' knowledge plus the labeled data.
-
-    Usage:
-        student = model_knowledge_transfer(
-            teacher_paths=[
-                'teacherA.pth', 
-                'teacherB.pth', 
-                ...
-            ],
-            student_save_path='distilled_student.pth',
-            data_loader=my_data_loader, 
-            device='cuda', 
-            student_model_name='maxvit_t',
-            alpha=0.5,
-            temperature=2.0,
-            lr=1e-4,
-            epochs=10
-        )
-
-    Then load it via:
-        fused_student = torch.load('distilled_student.pth')
-        # fused_student is a TorchModel instance, ready for inference.
-
-    Args:
-        teacher_paths (list[str]): List of paths to teacher models (TorchModel 
-            or dict with 'model' in it). They must have the same architecture 
-            or at least produce the same dimension of output.
-        student_save_path (str): Destination path to save the final student 
-            TorchModel. 
-        data_loader (DataLoader): Yields (images, labels) from the new dataset.
-        device (str): 'cpu' or 'cuda'.
-        student_model_name (str): Architecture name for the student TorchModel.
-        pretrained (bool): If the student should be initialized as pretrained.
-        dropout_rate (float): If needed by your TorchModel init.
-        use_checkpoint (bool): If needed by your TorchModel init.
-        alpha (float): Weight balancing real-label CE vs. distillation loss 
-            (0..1). 
-        temperature (float): Distillation temperature (>1 typically).
-        lr (float): Learning rate for the student.
-        epochs (int): Number of training epochs.
+def model_knowledge_transfer(teacher_paths, student_save_path, data_loader, device='cpu', student_model_name='maxvit_t', pretrained=True, dropout_rate=None, use_checkpoint=False, alpha=0.5, temperature=2.0, lr=1e-4, epochs=10):
 
-    Returns:
-        TorchModel: The final, trained student model.
-    """
     from spacr.utils import TorchModel  # Adapt if needed
 
     # Adjust filename to reflect knowledge-distillation if desired
@@ -1101,42 +1042,8 @@ def model_knowledge_transfer(
 
     return student_model
             
-def model_fusion(model_paths,
-                 save_path,
-                 device='cpu',
-                 model_name='maxvit_t',
-                 pretrained=True,
-                 dropout_rate=None,
-                 use_checkpoint=False,
-                 aggregator='mean'):
-    """
-    Fuses an arbitrary number of TorchModel instances by combining their weights 
-    (using mean, geomean, median, sum, max, or min) and saves the entire fused 
-    model object. 
-
-    You can later load the fused model with:
-        model = torch.load('fused_model.pth')
-
-    which returns a ready-to-use TorchModel instance.
-
-    Parameters:
-        model_paths (list of str): Paths to the model checkpoints to fuse.
-                                   Each checkpoint can be:
-                                     - A dict with keys ['model', 'model_name', ...]
-                                     - A TorchModel instance
-        save_path (str): Destination path to save the fused model.
-        device (str): 'cpu' or 'cuda' for loading weights and final model device.
-        model_name (str): Default model name (used if not in checkpoint).
-        pretrained (bool): Default if not in checkpoint.
-        dropout_rate (float): Default if not in checkpoint.
-        use_checkpoint (bool): Default if not in checkpoint.
-        aggregator (str): How to combine weights across models:
-                            'mean', 'geomean', 'median', 'sum', 'max', or 'min'.
+def model_fusion(model_paths,save_path,device='cpu',model_name='maxvit_t',pretrained=True,dropout_rate=None,use_checkpoint=False,aggregator='mean'):
 
-    Returns:
-        fused_model (TorchModel): The final fused TorchModel instance 
-                                  with combined weights.
-    """
     from spacr.utils import TorchModel
     
     if save_path.endswith('.pth'):

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 = []