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

spacr/settings.py

@@ -26,12 +26,14 @@ def set_default_plot_merge_settings():
 
 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)
+    settings.setdefault('consolidate', False)
     settings.setdefault('batch_size', 50)
     settings.setdefault('test_mode', False)
     settings.setdefault('test_images', 10)
@@ -86,7 +88,7 @@ def set_default_settings_preprocess_generate_masks(settings={}):
     settings.setdefault('fps', 2)
     settings.setdefault('timelapse_displacement', None)
     settings.setdefault('timelapse_memory', 3)
-    settings.setdefault('timelapse_frame_limits', None)
+    settings.setdefault('timelapse_frame_limits', [5,])
     settings.setdefault('timelapse_remove_transient', False)
     settings.setdefault('timelapse_mode', 'trackpy')
     settings.setdefault('timelapse_objects', None)
@@ -219,7 +221,7 @@ def set_default_umap_image_settings(settings={}):
     settings.setdefault('smooth_lines', True)
     settings.setdefault('clustering', 'dbscan')
     settings.setdefault('exclude', None)
-    settings.setdefault('col_to_compare', 'column_name')
+    settings.setdefault('col_to_compare', 'columnID')
     settings.setdefault('pos', 'c1')
     settings.setdefault('neg', 'c2')
     settings.setdefault('mix', 'c3')
@@ -256,7 +258,13 @@ def get_measure_crop_settings(settings={}):
     settings.setdefault('homogeneity', True)
     settings.setdefault('homogeneity_distances', [8,16,32])
 
-    # Cropping settings
+    # Cropping settings    # Cropping settings
+    settings.setdefault('save_arrays', False)
+    settings.setdefault('save_png',True)
+    settings.setdefault('use_bounding_box',False)
+    settings.setdefault('png_size',[224,224])
+    settings.setdefault('png_dims',[0,1,2])
+    settings.setdefault('normalize',False)    # Cropping settings
     settings.setdefault('save_arrays', False)
     settings.setdefault('save_png',True)
     settings.setdefault('use_bounding_box',False)
@@ -277,9 +285,9 @@ def get_measure_crop_settings(settings={}):
     settings.setdefault('n_jobs', os.cpu_count()-2)
 
     # Object settings
-    settings.setdefault('cell_mask_dim',None)
-    settings.setdefault('nucleus_mask_dim',None)
-    settings.setdefault('pathogen_mask_dim',None)
+    settings.setdefault('cell_mask_dim',4)
+    settings.setdefault('nucleus_mask_dim',5)
+    settings.setdefault('pathogen_mask_dim',6)
     settings.setdefault('cytoplasm',False)
     settings.setdefault('uninfected',True)
     settings.setdefault('cell_min_size',0)
@@ -312,7 +320,7 @@ def set_default_analyze_screen(settings):
     settings.setdefault('learning_rate',0.001)
     settings.setdefault('n_estimators',1000)
     settings.setdefault('test_size',0.2)
-    settings.setdefault('location_column','column_name')
+    settings.setdefault('location_column','columnID')
     settings.setdefault('positive_control','c2')
     settings.setdefault('negative_control','c1')
     settings.setdefault('exclude',None)
@@ -375,7 +383,7 @@ def set_generate_training_dataset_defaults(settings):
     settings.setdefault('size',224)
     settings.setdefault('test_split',0.1)
     settings.setdefault('class_metadata',[['c1'],['c2']])
-    settings.setdefault('metadata_type_by','column_name')
+    settings.setdefault('metadata_type_by','columnID')
     settings.setdefault('channel_of_interest',3)
     settings.setdefault('custom_measurement',None)
     settings.setdefault('tables',None)
@@ -397,7 +405,7 @@ def deep_spacr_defaults(settings):
     settings.setdefault('size',224)
     settings.setdefault('test_split',0.1)
     settings.setdefault('class_metadata',[['c1'],['c2']])
-    settings.setdefault('metadata_type_by','column_name')
+    settings.setdefault('metadata_type_by','columnID')
     settings.setdefault('channel_of_interest',3)
     settings.setdefault('custom_measurement',None)
     settings.setdefault('tables',None)
