spacr 0.3.1__py3-none-any.whl → 0.3.22__py3-none-any.whl

spacr/plot.py

@@ -1,4 +1,4 @@
-import os,re, random, cv2, glob, time, math, torch
+import os, random, cv2, glob, math, torch
 
 import numpy as np
 import pandas as pd
@@ -14,11 +14,15 @@ from skimage.segmentation import find_boundaries
 from skimage import measure
 from skimage.measure import find_contours, label, regionprops
 
+from scipy.stats import normaltest, ttest_ind, mannwhitneyu, f_oneway, kruskal
+from statsmodels.stats.multicomp import pairwise_tukeyhsd
+from scipy.stats import ttest_ind, mannwhitneyu, levene, wilcoxon, kruskal
+import itertools
+import pingouin as pg
+
 from ipywidgets import IntSlider, interact
 from IPython.display import Image as ipyimage
 
-from .logger import log_function_call
-
 def plot_image_mask_overlay(file, channels, cell_channel, nucleus_channel, pathogen_channel, figuresize=10, normalize=True, thickness=3, save_pdf=True):
     """Plot image and mask overlays."""
 
@@ -409,7 +413,7 @@ def plot_images_and_arrays(folders, lower_percentile=1, upper_percentile=99, thr
     plot_from_file_dict(file_dict, threshold, lower_percentile, upper_percentile, overlay, save=False)
     return
 
-def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mask_dim, mask_dims, filter_min_max, include_multinucleated, include_multiinfected):
+def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mask_dim, mask_dims, filter_min_max, nuclei_limit, pathogen_limit):
     """
     Filters objects in a plot based on various criteria.
 
@@ -420,8 +424,8 @@ def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mas
         pathogen_mask_dim (int): The dimension index of the pathogen mask.
         mask_dims (list): A list of dimension indices for additional masks.
         filter_min_max (list): A list of minimum and maximum area values for each mask.
-        include_multinucleated (bool): Whether to include multinucleated cells.
-        include_multiinfected (bool): Whether to include multiinfected cells.
+        nuclei_limit (bool): Whether to include multinucleated cells.
+        pathogen_limit (bool): Whether to include multiinfected cells.
 
     Returns:
         numpy.ndarray: The filtered stack of masks.
@@ -451,9 +455,9 @@ def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mas
         total_count_after = len(props_after['label'])
 
         if mask_dim == cell_mask_dim:
-            if include_multinucleated is False and nucleus_mask_dim is not None:
+            if nuclei_limit is False and nucleus_mask_dim is not None:
                 stack = _remove_multiobject_cells(stack, mask_dim, cell_mask_dim, nucleus_mask_dim, pathogen_mask_dim, object_dim=pathogen_mask_dim)
-            if include_multiinfected is False and cell_mask_dim is not None and pathogen_mask_dim is not None:
+            if pathogen_limit is False and cell_mask_dim is not None and pathogen_mask_dim is not None:
                 stack = _remove_multiobject_cells(stack, mask_dim, cell_mask_dim, nucleus_mask_dim, pathogen_mask_dim, object_dim=nucleus_mask_dim)
             cell_area_before = avg_size_before
             cell_count_before = total_count_before
@@ -662,18 +666,18 @@ def plot_merged(src, settings):
         display(settings)
         
     if settings['pathogen_mask_dim'] is None:
-        settings['include_multiinfected'] = True
+        settings['pathogen_limit'] = True
 
     for file in os.listdir(src):
         path = os.path.join(src, file)
         stack = np.load(path)
         print(f'Loaded: {path}')
-        if not settings['include_noninfected']:
+        if not settings['uninfected']:
             if settings['pathogen_mask_dim'] is not None and settings['cell_mask_dim'] is not None:
                 stack = _remove_noninfected(stack, settings['cell_mask_dim'], settings['nucleus_mask_dim'], settings['pathogen_mask_dim'])
 
-        if settings['include_multiinfected'] is not True or settings['include_multinucleated'] is not True or settings['filter_min_max'] is not None:
-            stack = _filter_objects_in_plot(stack, settings['cell_mask_dim'], settings['nucleus_mask_dim'], settings['pathogen_mask_dim'], mask_dims, settings['filter_min_max'], settings['include_multinucleated'], settings['include_multiinfected'])
+        if settings['pathogen_limit'] is not True or settings['nuclei_limit'] is not True or settings['filter_min_max'] is not None:
+            stack = _filter_objects_in_plot(stack, settings['cell_mask_dim'], settings['nucleus_mask_dim'], settings['pathogen_mask_dim'], mask_dims, settings['filter_min_max'], settings['nuclei_limit'], settings['pathogen_limit'])
 
         overlayed_image, image, outlines = _normalize_and_outline(image=stack, 
                                                                   remove_background=settings['remove_background'],
@@ -999,8 +1003,107 @@ def _display_gif(path):
     """
     with open(path, 'rb') as file:
         display(ipyimage(file.read()))
