spacr 0.0.2__py3-none-any.whl → 0.0.6__py3-none-any.whl

spacr/mask_app.py

@@ -13,7 +13,7 @@ from ttkthemes import ThemedTk
 
 from .logger import log_function_call
 
-from .gui_utils import ScrollableFrame, set_dark_style, set_default_font, create_dark_mode
+from .gui_utils import ScrollableFrame, set_dark_style, set_default_font, create_dark_mode, style_text_boxes, create_menu_bar
 
 class modify_masks:
 
@@ -128,10 +128,13 @@ class modify_masks:
         self.zoom_active = False
         self.magic_wand_active = False
         self.brush_active = False
+        self.dividing_line_active = False
+        self.dividing_line_coords = []
+        self.current_dividing_line = None
         self.lower_quantile = tk.StringVar(value="1.0")
         self.upper_quantile = tk.StringVar(value="99.9")
         self.magic_wand_tolerance = tk.StringVar(value="1000")
-    
+
     def update_mouse_info(self, event):
         x, y = event.x, event.y
         intensity = "N/A"
@@ -187,13 +190,14 @@ class modify_masks:
         self.max_pixels_entry.pack(side='left')
         self.erase_btn = tk.Button(self.mode_toolbar, text="Erase", command=self.toggle_erase_mode)
         self.erase_btn.pack(side='left')
-    
         self.brush_btn = tk.Button(self.mode_toolbar, text="Brush", command=self.toggle_brush_mode)
         self.brush_btn.pack(side='left')
         self.brush_size_entry = tk.Entry(self.mode_toolbar)
-        self.brush_size_entry.insert(0, "10") 
+        self.brush_size_entry.insert(0, "10")
         self.brush_size_entry.pack(side='left')
         tk.Label(self.mode_toolbar, text="Brush Size:").pack(side='left')
+        self.dividing_line_btn = tk.Button(self.mode_toolbar, text="Dividing Line", command=self.toggle_dividing_line_mode)
+        self.dividing_line_btn.pack(side='left')
 
     def setup_function_toolbar(self):
         self.function_toolbar = tk.Frame(self.root)
@@ -393,10 +397,12 @@ class modify_masks:
             self.magic_wand_active = False
             self.erase_active = False
             self.brush_active = False
+            self.dividing_line_active = False
             self.draw_btn.config(text="Draw")
             self.erase_btn.config(text="Erase")
             self.magic_wand_btn.config(text="Magic Wand")
             self.zoom_btn.config(text="Zoom ON")
+            self.dividing_line_btn.config(text="Dividing Line")
             self.canvas.unbind("<Button-1>")
             self.canvas.unbind("<Button-3>")
             self.canvas.unbind("<Motion>")
@@ -423,7 +429,7 @@ class modify_masks:
             self.zoom_mask = None
             self.zoom_image = None
             self.zoom_image_orig = None
-            
+
     def toggle_brush_mode(self):
         self.brush_active = not self.brush_active
         if self.brush_active:
@@ -448,7 +454,105 @@ class modify_masks:
             self.canvas.unbind("<B3-Motion>")
             self.canvas.unbind("<ButtonRelease-1>")
             self.canvas.unbind("<ButtonRelease-3>")
