spacr 0.4.60__py3-none-any.whl → 0.9.0__py3-none-any.whl

spacr/plot.py

@@ -1414,7 +1414,8 @@ def _plot_recruitment(df, df_type, channel_of_interest, columns=[], figuresize=1
         sns.barplot(ax=ax, data=df, x='condition', y=f'{col}', hue='pathogen', capsize=.1, ci='sd', dodge=False)
         ax.set_xlabel(f'pathogen {df_type}', fontsize=font)
         ax.set_ylabel(f'{col}', fontsize=int(font*2))
-        ax.legend_.remove()
+        if ax.get_legend() is not None:
+            ax.legend_.remove()
         ax.tick_params(axis='both', which='major', labelsize=font)
         ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
         if i <= 5:
@@ -2031,7 +2032,7 @@ def plot_comparison_results(comparison_results):
 def plot_object_outlines(src, objects=['nucleus','cell','pathogen'], channels=[0,1,2], max_nr=10):
     
     for object_, channel in zip(objects, channels):
-        folders = [os.path.join(src, 'norm_channel_stack', f'{object_}_mask_stack'),
+        folders = [os.path.join(src, 'masks', f'{object_}_mask_stack'),
                    os.path.join(src,f'{channel+1}')]
         print(folders)
         plot_images_and_arrays(folders,
@@ -2597,7 +2598,7 @@ class spacrGraph:
             # Group by ['prc', grouping_column]
             group_cols = ['prc', self.grouping_column]
 
-        elif self.representation == 'plateID':
+        elif self.representation == 'plate':
             # Make sure 'plateID' exists (split from 'prc' if needed)
             if 'plateID' not in df.columns:
                 if 'prc' in df.columns:
@@ -2930,6 +2931,7 @@ class spacrGraph:
         self.df_melted = pd.melt(self.df, id_vars=[self.grouping_column], value_vars=self.data_column,var_name='Data Column', value_name='Value')
         unique_groups = self.df[self.grouping_column].unique()
         is_normal, normality_results = self.perform_normality_tests()
+        is_normal = True
         levene_stat, levene_p = self.perform_levene_test(unique_groups)
         test_results = self.perform_statistical_tests(unique_groups, is_normal)
         posthoc_results = self.perform_posthoc_tests(is_normal, unique_groups)
@@ -3371,8 +3373,11 @@ class spacrGraph:
         return self.fig
 
 def plot_data_from_db(settings):
+    
     from .io import _read_db, _read_and_merge_data
     from .utils import annotate_conditions, save_settings
+    from .settings import set_default_plot_data_from_db
+    
     """
     Extracts the specified table from the SQLite database and plots a specified column.
 
@@ -3385,8 +3390,8 @@ def plot_data_from_db(settings):
         df (pd.DataFrame): The extracted table as a DataFrame.
     """
 
-
-
+    settings = set_default_plot_data_from_db(settings)
+    
     if isinstance(settings['src'], str):
         srcs = [settings['src']]
     elif isinstance(settings['src'], list):
@@ -3403,7 +3408,6 @@ def plot_data_from_db(settings):
 
     dfs = []
     for i, src in enumerate(srcs):
-
         db_loc = os.path.join(src, 'measurements', settings['database'][i])
         print(f"Database: {db_loc}")
         if settings['table_names'] in ['saliency_image_correlations']:
@@ -3415,7 +3419,7 @@ def plot_data_from_db(settings):
                                     verbose=settings['verbose'],
                                     nuclei_limit=settings['nuclei_limit'],
                                     pathogen_limit=settings['pathogen_limit'])
-     
+            
         dft = annotate_conditions(df1, 
                                 cells=settings['cell_types'], 
                                 cell_loc=settings['cell_plate_metadata'], 
@@ -3436,12 +3440,27 @@ def plot_data_from_db(settings):
 
     if settings['treatment_plate_metadata'] !=  None:
         df = df.dropna(subset='treatment')
-
+        
+    if settings['data_column'] == 'recruitment':
+        pahtogen_measurement = df[f"pathogen_channel_{settings['channel_of_interest']}_mean_intensity"]
+        cytoplasm_measurement = df[f"cytoplasm_channel_{settings['channel_of_interest']}_mean_intensity"]
+        df['recruitment'] = pahtogen_measurement / cytoplasm_measurement
+        
+    if settings['data_column'] not in df.columns:
+        print(f"Data column {settings['data_column']} not found in DataFrame.")
+        print(f'Please use one of the following columns:')
+        for col in df.columns:
+            print(col)
+        display(df)
+        return None
+    
     df = df.dropna(subset=settings['data_column'])
         
     if settings['grouping_column'] not in df.columns:
         print(f"Grouping column {settings['grouping_column']} not found in DataFrame.")
-        print(f'Please use one of the following columns: {df.columns}')
+        print(f'Please use one of the following columns:')
+        for col in df.columns:
+            print(col)
         display(df)
         return None
     
@@ -3480,7 +3499,8 @@ def plot_data_from_db(settings):
 
 def plot_data_from_csv(settings):
     from .io import _read_db, _read_and_merge_data
-    from .utils import annotate_conditions, save_settings
+    from .utils import annotate_conditions, save_settings, remove_outliers_by_group
+    from .settings import get_plot_data_from_csv_default_settings
     """
     Extracts the specified table from the SQLite database and plots a specified column.
 
@@ -3492,7 +3512,12 @@ def plot_data_from_csv(settings):
     Returns:
         df (pd.DataFrame): The extracted table as a DataFrame.
     """
+    
 
+    def filter_rows_by_column_values(df: pd.DataFrame, column: str, values: list) -> pd.DataFrame:
+        """Return a filtered DataFrame where only rows with the column value in the list are kept."""
+        return df[df[column].isin(values)].copy()
+    
     if isinstance(settings['src'], str):
         srcs = [settings['src']]
     elif isinstance(settings['src'], list):
@@ -3519,15 +3544,27 @@ def plot_data_from_csv(settings):
             except Exception as e:
                 print(f"Could not split the prc column: {e}")
 
-                
-    display(df)
-
+    if 'keep_groups' in settings.keys():
+        if isinstance(settings['keep_groups'], str):
+            settings['keep_groups'] = [settings['keep_groups']]
+        elif isinstance(settings['keep_groups'], list):
+            df = filter_rows_by_column_values(df, settings['grouping_column'], settings['keep_groups'])
+            
+    if settings['remove_outliers']:
+        df = remove_outliers_by_group(df, settings['grouping_column'], settings['data_column'], method='iqr', threshold=1.5)
+    
+    if settings['verbose']:       
+        display(df)
+    
     df = df.dropna(subset=settings['data_column'])
     df = df.dropna(subset=settings['grouping_column'])
     src = srcs[0] 
     dst = os.path.join(os.path.dirname(src), 'results', settings['graph_name'])
     os.makedirs(dst, exist_ok=True)
     
+    #data_csv = os.path.join(dst, f"{settings['graph_name']}_data.csv")
+    #df.to_csv(data_csv, index=False)
+    
     spacr_graph = spacrGraph(
         df=df,                                       # Your DataFrame
         grouping_column=settings['grouping_column'], # Column for grouping the data (x-axis)

spacr/settings.py

@@ -29,7 +29,6 @@ def set_default_settings_preprocess_generate_masks(settings={}):
     settings.setdefault('denoise', False)
     settings.setdefault('src', 'path')
     settings.setdefault('delete_intermediate', False)
-    settings.setdefault('segmentation_mode', 'cellpose')
     settings.setdefault('preprocess', True)
     settings.setdefault('masks', True)
     settings.setdefault('save', True)
@@ -95,14 +94,39 @@ def set_default_settings_preprocess_generate_masks(settings={}):
 
     # Misc settings
     settings.setdefault('all_to_mip', False)
-    settings.setdefault('pick_slice', False)
-    settings.setdefault('skip_mode', '01')
     settings.setdefault('upscale', False)
     settings.setdefault('upscale_factor', 2.0)
     settings.setdefault('adjust_cells', False)
     return settings
 
-def set_default_settings_preprocess_img_data(settings):
+def set_default_plot_data_from_db(settings):
+    settings.setdefault('src', 'path')
+    settings.setdefault('database', 'measurements.db')
+    settings.setdefault('graph_name', 'Figure_1')
+    settings.setdefault('table_names', ['cell', 'cytoplasm', 'nucleus', 'pathogen'])
+    settings.setdefault('data_column', 'recruitment')
+    settings.setdefault('grouping_column', 'condition')
+    settings.setdefault('cell_types', ['Hela'])
+    settings.setdefault('cell_plate_metadata', None)
+    settings.setdefault('pathogen_types', None)
+    settings.setdefault('pathogen_plate_metadata', None)
+    settings.setdefault('treatments', None)
+    settings.setdefault('treatment_plate_metadata', None)
+    settings.setdefault('graph_type', 'jitter')
+    settings.setdefault('theme', 'deep')
+    settings.setdefault('save', True)
+    settings.setdefault('y_lim', [1,1.5])
+    settings.setdefault('verbose', False)
+    settings.setdefault('channel_of_interest', 1)
+    settings.setdefault('nuclei_limit', 2)
+    settings.setdefault('pathogen_limit', 3)
+    settings.setdefault('representation', 'well')
+    settings.setdefault('uninfected', False)
+    return settings
+
+
+
+def set_default_settings_preprocess_img_data_v1(settings):
 
     metadata_type = settings.setdefault('metadata_type', 'cellvoyager')
     custom_regex = settings.setdefault('custom_regex', None)
@@ -127,6 +151,27 @@ def set_default_settings_preprocess_img_data(settings):
 
     return settings, metadata_type, custom_regex, nr, plot, batch_size, timelapse, lower_percentile, randomize, all_to_mip, pick_slice, skip_mode, cmap, figuresize, normalize, save_dtype, test_mode, test_images, random_test
 
+def set_default_settings_preprocess_img_data(settings):
+
+    settings.setdefault('metadata_type', 'cellvoyager')
+    settings.setdefault('custom_regex', None)
+    settings.setdefault('nr', 1)
+    settings.setdefault('plot', True)
+    settings.setdefault('batch_size', 50)
+    settings.setdefault('timelapse', False)
+    settings.setdefault('lower_percentile', 2)
+    settings.setdefault('randomize', True)
+    settings.setdefault('all_to_mip', False)
+    settings.setdefault('cmap', 'inferno')
+    settings.setdefault('figuresize', 10)
+    settings.setdefault('normalize', True)
+    settings.setdefault('save_dtype', 'uint16')
+    settings.setdefault('test_mode', False)
+    settings.setdefault('test_images', 10)
+    settings.setdefault('random_test', True)
+    settings.setdefault('fps', 2)
+    return settings
+
 def _get_object_settings(object_type, settings):
 
     from .utils import _get_diam
@@ -278,7 +323,7 @@ def get_measure_crop_settings(settings={}):
 
     # Timelapsed settings
     settings.setdefault('timelapse', False)
-    settings.setdefault('timelapse_objects', 'cell')
+    settings.setdefault('timelapse_objects', ['cell'])
 
     # Operational settings
     settings.setdefault('plot',False)
@@ -715,7 +760,7 @@ expected_types = {
     #"timelapse_frame_limits": (list, type(None)),  # This can be a list of lists
     "timelapse_remove_transient": bool,
     "timelapse_mode": str,
-    "timelapse_objects": list,
+    "timelapse_objects": (list, type(None)),
     "fps": int,
     "remove_background": bool,
     "lower_percentile": (int, float),
@@ -936,7 +981,6 @@ expected_types = {
     "png_type":str,
     "custom_model_path":str,
     "generate_training_dataset":bool,
-    "segmentation_mode":str,
     "train_DL_model":bool,
     "normalize":bool,
     "overlay":bool,
@@ -987,7 +1031,7 @@ expected_types = {
 }
 
 categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv", "metadata_files", "score_data","count_data"],
-             "General": ["cell_mask_dim", "cytoplasm", "cell_chann_dim", "cell_channel", "nucleus_chann_dim", "nucleus_channel", "nucleus_mask_dim", "pathogen_mask_dim", "pathogen_chann_dim", "pathogen_channel", "test_mode", "plot", "metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "segmentation_mode", "delete_intermediate", "uninfected", ],
+             "General": ["cell_mask_dim", "cytoplasm", "cell_chann_dim", "cell_channel", "nucleus_chann_dim", "nucleus_channel", "nucleus_mask_dim", "pathogen_mask_dim", "pathogen_chann_dim", "pathogen_channel", "test_mode", "plot", "metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "delete_intermediate", "uninfected", ],
              "Cellpose":["denoise","fill_in","from_scratch", "n_epochs", "width_height", "model_name", "custom_model", "resample", "rescale", "CP_prob", "flow_threshold", "percentiles", "invert", "diameter", "grayscale", "Signal_to_noise", "resize", "target_height", "target_width"],
              "Cell": ["cell_diamiter","cell_intensity_range", "cell_size_range", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cytoplasm_min_size", "adjust_cells", "cells", "cell_loc"],
              "Nucleus": ["nucleus_diamiter","nucleus_intensity_range", "nucleus_size_range", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_loc"],
@@ -1005,7 +1049,7 @@ categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset
              "Plot": ["split_axis_lims", "x_lim","log_x","log_y", "plot_control", "plot_nr", "examples_to_plot", "normalize_plots", "cmap", "figuresize", "plot_cluster_grids", "img_zoom", "row_limit", "color_by", "plot_images", "smooth_lines", "plot_points", "plot_outlines", "black_background", "plot_by_cluster", "heatmap_feature","grouping","min_max","cmap","save_figure"],
              "Timelapse": ["timelapse", "fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
              "Advanced": ["merge_edge_pathogen_cells", "test_images", "random_test", "test_nr", "test", "test_split", "normalize", "target_unique_count","threshold_multiplier", "threshold_method", "min_n","shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "background", "backgrounds", "schedule", "test_size","exclude","n_repeats","top_features", "model_type_ml", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs"],
-             "Beta": ["all_to_mip", "pick_slice", "skip_mode", "upscale", "upscale_factor", "consolidate"]
+             "Beta": ["all_to_mip", "upscale", "upscale_factor", "consolidate"]
              }
 
 
@@ -1033,7 +1077,7 @@ def check_settings(vars_dict, expected_types, q=None):
         expected_type = expected_types.get(key, str)
 
         try:
-            if key in ["cell_plate_metadata", "timelapse_frame_limits", "png_size", "png_dims", "pathogen_plate_metadata", "treatment_plate_metadata", "class_metadata", "crop_mode"]:
+            if key in ["cell_plate_metadata", "timelapse_frame_limits", "png_size", "png_dims", "pathogen_plate_metadata", "treatment_plate_metadata", "timelapse_objects", "class_metadata", "crop_mode"]:
                 if value is None:
                     parsed_value = None
                 else:
@@ -1198,7 +1242,7 @@ def generate_fields(variables, scrollable_frame):
         "nucleus_min_size": "(int) - The minimum size of nucleus objects in pixels^2.",
         "normalize_by": "(str) - Normalize cropped png images by png or by field of view.",
         "dependent_variable": "(str) - The dependent variable for the regression analysis.",
-        "delete_intermediate": "(bool) - Delete intermediate folders (stack, channel, norm_channel_stack).",
+        "delete_intermediate": "(bool) - Delete intermediate folders (stack, channel, masks).",
         "diameter": "(float) - Diameter of the objects to segment.",
         "dialate_png_ratios": "(list) - The ratios to use for dilating the PNG images. This will determine the amount of dilation applied to the images before cropping.",
         "dialate_pngs": "(bool) - Whether to dilate the PNG images before saving.",
@@ -1274,7 +1318,6 @@ def generate_fields(variables, scrollable_frame):
         "pc": "(str) - Positive control identifier.",
         "pc_loc": "(str) - Location of the positive control in the images.",
         "percentiles": "(list) - Percentiles to use for normalizing the images.",
-        "pick_slice": "(bool) - Whether to pick a single slice from the z-stack images. If False, the maximum intensity projection will be used.",
         "pin_memory": "(bool) - Whether to pin memory for the data loader.",
         "plate": "(str) - Plate identifier for the experiment.",
         "plate_dict": "(dict) - Dictionary of plate metadata.",
@@ -1319,7 +1362,6 @@ def generate_fields(variables, scrollable_frame):
         "skip_mode": "(str) - The mode to use for skipping images. This will determine how to handle images that cannot be processed.",
         "smooth_lines": "(bool) - Whether to smooth lines in the plots.",
         "src": "(str, path) - Path to source directory.",
-        "segmentation_mode": "(str) - Algorithm to use for segmentation (cellpose or mediar).",
         "target": "(str) - Target variable for the analysis.",
         "target_height": "(int) - Target height for resizing the images.",
         "target_intensity_min": "(float) - Minimum intensity for the target objects.",
@@ -1358,7 +1400,6 @@ def generate_fields(variables, scrollable_frame):
         "dataset_mode": "str - How to generate train/test dataset.",
         "annotated_classes": "list - list of numbers in annotation column.",
         "um_per_pixel": "(float) - The micrometers per pixel for the images.",
-        "segmentation_model": "(str) - The segmentation model to use, either cellpose or mediar.",
         "pathogen_model": "(str) - use a custom cellpose model to detect pathogen objects.",
         "timelapse_displacement": "(int) - Displacement for timelapse tracking.",
         "timelapse_memory": "(int) - Memory for timelapse tracking.",
@@ -1578,4 +1619,20 @@ def set_analyze_class_proportion_defaults(settings):
     settings.setdefault('level','well')
     settings.setdefault('save',False)
     settings.setdefault('verbose', False)
+    return settings
+
+def get_plot_data_from_csv_default_settings(settings):
+    settings.setdefault('src','path')
+    settings.setdefault('data_column','choose column')
+    settings.setdefault('grouping_column','choose column')
+    settings.setdefault('graph_type','violin')
+    settings.setdefault('save',False)
+    settings.setdefault('y_lim',None)
+    settings.setdefault('log_y',False)
+    settings.setdefault('log_x',False)
+    settings.setdefault('keep_groups',None)
+    settings.setdefault('representation','well')
+    settings.setdefault('theme','dark')
+    settings.setdefault('remove_outliers',False)
+    settings.setdefault('verbose',False)
     return settings

spacr/submodules.py

@@ -1,5 +1,5 @@
 import seaborn as sns
-import os, random, sqlite3, re, shap, string, time
+import os, random, sqlite3, re, shap, string, time, shutil
 import pandas as pd
 import numpy as np
 
@@ -28,10 +28,7 @@ from skimage.measure import regionprops, label as sklabel
 import matplotlib.pyplot as plt
 from natsort import natsorted
 
-import torch
 from torch.utils.data import Dataset
-from spacr.settings import get_train_cellpose_default_settings
-from spacr.utils import save_settings, invert_image
 
 class CellposeLazyDataset(Dataset):
     def __init__(self, image_files, label_files, settings, randomize=True, augment=False):
@@ -91,8 +88,8 @@ class CellposeLazyDataset(Dataset):
 
 def train_cellpose(settings):
     
-    from spacr.settings import get_train_cellpose_default_settings
-    from spacr.utils import save_settings
+    from .settings import get_train_cellpose_default_settings
+    from .utils import save_settings
     
     settings = get_train_cellpose_default_settings(settings)
     img_src = os.path.join(settings['src'], 'train', 'images')
@@ -161,11 +158,11 @@ def train_cellpose(settings):
     
 def test_cellpose_model(settings):
     
-    from spacr.utils import save_settings, print_progress
+    from .utils import save_settings, print_progress
     from .settings import get_default_test_cellpose_model_settings
     
     def plot_cellpose_resilts(i, j, results_dir, img, lbl, pred, flow):
-        from spacr. plot import generate_mask_random_cmap
+        from . plot import generate_mask_random_cmap
         fig, axs = plt.subplots(1, 5, figsize=(16, 4), gridspec_kw={'wspace': 0.1, 'hspace': 0.1})
         cmap_lbl = generate_mask_random_cmap(lbl)
         cmap_pred = generate_mask_random_cmap(pred)
@@ -348,7 +345,7 @@ def test_cellpose_model(settings):
 def apply_cellpose_model(settings):
     
     from .settings import get_default_apply_cellpose_model_settings
-    from spacr.utils import save_settings, print_progress
+    from .utils import save_settings, print_progress
     
     def plot_cellpose_result(i, j, results_dir, img, pred, flow):
         
@@ -466,7 +463,7 @@ def apply_cellpose_model(settings):
         print("Saved object count and average area to summary.csv")
 
 def plot_cellpose_batch(images, labels):
-    from spacr.plot import generate_mask_random_cmap
+    from .plot import generate_mask_random_cmap
 
     cmap_lbl = generate_mask_random_cmap(labels)
     batch_size = len(images)
@@ -481,8 +478,8 @@ def plot_cellpose_batch(images, labels):
     plt.show()
 
 def analyze_percent_positive(settings):
-    from spacr.io import _read_and_merge_data
-    from spacr.utils import save_settings
+    from .io import _read_and_merge_data
+    from .utils import save_settings
     from .settings import default_settings_analyze_percent_positive
     
     settings = default_settings_analyze_percent_positive(settings)
@@ -583,6 +580,16 @@ def analyze_recruitment(settings):
     from .settings import get_analyze_recruitment_default_settings
 
     settings = get_analyze_recruitment_default_settings(settings=settings)
+    
+    if settings['src'].endswith('/measurements.db'):
+        src_orig = settings['src']
+        settings['src'] = os.path.dirname(settings['src'])
+        if not settings['src'].endswith('/measurements'):
+            src_mes = os.path.join(settings['src'], 'measurements')
+            if not os.path.exists(src_mes):
+                os.makedirs(src_mes)
+                shutil.move(src_orig, os.path.join(src_mes, 'measurements.db'))
+
     save_settings(settings, name='recruitment')
 
     print(f"Cell(s): {settings['cell_types']}, in {settings['cell_plate_metadata']}")
@@ -681,7 +688,7 @@ def analyze_recruitment(settings):
 
 def analyze_plaques(settings):
 
-    from .cellpose import identify_masks_finetune
+    from .spacr_cellpose import identify_masks_finetune
     from .settings import get_analyze_plaque_settings
     from .utils import save_settings, download_models
     from spacr import __file__ as spacr_path
@@ -1020,7 +1027,7 @@ def interperate_vision_model(settings={}):
             else:
                 return None
 
-        from spacr.plot import spacrGraph
+        from .plot import spacrGraph
 
         df[name] = df['feature'].apply(lambda x: find_feature_class(x, feature_groups))