+
+def _plot_recruitment_v2(df, df_type, channel_of_interest, columns=[], figuresize=10):
+    """
+    Plot recruitment data for different conditions and pathogens.
+
+    Args:
+        df (DataFrame): The input DataFrame containing the recruitment data.
+        df_type (str): The type of DataFrame (e.g., 'train', 'test').
+        channel_of_interest (str): The channel of interest for plotting.
+        target (str): The target variable for plotting.
+        columns (list, optional): Additional columns to plot. Defaults to an empty list.
+        figuresize (int, optional): The size of the figure. Defaults to 50.
+
+    Returns:
+        None
+    """
+
+    from .plot import spacrGraph
+
+    color_list = [(55/255, 155/255, 155/255), 
+                  (155/255, 55/255, 155/255), 
+                  (55/255, 155/255, 255/255), 
+                  (255/255, 55/255, 155/255)]
+
+    sns.set_palette(sns.color_palette(color_list))
+    font = figuresize/2
+    width=figuresize
+    height=figuresize/4
+
+    # Create the subplots
+    fig, axes = plt.subplots(nrows=1, ncols=4, figsize=(width, height))
+
+    # Plot for 'cell_channel' on axes[0]
+    plotter_cell = spacrGraph(df,grouping_column='condition', data_column=f'cell_channel_{channel_of_interest}_mean_intensity')
+    plotter_cell.create_plot(ax=axes[0])
+    axes[0].set_xlabel(f'pathogen {df_type}', fontsize=font)
+    axes[0].set_ylabel(f'cell_channel_{channel_of_interest}_mean_intensity', fontsize=font)
+
+    # Plot for 'nucleus_channel' on axes[1]
+    plotter_nucleus = spacrGraph(df,grouping_column='condition', data_column=f'nucleus_channel_{channel_of_interest}_mean_intensity')
+    plotter_nucleus.create_plot(ax=axes[1])
+    axes[1].set_xlabel(f'pathogen {df_type}', fontsize=font)
+    axes[1].set_ylabel(f'nucleus_channel_{channel_of_interest}_mean_intensity', fontsize=font)
+
+    # Plot for 'cytoplasm_channel' on axes[2]
+    plotter_cytoplasm = spacrGraph(df, grouping_column='condition', data_column=f'cytoplasm_channel_{channel_of_interest}_mean_intensity')
+    plotter_cytoplasm.create_plot(ax=axes[2])
+    axes[2].set_xlabel(f'pathogen {df_type}', fontsize=font)
+    axes[2].set_ylabel(f'cytoplasm_channel_{channel_of_interest}_mean_intensity', fontsize=font)
+
+    # Plot for 'pathogen_channel' on axes[3]
+    plotter_pathogen = spacrGraph(df, grouping_column='condition', data_column=f'pathogen_channel_{channel_of_interest}_mean_intensity')
+    plotter_pathogen.create_plot(ax=axes[3])
+    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()
+
+    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]:
+        axes[i].tick_params(axis='both', which='major', labelsize=font)
+        axes[i].set_xticklabels(axes[i].get_xticklabels(), rotation=45)
+
+    plt.tight_layout()
+    plt.show()
+
+    columns = columns + ['pathogen_cytoplasm_mean_mean', 'pathogen_cytoplasm_q75_mean', 'pathogen_periphery_cytoplasm_mean_mean', 'pathogen_outside_cytoplasm_mean_mean', 'pathogen_outside_cytoplasm_q75_mean']
+    #columns = columns + [f'pathogen_slope_channel_{channel_of_interest}', f'pathogen_cell_distance_channel_{channel_of_interest}', f'nucleus_cell_distance_channel_{channel_of_interest}']
+
+    width = figuresize*2
+    columns_per_row = math.ceil(len(columns) / 2)
+    height = (figuresize*2)/columns_per_row
+
+    fig, axes = plt.subplots(nrows=2, ncols=columns_per_row, figsize=(width, height * 2))
+    axes = axes.flatten()
+
+    print(f'{columns}')
+    for i, col in enumerate(columns):
+        ax = axes[i]
+        plotter_col = spacrGraph(df, grouping_column='condition', data_column=col)
+        plotter_col.create_plot(ax=ax)
+        ax.set_xlabel(f'pathogen {df_type}', fontsize=font)
+        ax.set_ylabel(f'{col}', fontsize=int(font * 2))
+        #ax.legend_.remove()
+        ax.tick_params(axis='both', which='major', labelsize=font)
+        ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
+        if i <= 5:
+            ax.set_ylim(1, None)
+
+    # Turn off any unused axes
+    for i in range(len(columns), len(axes)):
+        axes[i].axis('off')
+
+    plt.tight_layout()
+    plt.show()
         