-            
+
+    def image_to_canvas(self, x_image, y_image):
+        x_scale, y_scale = self.get_scaling_factors(
+            self.image.shape[1], self.image.shape[0],
+            self.canvas_width, self.canvas_height
+        )
+        x_canvas = int(x_image / x_scale)
+        y_canvas = int(y_image / y_scale)
+        return x_canvas, y_canvas
+
+    def toggle_dividing_line_mode(self):
+        self.dividing_line_active = not self.dividing_line_active
+        if self.dividing_line_active:
+            self.drawing = False
+            self.magic_wand_active = False
+            self.erase_active = False
+            self.brush_active = False
+            self.draw_btn.config(text="Draw")
+            self.erase_btn.config(text="Erase")
+            self.magic_wand_btn.config(text="Magic Wand")
+            self.brush_btn.config(text="Brush")
+            self.dividing_line_btn.config(text="Dividing Line ON")
+            self.canvas.unbind("<Button-1>")
+            self.canvas.unbind("<ButtonRelease-1>")
+            self.canvas.unbind("<Motion>")
+            self.canvas.bind("<Button-1>", self.start_dividing_line)
+            self.canvas.bind("<ButtonRelease-1>", self.finish_dividing_line)
+            self.canvas.bind("<Motion>", self.update_dividing_line_preview)
+        else:
+            print("Dividing Line Mode: OFF")
+            self.dividing_line_active = False
+            self.dividing_line_btn.config(text="Dividing Line")
+            self.canvas.unbind("<Button-1>")
+            self.canvas.unbind("<ButtonRelease-1>")
+            self.canvas.unbind("<Motion>")
+            self.display_image()
+
+    def start_dividing_line(self, event):
+        if self.dividing_line_active:
+            self.dividing_line_coords = [(event.x, event.y)]
+            self.current_dividing_line = self.canvas.create_line(event.x, event.y, event.x, event.y, fill="red", width=2)
+
+    def finish_dividing_line(self, event):
+        if self.dividing_line_active:
+            self.dividing_line_coords.append((event.x, event.y))
+            if self.zoom_active:
+                self.dividing_line_coords = [self.canvas_to_image(x, y) for x, y in self.dividing_line_coords]
+            self.apply_dividing_line()
+            self.canvas.delete(self.current_dividing_line)
+            self.current_dividing_line = None
+
+    def update_dividing_line_preview(self, event):
+        if self.dividing_line_active and self.dividing_line_coords:
+            x, y = event.x, event.y
+            if self.zoom_active:
+                x, y = self.canvas_to_image(x, y)
+            self.dividing_line_coords.append((x, y))
+            canvas_coords = [(self.image_to_canvas(*pt) if self.zoom_active else pt) for pt in self.dividing_line_coords]
+            flat_canvas_coords = [coord for pt in canvas_coords for coord in pt]
+            self.canvas.coords(self.current_dividing_line, *flat_canvas_coords)
+
+    def apply_dividing_line(self):
+        if self.dividing_line_coords:
+            coords = self.dividing_line_coords
+            if self.zoom_active:
+                coords = [self.canvas_to_image(x, y) for x, y in coords]
+
+            rr, cc = [], []
+            for (x0, y0), (x1, y1) in zip(coords[:-1], coords[1:]):
+                line_rr, line_cc = line(y0, x0, y1, x1)
+                rr.extend(line_rr)
+                cc.extend(line_cc)
+            rr, cc = np.array(rr), np.array(cc)
+
+            mask_copy = self.mask.copy()
+
+            if self.zoom_active:
+                # Update the zoomed mask
+                self.zoom_mask[rr, cc] = 0
+                # Reflect changes to the original mask
+                y0, y1, x0, x1 = self.zoom_y0, self.zoom_y1, self.zoom_x0, self.zoom_x1
+                zoomed_mask_resized_back = resize(self.zoom_mask, (y1 - y0, x1 - x0), order=0, preserve_range=True).astype(np.uint8)
+                self.mask[y0:y1, x0:x1] = zoomed_mask_resized_back
+            else:
+                # Directly update the original mask
+                mask_copy[rr, cc] = 0
+                self.mask = mask_copy
+
+            labeled_mask, num_labels = label(self.mask > 0)
+            self.mask = labeled_mask
+            self.update_display()
+
+            self.dividing_line_coords = []
+            self.canvas.unbind("<Button-1>")
+            self.canvas.unbind("<ButtonRelease-1>")
+            self.canvas.unbind("<Motion>")
+            self.dividing_line_active = False
+            self.dividing_line_btn.config(text="Dividing Line")
+
     def toggle_draw_mode(self):
         self.drawing = not self.drawing
         if self.drawing:
@@ -753,15 +857,18 @@ class modify_masks:
                 self.mask[labeled_mask == i] = 0  # Remove small objects
         self.update_display()
 
-@log_function_call
+##@log_function_call
 def initiate_mask_app_root(width, height):
     theme = 'breeze'
     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("Mask App")
+    create_menu_bar(root)
 
     container = tk.PanedWindow(root, orient=tk.HORIZONTAL)
     container.pack(fill=tk.BOTH, expand=True)