@@ -473,7 +481,7 @@ def get_train_test_model_settings(settings):
      return settings
 
 def get_analyze_recruitment_default_settings(settings):
-    settings.setdefault('src','path')
+    settings.setdefault('src', 'path')
     settings.setdefault('target','protein')
     settings.setdefault('cell_types',['HeLa'])
     settings.setdefault('cell_plate_metadata',None)
@@ -481,7 +489,7 @@ def get_analyze_recruitment_default_settings(settings):
     settings.setdefault('pathogen_plate_metadata',[['c1', 'c2', 'c3'],['c4','c5', 'c6']])
     settings.setdefault('treatments',['cm', 'lovastatin'])
     settings.setdefault('treatment_plate_metadata',[['r1', 'r2','r3'], ['r4', 'r5','r6']])
-    #settings.setdefault('metadata_types',['column_name', 'column_name', 'row_name'])
+    #settings.setdefault('metadata_types',['columnID', 'columnID', 'rowID'])
     settings.setdefault('channel_dims',[0,1,2,3])
     settings.setdefault('cell_chann_dim',3)
     settings.setdefault('cell_mask_dim',4)
@@ -503,7 +511,40 @@ def get_analyze_recruitment_default_settings(settings):
     settings.setdefault('pathogen_intensity_range',[0,100000])
     settings.setdefault('nucleus_intensity_range',[0,100000])
     settings.setdefault('cell_intensity_range',[0,100000])
-    settings.setdefault('target_intensity_min',0)
+    settings.setdefault('target_intensity_min',1)
+    return settings
+
+def get_default_test_cellpose_model_settings(settings):
+    settings.setdefault('src','path')
+    settings.setdefault('model_path','path')
+    settings.setdefault('save',True)
+    settings.setdefault('normalize',True)
+    settings.setdefault('percentiles',(2,98))
+    settings.setdefault('batch_size',50)
+    settings.setdefault('CP_probability',0)
+    settings.setdefault('FT',100)
+    settings.setdefault('target_size',1000)
+    return settings
+
+def get_default_apply_cellpose_model_settings(settings):
+    settings.setdefault('src','path')
+    settings.setdefault('model_path','path')
+    settings.setdefault('save',True)
+    settings.setdefault('normalize',True)
+    settings.setdefault('percentiles',(2,98))
+    settings.setdefault('batch_size',50)
+    settings.setdefault('CP_probability',0)
+    settings.setdefault('FT',100)
+    settings.setdefault('circularize',False)
+    settings.setdefault('target_size',1000)
+    return settings
+
+def default_settings_analyze_percent_positive(settings):
+    settings.setdefault('src','path')
+    settings.setdefault('tables',['cell'])
+    settings.setdefault('filter_1',['cell_area',1000])
+    settings.setdefault('value_col','cell_channel_2_mean_intensity')
+    settings.setdefault('threshold',2000)
     return settings
 
 def get_analyze_reads_default_settings(settings):
@@ -578,9 +619,8 @@ def get_perform_regression_default_settings(settings):
     settings.setdefault('cov_type',None)
     settings.setdefault('alpha',1)
     settings.setdefault('filter_value',['c1', 'c2', 'c3'])
-    settings.setdefault('filter_column','column')
-    settings.setdefault('plate','plate1')
-    settings.setdefault('class_1_threshold',None)
+    settings.setdefault('filter_column','columnID')
+    settings.setdefault('plateID','plate1')
     settings.setdefault('metadata_files',['/home/carruthers/Documents/TGGT1_Summary.csv','/home/carruthers/Documents/TGME49_Summary.csv'])
     settings.setdefault('volcano','gene')
     settings.setdefault('toxo', True)
