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

spacr/__init__.py

@@ -21,7 +21,6 @@ from . import app_measure
 from . import app_classify
 from . import app_sequencing
 from . import app_umap
-from . import mediar
 from . import submodules
 from . import openai
 from . import ml
@@ -52,7 +51,6 @@ __all__ = [
     "app_classify",
     "app_sequencing",
     "app_umap",
-    "mediar",
     "submodules",
     "openai",
     "ml",

spacr/__main__.py

@@ -1,6 +1,6 @@
 """
-Copyright © 2024 Something
+Copyright © 2025 Something
 """
 
-if __name__ == "__main__":
-    main()
+#if __name__ == "__main__":
+#    main()

spacr/core.py

@@ -98,15 +98,12 @@ def preprocess_generate_masks(settings):
             files_to_process = 3
             files_processed = 0
             if settings['masks']:
-                mask_src = os.path.join(src, 'norm_channel_stack')
+                mask_src = os.path.join(src, 'masks')
                 if settings['cell_channel'] != None:
                     time_ls=[]
                     if check_mask_folder(src, 'cell_mask_stack'):
                         start = time.time()
-                        if settings['segmentation_mode'] == 'cellpose':
-                            generate_cellpose_masks(mask_src, settings, 'cell')
-                        elif settings['segmentation_mode'] == 'mediar':
-                            generate_mediar_masks(mask_src, settings, 'cell')
+                        generate_cellpose_masks(mask_src, settings, 'cell')
                         stop = time.time()
                         duration = (stop - start)
                         time_ls.append(duration)
@@ -117,10 +114,7 @@ def preprocess_generate_masks(settings):
                     time_ls=[]
                     if check_mask_folder(src, 'nucleus_mask_stack'):
                         start = time.time()
-                        if settings['segmentation_mode'] == 'cellpose':
-                            generate_cellpose_masks(mask_src, settings, 'nucleus')
-                        elif settings['segmentation_mode'] == 'mediar':
-                            generate_mediar_masks(mask_src, settings, 'nucleus')
+                        generate_cellpose_masks(mask_src, settings, 'nucleus')
                         stop = time.time()
                         duration = (stop - start)
                         time_ls.append(duration)
@@ -131,10 +125,7 @@ def preprocess_generate_masks(settings):
                     time_ls=[]
                     if check_mask_folder(src, 'pathogen_mask_stack'):
                         start = time.time()
-                        if settings['segmentation_mode'] == 'cellpose':
-                            generate_cellpose_masks(mask_src, settings, 'pathogen')
-                        elif settings['segmentation_mode'] == 'mediar':
-                            generate_mediar_masks(mask_src, settings, 'pathogen')
+                        generate_cellpose_masks(mask_src, settings, 'pathogen')
                         stop = time.time()
                         duration = (stop - start)
                         time_ls.append(duration)
@@ -386,7 +377,13 @@ def generate_cellpose_masks(src, settings, object_type):
                                                          timelapse_remove_transient=timelapse_remove_transient,
                                                          radius=radius,
                                                          n_jobs=n_jobs)
-                    if timelapse_mode == 'trackpy':
+                    
+                    if timelapse_mode == 'trackpy' or timelapse_mode == 'iou':
+                        if timelapse_mode == 'iou':
+                            track_by_iou = True
+                        else:
+                            track_by_iou = False
+                        
                         mask_stack = _trackpy_track_cells(src=src,
                                                           name=name,
                                                           batch_filenames=batch_filenames,
@@ -397,7 +394,8 @@ def generate_cellpose_masks(src, settings, object_type):
                                                           timelapse_remove_transient=timelapse_remove_transient,
                                                           plot=settings['plot'],
                                                           save=settings['save'],
-                                                          mode=timelapse_mode)
+                                                          mode=timelapse_mode,
+                                                          track_by_iou=track_by_iou)
                 else:
                     mask_stack = _masks_to_masks_stack(masks)
             else:
@@ -819,97 +817,6 @@ def reducer_hyperparameter_search(settings={}, reduction_params=None, dbscan_par
 
     return
 
-def generate_mediar_masks(src, settings, object_type):
-    """
-    Generates masks using the MEDIARPredictor.
-    
-    :param src: Source folder containing images or npz files.
-    :param settings: Dictionary of settings for generating masks.
-    :param object_type: Type of object to detect (e.g., 'cell', 'nucleus', etc.).
-    """
-    from .mediar import MEDIARPredictor
-    from .io import _create_database, _save_object_counts_to_database
-    from .plot import plot_masks
-    from .settings import set_default_settings_preprocess_generate_masks
-    from .utils import prepare_batch_for_segmentation
-
-    # Clear CUDA cache and check if CUDA is available
-    gc.collect()
-    if not torch.cuda.is_available():
-        print(f'Torch CUDA is not available, using CPU')
-
-    settings['src'] = src
-
-    # Preprocess settings
-    settings = set_default_settings_preprocess_generate_masks(settings)
-
-    if settings['verbose']:
-        settings_df = pd.DataFrame(list(settings.items()), columns=['setting_key', 'setting_value'])
-        settings_df['setting_value'] = settings_df['setting_value'].apply(str)
-        display(settings_df)
-
-    figuresize = 10
-    timelapse = settings['timelapse']
-    batch_size = settings['batch_size']
-
-    # Get object settings and initialize MEDIARPredictor
-    mediar_predictor = MEDIARPredictor(input_path=None, output_path=None, normalize=settings['normalize'], use_tta=False)
-
-    # Paths to input npz files
-    paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
-
-    # Initialize a database for saving measurements
-    count_loc = os.path.join(os.path.dirname(src), 'measurements', 'measurements.db')
-    os.makedirs(os.path.dirname(src) + '/measurements', exist_ok=True)
-    _create_database(count_loc)
-
-    for file_index, path in enumerate(paths):
-        name = os.path.basename(path)
-        name, ext = os.path.splitext(name)
-        output_folder = os.path.join(os.path.dirname(path), f'{object_type}_mask_stack')
-        os.makedirs(output_folder, exist_ok=True)
-
-        with np.load(path) as data:
-            stack = data['data']
-            filenames = data['filenames']
-
-            for i, filename in enumerate(filenames):
-                output_path = os.path.join(output_folder, filename)
-                if os.path.exists(output_path):
-                    print(f"File {filename} already exists. Skipping...")
-                    continue
-
-        # Process each batch of images in the stack
-        for i in range(0, stack.shape[0], batch_size):
-            batch = stack[i: i + batch_size]
-            batch_filenames = filenames[i: i + batch_size]
-
-            # Prepare batch for MEDIARPredictor (optional)
-            batch = prepare_batch_for_segmentation(batch)
-
-            # Predict masks using MEDIARPredictor
-            predicted_masks = mediar_predictor.predict_batch(batch)
-
-            # Save predicted masks
-            for j, mask in enumerate(predicted_masks):
-                output_filename = os.path.join(output_folder, batch_filenames[j])
-                mask = mask.astype(np.uint16)
-                np.save(output_filename, mask)
-
-            # Optional: Plot the masks
-            if settings['plot']:
-                for idx, mask in enumerate(predicted_masks):
-                    plot_masks(batch[idx], mask, cmap='inferno', figuresize=figuresize)
-
-            # Save object counts to database
-            _save_object_counts_to_database(predicted_masks, object_type, batch_filenames, count_loc)
-
-        # Clear CUDA cache after each file
-        gc.collect()
-        torch.cuda.empty_cache()
-
-    print("Mask generation completed.")
-
 def generate_screen_graphs(settings):
     """
     Generate screen graphs for different measurements in a given source directory.

spacr/gui_core.py

@@ -872,7 +872,7 @@ def check_src_folders_files(settings, settings_type, q):
                 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")
+                folder_npz_continue = _has_folder(path, "masks")
             
                 if not pictures_continue:
                     if not any([folder_chan_continue, folder_stack_continue, folder_npz_continue]):
@@ -883,7 +883,7 @@ def check_src_folders_files(settings, settings_type, q):
                             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}")
+                            q.put(f"Error: Missing masks folder in folder: {path}")
                         else:
                             q.put(f"Error: No images in folder: {path}")
                 

spacr/gui_utils.py

@@ -376,26 +376,14 @@ def convert_settings_dict_for_gui(settings):
         'channel_dims': ('combo', chan_list, '[0,1,2,3]'),
         'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'metadata'),
         'cov_type': ('combo', ['HC0', 'HC1', 'HC2', 'HC3', None], None),
-        #'cell_mask_dim': ('combo', chans_v3, None),
-        #'cell_chann_dim': ('combo', chans_v3, None),
-        #'nucleus_mask_dim': ('combo', chans_v3, None),
-        #'nucleus_chann_dim': ('combo', chans_v3, None),
-        #'pathogen_mask_dim': ('combo', chans_v3, None),
-        #'pathogen_chann_dim': ('combo', chans_v3, None),
         'crop_mode': ('combo', ["['cell']", "['nucleus']", "['pathogen']", "['cell', 'nucleus']", "['cell', 'pathogen']", "['nucleus', 'pathogen']", "['cell', 'nucleus', 'pathogen']"], "['cell']"),
-         #'magnification': ('combo', [20, 40, 60], 20),
-        #'nucleus_channel': ('combo', chans_v3, None),
-        #'cell_channel': ('combo', chans_v3, None),
-        #'channel_of_interest': ('combo', chans_v3, None),
-        #'pathogen_channel': ('combo', chans_v3, None),
-        'timelapse_mode': ('combo', ['trackpy', 'btrack'], 'trackpy'),
+        'timelapse_mode': ('combo', ['trackpy', 'iou', 'btrack'], 'trackpy'),
         'train_mode': ('combo', ['erm', 'irm'], 'erm'),
         'clustering': ('combo', ['dbscan', 'kmean'], 'dbscan'),
         'reduction_method': ('combo', ['umap', 'tsne'], 'umap'),
         'model_name': ('combo', ['cyto', 'cyto_2', 'cyto_3', 'nuclei'], 'cyto'),
         'regression_type': ('combo', ['ols','gls','wls','rlm','glm','mixed','quantile','logit','probit','poisson','lasso','ridge'], 'ols'),
         'timelapse_objects': ('combo', ["['cell']", "['nucleus']", "['pathogen']", "['cell', 'nucleus']", "['cell', 'pathogen']", "['nucleus', 'pathogen']", "['cell', 'nucleus', 'pathogen']", None], None),
-        #'timelapse_objects': ('combo', '[cell]', '[nucleus]', '[pathogen]', '[cytoplasm]', None, None),
         'model_type': ('combo', torchvision_models, 'resnet50'),
         'optimizer_type': ('combo', ['adamw', 'adam'], 'adamw'),
         'schedule': ('combo', ['reduce_lr_on_plateau', 'step_lr'], 'reduce_lr_on_plateau'),

spacr/io.py

@@ -1175,7 +1175,7 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
 
     paths = []
     time_ls = []
-    output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
+    output_fldr = os.path.join(os.path.dirname(src), 'masks')
     os.makedirs(output_fldr, exist_ok=True)
 
     if settings['timelapse']:
@@ -1333,7 +1333,7 @@ def _normalize_stack(src, backgrounds=[100, 100, 100], remove_backgrounds=[False
         None
     """
     paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
-    output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
+    output_fldr = os.path.join(os.path.dirname(src), 'masks')
     os.makedirs(output_fldr, exist_ok=True)
     time_ls = []
     
@@ -1418,7 +1418,7 @@ def _normalize_timelapse(src, lower_percentile=2, save_dtype=np.float32):
         save_dtype (numpy.dtype, optional): The data type to save the normalized stack. Defaults to np.float32.
     """
     paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
-    output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
+    output_fldr = os.path.join(os.path.dirname(src), 'masks')
     os.makedirs(output_fldr, exist_ok=True)
 
     for file_index, path in enumerate(paths):
@@ -1567,16 +1567,16 @@ def preprocess_img_data(settings):
     Returns:
         None
     """
-    
     src = settings['src']
-    delete_empty_subdirectories(src)
-    files = os.listdir(src)
     
+    if len(os.listdir(src)) < 100:
+        delete_empty_subdirectories(src)
+    
+    files = os.listdir(src)
     valid_ext = ['tif', 'tiff', 'png', 'jpg', 'jpeg', 'bmp', 'nd2', 'czi', 'lif']
     extensions = [file.split('.')[-1].lower() for file in files]
     # Filter only valid extensions
     valid_extensions = [ext for ext in extensions if ext in valid_ext]
-
     # Determine most common valid extension
     img_format = None
     if valid_extensions:
@@ -1595,10 +1595,10 @@ def preprocess_img_data(settings):
             print('Found existing stack folder.')
         if os.path.exists(os.path.join(src,'channel_stack')):
             print('Found existing channel_stack folder.')
-        if os.path.exists(os.path.join(src,'norm_channel_stack')):
-            print('Found existing norm_channel_stack folder. Skipping preprocessing')
+        if os.path.exists(os.path.join(src,'masks')):
+            print('Found existing masks folder. Skipping preprocessing')
             return settings, src
-        
+
     mask_channels = [settings['nucleus_channel'], settings['cell_channel'], settings['pathogen_channel']]
 
     settings = set_default_settings_preprocess_img_data(settings)
@@ -1606,16 +1606,16 @@ def preprocess_img_data(settings):
     regex = _get_regex(settings['metadata_type'], img_format, settings['custom_regex'])
     
     if settings['test_mode']:
-
         print(f"Running spacr in test mode")
         settings['plot'] = True
-        try:
-            os.rmdir(os.path.join(src, 'test'))
-            print(f"Deleted test directory: {os.path.join(src, 'test')}")
-        except OSError as e:
-            print(f"Error deleting test directory: {e}")
-            print(f"Delete manually before running test mode")
-            pass
+        if os.path.exists(os.path.join(src,'test')):
+            try:
+                os.rmdir(os.path.join(src, 'test'))
+                print(f"Deleted test directory: {os.path.join(src, 'test')}")
+            except OSError as e:
+                print(f"Error deleting test directory: {e}")
+                print(f"Delete manually before running test mode")
+                pass
 
         src = _run_test_mode(settings['src'], regex, settings['timelapse'], settings['test_images'], settings['random_test'])
         settings['src'] = src
@@ -1991,12 +1991,12 @@ def _load_and_concatenate_arrays(src, channels, cell_chann_dim, nucleus_chann_di
     """
     folder_paths = [os.path.join(src+'/stack')]
 
-    if cell_chann_dim is not None or os.path.exists(os.path.join(src, 'norm_channel_stack', 'cell_mask_stack')):
-        folder_paths = folder_paths + [os.path.join(src, 'norm_channel_stack','cell_mask_stack')]
-    if nucleus_chann_dim is not None or os.path.exists(os.path.join(src, 'norm_channel_stack', 'nucleus_mask_stack')):
-        folder_paths = folder_paths + [os.path.join(src, 'norm_channel_stack','nucleus_mask_stack')]
-    if pathogen_chann_dim is not None or os.path.exists(os.path.join(src, 'norm_channel_stack', 'pathogen_mask_stack')):
-        folder_paths = folder_paths + [os.path.join(src, 'norm_channel_stack','pathogen_mask_stack')]
+    if cell_chann_dim is not None or os.path.exists(os.path.join(src, 'masks', 'cell_mask_stack')):
+        folder_paths = folder_paths + [os.path.join(src, 'masks','cell_mask_stack')]
+    if nucleus_chann_dim is not None or os.path.exists(os.path.join(src, 'masks', 'nucleus_mask_stack')):
+        folder_paths = folder_paths + [os.path.join(src, 'masks','nucleus_mask_stack')]
+    if pathogen_chann_dim is not None or os.path.exists(os.path.join(src, 'masks', 'pathogen_mask_stack')):
+        folder_paths = folder_paths + [os.path.join(src, 'masks','pathogen_mask_stack')]
 
     output_folder = src+'/merged'
     reference_folder = folder_paths[0]
@@ -2870,7 +2870,6 @@ def generate_training_dataset(settings):
 
         return class_paths_ls
     
-    from .io import _read_and_merge_data, _read_db
     from .utils import get_paths_from_db, annotate_conditions, save_settings
     from .settings import set_generate_training_dataset_defaults
     

spacr/mediar.py

@@ -15,14 +15,18 @@ if not os.path.exists(init_file):
 # Add MEDIAR to sys.path
 sys.path.insert(0, mediar_path)
 
-try:
-    # Now import the dependencies from MEDIAR
-    from core.MEDIAR import Predictor, EnsemblePredictor
-    from train_tools.models import MEDIARFormer
-finally:
-    # Remove the temporary __init__.py file after the import
-    if os.path.exists(init_file):
-        os.remove(init_file)  # Remove the __init__.py file
+#try:
+#     Now import the dependencies from MEDIAR
+#    from core.MEDIAR import Predictor, EnsemblePredictor
+#    from train_tools.models import MEDIARFormer
+
+#    from train_tools.models import MEDIARFormer
+Predictor, EnsemblePredictor, MEDIARFormer = None, None, None
+
+#finally:
+#    # Remove the temporary __init__.py file after the import
+#    if os.path.exists(init_file):
+#        os.remove(init_file)  # Remove the __init__.py file
 
 def display_imgs_in_list(lists_of_imgs, cmaps=None):
     """

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)
@@ -100,6 +99,33 @@ def set_default_settings_preprocess_generate_masks(settings={}):
     settings.setdefault('adjust_cells', False)
     return 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')
@@ -955,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,
@@ -1006,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"],
@@ -1217,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.",
@@ -1337,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.",
@@ -1376,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.",
@@ -1596,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