@@ -806,7 +913,7 @@ def initiate_mask_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/measure.py

@@ -3,7 +3,6 @@ import numpy as np
 import pandas as pd
 from collections import defaultdict
 from scipy.stats import pearsonr
-import matplotlib as mpl
 import multiprocessing as mp
 from scipy.ndimage import distance_transform_edt, generate_binary_structure
 from skimage.measure import regionprops, regionprops_table, shannon_entropy
@@ -12,6 +11,8 @@ from scipy.ndimage import binary_dilation
 from skimage.segmentation import find_boundaries
 from skimage.feature import graycomatrix, graycoprops
 from mahotas.features import zernike_moments
+from skimage import morphology, measure, filters
+from skimage.util import img_as_bool
 
 from .logger import log_function_call
 
@@ -92,7 +93,70 @@ def _calculate_zernike(mask, df, degree=8):
     else:
         return df
 
-@log_function_call
+def _analyze_cytoskeleton(array, mask, channel):
+    """
+    Analyzes and extracts skeleton properties from labeled objects in a masked image based on microtubule staining intensities.
+
+    Parameters:
+    image : numpy array
+        Intensity image where the microtubules are stained.
+    mask : numpy array
+        Mask where objects are labeled for analysis. Each label corresponds to a unique object.
+
+    Returns:
+    DataFrame
+        A pandas DataFrame containing the measured properties of each object's skeleton.
+    """
+
+    image = array[:, :, channel]
+
+    properties_list = []
+
+    # Process each object in the mask based on its label
+    for label in np.unique(mask):
+        if label == 0:
+            continue  # Skip background
+
+        # Isolate the object using the label
+        object_region = mask == label
+        region_intensity = np.where(object_region, image, 0)  # Use np.where for more efficient masking
+
+        # Ensure there are non-zero values to process
+        if np.any(region_intensity):
+            # Calculate adaptive offset based on intensity percentiles within the object
+            valid_pixels = region_intensity[region_intensity > 0]
+            if len(valid_pixels) > 1:  # Ensure there are enough pixels to compute percentiles
+                offset = np.percentile(valid_pixels, 90) - np.percentile(valid_pixels, 50)
+                block_size = 35  # Adjust this based on your object sizes and detail needs
+                local_thresh = filters.threshold_local(region_intensity, block_size=block_size, offset=offset)
+                cytoskeleton = region_intensity > local_thresh
+
+                # Skeletonize the thresholded cytoskeleton
+                skeleton = morphology.skeletonize(img_as_bool(cytoskeleton))
+
+                # Measure properties of the skeleton
+                skeleton_props = measure.regionprops(measure.label(skeleton), intensity_image=image)
+                skeleton_length = sum(prop.area for prop in skeleton_props)  # Sum of lengths of all skeleton segments
+                branch_data = morphology.skeleton_branch_analysis(skeleton)
+
+                # Store properties
+                properties = {
+                    "object_label": label,
+                    "skeleton_length": skeleton_length,
+                    "skeleton_branch_points": len(branch_data['branch_points'])
+                }
+                properties_list.append(properties)
+            else:
+                # Handle cases with insufficient pixels
+                properties_list.append({
+                    "object_label": label,
+                    "skeleton_length": 0,
+                    "skeleton_branch_points": 0
+                })
+
+    return pd.DataFrame(properties_list)
+
+#@log_function_call
 def _morphological_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, settings, zernike=True, degree=8):
     """
     Calculate morphological measurements for cells, nucleus, pathogens, and cytoplasms based on the given masks.
@@ -436,7 +500,7 @@ def _estimate_blur(image):
     # Compute and return the variance of the Laplacian
     return lap.var()
 
-@log_function_call
+#@log_function_call
 def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, channel_arrays, settings, sizes=[3, 6, 12, 24], periphery=True, outside=True):
     """
     Calculate various intensity measurements for different regions in the image.
@@ -524,8 +588,9 @@ def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_ma
     
     return pd.concat(cell_dfs, axis=1), pd.concat(nucleus_dfs, axis=1), pd.concat(pathogen_dfs, axis=1), pd.concat(cytoplasm_dfs, axis=1)
 