-def _plot_recruitment(df, df_type, channel_of_interest, target, columns=[], figuresize=10):
+def _plot_recruitment(df, df_type, channel_of_interest, columns=[], figuresize=10):
     """
     Plot recruitment data for different conditions and pathogens.
 
@@ -1153,10 +1256,6 @@ def _plot_controls(df, mask_chans, channel_of_interest, figuresize=5):
     plt.tight_layout()
     plt.show()
 
-###################################################
-#  Classify
-###################################################
-
 def _imshow(img, labels, nrow=20, color='white', fontsize=12):
     """
     Display multiple images in a grid with corresponding labels.
@@ -1359,7 +1458,7 @@ def generate_plate_heatmap(df, plate_number, variable, grouping, min_max, min_co
         
     return plate_map, min_max
 
-def plot_plates(df, variable, grouping, min_max, cmap, min_count=0, verbose=True):
+def plot_plates(df, variable, grouping, min_max, cmap, min_count=0, verbose=True, dst=None):
     plates = df['prc'].str.split('_', expand=True)[0].unique()
     n_rows, n_cols = (len(plates) + 3) // 4, 4
     fig, ax = plt.subplots(n_rows, n_cols, figsize=(40, 5 * n_rows))
@@ -1374,6 +1473,12 @@ def plot_plates(df, variable, grouping, min_max, cmap, min_count=0, verbose=True
         fig.delaxes(ax[i])
     
     plt.subplots_adjust(wspace=0.1, hspace=0.4)
+
+    if not dst is None:
+        filename = os.path.join(dst, 'plate_heatmap.pdf')
+        fig.savefig(filename, format='pdf')
+        print(f'Saved heatmap to {filename}')
+
     if verbose:
         plt.show()
     return fig
@@ -1605,13 +1710,19 @@ def volcano_plot(coef_df, filename='volcano_plot.pdf'):
     print(f'Saved Volcano plot: {filename}')
     plt.show()
 
-def plot_histogram(df, dependent_variable):
+def plot_histogram(df, dependent_variable, dst=None):
     # Plot histogram of the dependent variable
     plt.figure(figsize=(10, 6))
     sns.histplot(df[dependent_variable], kde=True)
     plt.title(f'Histogram of {dependent_variable}')
     plt.xlabel(dependent_variable)
     plt.ylabel('Frequency')
+    
+    if not dst is None:
+        filename = os.path.join(dst, 'dependent_variable_histogram.pdf')
+        plt.savefig(filename, format='pdf')
+        print(f'Saved histogram to {filename}')
+
     plt.show()
 
 def plot_lorenz_curves(csv_files, remove_keys=['TGGT1_220950_1', 'TGGT1_233460_4']):
@@ -1732,4 +1843,580 @@ def read_and_plot__vision_results(base_dir, y_axis='accuracy', name_split='_time
             plt.ylim(y_lim)
         plt.show()
     else:
-        print("No CSV files found in the specified directory.")
+        print("No CSV files found in the specified directory.")
+
+def jitterplot_by_annotation(src, x_column, y_column, plot_title='Jitter Plot', output_path=None, filter_column=None, filter_values=None):
+    """
+    Reads a CSV file and creates a jitter plot of one column grouped by another column.
+    
+    Args:
+    src (str): Path to the source data.
+    x_column (str): Name of the column to be used for the x-axis.
+    y_column (str): Name of the column to be used for the y-axis.
+    plot_title (str): Title of the plot. Default is 'Jitter Plot'.
+    output_path (str): Path to save the plot image. If None, the plot will be displayed. Default is None.
+    
+    Returns:
+    pd.DataFrame: The filtered and balanced DataFrame.
+    """
+
+    def join_measurments_and_annotation(src, tables = ['cell', 'nucleus', 'pathogen','cytoplasm']):
+        from .io import _read_and_merge_data, _read_db
+        db_loc = [src+'/measurements/measurements.db']
+        loc = src+'/measurements/measurements.db'
+        df, _ = _read_and_merge_data(db_loc, 
+                                    tables, 
+                                    verbose=True, 
+                                    nuclei_limit=True, 
+                                    pathogen_limit=True, 
+                                    uninfected=True)
+        paths_df = _read_db(loc, tables=['png_list'])
+        merged_df = pd.merge(df, paths_df[0], on='prcfo', how='left')
+        return merged_df
+
+    # Read the CSV file into a DataFrame
+    df = join_measurments_and_annotation(src, tables=['cell', 'nucleus', 'pathogen', 'cytoplasm'])
+
+    # Print column names for debugging
+    print(f"Generated dataframe with: {df.shape[1]} columns and {df.shape[0]} rows")
+    #print("Columns in DataFrame:", df.columns.tolist())
+
+    # Replace NaN values with a specific label in x_column
+    df[x_column] = df[x_column].fillna('NaN')
+
+    # Filter the DataFrame if filter_column and filter_values are provided
+    if not filter_column is None:
+        if isinstance(filter_column, str):
+            df = df[df[filter_column].isin(filter_values)]
+        if isinstance(filter_column, list):
+            for i,val in enumerate(filter_column):
+                print(f'hello {len(df)}')
+                df = df[df[val].isin(filter_values[i])]
+
+    # Use the correct column names based on your DataFrame
+    required_columns = ['plate_x', 'row_x', 'col_x']
+    if not all(column in df.columns for column in required_columns):
+        raise KeyError(f"DataFrame does not contain the necessary columns: {required_columns}")
+
+    # Filter to retain rows with non-NaN values in x_column and with matching plate, row, col values
+    non_nan_df = df[df[x_column] != 'NaN']
+    retained_rows = df[df[['plate_x', 'row_x', 'col_x']].apply(tuple, axis=1).isin(non_nan_df[['plate_x', 'row_x', 'col_x']].apply(tuple, axis=1))]
+
+    # Determine the minimum count of examples across all groups in x_column
+    min_count = retained_rows[x_column].value_counts().min()
+    print(f'Found {min_count} annotated images')
+
+    # Randomly sample min_count examples from each group in x_column
+    balanced_df = retained_rows.groupby(x_column).apply(lambda x: x.sample(min_count, random_state=42)).reset_index(drop=True)
+
+    # Create the jitter plot
+    plt.figure(figsize=(10, 6))
+    jitter_plot = sns.stripplot(data=balanced_df, x=x_column, y=y_column, hue=x_column, jitter=True, palette='viridis', dodge=False)
+    plt.title(plot_title)
+    plt.xlabel(x_column)
+    plt.ylabel(y_column)
+    
+    # Customize the x-axis labels
+    plt.xticks(rotation=45, ha='right')
+    
+    # Adjust the position of the x-axis labels to be centered below the data
+    ax = plt.gca()
+    ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha='center')
+    
+    # Save the plot to a file or display it
+    if output_path:
+        plt.savefig(output_path, bbox_inches='tight')
+        print(f"Jitter plot saved to {output_path}")
+    else:
+        plt.show()
+
+    return balanced_df
+
+def create_grouped_plot(df, grouping_column, data_column, graph_type='bar', summary_func='mean', order=None, colors=None, output_dir='./output', save=False, y_axis_start=None, error_bar_type='std'):
+    """
+    Create a grouped plot, perform statistical tests, and optionally export the results along with the plot.
+
+    Parameters:
+    - df: DataFrame containing the data.
+    - grouping_column: Column name for the categorical grouping.
+    - data_column: Column name for the data to be grouped and plotted.
+    - graph_type: Type of plot ('bar', 'violin', 'jitter', 'box', 'jitter_box').
+    - summary_func: Summary function to apply to each group ('mean', 'median', etc.).
+    - order: List specifying the order of the groups. If None, groups will be ordered alphabetically.
+    - colors: List of colors for each group.
+    - output_dir: Directory where the figure and test results will be saved if `save=True`.
+    - save: Boolean flag indicating whether to save the plot and results to files.
+    - y_axis_start: Optional starting value for the y-axis.
+    - error_bar_type: Type of error bars to plot, either 'std' for standard deviation or 'sem' for standard error of the mean.
+
+    Outputs:
+    - Figure of the plot.
+    - DataFrame with full statistical test results, including normality tests.
+    """
+    
+    # Remove NaN rows in grouping_column
+    df = df.dropna(subset=[grouping_column])
+    
+    # Ensure the output directory exists if save is True
+    if save:
+        os.makedirs(output_dir, exist_ok=True)
+    
+    # Sorting and ordering
+    if order:
+        df[grouping_column] = pd.Categorical(df[grouping_column], categories=order, ordered=True)
+    else:
+        df[grouping_column] = pd.Categorical(df[grouping_column], categories=sorted(df[grouping_column].unique()), ordered=True)
+    
+    # Get unique groups
+    unique_groups = df[grouping_column].unique()
+    
+    # Initialize test results
+    test_results = []
+
+    # Test normality for each group
+    grouped_data = [df.loc[df[grouping_column] == group, data_column] for group in unique_groups]
+    normal_p_values = [normaltest(data).pvalue for data in grouped_data]
+    normal_stats = [normaltest(data).statistic for data in grouped_data]
+    is_normal = all(p > 0.05 for p in normal_p_values)
+
+    # Add normality test results to the results_df
+    for group, stat, p_value in zip(unique_groups, normal_stats, normal_p_values):
+        test_results.append({
+            'Comparison': f'Normality test for {group}',
+            'Test Statistic': stat,
+            'p-value': p_value,
+            'Test Name': 'Normality test'
+        })
+
+    # Determine statistical test
+    if len(unique_groups) == 2:
+        if is_normal:
+            stat_test = ttest_ind
+            test_name = 'T-test'
+        else:
+            stat_test = mannwhitneyu
+            test_name = 'Mann-Whitney U test'
+    else:
+        if is_normal:
+            stat_test = f_oneway
+            test_name = 'One-way ANOVA'
+        else:
+            stat_test = kruskal
+            test_name = 'Kruskal-Wallis test'
+
+    # Perform pairwise statistical tests
+    comparisons = list(itertools.combinations(unique_groups, 2))
+    p_values = []
+    test_statistics = []
+
+    for (group1, group2) in comparisons:
+        data1 = df[df[grouping_column] == group1][data_column]
+        data2 = df[df[grouping_column] == group2][data_column]
+        stat, p = stat_test(data1, data2)
+        p_values.append(p)
+        test_statistics.append(stat)
+        test_results.append({'Comparison': f'{group1} vs {group2}', 'Test Statistic': stat, 'p-value': p, 'Test Name': test_name})
+    
+    # Post-hoc test (Tukey HSD for ANOVA)
+    posthoc_p_values = None
+    if is_normal and len(unique_groups) > 2:
+        tukey_result = pairwise_tukeyhsd(df[data_column], df[grouping_column], alpha=0.05)
+        posthoc_p_values = tukey_result.pvalues
+        for comparison, p_value in zip(tukey_result._results_table.data[1:], tukey_result.pvalues):
+            test_results.append({
+                'Comparison': f'{comparison[0]} vs {comparison[1]}',
+                'Test Statistic': None,  # Tukey does not provide a test statistic in the same way
+                'p-value': p_value,
+                'Test Name': 'Tukey HSD Post-hoc'
+            })
+
+    # Create plot
+    plt.figure(figsize=(10, 6))
+    sns.set(style="whitegrid")
+
+    if colors:
+        color_palette = colors
+    else:
+        color_palette = sns.color_palette("husl", len(unique_groups))
+    
+    # Choose graph type
+    if graph_type == 'bar':
+        summary_df = df.groupby(grouping_column)[data_column].agg([summary_func, 'std', 'sem'])
+        
+        # Set error bars based on error_bar_type
+        if error_bar_type == 'std':
+            error_bars = summary_df['std']
+        elif error_bar_type == 'sem':
+            error_bars = summary_df['sem']
+        else:
+            raise ValueError(f"Invalid error_bar_type: {error_bar_type}. Choose either 'std' or 'sem'.")
+
+        sns.barplot(x=grouping_column, y=summary_func, data=summary_df.reset_index(), ci=None, order=order, palette=color_palette)
+
+        # Add error bars (standard deviation or standard error of the mean)
+        plt.errorbar(x=np.arange(len(summary_df)), y=summary_df[summary_func], yerr=error_bars, fmt='none', c='black', capsize=5)
+    
+    elif graph_type == 'violin':
+        sns.violinplot(x=grouping_column, y=data_column, data=df, order=order, palette=color_palette)
+    elif graph_type == 'jitter':
+        sns.stripplot(x=grouping_column, y=data_column, data=df, jitter=True, order=order, palette=color_palette)
+    elif graph_type == 'box':
+        sns.boxplot(x=grouping_column, y=data_column, data=df, order=order, palette=color_palette)
+    elif graph_type == 'jitter_box':
+        sns.boxplot(x=grouping_column, y=data_column, data=df, order=order, palette=color_palette)
+        sns.stripplot(x=grouping_column, y=data_column, data=df, jitter=True, color='black', alpha=0.5, order=order)
+
+    # Create a DataFrame to summarize the test results
+    results_df = pd.DataFrame(test_results)
+
+    # Set y-axis start if provided
+    if y_axis_start is not None:
+        plt.ylim(bottom=y_axis_start)
+    else:
+        plt.ylim(0, None)  # Default to starting at 0 if no custom start value is provided
+
+    # If save is True, save the plot and results as PNG and CSV
+    if save:
+        # Save the plot as PNG
+        plot_path = os.path.join(output_dir, 'grouped_plot.png')
+        plt.title(f'{test_name} results for {graph_type} plot')
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        plt.savefig(plot_path)
+        print(f"Plot saved to {plot_path}")
+
+        # Save the test results as a CSV file
+        results_path = os.path.join(output_dir, 'test_results.csv')
+        results_df.to_csv(results_path, index=False)
+        print(f"Test results saved to {results_path}")
+
+    # Show the plot
+    plt.show()
+
+    return plt.gcf(), results_df
+    
+class spacrGraph:
+    def __init__(self, df, grouping_column, data_column, graph_type='bar', summary_func='mean', 
+                 order=None, colors=None, output_dir='./output', save=False, y_axis_start=None, 
+                 error_bar_type='std', remove_outliers=False, theme='pastel', representation='object',
+                 paired=False, all_to_all=True, compare_group=None):
+        """
+        Class for creating grouped plots with optional statistical tests and data preprocessing.
+        """
+        self.df = df
+        self.grouping_column = grouping_column
+        self.data_column = data_column
+        self.graph_type = graph_type
+        self.summary_func = summary_func
+        self.order = order
+        self.colors = colors
+        self.output_dir = output_dir
+        self.save = save
+        self.y_axis_start = y_axis_start
+        self.error_bar_type = error_bar_type
+        self.remove_outliers = remove_outliers
+        self.theme = theme
+        self.representation = representation
+        self.paired = paired
+        self.all_to_all = all_to_all
+        self.compare_group = compare_group
+
+        self.results_df = pd.DataFrame()
+        self.sns_palette = None
+        self.fig = None  # To store the generated figure
+        
+        # Preprocess and set palette
+        self._set_theme()
+        self.raw_df = self.df.copy()  # Preserve the raw data for n_object count
+        self.df = self.preprocess_data()
+        
+    def _set_theme(self):
+        """Set the Seaborn theme and reorder colors if necessary."""
+        integer_list = list(range(1, 81))
+        color_order = [0, 3, 9, 4, 6, 7, 9, 2] + integer_list
+        self.sns_palette = self._set_reordered_theme(self.theme, color_order, 100)
+
+    def _set_reordered_theme(self, theme='muted', order=None, n_colors=100, show_theme=False):
+        """Set and reorder the Seaborn color palette."""
+        palette = sns.color_palette(theme, n_colors)
+        if order:
+            reordered_palette = [palette[i] for i in order]
+        else:
+            reordered_palette = palette
+        if show_theme:
+            sns.palplot(reordered_palette)
+            plt.show()
+        return reordered_palette
+
+    def preprocess_data(self):
+        """Preprocess the data: remove NaNs, sort/order the grouping column, and optionally group by 'prc'."""
+        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.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 remove_outliers_from_plot(self):
+        """Remove outliers from the plot but keep them in the data."""
+        filtered_df = self.df.copy()
+        unique_groups = filtered_df[self.grouping_column].unique()
+        for group in unique_groups:
+            group_data = filtered_df[filtered_df[self.grouping_column] == group][self.data_column]
+            q1 = group_data.quantile(0.25)
+            q3 = group_data.quantile(0.75)
+            iqr = q3 - q1
+            lower_bound = q1 - 1.5 * iqr
+            upper_bound = q3 + 1.5 * iqr
+            filtered_df = filtered_df.drop(filtered_df[(filtered_df[self.grouping_column] == group) & ((filtered_df[self.data_column] < lower_bound) | (filtered_df[self.data_column] > upper_bound))].index)
+        return filtered_df
+
+    def perform_normality_tests(self):
+        """Perform normality tests for each group."""
+        unique_groups = self.df[self.grouping_column].unique()
+        grouped_data = [self.df.loc[self.df[self.grouping_column] == group, self.data_column] for group in unique_groups]
+        raw_grouped_data = [self.raw_df.loc[self.raw_df[self.grouping_column] == group, self.data_column] for group in unique_groups]
+        
+        normal_p_values = [normaltest(data).pvalue for data in grouped_data]
+        normal_stats = [normaltest(data).statistic for data in grouped_data]
+        is_normal = all(p > 0.05 for p in normal_p_values)
+
+        test_results = []
+        for group, stat, p_value in zip(unique_groups, normal_stats, normal_p_values):
+            test_results.append({
+                'Comparison': f'Normality test for {group}',
+                'Test Statistic': stat,
+                'p-value': p_value,
+                'Test Name': 'Normality test',
+                'n_object': len(raw_grouped_data[unique_groups.tolist().index(group)]),  # Raw sample size (objects/cells)
+                'n_well': len(grouped_data[unique_groups.tolist().index(group)]) if self.representation == 'well' else np.nan  # Summarized size (wells)
+            })
+        return is_normal, test_results
+
+    def perform_levene_test(self, unique_groups):
+        """Perform Levene's test for equal variance."""
+        grouped_data = [self.df.loc[self.df[self.grouping_column] == group, self.data_column] for group in unique_groups]
+        stat, p_value = levene(*grouped_data)
+        return stat, p_value
+
+    def perform_statistical_tests(self, unique_groups, is_normal):
+        """Perform statistical tests based on the number of groups, normality, and paired flag."""
+        if len(unique_groups) == 2:
+            if is_normal:
+                if self.paired:
+                    stat_test = pg.ttest  # Paired T-test
+                    test_name = 'Paired T-test'
+                else:
+                    stat_test = ttest_ind
+                    test_name = 'T-test'
+            else:
+                if self.paired:
+                    stat_test = pg.wilcoxon  # Paired Wilcoxon test
+                    test_name = 'Paired Wilcoxon test'
+                else:
+                    stat_test = mannwhitneyu
+                    test_name = 'Mann-Whitney U test'
+        else:
+            if is_normal:
+                stat_test = f_oneway
+                test_name = 'One-way ANOVA'
+            else:
+                stat_test = kruskal
+                test_name = 'Kruskal-Wallis test'
+
+        comparisons = list(itertools.combinations(unique_groups, 2))
+        test_results = []
+        for (group1, group2) in comparisons:
+            data1 = self.df[self.df[self.grouping_column] == group1][self.data_column]
+            data2 = self.df[self.df[self.grouping_column] == group2][self.data_column]
+            raw_data1 = self.raw_df[self.raw_df[self.grouping_column] == group1][self.data_column]
+            raw_data2 = self.raw_df[self.raw_df[self.grouping_column] == group2][self.data_column]
+            
+            if self.paired:
+                stat, p = stat_test(data1, data2, paired=True)
+            else:
+                stat, p = stat_test(data1, data2)
+
+            test_results.append({
+                'Comparison': f'{group1} vs {group2}',
+                'Test Statistic': stat,
+                'p-value': p,
+                'Test Name': test_name,
+                'n_object': len(raw_data1) + len(raw_data2),  # Raw sample size (objects/cells)
+                'n_well': len(data1) + len(data2) if self.representation == 'well' else np.nan  # Summarized size (wells)
+            })
+        return test_results
+
+    def perform_posthoc_tests(self, is_normal, unique_groups):
+        """Perform post-hoc tests for multiple groups based on all_to_all flag."""
+        if is_normal and len(unique_groups) > 2 and self.all_to_all:
+            # Tukey HSD Post-hoc when comparing all to all
+            tukey_result = pairwise_tukeyhsd(self.df[self.data_column], self.df[self.grouping_column], alpha=0.05)
+            posthoc_results = []
+            for comparison, p_value in zip(tukey_result._results_table.data[1:], tukey_result.pvalues):
+                raw_data1 = self.raw_df[self.raw_df[self.grouping_column] == comparison[0]][self.data_column]
+                raw_data2 = self.raw_df[self.raw_df[self.grouping_column] == comparison[1]][self.data_column]
+
+                posthoc_results.append({
+                    'Comparison': f'{comparison[0]} vs {comparison[1]}',
+                    'Test Statistic': None,  # Tukey does not provide a test statistic
+                    'p-value': p_value,
+                    'Test Name': 'Tukey HSD Post-hoc',
+                    'n_object': len(raw_data1) + len(raw_data2),
+                    'n_well': len(self.df[self.df[self.grouping_column] == comparison[0]]) + len(self.df[self.df[self.grouping_column] == comparison[1]])
+                })
+            return posthoc_results
+       
+        elif len(unique_groups) > 2 and not self.all_to_all and self.compare_group:
+            # Dunn's post-hoc test using Pingouin
+            dunn_result = pg.pairwise_tests(data=self.df, dv=self.data_column, between=self.grouping_column, padjust='bonf', test='dunn')
+            posthoc_results = []
+            for idx, row in dunn_result.iterrows():
+                if row['A'] == self.compare_group or row['B'] == self.compare_group:
+                    posthoc_results.append({
+                        'Comparison': f"{row['A']} vs {row['B']}",
+                        'Test Statistic': row['T'],  # Test statistic from Dunn's test
+                        'p-value': row['p-val'],
+                        'Test Name': 'Dunn’s Post-hoc',
+                        'n_object': None,
+                        'n_well': None
+                    })
+            return posthoc_results
+        return []
+
+    def create_plot(self, ax=None):
+        """Create and display the plot based on the chosen graph type."""
+        # Optional: Remove outliers for plotting
+        if self.remove_outliers:
+            self.df = self.remove_outliers_from_plot()
+
+        # Perform normality tests
+        is_normal, normality_results = self.perform_normality_tests()
+
+        # Perform Levene's test for equal variance
+        unique_groups = self.df[self.grouping_column].unique()
+        levene_stat, levene_p = self.perform_levene_test(unique_groups)
+        levene_result = {
+            'Comparison': 'Levene’s test for equal variance',
+            'Test Statistic': levene_stat,
+            'p-value': levene_p,
+            'Test Name': 'Levene’s Test'
+        }
+
+        # Perform statistical tests
+        stat_results = self.perform_statistical_tests(unique_groups, is_normal)
+
+        # Perform post-hoc tests if applicable
+        posthoc_results = self.perform_posthoc_tests(is_normal, unique_groups)
+
+        # Combine all test results
+        self.results_df = pd.DataFrame(normality_results + [levene_result] + stat_results + posthoc_results)
+
+        # Add sample size column
+        sample_sizes = self.df.groupby(self.grouping_column)[self.data_column].count().reset_index(name='n')
+        self.results_df['n'] = self.results_df['Comparison'].apply(
+            lambda x: next((sample_sizes[sample_sizes[self.grouping_column] == g]['n'].values[0] for g in sample_sizes[self.grouping_column] if g in x), np.nan)
+        )
+
+        # Dynamically set figure dimensions based on the number of unique groups
+        num_groups = len(unique_groups)
+        bar_width = 0.6  # Set the desired thickness of each bar
+        spacing_between_groups = 0.3  # Set the desired spacing between bars and axis
+
+        fig_width = num_groups * (bar_width + spacing_between_groups)  # Dynamically calculate the figure width
+        fig_height = 6  # Fixed height for the plot
+
+        if ax is None:
+            self.fig, ax = plt.subplots(figsize=(fig_width, fig_height))  # Store the figure in self.fig
+        else:
+            self.fig = ax.figure  # Store the figure if ax is provided
+
+        sns.set(style="ticks")
+        color_palette = self.sns_palette if not self.colors else self.colors
+
+        # Calculate x-axis limits to ensure equal space between the bars and the y-axis
+        xlim_lower = -0.5  # Ensures space between the y-axis and the first category
+        xlim_upper = num_groups - 0.5  # Ensures space after the last category
+        ax.set_xlim(xlim_lower, xlim_upper)
+
+        if self.summary_func is None:
+            sns.stripplot(x=self.grouping_column, y=self.data_column, data=self.df, palette=color_palette, jitter=True, alpha=0.6, ax=ax)
+        elif self.graph_type == 'bar':
+            self._create_bar_plot(bar_width, ax)
+        elif self.graph_type == 'box':
+            self._create_box_plot(ax)
+        elif self.graph_type == 'violin':
+            self._create_violin_plot(ax)
+        elif self.graph_type == 'jitter':
+            self._create_jitter_plot(ax)
+        else:
+            raise ValueError(f"Invalid graph_type: {self.graph_type}. Choose from 'bar', 'box', 'violin', or 'jitter'.")
+
+        # Set y-axis start
+        if self.y_axis_start is not None:
+            ax.set_ylim(bottom=self.y_axis_start)
+
+        # Add ticks, remove grid, and save plot
+        ax.minorticks_on()
+        ax.tick_params(axis='x', which='minor', bottom=False)  # Disable minor ticks on x-axis
+        ax.tick_params(axis='x', which='major', length=6, width=2, direction='out')
+        ax.tick_params(axis='y', which='major', length=6, width=2, direction='out')
+        ax.tick_params(axis='y', which='minor', length=4, width=1, direction='out')
+        sns.despine(ax=ax, top=True, right=True)
+
+        if self.save:
+            self._save_results()
+
+        plt.show()  # Ensure the plot is shown, but plt.show() doesn't clear the figure context
+
+    def get_figure(self):
+        """Return the generated figure."""
+        return self.fig
+
+    def _create_bar_plot(self, bar_width, ax):
+        """Helper method to create a bar plot with consistent bar thickness and centered error bars."""
+        summary_df = self.df.groupby(self.grouping_column)[self.data_column].agg([self.summary_func, 'std', 'sem'])
+
+        if self.error_bar_type == 'std':
+            error_bars = summary_df['std']
+        elif self.error_bar_type == 'sem':
+            error_bars = summary_df['sem']
+        else:
+            raise ValueError(f"Invalid error_bar_type: {self.error_bar_type}. Choose either 'std' or 'sem'.")
+
+        sns.barplot(x=self.grouping_column, y=self.summary_func, data=summary_df.reset_index(), ci=None, palette=self.sns_palette, width=bar_width, ax=ax)
+
+        # Plot the error bars
+        ax.errorbar(x=np.arange(len(summary_df)), y=summary_df[self.summary_func], yerr=error_bars, fmt='none', c='black', capsize=5)
+
+    def _create_jitter_plot(self, ax):
+        """Helper method to create a jitter plot (strip plot)."""
+        sns.stripplot(x=self.grouping_column, y=self.data_column, data=self.df, palette=self.sns_palette, jitter=True, alpha=0.6, ax=ax)
+
+    def _create_box_plot(self, ax):
+        """Helper method to create a box plot."""
+        sns.boxplot(x=self.grouping_column, y=self.data_column, data=self.df, palette=self.sns_palette, ax=ax)
+
+    def _create_violin_plot(self, ax):
+        """Helper method to create a violin plot."""
+        sns.violinplot(x=self.grouping_column, y=self.data_column, data=self.df, palette=self.sns_palette, ax=ax)
+
+    def _save_results(self):
+        """Helper method to save the plot and results."""
+        os.makedirs(self.output_dir, exist_ok=True)
+        plot_path = os.path.join(self.output_dir, 'grouped_plot.png')
+        self.fig.savefig(plot_path)
+        results_path = os.path.join(self.output_dir, 'test_results.csv')
+        self.results_df.to_csv(results_path, index=False)
+        print(f"Plot saved to {plot_path}")
+        print(f"Test results saved to {results_path}")
+
+    def get_results(self):
+        """Return the results dataframe."""
+        return self.results_df