spacr 0.3.81__py3-none-any.whl → 0.4.0__py3-none-any.whl

spacr/plot.py

@@ -32,6 +32,7 @@ from IPython.display import Image as ipyimage
 import matplotlib.patches as patches
 from collections import defaultdict
 from matplotlib.gridspec import GridSpec
+from matplotlib_venn import venn2
 
 #filter_dict={'cell':[(0,100000), (0, 65000)],'nucleus':[(3000,100000), (1500, 65000)],'pathogen':[(500,100000), (0, 65000)]}
 def plot_image_mask_overlay(
@@ -1381,11 +1382,11 @@ def _plot_recruitment(df, df_type, channel_of_interest, columns=[], figuresize=1
     axes[3].set_xlabel(f'pathogen {df_type}', fontsize=font)
     axes[3].set_ylabel(f'pathogen_channel_{channel_of_interest}_mean_intensity', fontsize=font)
 
-    axes[0].legend_.remove()
-    axes[1].legend_.remove()
-    axes[2].legend_.remove()
-    axes[3].legend_.remove()
-
+    #axes[0].legend_.remove()
+    #axes[1].legend_.remove()
+    #axes[2].legend_.remove()
+    #axes[3].legend_.remove()
+        
     handles, labels = axes[3].get_legend_handles_labels()
     axes[3].legend(handles, labels, bbox_to_anchor=(1.05, 0.5), loc='center left')
     for i in [0,1,2,3]:
@@ -2043,7 +2044,9 @@ def plot_histogram(df, column, dst=None):
 
     plt.show()
 
-def plot_lorenz_curves(csv_files, name_column='grna_name', value_column='count', remove_keys=['TGGT1_220950_1', 'TGGT1_233460_4'], x_lim=[0.0,1], y_lim=[0,1], save=True):
+def plot_lorenz_curves(csv_files, name_column='grna_name', value_column='count', 
+                       remove_keys=None, 
+                       x_lim=[0.0, 1], y_lim=[0, 1], remove_outliers=False, save=True):
     
     def lorenz_curve(data):
         """Calculate Lorenz curve."""
@@ -2053,34 +2056,64 @@ def plot_lorenz_curves(csv_files, name_column='grna_name', value_column='count',
         lorenz_curve = np.insert(lorenz_curve, 0, 0)
         return lorenz_curve
     
+    def gini_coefficient(data):
+        """Calculate Gini coefficient from data."""
+        sorted_data = np.sort(data)
+        n = len(data)
+        cumulative_data = np.cumsum(sorted_data) / np.sum(sorted_data)
+        cumulative_data = np.insert(cumulative_data, 0, 0)
+        gini = 1 - 2 * np.sum(cumulative_data[:-1] * np.diff(np.linspace(0, 1, n + 1)))
+        return gini
+
+    def remove_outliers_by_wells(data, name_col, wells_col):
+        """Remove outliers based on 95% confidence interval for well counts."""
+        well_counts = data.groupby(name_col).size()
+        q1 = well_counts.quantile(0.05)
+        q3 = well_counts.quantile(0.95)
+        iqr_range = q3 - q1
+        lower_bound = q1 - 1.5 * iqr_range
+        upper_bound = q3 + 1.5 * iqr_range
+        valid_names = well_counts[(well_counts >= lower_bound) & (well_counts <= upper_bound)].index
+        return data[data[name_col].isin(valid_names)]
+    
     combined_data = []
+    gini_values = {}
 
     plt.figure(figsize=(10, 10))
 
     for idx, csv_file in enumerate(csv_files):
-        if idx == 1:
-            save_fldr = os.path.dirname(csv_file)
-            save_path = os.path.join(save_fldr, 'lorenz_curve.pdf')
-            
         df = pd.read_csv(csv_file)
+        
+        # Remove specified keys
         for remove in remove_keys:
             df = df[df[name_column] != remove]
         
+        # Remove outliers
+        if remove_outliers:
+            df = remove_outliers_by_wells(df, name_column, value_column)
+        
         values = df[value_column].values
         combined_data.extend(values)
         
+        # Calculate Lorenz curve and Gini coefficient
         lorenz = lorenz_curve(values)
-        name = f"plate {idx+1}"
+        gini = gini_coefficient(values)
+        gini_values[f"plate {idx+1}"] = gini
+        
+        name = f"plate {idx+1} (Gini: {gini:.4f})"
         plt.plot(np.linspace(0, 1, len(lorenz)), lorenz, label=name)
 
     # Plot combined Lorenz curve
     combined_lorenz = lorenz_curve(np.array(combined_data))
-    plt.plot(np.linspace(0, 1, len(combined_lorenz)), combined_lorenz, label="Combined", linestyle='--', color='black')
+    combined_gini = gini_coefficient(np.array(combined_data))
+    gini_values["Combined"] = combined_gini
+    
+    plt.plot(np.linspace(0, 1, len(combined_lorenz)), combined_lorenz, label=f"Combined (Gini: {combined_gini:.4f})", linestyle='--', color='black')
     
-    if x_lim != None:
+    if x_lim is not None:
         plt.xlim(x_lim)
     
-    if y_lim != None:
+    if y_lim is not None:
         plt.ylim(y_lim)
         
     plt.title('Lorenz Curves')
@@ -2092,10 +2125,15 @@ def plot_lorenz_curves(csv_files, name_column='grna_name', value_column='count',
     if save:
         save_path = os.path.join(os.path.dirname(csv_files[0]), 'results')
         os.makedirs(save_path, exist_ok=True)
-        save_file_path = os.path.join(save_path, 'lorenz_curve.pdf')
+        save_file_path = os.path.join(save_path, 'lorenz_curve_with_gini.pdf')
         plt.savefig(save_file_path, format='pdf', bbox_inches='tight')
         print(f"Saved Lorenz Curve: {save_file_path}")
-        plt.show()
+    
+    plt.show()
+
+    # Print Gini coefficients
+    for plate, gini in gini_values.items():
+        print(f"{plate}: Gini Coefficient = {gini:.4f}")
 
 def plot_permutation(permutation_df):
     num_features = len(permutation_df)
@@ -2484,21 +2522,79 @@ class spacrGraph:
             plt.show()
         return reordered_palette
 
+    #def preprocess_data(self):
+    #    """Preprocess the data: remove NaNs, sort/order the grouping column, and optionally group by 'prc'."""
+    #    # Remove NaNs in both the grouping column and each data column
+    #    df = self.df.dropna(subset=[self.grouping_column] + self.data_column)
+    #    # Group by 'prc' column if representation is 'well'
+    #    if self.representation == 'well':
+    #        df = df.groupby(['prc', self.grouping_column])[self.data_column].agg(self.summary_func).reset_index()
+    #    if self.representation == 'plate':
+    #        df = df.groupby(['plate', self.grouping_column])[self.data_column].agg(self.summary_func).reset_index()
+    #    if self.order:
+    #        df[self.grouping_column] = pd.Categorical(df[self.grouping_column], categories=self.order, ordered=True)
+    #    else:
+    #        df[self.grouping_column] = pd.Categorical(df[self.grouping_column], categories=sorted(df[self.grouping_column].unique()), ordered=True)
+    #    return df
+  
     def preprocess_data(self):
-        """Preprocess the data: remove NaNs, sort/order the grouping column, and optionally group by 'prc'."""
-        # Remove NaNs in both the grouping column and each data column
+        """
+        Preprocess the data: remove NaNs, optionally ensure 'plate' column is created,
+        then group by either 'prc', 'plate', or do no grouping at all if representation == 'object'.
+        """
+        # 1) Remove NaNs in both the grouping column and each data column
         df = self.df.dropna(subset=[self.grouping_column] + self.data_column)
-        # Group by 'prc' column if representation is 'well'
-        if self.representation == 'well':
-            df = df.groupby(['prc', self.grouping_column])[self.data_column].agg(self.summary_func).reset_index()
-        if self.representation == 'plate':
-            df = df.groupby(['plate', self.grouping_column])[self.data_column].agg(self.summary_func).reset_index()
-        if self.order:
-            df[self.grouping_column] = pd.Categorical(df[self.grouping_column], categories=self.order, ordered=True)
+
+        # 2) Decide how to handle grouping based on 'representation'
+        if self.representation == 'object':
+            # -- No grouping at all --
+            # We do nothing except keep df as-is after removing NaNs
+            group_cols = None
+
+        elif self.representation == 'well':
+            # Group by ['prc', grouping_column]
+            group_cols = ['prc', self.grouping_column]
+
+        elif self.representation == 'plate':
+            # Make sure 'plate' exists (split from 'prc' if needed)
+            if 'plate' not in df.columns:
+                if 'prc' in df.columns:
+                    df[['plate', 'row', 'column']] = df['prc'].str.split('_', expand=True)
+                else:
+                    raise KeyError(
+                        "Representation is 'plate', but no 'plate' column found. "
+                        "Also cannot split from 'prc' because 'prc' column is missing."
+                    )
+            # If the grouping column IS 'plate', only group by ['plate'] once
+            if self.grouping_column == 'plate':
+                group_cols = ['plate']
+            else:
+                group_cols = ['plate', self.grouping_column]
+
         else:
-            df[self.grouping_column] = pd.Categorical(df[self.grouping_column], categories=sorted(df[self.grouping_column].unique()), ordered=True)
-        return df
+            raise ValueError(f"Unknown representation: {self.representation}")
+
+        # 3) Perform grouping only if group_cols is set
+        if group_cols is not None:
+            df = df.groupby(group_cols)[self.data_column].agg(self.summary_func).reset_index()
+
+        # 4) Handle ordering if specified (and if the grouping_column still exists)
+        if self.order and (self.grouping_column in df.columns):
+            df[self.grouping_column] = pd.Categorical(
+                df[self.grouping_column],
+                categories=self.order,
+                ordered=True
+            )
+        elif (self.grouping_column in df.columns):
+            # Default to sorting unique values
+            df[self.grouping_column] = pd.Categorical(
+                df[self.grouping_column],
+                categories=sorted(df[self.grouping_column].unique()),
+                ordered=True
+            )
 
+        return df
+   
     def remove_outliers_from_plot(self):
         """Remove outliers from the plot but keep them in the data."""
         filtered_df = self.df.copy()
@@ -2900,6 +2996,11 @@ class spacrGraph:
 
         # Set figure size to ensure it remains square with a minimum size
         fig_size = max(6, num_groups * 2)  / correction_factor
+        
+        if fig_size < 10:
+            fig_size = 10
+        
+        
         ax.figure.set_size_inches(fig_size, fig_size)
 
         # Configure layout based on the number of groups
@@ -2948,66 +3049,6 @@ class spacrGraph:
         # Redraw the figure to apply changes
         ax.figure.canvas.draw()
         
-    def _standerdize_figure_format_v1(self, ax, num_groups, graph_type):
-        """
-        Adjusts the figure layout (size, bar width, jitter, and spacing) based on the number of groups.
-        """
-        if graph_type in ['line', 'line_std']:
-            print("Skipping layout adjustment for line graphs.")
-            return  # Skip layout adjustment for line graphs
-
-        correction_factor = 4
-
-        # Set figure size to ensure it remains square with a minimum size
-        fig_size = max(6, num_groups * 2) / correction_factor
-        ax.figure.set_size_inches(fig_size, fig_size)
-
-        # Configure layout based on the number of groups
-        bar_width = min(0.8, 1.5 / num_groups) / correction_factor
-        jitter_amount = min(0.1, 0.2 / num_groups) / correction_factor
-        jitter_size = max(50 / num_groups, 200)
-
-        # Adjust x-axis limits to fit the specified order of groups
-        ax.set_xlim(-0.5, len(self.order) - 0.5)  # Use `self.order` length to ensure alignment
-
-        # Use `self.order` as the x-tick labels to maintain consistent ordering
-        ax.set_xticks(range(len(self.order)))
-        #ax.set_xticklabels(self.order, rotation=45, ha='right')
-        plt.setp(ax.get_xticklabels(), rotation=45, ha='right')
-
-        # Customize elements based on the graph type
-        if graph_type == 'bar':
-            # Adjust bars' width and position
-            for bar in ax.patches:
-                bar.set_width(bar_width)
-                bar.set_x(bar.get_x() - bar_width / 2)
-
-        elif graph_type in ['jitter', 'jitter_bar', 'jitter_box']:
-            # Adjust jitter points' position and size
-            for coll in ax.collections:
-                offsets = coll.get_offsets()
-                offsets[:, 0] += jitter_amount  # Shift jitter points slightly
-                coll.set_offsets(offsets)
-                coll.set_sizes([jitter_size] * len(offsets))  # Adjust point size dynamically
-
-        elif graph_type in ['box', 'violin']:
-            # Adjust box width for consistent spacing
-            for artist in ax.artists:
-                artist.set_width(bar_width)
-
-        # Adjust legend and axis labels
-        ax.tick_params(axis='x', labelsize=max(10, 15 - num_groups // 2))
-        ax.tick_params(axis='y', labelsize=max(10, 15 - num_groups // 2))
-
-        # Adjust legend placement and size
-        if ax.get_legend():
-            ax.get_legend().set_bbox_to_anchor((1.05, 1))
-            ax.get_legend().prop.set_size(max(8, 12 - num_groups // 3))
-
-        # Redraw the figure to apply changes
-        ax.figure.canvas.draw()
-
-
     def _create_bar_plot(self, ax):
         """Helper method to create a bar plot with consistent bar thickness and centered error bars."""
         # Flatten DataFrame: Combine grouping column and data column into one group if needed
@@ -3328,7 +3369,7 @@ def plot_data_from_db(settings):
             [df1] = _read_db(db_loc, tables=[settings['table_names']])
         else:
             df1, _ = _read_and_merge_data(locs=[db_loc],
-                                    tables = settings['tables'],
+                                    tables = settings['table_names'],
                                     verbose=settings['verbose'],
                                     nuclei_limit=settings['nuclei_limit'],
                                     pathogen_limit=settings['pathogen_limit'])
@@ -3355,6 +3396,13 @@ def plot_data_from_db(settings):
         df = df.dropna(subset='treatment')
 
     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}')
+        display(df)
+        return None
+    
     df = df.dropna(subset=settings['grouping_column'])
 
     src = srcs[0] 
@@ -3410,8 +3458,6 @@ def plot_data_from_csv(settings):
     else:
         raise ValueError("src must be a string or a list of strings.")
     
-    #save_settings(settings, name=f"{settings['graph_name']}_plot_settings_csv", show=True)
-
     dfs = []
     for i, src in enumerate(srcs):
         dft = pd.read_csv(src)
@@ -3421,7 +3467,17 @@ def plot_data_from_csv(settings):
         dfs.append(dft)
 
     df = pd.concat(dfs, axis=0)
+    
+    if 'prc' in df.columns:
+        # Check if 'plate', 'row', and 'column' are all missing from df.columns
+        if not all(col in df.columns for col in ['plate', 'row_name', 'column_name']):
+            try:
+                # Split 'prc' into 'plate', 'row', and 'column'
+                df[['plate', 'row_name', 'column_name']] = df['prc'].str.split('_', expand=True)
+            except Exception as e:
+                print(f"Could not split the prc column: {e}")
 
+                
     display(df)
 
     df = df.dropna(subset=settings['data_column'])
@@ -3812,3 +3868,58 @@ def plot_proportion_stacked_bars(settings, df, group_column, bin_column, prc_col
     })
 
     return results_df, pairwise_results, fig
+
+def create_venn_diagram(file1, file2, gene_column="gene", filter_coeff=0.1, save=True, save_path=None):
+    """
+    Reads two CSV files, extracts the `gene` column, and creates a Venn diagram
+    to show overlapping and non-overlapping genes.
+
+    Parameters:
+        file1 (str): Path to the first CSV file.
+        file2 (str): Path to the second CSV file.
+        gene_column (str): Name of the column containing gene data (default: "gene").
+        filter_coeff (float): Coefficient threshold for filtering genes.
+        save (bool): Whether to save the plot.
+        save_path (str): Path to save the Venn diagram figure.
+
+    Returns:
+        dict: Overlapping and non-overlapping genes.
+    """
+    # Read CSV files
+    df1 = pd.read_csv(file1)
+    df2 = pd.read_csv(file2)
+
+    # Filter based on coefficient
+    if filter_coeff is not None:
+        df1 = df1[df1['coefficient'] > filter_coeff] if filter_coeff >= 0 else df1[df1['coefficient'] < filter_coeff]
+        df2 = df2[df2['coefficient'] > filter_coeff] if filter_coeff >= 0 else df2[df2['coefficient'] < filter_coeff]
+
+    # Extract gene columns and drop NaN values
+    genes1 = set(df1[gene_column].dropna())
+    genes2 = set(df2[gene_column].dropna())
+
+    # Calculate overlapping and non-overlapping genes
+    overlapping_genes = genes1.intersection(genes2)
+    unique_to_file1 = genes1.difference(genes2)
+    unique_to_file2 = genes2.difference(genes1)
+
+    # Create a Venn diagram
+    plt.figure(figsize=(8, 6))
+    venn = venn2([genes1, genes2], ('File 1 Genes', 'File 2 Genes'))
+    plt.title("Venn Diagram of Overlapping Genes")
+
+    # Save or show the figure
+    if save:
+        if save_path is None:
+            raise ValueError("save_path must be provided when save=True.")
+        plt.savefig(save_path, dpi=300, bbox_inches="tight", format='pdf')
+        print(f"Venn diagram saved to {save_path}")
+    else:
+        plt.show()
+
+    # Return the results
+    return {
+        "overlap": list(overlapping_genes),
+        "unique_to_file1": list(unique_to_file1),
+        "unique_to_file2": list(unique_to_file2)
+    }

spacr/settings.py

@@ -24,15 +24,10 @@ def set_default_plot_merge_settings():
     settings.setdefault('verbose', True)
     return settings
 
-def set_default_settings_preprocess_generate_masks(src, settings={}):
-    # Main settings
-    if src != None:
-        settings['src'] = src
-    else:
-        settings.setdefault('src', 'path')
-    if 'src' not in settings:
-        settings['src'] = 'path'
-
+def set_default_settings_preprocess_generate_masks(settings={}):
+    
+    settings.setdefault('src', 'path')
+    settings.setdefault('delete_intermediate', False)
     settings.setdefault('segmentation_mode', 'cellpose')
     settings.setdefault('preprocess', True)
     settings.setdefault('masks', True)
@@ -49,6 +44,10 @@ def set_default_settings_preprocess_generate_masks(src, settings={}):
     settings.setdefault('remove_background_cell', False)
     settings.setdefault('remove_background_nucleus', False)
     settings.setdefault('remove_background_pathogen', False)
+    
+    settings.setdefault('cell_diamiter', None)
+    settings.setdefault('nucleus_diamiter', None)
+    settings.setdefault('pathogen_diamiter', None)
 
     # Channel settings
     settings.setdefault('cell_channel', None)
@@ -147,12 +146,27 @@ def _get_object_settings(object_type, settings):
         object_settings['filter_size'] = False
         object_settings['filter_intensity'] = False
         object_settings['restore_type'] = settings.get('cell_restore_type', None)
+        if settings['cell_diamiter'] is not None:
+            if isinstance(settings['cell_diamiter'], (int, float)):
+                object_settings['diameter'] = settings['cell_diamiter']
+                object_settings['minimum_size'] = (object_settings['diameter']**2)/4
+                object_settings['maximum_size'] = (object_settings['diameter']**2)*10
+            else:
+                print(f'Cell diameter must be an integer or float, got {settings["cell_diamiter"]}')
 
     elif object_type == 'nucleus':
         object_settings['model_name'] = 'nuclei'
         object_settings['filter_size'] = False
         object_settings['filter_intensity'] = False
         object_settings['restore_type'] = settings.get('nucleus_restore_type', None)
+        
+        if settings['nucleus_diamiter'] is not None:
+            if isinstance(settings['nucleus_diamiter'], (int, float)):
+                object_settings['diameter'] = settings['nucleus_diamiter']
+                object_settings['minimum_size'] = (object_settings['diameter']**2)/4
+                object_settings['maximum_size'] = (object_settings['diameter']**2)*10
+            else:
+                print(f'Nucleus diameter must be an integer or float, got {settings["nucleus_diamiter"]}')
 
     elif object_type == 'pathogen':
         object_settings['model_name'] = 'cyto'
@@ -162,6 +176,14 @@ def _get_object_settings(object_type, settings):
         object_settings['restore_type'] = settings.get('pathogen_restore_type', None)
         object_settings['merge'] = settings['merge_pathogens']
         
+        if settings['pathogen_diamiter'] is not None:
+            if isinstance(settings['pathogen_diamiter'], (int, float)):
+                object_settings['diameter'] = settings['pathogen_diamiter']
+                object_settings['minimum_size'] = (object_settings['diameter']**2)/4
+                object_settings['maximum_size'] = (object_settings['diameter']**2)*10
+            else:
+                print(f'Pathogen diameter must be an integer or float, got {settings["pathogen_diamiter"]}')
+        
     else:
         print(f'Object type: {object_type} not supported. Supported object types are : cell, nucleus and pathogen')
 
@@ -216,6 +238,8 @@ def set_default_umap_image_settings(settings={}):
 def get_measure_crop_settings(settings={}):
 
     settings.setdefault('src', 'path')
+    settings.setdefault('delete_intermediate', False)
+    
     settings.setdefault('verbose', False)
     settings.setdefault('experiment', 'exp')
     
@@ -339,7 +363,7 @@ def set_default_train_test_model(settings):
 def set_generate_training_dataset_defaults(settings):
     
     settings.setdefault('src','path')
-    settings.setdefault('tables',['cell', 'nucleus', 'pathogen', 'cytoplasm'])
+    settings.setdefault('tables', ['cell', 'nucleus', 'pathogen', 'cytoplasm'])
     settings.setdefault('dataset_mode','metadata')
     settings.setdefault('annotation_column','test')
     settings.setdefault('annotated_classes',[1,2])
@@ -457,7 +481,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',['column_name', 'column_name', 'row_name'])
     settings.setdefault('channel_dims',[0,1,2,3])
     settings.setdefault('cell_chann_dim',3)
     settings.setdefault('cell_mask_dim',4)
@@ -545,6 +569,7 @@ def get_perform_regression_default_settings(settings):
     settings.setdefault('log_x',False)
     settings.setdefault('log_y',False)
     settings.setdefault('x_lim',None)
+    settings.setdefault('outlier_detection',True)
     settings.setdefault('agg_type','mean')
     settings.setdefault('min_cell_count',None)
     settings.setdefault('regression_type','ols')
@@ -908,17 +933,25 @@ expected_types = {
     "offset_start":int,
     "chunk_size":int,
     "single_direction":str,
+    "delete_intermediate":bool,
+    "outlier_detection":bool,
+    "CP_prob":int,
+    "diameter":int,
+    "flow_threshold":float,
+    "cell_diamiter":int,
+    "nucleus_diamiter":int,
+    "pathogen_diamiter":int
 }
 
 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"],
+             "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_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_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_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", ],
+             "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", ],
              "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"],
-             "Sequencing": ["offset_start","chunk_size","single_direction", "signal_direction","mode","comp_level","comp_type","save_h5","expected_end","offset","target_sequence","regex", "highlight"],
+             "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"],
@@ -1032,6 +1065,9 @@ def generate_fields(variables, scrollable_frame):
     row = 1
     vars_dict = {}
     tooltips = {
+        "cell_diamiter": "(int) - Diameter for cellpose objects to segment.",
+        "nucleus_diamiter": "(int) - Diameter for cellpose objects to segment.",
+        "pathogen_diamiter": "(int) - Diameter for cellpose objects to segment.",
         "adjust_cells": "(bool) - Adjust cell parameters for better segmentation.",
         "agg_type": "(str) - Type of aggregation to use for the data.",
         "alpha": "(float) - Alpha parameter for the regression model.",