-@log_function_call
+#@log_function_call
 def _measure_crop_core(index, time_ls, file, settings):
+
     """
     Measure and crop the images based on specified settings.
 
@@ -624,9 +689,8 @@ def _measure_crop_core(index, time_ls, file, settings):
         if settings['cytoplasm_min_size'] is not None and settings['cytoplasm_min_size'] != 0:
             cytoplasm_mask = _filter_object(cytoplasm_mask, settings['cytoplasm_min_size'])
 
-        if settings['cell_mask_dim'] is not None and settings['pathogen_mask_dim'] is not None:
-            if settings['include_uninfected'] == False:
-                cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask = _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, include_uninfected=False)
+        if settings['cell_mask_dim'] is not None:
+            cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask = _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, include_uninfected=settings['include_uninfected'])
 
         # Update data with the new masks
         if settings['cell_mask_dim'] is not None:
@@ -645,6 +709,10 @@ def _measure_crop_core(index, time_ls, file, settings):
 
             cell_df, nucleus_df, pathogen_df, cytoplasm_df = _morphological_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, settings)
 
+            #if settings['skeleton']:
+                #skeleton_df = _analyze_cytoskeleton(image=channel_arrays, mask=cell_mask, channel=1)
+                #merge skeleton_df with cell_df here
+
             cell_intensity_df, nucleus_intensity_df, pathogen_intensity_df, cytoplasm_intensity_df = _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, channel_arrays, settings, sizes=[1, 2, 3, 4, 5], periphery=True, outside=True)
             if settings['cell_mask_dim'] is not None:
                 cell_merged_df = _merge_and_save_to_database(cell_df, cell_intensity_df, 'cell', source_folder, file_name, settings['experiment'], settings['timelapse'])
@@ -658,7 +726,6 @@ def _measure_crop_core(index, time_ls, file, settings):
             if settings['cytoplasm']:
                 cytoplasm_merged_df = _merge_and_save_to_database(cytoplasm_df, cytoplasm_intensity_df, 'cytoplasm', source_folder, file_name, settings['experiment'], settings['timelapse'])
 
-        
         if settings['save_png'] or settings['save_arrays'] or settings['plot']:
 
             if isinstance(settings['dialate_pngs'], bool):
@@ -731,7 +798,7 @@ def _measure_crop_core(index, time_ls, file, settings):
                             png_channels = data[:, :, settings['png_dims']].astype(data_type)
 
                             if settings['normalize_by'] == 'fov':
-                                percentiles_list = _get_percentiles(png_channels, settings['normalize_percentiles'][0],q2=settings['normalize_percentiles'][1])
+                                percentiles_list = _get_percentiles(png_channels, settings['normalize'][0],q2=settings['normalize'][1])
 
                             png_channels = _crop_center(png_channels, region, new_width=width, new_height=height)
 
@@ -788,6 +855,7 @@ def _measure_crop_core(index, time_ls, file, settings):
                                     conn.commit()
                                 except sqlite3.OperationalError as e:
                                     print(f"SQLite error: {e}", flush=True)
+                                    traceback.print_exc()
 
                             if settings['plot']:
                                 _plot_cropped_arrays(png_channels)
@@ -818,15 +886,14 @@ def _measure_crop_core(index, time_ls, file, settings):
     average_time = np.mean(time_ls) if len(time_ls) > 0 else 0
     return average_time, cells
 
-@log_function_call
-def measure_crop(settings, annotation_settings, advanced_settings):
+#@log_function_call
+def measure_crop(settings):
+    
     """
     Measure the crop of an image based on the provided settings.
 
     Args:
         settings (dict): The settings for measuring the crop.
-        annotation_settings (dict): The annotation settings.
-        advanced_settings (dict): The advanced settings.
 
     Returns:
         None
@@ -845,19 +912,6 @@ def measure_crop(settings, annotation_settings, advanced_settings):
     from .plot import _save_scimg_plot
     from .utils import _list_endpoint_subdirectories, _generate_representative_images
     