@@ -672,6 +712,7 @@ expected_types = {
     "timelapse_displacement": int,
     "timelapse_memory": int,
     "timelapse_frame_limits": (list, type(None)),  # This can be a list of lists
+    #"timelapse_frame_limits": (list, type(None)),  # This can be a list of lists
     "timelapse_remove_transient": bool,
     "timelapse_mode": str,
     "timelapse_objects": list,
@@ -848,6 +889,7 @@ expected_types = {
     "agg_type": str,
     "min_cell_count": int,
     "resize": bool,
+    "denoise":bool,
     "target_height": (int, type(None)),
     "target_width": (int, type(None)),
     "rescale": bool,
@@ -940,30 +982,30 @@ expected_types = {
     "flow_threshold":float,
     "cell_diamiter":int,
     "nucleus_diamiter":int,
-    "pathogen_diamiter":int
+    "pathogen_diamiter":int,
+    "consolidate":bool
 }
 
 categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv", "metadata_files", "score_data","count_data"],
-             "General": ["metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "segmentation_mode", "delete_intermediate"],
-             "Cellpose":["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_chann_dim", "cell_channel", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cell_mask_dim", "cytoplasm", "cytoplasm_min_size", "uninfected", "merge_edge_pathogen_cells", "adjust_cells", "cells", "cell_loc"],
-             "Nucleus": ["nucleus_diamiter","nucleus_intensity_range", "nucleus_size_range", "nucleus_chann_dim", "nucleus_channel", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_mask_dim", "nucleus_loc"],
-             "Pathogen": ["pathogen_diamiter","pathogen_intensity_range", "pathogen_size_range", "pathogen_chann_dim", "pathogen_channel", "pathogen_background", "pathogen_Signal_to_noise", "pathogen_CP_prob", "pathogen_FT", "pathogen_model", "remove_background_pathogen", "pathogen_min_size", "pathogen_mask_dim", "pathogens", "pathogen_loc", "pathogen_types", "pathogen_plate_metadata", ],
+             "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", ],
+             "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"],
+             "Pathogen": ["pathogen_diamiter","pathogen_intensity_range", "pathogen_size_range", "pathogen_background", "pathogen_Signal_to_noise", "pathogen_CP_prob", "pathogen_FT", "pathogen_model", "remove_background_pathogen", "pathogen_min_size", "pathogens", "pathogen_loc", "pathogen_types", "pathogen_plate_metadata", ],
              "Measurements": ["remove_image_canvas", "remove_highly_correlated", "homogeneity", "homogeneity_distances", "radial_dist", "calculate_correlation", "manders_thresholds", "save_measurements", "tables", "image_nr", "dot_size", "filter_by", "remove_highly_correlated_features", "remove_low_variance_features", "channel_of_interest"],
-             "Object Image": ["save_png", "dialate_pngs", "dialate_png_ratios", "png_size", "png_dims", "save_arrays", "normalize_by", "crop_mode", "normalize", "use_bounding_box"],
+             "Object Image": ["save_png", "dialate_pngs", "dialate_png_ratios", "png_size", "png_dims", "save_arrays", "normalize_by", "crop_mode", "use_bounding_box"],
              "Sequencing": ["outlier_detection","offset_start","chunk_size","single_direction", "signal_direction","mode","comp_level","comp_type","save_h5","expected_end","offset","target_sequence","regex", "highlight"],
              "Generate Dataset":["save_to_db","file_metadata","class_metadata", "annotation_column","annotated_classes", "dataset_mode", "metadata_type_by","custom_measurement", "sample", "size"],
              "Hyperparamiters (Training)": ["png_type", "score_threshold","file_type", "train_channels", "epochs", "loss_type", "optimizer_type","image_size","val_split","learning_rate","weight_decay","dropout_rate", "init_weights", "train", "classes", "augment", "amsgrad","use_checkpoint","gradient_accumulation","gradient_accumulation_steps","intermedeate_save","pin_memory"],
              "Hyperparamiters (Embedding)": ["visualize","n_neighbors","min_dist","metric","resnet_features","reduction_method","embedding_by_controls","col_to_compare","log_data"],
              "Hyperparamiters (Clustering)": ["eps","min_samples","analyze_clusters","clustering","remove_cluster_noise"],
-             "Hyperparamiters (Regression)":["cross_validation","prune_features","reg_lambda","reg_alpha","cov_type", "class_1_threshold", "plate", "other", "fraction_threshold", "alpha", "random_row_column_effects", "regression_type", "min_cell_count", "agg_type", "transform", "dependent_variable"],
+             "Hyperparamiters (Regression)":["cross_validation","prune_features","reg_lambda","reg_alpha","cov_type", "plate", "other", "fraction_threshold", "alpha", "random_row_column_effects", "regression_type", "min_cell_count", "agg_type", "transform", "dependent_variable"],
              "Hyperparamiters (Activation)":["cam_type", "overlay", "correlation", "target_layer", "normalize_input"],
              "Annotation": ["filter_column", "filter_value","volcano", "toxo", "controls", "nc_loc", "pc_loc", "nc", "pc", "cell_plate_metadata","treatment_plate_metadata", "metadata_types", "cell_types", "target","positive_control","negative_control", "location_column", "treatment_loc", "channel_of_interest", "measurement", "treatments", "um_per_pixel", "nr_imgs", "exclude", "exclude_conditions", "mix", "pos", "neg"],
-             "Plot": ["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"],
-             "Test": ["test_mode", "test_images", "random_test", "test_nr", "test", "test_split"],
+             "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": ["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"],
-             "Miscellaneous": ["all_to_mip", "pick_slice", "skip_mode", "upscale", "upscale_factor"]
+             "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"]
              }
 
 
@@ -977,32 +1019,38 @@ def check_settings(vars_dict, expected_types, q=None):
         q = Queue()
 
     settings = {}
+    errors = []  # Collect errors instead of stopping at the first one
 
     for key, (label, widget, var, _) in vars_dict.items():
-        if key not in expected_types:
-            if key not in category_keys:
-                q.put(f"Key {key} not found in expected types.")
-                continue
+        if key not in expected_types and key not in category_keys:
+            errors.append(f"Warning: Key '{key}' not found in expected types.")
+            continue
 
         value = var.get()
-        if value == 'None':
+        if value in ['None', '']:
             value = None
 
         expected_type = expected_types.get(key, str)
 
         try:
-            if key in ["cell_plate_metadata", "timelapse_frame_limits", "png_size", "pathogen_loc", "treatment_loc", "pathogen_plate_metadata", "treatment_plate_metadata", "barcode_coordinates", "class_metadata"]:
-                parsed_value = ast.literal_eval(value) if value else None
+            if key in ["cell_plate_metadata", "timelapse_frame_limits", "png_size", "png_dims", "pathogen_plate_metadata", "treatment_plate_metadata", "class_metadata", "crop_mode"]:
+                if value is None:
+                    parsed_value = None
+                else:
+                    try:
+                        parsed_value = ast.literal_eval(value)
+                    except (ValueError, SyntaxError):
+                        raise ValueError(f"Expected a list or list of lists but got an invalid format: {value}")
+
                 if isinstance(parsed_value, list):
                     if all(isinstance(i, list) for i in parsed_value) or all(not isinstance(i, list) for i in parsed_value):
                         settings[key] = parsed_value
                     else:
-                        raise ValueError("Invalid format: Mixed list and list of lists")
-                #elif parsed_value == None:
-                #    settings[key] = None
+                        raise ValueError(f"Invalid format: '{key}' contains mixed types (single values and lists).")
+
                 else:
-                    raise ValueError("Invalid format for list or list of lists")
-                
+                    raise ValueError(f"Expected a list for '{key}', but got {type(parsed_value).__name__}.")
+            
             elif expected_type == list:
                 settings[key] = parse_list(value) if value else None
 
@@ -1010,37 +1058,52 @@ def check_settings(vars_dict, expected_types, q=None):
                     settings[key] = settings[key][0]
 
             elif expected_type == bool:
-                settings[key] = value if isinstance(value, bool) else value.lower() in ['true', '1', 't', 'y', 'yes']
+                settings[key] = value.lower() in ['true', '1', 't', 'y', 'yes'] if isinstance(value, str) else bool(value)
+            
             elif expected_type == (int, type(None)):
-                settings[key] = settings[key] = int(value) if isinstance(value, int) or str(value).isdigit() else None
+                if value is None or str(value).isdigit():
+                    settings[key] = int(value) if value is not None else None
+                else:
+                    raise ValueError(f"Expected an integer or None for '{key}', but got '{value}'.")
+
             elif expected_type == (float, type(None)):
-                settings[key] = float(value) if isinstance(value, float) or (isinstance(value, str) and value.replace(".", "", 1).isdigit()) else None
+                if value is None or (isinstance(value, str) and value.replace(".", "", 1).isdigit()):
+                    settings[key] = float(value) if value is not None else None
+                else:
+                    raise ValueError(f"Expected a float or None for '{key}', but got '{value}'.")
+
             elif expected_type == (int, float):
-                settings[key] = float(value) if '.' in value else int(value)
+                try:
+                    settings[key] = float(value) if '.' in str(value) else int(value)
+                except ValueError:
+                    raise ValueError(f"Expected an integer or float for '{key}', but got '{value}'.")
+
             elif expected_type == (str, type(None)):
-                settings[key] = str(value) if value else None
+                settings[key] = str(value) if value is not None else None
+
             elif expected_type == (str, type(None), list):
                 if isinstance(value, list):
                     settings[key] = parse_list(value) if value else None
                 elif isinstance(value, str):
-                    settings[key] = str(value) 
+                    settings[key] = str(value)
                 else:
                     settings[key] = None
             
             elif expected_type == dict:
                 try:
-                    # Ensure that the value is a string that can be converted to a dictionary
                     if isinstance(value, str):
-                        settings[key] = ast.literal_eval(value)
+                        parsed_dict = ast.literal_eval(value)
                     else:
                         raise ValueError("Expected a string representation of a dictionary.")
-                    
-                    # Check if the result is actually a dictionary
-                    if not isinstance(settings[key], dict):
-                        raise ValueError("Value is not a valid dictionary.")
+
+                    if not isinstance(parsed_dict, dict):
+                        raise ValueError(f"Expected a dictionary for '{key}', but got {type(parsed_dict).__name__}.")
+
+                    settings[key] = parsed_dict
                 except (ValueError, SyntaxError) as e:
                     settings[key] = {}
-                    q.put(f"Error: Invalid format for {key}. Expected type: dict. Error: {e}")
+                    errors.append(f"Error: Invalid dictionary format for '{key}'. Expected type: dict. Error: {e}")
+
             elif isinstance(expected_type, tuple):
                 for typ in expected_type:
                     try:
@@ -1049,15 +1112,25 @@ def check_settings(vars_dict, expected_types, q=None):
                     except (ValueError, TypeError):
                         continue
                 else:
-                    raise ValueError
+                    raise ValueError(f"Value '{value}' for '{key}' does not match any expected types: {expected_type}.")
+
             else:
-                settings[key] = expected_type(value) if value else None
+                try:
+                    settings[key] = expected_type(value) if value else None
+                except (ValueError, TypeError):
+                    raise ValueError(f"Expected type {expected_type.__name__} for '{key}', but got '{value}'.")
+
         except (ValueError, SyntaxError) as e:
             expected_type_name = ' or '.join([t.__name__ for t in expected_type]) if isinstance(expected_type, tuple) else expected_type.__name__
-            q.put(f"Error: Invalid format for {key}. Expected type: {expected_type_name}. Error: {e}, Value entered: {value}")
-            return
+            errors.append(f"Error: '{key}' has invalid format. Expected type: {expected_type_name}. Got value: '{value}'. Error: {e}")
 
-    return settings
+    # Send all collected errors to the queue
+    for error in errors:
+        q.put(error)
+        
+    
+
+    return settings, errors
 
 def generate_fields(variables, scrollable_frame):
     from .gui_utils import create_input_field
@@ -1082,16 +1155,25 @@ def generate_fields(variables, scrollable_frame):
         "black_background": "(bool) - Whether to use a black background for plots.",
         "calculate_correlation": "(bool) - Whether to calculate correlations between features.",
         "cell_CP_prob": "(float) - The cellpose probability threshold for the cell channel. This will be used in cell segmentation.",
+        "nucleus_CP_prob": "(float) - The cellpose probability threshold for the nucleus channel. This will be used in cell segmentation.",
+        "pathogen_CP_prob": "(float) - The cellpose probability threshold for the pathogen channel. This will be used in cell segmentation.",
         "cell_FT": "(float) - The flow threshold for cell objects. This will be used to segment the cells.",
-        "cell_background": "(float) - The background intensity for the cell channel. This will be used to remove background noise.",
+        "nucleus_FT": "(float) - The flow threshold for nucleus objects. This will be used to segment the cells.",
+        "pathogen_FT": "(float) - The flow threshold for pathogen objects. This will be used to segment the cells.",
+        "cell_background": "(int) - The background intensity for the cell channel. This will be used to remove background noise.",
+        "nucleus_background": "(int) - The background intensity for the nucleus channel. This will be used to remove background noise.",
+        "pathogen_background": "(int) - The background intensity for the pathogen channel. This will be used to remove background noise.",
         "cell_chann_dim": "(int) - Dimension of the channel to use for cell segmentation.",
-        "cell_channel": "(int) - The channel to use for the cell. If None, the cell will not be segmented.",
+        "cell_channel": "(int) - The channel to use for generatin cell masks. If None, cell masks will not be generated.",
+        "nucleus_channel": "(int) - The channel to use for generatin nucleus masks. If None, nucleus masks will not be generated.",
+        "pathogen_channel": "(int) - The channel to use for generatin pathogen masks. If None, pathogen masks will not be generated.",
         "cell_intensity_range": "(list) - Intensity range for cell segmentation.",
         "cell_loc": "(list) - The locations of the cell types in the images.",
-        "cell_mask_dim": "(int) - The dimension of the array the cell mask is saved in.",
+        "cell_mask_dim": "(int) - The dimension of the array the cell mask is saved in (array order:channels,cell, nucleus, pathogen, cytoplasm) array starts at dimension 0.",
+        "nucleus_mask_dim": "(int) - The dimension of the array the nucleus mask is saved in (array order:channels,cell, nucleus, pathogen, cytoplasm) array starts at dimension 0.",
         "cell_min_size": "(int) - The minimum size of cell objects in pixels^2.",
         "cell_plate_metadata": "(str) - Metadata for the cell plate.",
-        "cell_Signal_to_noise": "(float) - The signal-to-noise ratio for the cell channel. This will be used to determine the range of intensities to normalize images to for cell segmentation.",
+        "cell_Signal_to_noise": "(int) - The signal-to-noise ratio for the cell channel. This will be used to determine the range of intensities to normalize images to for cell segmentation.",
         "cell_size_range": "(list) - Size range for cell segmentation.",
         "cell_types": "(list) - Types of cells to include in the analysis.",
         "cells": "(list of lists) - The cell types to include in the analysis.",
@@ -1106,13 +1188,17 @@ def generate_fields(variables, scrollable_frame):
         "col_to_compare": "(str) - Column to compare in the embeddings.",
         "color_by": "(str) - Coloring scheme for the plots.",
         "compartments": "(list) - The compartments to measure in the images.",
+        "consolidate": "(bool) - Consolidate image files from subfolders into one folder named consolidated.",
         "CP_prob": "(float) - Cellpose probability threshold for segmentation.",
         "crop_mode": "(str) - Mode to use for cropping images (cell, nucleus, pathogen, cytoplasm).",
         "custom_model": "(str) - Path to a custom Cellpose model.",
-        "custom_regex": "(str) - Custom regex pattern to extract metadata from the image names. This will only be used if 'custom' is selected for 'metadata_type'.",
+        "custom_regex": "(str) - Custom regex pattern to extract metadata from the image names. This will only be used if 'custom' or 'auto' is selected for 'metadata_type'.",
         "cytoplasm": "(bool) - Whether to segment the cytoplasm (Cell - Nucleus + Pathogen).",
         "cytoplasm_min_size": "(int) - The minimum size of cytoplasm objects in pixels^2.",
+        "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).",
         "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.",
@@ -1160,7 +1246,7 @@ def generate_fields(variables, scrollable_frame):
         "manders_thresholds": "(list) - Thresholds for Manders' coefficients.",
         "mask": "(bool) - Whether to generate masks for the segmented objects. If True, masks will be generated for the nucleus, cell, and pathogen.",
         "measurement": "(str) - The measurement to use for the analysis.",
-        "metadata_type": "(str) - Type of metadata to expect in the images. This will determine how the images are processed. If 'custom' is selected, you can provide a custom regex pattern to extract metadata from the image names.",
+        "metadata_type": "(str) - Type of metadata to expect in the images. If 'custom' is selected, you can provide a custom regex pattern to extract metadata from the image names. auto will attempt to automatically extract metadata from the image names. cellvoyager and cq1 will use the default metadata extraction for CellVoyager and CQ1 images.",
         "metadata_types": "(list) - Types of metadata to include in the analysis.",
         "merge_edge_pathogen_cells": "(bool) - Whether to merge cells that share pathogen objects.",
         "merge_pathogens": "(bool) - Whether to merge pathogen objects that share more than 75 percent of their perimeter.",
@@ -1180,31 +1266,9 @@ def generate_fields(variables, scrollable_frame):
         "n_epochs": "(int) - Number of epochs for training the Cellpose model.",
         "n_jobs": "(int) - The number of n_jobs to use for processing the images. This will determine how many images are processed in parallel. Increase to speed up processing.",
         "n_neighbors": "(int) - Number of neighbors for UMAP.",
-        "n_repeats": "(int) - Number of repeats for cross-validation.",
-        "normalize": "(list) - The percentiles to use for normalizing the images. This will be used to determine the range of intensities to normalize images to. If None, no normalization is done.",
-        "normalize_by": "(str) - Whether to normalize the images by field of view (fov) or by PNG image (png).",
-        "normalize_plots": "(bool) - Whether to normalize the plots.",
-        "nr_imgs": "(int) - The number of images to plot.",
-        "nucleus_CP_prob": "(float) - The cellpose probability threshold for the nucleus channel. This will be used to segment the nucleus.",
-        "nucleus_FT": "(float) - The flow threshold for nucleus objects. This will be used in nucleus segmentation.",
-        "nucleus_background": "(float) - The background intensity for the nucleus channel. This will be used to remove background noise.",
-        "nucleus_chann_dim": "(int) - Dimension of the channel to use for nucleus segmentation.",
-        "nucleus_channel": "(int) - The channel to use for the nucleus. If None, the nucleus will not be segmented.",
-        "nucleus_intensity_range": "(list) - Intensity range for nucleus segmentation.",
-        "nucleus_loc": "(str) - Location of the nucleus in the images.",
-        "nucleus_mask_dim": "(int) - The dimension of the array the nucleus mask is saved in.",
-        "nucleus_min_size": "(int) - The minimum size of nucleus objects in pixels^2.",
-        "nucleus_Signal_to_noise": "(float) - The signal-to-noise ratio for the nucleus channel. This will be used to determine the range of intensities to normalize images to for nucleus segmentation.",
-        "nucleus_size_range": "(list) - Size range for nucleus segmentation.",
-        "optimizer_type": "(str) - Type of optimizer to use.",
-        "other": "(dict) - Additional parameters for the regression analysis.",
-        "pathogen_CP_prob": "(float) - The cellpose probability threshold for the pathogen channel. This will be used to segment the pathogen.",
-        "pathogen_FT": "(float) - The flow threshold for pathogen objects. This will be used in pathogen segmentation.",
-        "pathogen_background": "(float) - The background intensity for the pathogen channel. This will be used to remove background noise.",
-        "pathogen_chann_dim": "(int) - Dimension of the channel to use for pathogen segmentation.",
-        "pathogen_channel": "(int) - The channel to use for the pathogen. If None, the pathogen will not be segmented.",
-        "pathogen_intensity_range": "(str) - Metadata for the pathogen plate.",
-        "pathogen_Signal_to_noise": "(float) - The signal-to-noise ratio for the pathogen channel. This will be used to determine the range of intensities to normalize images to for pathogen segmentation.",
+        "n_repeats": "(int) - Number of repeats for the pathogen plate.",
+        "pathogen_Signal_to_noise": "(int) - The signal-to-noise ratio for the pathogen channel. This will be used to determine the range of intensities to normalize images to for pathogen segmentation.",
+        "nucleus_Signal_to_noise": "(int) - The signal-to-noise ratio for the nucleus channel. This will be used to determine the range of intensities to normalize images to for nucleus segmentation.",
         "pathogen_size_range": "(list) - Size range for pathogen segmentation.",
         "pathogen_types": "(list) - Types of pathogens to include in the analysis.",
         "pc": "(str) - Positive control identifier.",
@@ -1222,7 +1286,7 @@ def generate_fields(variables, scrollable_frame):
         "plot_nr": "(int) - Number of plots to generate.",
         "plot_outlines": "(bool) - Whether to plot outlines of segmented objects.",
         "png_dims": "(list) - The dimensions of the PNG images to save. This will determine the dimensions of the saved images. Maximum of 3 dimensions e.g. [1,2,3].",
-        "png_size": "(int) - The size of the PNG images to save. This will determine the size of the saved images.",
+        "png_size": "(list) - The size of the PNG images to save. This will determine the size of the saved images.",
         "positive_control": "(str) - Identifier for the positive control.",
         "preprocess": "(bool) - Whether to preprocess the images before segmentation. This includes background removal and normalization. Set to False only if this step has already been done.",
         "radial_dist": "(list) - Radial distances for measuring features.",
@@ -1251,10 +1315,11 @@ def generate_fields(variables, scrollable_frame):
         "save_measurements": "(bool) - Whether to save the measurements to disk.",
         "save_png": "(bool) - Whether to save the segmented objects as PNG images.",
         "schedule": "(str) - Schedule for processing the data.",
-        "Signal_to_noise": "(float) - Signal-to-noise ratio for the images.",
+        "Signal_to_noise": "(int) - Signal-to-noise ratio for the images.",
         "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.",
@@ -1304,7 +1369,7 @@ def generate_fields(variables, scrollable_frame):
         "masks": "(bool) - Whether to generate masks for the segmented objects.",
         "timelapse": "(bool) - Whether to analyze images as a timelapse.",
         "pathogen_min_size": "(int) - The minimum size of pathogen objects in pixels^2.",
-        "pathogen_mask_dim": "(int) - The dimension of the array the pathogen mask is saved in.",
+        "pathogen_mask_dim": "(int) - The dimension of the array the pathogen mask is saved in (array order:channels,cell, nucleus, pathogen, cytoplasm) array starts at dimension 0.",
         "use_bounding_box": "(bool) - Whether to use the bounding box for cropping the images.",
         "plot_points": "(bool) - Whether to plot scatterplot points.",
         "embedding_by_controls": "(bool) - Use the controlls to greate the embedding, then apply this embedding to all of the data.",
@@ -1334,6 +1399,7 @@ def generate_fields(variables, scrollable_frame):
         "shuffle": "(bool) - Shuffle the dataset bufore generating the activation maps",
         "correlation": "(bool) - Calculate correlation between image channels and activation maps. Data is saved to .db.",
         "normalize_input": "(bool) - Normalize the input images before passing them to the model.",
+        "normalize_plots": "(bool) - Normalize images before plotting.",
     }
     
     for key, (var_type, options, default_value) in variables.items():
@@ -1385,8 +1451,8 @@ def set_annotate_default_settings(settings):
     settings.setdefault('normalize', 'False')
     settings.setdefault('normalize_channels', "r,g,b")
     settings.setdefault('percentiles', [2, 98])
-    settings.setdefault('measurement', '')#'cytoplasm_channel_3_mean_intensity,pathogen_channel_3_mean_intensity')
-    settings.setdefault('threshold', '')#'2')
+    settings.setdefault('measurement', '') #'cytoplasm_channel_3_mean_intensity,pathogen_channel_3_mean_intensity')
+    settings.setdefault('threshold', '') #'2')
     return settings
 
 def set_default_generate_barecode_mapping(settings={}):
@@ -1406,6 +1472,7 @@ def set_default_generate_barecode_mapping(settings={}):
     settings.setdefault('mode', 'paired')
     settings.setdefault('single_direction', 'R1')
     settings.setdefault('test', False)
+    settings.setdefault('fill_na', False)
     return settings
 
 def get_default_generate_activation_map_settings(settings):