spacr 0.0.36__py3-none-any.whl → 0.0.62__py3-none-any.whl

spacr/mask_app.py

@@ -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:

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
@@ -1092,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

@@ -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

spacr/plot.py

@@ -11,8 +11,6 @@ import statsmodels.api as sm
 import imageio.v2 as imageio
 from IPython.display import display
 from skimage.segmentation import find_boundaries
-from skimage.measure import find_contours
-from skimage.morphology import square, dilation 
 from skimage import measure
 
 from ipywidgets import IntSlider, interact
@@ -376,7 +374,7 @@ def plot_arrays(src, figuresize=50, cmap='inferno', nr=1, normalize=True, q1=1,
         print(f'Image path:{path}')
         img = np.load(path)
         if normalize:
-            img = normalize_to_dtype(array=img, q1=q1, q2=q2)
+            img = normalize_to_dtype(array=img, p1=q1, p2=q2)
         dim = img.shape
         if len(img.shape)>2:
             array_nr = img.shape[2]
@@ -426,9 +424,11 @@ def _normalize_and_outline(image, remove_background, normalize, normalization_pe
         image[mask] = 0
 
     if normalize:
-        image = normalize_to_dtype(array=image, q1=normalization_percentiles[0], q2=normalization_percentiles[1])
+        image = normalize_to_dtype(array=image, p1=normalization_percentiles[0], p2=normalization_percentiles[1])
+    else:
+        image = normalize_to_dtype(array=image, p1=0, p2=100)
 
-    rgb_image = _gen_rgb_image(image, cahnnels=overlay_chans)
+    rgb_image = _gen_rgb_image(image, channels=overlay_chans)
 
     if overlay:
         overlayed_image, outlines, image = _outline_and_overlay(image, rgb_image, mask_dims, outline_colors, outline_thickness)
@@ -440,6 +440,7 @@ def _normalize_and_outline(image, remove_background, normalize, normalization_pe
         image = np.take(image, channels_to_keep, axis=-1)
         return [], image, []
 
+
 def _plot_merged_plot(overlay, image, stack, mask_dims, figuresize, overlayed_image, outlines, cmap, outline_colors, print_object_number):
     
     """
@@ -513,6 +514,8 @@ def plot_merged(src, settings):
         None
     """
     from .utils import _remove_noninfected
+
+    
     
     font = settings['figuresize']/2
     outline_colors = _get_colours_merged(settings['outline_color'])
@@ -1347,7 +1350,7 @@ def visualize_masks(mask1, mask2, mask3, title="Masks Comparison"):
     plt.suptitle(title)
     plt.show()
 
-def visualize_cellpose_masks(masks, titles=None, comparison_title="Masks Comparison"):
+def visualize_cellpose_masks(masks, titles=None, filename=None, save=False, src=None):
     """
     Visualize multiple masks with optional titles.
     
@@ -1356,6 +1359,9 @@ def visualize_cellpose_masks(masks, titles=None, comparison_title="Masks Compari
         titles (list of str, optional): A list of titles for the masks. If None, default titles will be used.
         comparison_title (str): Title for the entire figure.
     """
+    
+    comparison_title=f"Masks Comparison for {filename}"
+    
     if titles is None:
         titles = [f'Mask {i+1}' for i in range(len(masks))]
     
@@ -1376,6 +1382,17 @@ def visualize_cellpose_masks(masks, titles=None, comparison_title="Masks Compari
     plt.suptitle(comparison_title)
     plt.show()
     
+    if save:
+        if src is None:
+            src = os.getcwd()
+        results_dir = os.path.join(src, 'results')
+        os.makedirs(results_dir, exist_ok=True)
+        fig_path = os.path.join(results_dir, f'{filename}.pdf')
+        fig.savefig(fig_path, format='pdf')
+        print(f'Saved figure to {fig_path}')
+    return
+
+    
 def plot_comparison_results(comparison_results):
     df = pd.DataFrame(comparison_results)
     df_melted = pd.melt(df, id_vars=['filename'], var_name='metric', value_name='value')