-    settings = {**settings, **annotation_settings, **advanced_settings}
-    
-    dirname = os.path.dirname(settings['input_folder'])
-    settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
-    settings_csv = os.path.join(dirname,'settings','measure_crop_settings.csv')
-    os.makedirs(os.path.join(dirname,'settings'), exist_ok=True)
-    settings_df.to_csv(settings_csv, index=False)
-
-    if settings['timelapse_objects'] == 'nucleus':
-        if not settings['cell_mask_dim'] is None:
-            tlo = settings['timelapse_objects']
-            print(f'timelapse object:{tlo}, cells will be relabeled to nucleus labels to track cells.')
-
     #general settings
     settings['merge_edge_pathogen_cells'] = True
     settings['radial_dist'] = True
@@ -866,6 +920,26 @@ def measure_crop(settings, annotation_settings, advanced_settings):
     settings['homogeneity'] = True
     settings['homogeneity_distances'] = [8,16,32]
     settings['save_arrays'] = False
+
+    settings['dialate_pngs'] = False
+    settings['dialate_png_ratios'] = [0.2]
+    settings['timelapse'] = False
+    settings['representative_images'] = False
+    settings['timelapse_objects'] = 'cell'
+    settings['max_workers'] = os.cpu_count()-2
+    settings['experiment'] = 'test'
+    settings['cells'] = 'HeLa'
+    settings['cell_loc'] = None
+    settings['pathogens'] = ['ME49Dku80WT', 'ME49Dku80dgra8:GRA8', 'ME49Dku80dgra8', 'ME49Dku80TKO']
+    settings['pathogen_loc'] = [['c1', 'c2', 'c3', 'c4', 'c5', 'c6'], ['c7', 'c8', 'c9', 'c10', 'c11', 'c12'], ['c13', 'c14', 'c15', 'c16', 'c17', 'c18'], ['c19', 'c20', 'c21', 'c22', 'c23', 'c24']]
+    settings['treatments'] = ['BR1', 'BR2', 'BR3']
+    settings['treatment_loc'] = [['c1', 'c2', 'c7', 'c8', 'c13', 'c14', 'c19', 'c20'], ['c3', 'c4', 'c9', 'c10', 'c15', 'c16', 'c21', 'c22'], ['c5', 'c6', 'c11', 'c12', 'c17', 'c18', 'c23', 'c24']]
+    settings['channel_of_interest'] = 2
+    settings['compartments'] = ['pathogen', 'cytoplasm']
+    settings['measurement'] = 'mean_intensity'
+    settings['nr_imgs'] = 32
+    settings['um_per_pixel'] = 0.1
+    settings['center_crop'] = True
     
     if settings['cell_mask_dim'] is None:
         settings['include_uninfected'] = True
@@ -878,7 +952,18 @@ def measure_crop(settings, annotation_settings, advanced_settings):
     else:
         settings['cytoplasm'] = False
 
-    settings['center_crop'] = True
+    #settings = {**settings, **annotation_settings, **advanced_settings}
+    
+    dirname = os.path.dirname(settings['input_folder'])
+    settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
+    settings_csv = os.path.join(dirname,'settings','measure_crop_settings.csv')
+    os.makedirs(os.path.join(dirname,'settings'), exist_ok=True)
+    settings_df.to_csv(settings_csv, index=False)
+
+    if settings['timelapse_objects'] == 'nucleus':
+        if not settings['cell_mask_dim'] is None:
+            tlo = settings['timelapse_objects']
+            print(f'timelapse object:{tlo}, cells will be relabeled to nucleus labels to track cells.')
 
     int_setting_keys = ['cell_mask_dim', 'nucleus_mask_dim', 'pathogen_mask_dim', 'cell_min_size', 'nucleus_min_size', 'pathogen_min_size', 'cytoplasm_min_size']
     
@@ -922,49 +1007,49 @@ def measure_crop(settings, annotation_settings, advanced_settings):
                 time_left = (((files_to_process-files_processed)*average_time)/max_workers)/60
                 print(f'Progress: {files_processed}/{files_to_process} Time/img {average_time:.3f}sec, Time Remaining {time_left:.3f} min.', end='\r', flush=True)
             result.get()
-    
-    if settings['save_png']:
-        img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
-        sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
-
-        for i, well_src in enumerate(sc_img_fldrs):
-            if len(os.listdir(well_src)) < 16:
-                nr_imgs = len(os.listdir(well_src))
-                standardize = False
-            else:
-                nr_imgs = 16
-                standardize = True
-            try:
-                all_folders = len(sc_img_fldrs)
-                _save_scimg_plot(src=well_src, nr_imgs=nr_imgs, channel_indices=settings['png_dims'], um_per_pixel=0.1, scale_bar_length_um=10, standardize=standardize, fontsize=12, show_filename=True, channel_names=['red','green','blue'], dpi=300, plot=False, i=i, all_folders=all_folders)
-
-            except Exception as e:
-                print(f"Unable to generate figure for folder {well_src}: {e}", end='\r', flush=True)
-                #traceback.print_exc()
+
+    if settings['representative_images']:
+        if settings['save_png']:
+            img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
+            sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
+
+            for i, well_src in enumerate(sc_img_fldrs):
+                if len(os.listdir(well_src)) < 16:
+                    nr_imgs = len(os.listdir(well_src))
+                    standardize = False
+                else:
+                    nr_imgs = 16
+                    standardize = True
+                try:
+                    all_folders = len(sc_img_fldrs)
+                    _save_scimg_plot(src=well_src, nr_imgs=nr_imgs, channel_indices=settings['png_dims'], um_per_pixel=0.1, scale_bar_length_um=10, standardize=standardize, fontsize=12, show_filename=True, channel_names=['red','green','blue'], dpi=300, plot=False, i=i, all_folders=all_folders)
+
+                except Exception as e:
+                    print(f"Unable to generate figure for folder {well_src}: {e}", end='\r', flush=True)
+                    #traceback.print_exc()
     
         if settings['save_measurements']:
-            if settings['representative_images']:
-                db_path = os.path.join(os.path.dirname(settings['input_folder']), 'measurements', 'measurements.db')
-                channel_indices = settings['png_dims']
-                channel_indices = [min(value, 2) for value in channel_indices]
-                _generate_representative_images(db_path,
-                                            cells=settings['cells'],
-                                            cell_loc=settings['cell_loc'],
-                                            pathogens=settings['pathogens'],
-                                            pathogen_loc=settings['pathogen_loc'],
-                                            treatments=settings['treatments'],
-                                            treatment_loc=settings['treatment_loc'],
-                                            channel_of_interest=settings['channel_of_interest'],
-                                            compartments = settings['compartments'],
-                                            measurement = settings['measurement'],
-                                            nr_imgs=settings['nr_imgs'],
-                                            channel_indices=channel_indices,
-                                            um_per_pixel=settings['um_per_pixel'],
-                                            scale_bar_length_um=10,
-                                            plot=False,
-                                            fontsize=12,
-                                            show_filename=True,
-                                            channel_names=None)
+            db_path = os.path.join(os.path.dirname(settings['input_folder']), 'measurements', 'measurements.db')
+            channel_indices = settings['png_dims']
+            channel_indices = [min(value, 2) for value in channel_indices]
+            _generate_representative_images(db_path,
+                                        cells=settings['cells'],
+                                        cell_loc=settings['cell_loc'],
+                                        pathogens=settings['pathogens'],
+                                        pathogen_loc=settings['pathogen_loc'],
+                                        treatments=settings['treatments'],
+                                        treatment_loc=settings['treatment_loc'],
+                                        channel_of_interest=settings['channel_of_interest'],
+                                        compartments = settings['compartments'],
+                                        measurement = settings['measurement'],
+                                        nr_imgs=settings['nr_imgs'],
+                                        channel_indices=channel_indices,
+                                        um_per_pixel=settings['um_per_pixel'],
+                                        scale_bar_length_um=10,
+                                        plot=False,
+                                        fontsize=12,
+                                        show_filename=True,
+                                        channel_names=None)
 
     if settings['timelapse']:
         if settings['timelapse_objects'] == 'nucleus':
@@ -973,7 +1058,7 @@ def measure_crop(settings, annotation_settings, advanced_settings):
             object_types = ['nucleus','pathogen','cell']
             _timelapse_masks_to_gif(folder_path, mask_channels, object_types)
 
-        if settings['save_png']:
+        #if settings['save_png']:
             img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
             sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
             _scmovie(sc_img_fldrs)
@@ -1006,3 +1091,18 @@ def generate_cellpose_train_set(folders, dst, min_objects=5):
                     shutil.copy(img_path, new_img)
                 except Exception as e:
                     print(f"Error copying {path} to {new_mask}: {e}")
+
+def get_object_counts(src):
+    database_path = os.path.join(src, 'measurements/measurements.db')
+    # Connect to the SQLite database
+    conn = sqlite3.connect(database_path)
+    # Read the table into a pandas DataFrame
+    df = pd.read_sql_query("SELECT * FROM object_counts", conn)
+    # Group by 'count_type' and calculate the sum of 'object_count' and the average 'object_count' per 'file_name'
+    grouped_df = df.groupby('count_type').agg(
+        total_object_count=('object_count', 'sum'),
+        avg_object_count_per_file_name=('object_count', 'mean')
+    ).reset_index()
+    # Close the database connection
+    conn.close()
+    return grouped_df

spacr/old_code.py

@@ -103,7 +103,7 @@ def run_mask_gui(q):
     except Exception as e:
         q.put(f"Error during processing: {e}\n")
 
-@log_function_call   
+#@log_function_call   
 def main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label):
     try:
         while not q.empty():
@@ -287,4 +287,72 @@ def _extract_filename_metadata(filenames, src, images_by_key, regular_expression
             print(f"Filename {filename} did not match provided regex")
             continue
         
-    return images_by_key
+    return images_by_key
+
+def compare_cellpose_masks_v1(src, verbose=False, save=False):
+    
+    from .io import _read_mask
+    from .plot import visualize_masks, plot_comparison_results, visualize_cellpose_masks
+    from .utils import extract_boundaries, boundary_f1_score, compute_segmentation_ap, jaccard_index
+
+    import os
+    import numpy as np
+    from skimage.measure import label
+
+    # Collect all subdirectories in src
+    dirs = [os.path.join(src, d) for d in os.listdir(src) if os.path.isdir(os.path.join(src, d))]
+
+    dirs.sort()  # Optional: sort directories if needed
+
+    # Get common files in all directories
+    common_files = set(os.listdir(dirs[0]))
+    for d in dirs[1:]:
+        common_files.intersection_update(os.listdir(d))
+    common_files = list(common_files)
+
+    results = []
+    conditions = [os.path.basename(d) for d in dirs]
+
+    for index, filename in enumerate(common_files):
+        print(f'Processing image {index+1}/{len(common_files)}', end='\r', flush=True)
+        paths = [os.path.join(d, filename) for d in dirs]
+
+        # Check if file exists in all directories
+        if not all(os.path.exists(path) for path in paths):
+            print(f'Skipping {filename} as it is not present in all directories.')
+            continue
+
+        masks = [_read_mask(path) for path in paths]
+        boundaries = [extract_boundaries(mask) for mask in masks]
+
+        if verbose:
+            visualize_cellpose_masks(masks, titles=conditions, comparison_title=f"Masks Comparison for {filename}", save=save, src=src)
+
+        # Initialize data structure for results
+        file_results = {'filename': filename}
+
+        # Compare each mask with each other
+        for i in range(len(masks)):
+            for j in range(i + 1, len(masks)):
+                condition_i = conditions[i]
+                condition_j = conditions[j]
+                mask_i = masks[i]
+                mask_j = masks[j]
+
+                # Compute metrics
+                boundary_f1 = boundary_f1_score(mask_i, mask_j)
+                jaccard = jaccard_index(mask_i, mask_j)
+                average_precision = compute_segmentation_ap(mask_i, mask_j)
+
+                # Store results
+                file_results[f'jaccard_{condition_i}_{condition_j}'] = jaccard
+                file_results[f'boundary_f1_{condition_i}_{condition_j}'] = boundary_f1
+                file_results[f'average_precision_{condition_i}_{condition_j}'] = average_precision
+
+        results.append(file_results)
+
+    fig = plot_comparison_results(results)
+
+    save_results_and_figure(src, fig, results)
+
+    return results, fig