spacr 0.3.64__py3-none-any.whl → 0.3.66__py3-none-any.whl

spacr/__init__.py

@@ -27,6 +27,7 @@ from . import openai
 from . import ml
 from . import toxo
 from . import cellpose
+from . import stats
 from . import logger
 
 __all__ = [
@@ -57,6 +58,7 @@ __all__ = [
     "ml",
     "toxo",
     "cellpose",
+    "stats",
     "logger"
 ]
 

spacr/io.py

@@ -2445,7 +2445,7 @@ def _read_and_merge_data_v1(locs, tables, verbose=False, nuclei_limit=False, pat
         
     return merged_df, obj_df_ls 
 
-def _read_and_merge_data(locs, tables, verbose=False, nuclei_limit=10, pathogen_limit=10):
+def _read_and_merge_data(locs, tables, verbose=False, nuclei_limit=10, pathogen_limit=10, change_plate=False):
     from .io import _read_db
     from .utils import _split_data
 
@@ -2453,8 +2453,10 @@ def _read_and_merge_data(locs, tables, verbose=False, nuclei_limit=10, pathogen_
     data_dict = {table: [] for table in tables}
 
     # Extract plate DataFrames
-    for loc in locs:
+    for idx, loc in enumerate(locs):
         db_dfs = _read_db(loc, tables)
+        if change_plate:
+            db_dfs['plate'] = f'plate{idx}'
         for table, df in zip(tables, db_dfs):
             data_dict[table].append(df)
 

spacr/plot.py

@@ -17,7 +17,7 @@ from skimage.measure import find_contours, label, regionprops
 from skimage.segmentation import mark_boundaries
 from skimage.transform import resize as sk_resize
 import scikit_posthocs as sp
-
+from scipy.stats import chi2_contingency
 import tifffile as tiff
 
 from scipy.stats import normaltest, ttest_ind, mannwhitneyu, f_oneway, kruskal
@@ -2609,7 +2609,7 @@ class spacrGraph:
     def perform_posthoc_tests(self, is_normal, unique_groups):
         """Perform post-hoc tests for multiple groups based on all_to_all flag."""
 
-        from .utils import choose_p_adjust_method
+        from .stats import choose_p_adjust_method
 
         posthoc_results = []
         if is_normal and len(unique_groups) > 2 and self.all_to_all:
@@ -3736,3 +3736,79 @@ def graph_importance(settings):
     # Get the figure object if needed
     fig = spacr_graph.get_figure()
     plt.show()
+    
+def plot_proportion_stacked_bars(settings, df, group_column, bin_column, prc_column='prc', level='object', cmap='viridis'):
+    """
+    Generate a stacked bar plot for proportions and perform chi-squared and pairwise tests.
+    
+    Parameters:
+    - settings (dict): Analysis settings.
+    - df (DataFrame): Input data.
+    - group_column (str): Column indicating the groups.
+    - bin_column (str): Column indicating the categories.
+    - prc_column (str): Optional; column for additional stratification.
+    - level (str): Level of aggregation ('well' or 'object').
+    
+    Returns:
+    - chi2 (float): Chi-squared statistic for the overall test.
+    - p (float): p-value for the overall chi-squared test.
+    - dof (int): Degrees of freedom for the overall chi-squared test.
+    - expected (ndarray): Expected frequencies for the overall chi-squared test.
+    - raw_counts (DataFrame): Contingency table of observed counts.
+    - fig (Figure): The generated plot.
+    - pairwise_results (list): Pairwise test results from `chi_pairwise`.
+    """
+    
+    from .stats import chi_pairwise
+    
+    # Calculate contingency table for overall chi-squared test
+    raw_counts = df.groupby([group_column, bin_column]).size().unstack(fill_value=0)
+    chi2, p, dof, expected = chi2_contingency(raw_counts)
+    print(f"Chi-squared test statistic (raw data): {chi2:.4f}")
+    print(f"p-value (raw data): {p:.4e}")
+
+    # Perform pairwise comparisons
+    pairwise_results = chi_pairwise(raw_counts, verbose=settings.get('verbose', False))
+
+    # Plot based on level setting
+    if level == 'well':
+        # Aggregate by well for mean ± SD visualization
+        well_proportions = (
+            df.groupby([group_column, prc_column, bin_column])
+            .size()
+            .groupby(level=[0, 1])
+            .apply(lambda x: x / x.sum())
+            .unstack(fill_value=0)
+        )
+        mean_proportions = well_proportions.groupby(group_column).mean()
+        std_proportions = well_proportions.groupby(group_column).std()
+
+        ax = mean_proportions.plot(
+            kind='bar', stacked=True, yerr=std_proportions, capsize=5, colormap=cmap, figsize=(12, 8)
+        )
+        plt.title('Proportion of Volume Bins by Group (Mean ± SD across wells)')
+    else:
+        # Object-level plotting without aggregation
+        group_counts = df.groupby([group_column, bin_column]).size()
+        group_totals = group_counts.groupby(level=0).sum()
+        proportions = group_counts / group_totals
+        proportion_df = proportions.unstack(fill_value=0)
+
+        ax = proportion_df.plot(kind='bar', stacked=True, colormap=cmap, figsize=(12, 8))
+        plt.title('Proportion of Volume Bins by Group')
+
+    plt.xlabel('Group')
+    plt.ylabel('Proportion')
+
+    # Update legend with formatted labels, maintaining correct order
+    plt.legend(title=f'Classes', bbox_to_anchor=(1.05, 1), loc='upper left')
+    plt.ylim(0, 1)
+    fig = plt.gcf()
+    
+    results_df = pd.DataFrame({
+        'chi_squared_stat': [chi2],
+        'p_value': [p],
+        'degrees_of_freedom': [dof]
+    })
+
+    return results_df, pairwise_results, fig

spacr/settings.py

@@ -1415,6 +1415,8 @@ def set_analyze_endodyogeny_defaults(settings):
     settings.setdefault('um_per_px',0.1)
     settings.setdefault('max_bins',None)
     settings.setdefault('save',False)
+    settings.setdefault('change_plate',False)
+    settings.setdefault('cmap','viridis')
     settings.setdefault('verbose',False)
     return settings
 

spacr/stats.py

@@ -0,0 +1,221 @@
+from scipy.stats import shapiro, normaltest, levene, ttest_ind, mannwhitneyu, kruskal, f_oneway
+from statsmodels.stats.multicomp import pairwise_tukeyhsd
+import scikit_posthocs as sp
+import numpy as np
+import pandas as pd
+from scipy.stats import chi2_contingency, fisher_exact
+import itertools
+from statsmodels.stats.multitest import multipletests
+
+
+def choose_p_adjust_method(num_groups, num_data_points):
+    """
+    Selects the most appropriate p-value adjustment method based on data characteristics.
+    
+    Parameters:
+    - num_groups: Number of unique groups being compared
+    - num_data_points: Number of data points per group (assuming balanced groups)
+    
+    Returns:
+    - A string representing the recommended p-adjustment method
+    """
+    num_comparisons = (num_groups * (num_groups - 1)) // 2  # Number of pairwise comparisons
+
+    # Decision logic for choosing the adjustment method
+    if num_comparisons <= 10 and num_data_points > 5:
+        return 'holm'  # Balanced between power and Type I error control
+    elif num_comparisons > 10 and num_data_points <= 5:
+        return 'fdr_bh'  # FDR control for large number of comparisons and small sample size
+    elif num_comparisons <= 10:
+        return 'sidak'  # Less conservative than Bonferroni, good for independent comparisons
+    else:
+        return 'bonferroni'  # Very conservative, use for strict control of Type I errors
+
+def perform_normality_tests(df, grouping_column, data_columns):
+    """Perform normality tests for each group and data column."""
+    unique_groups = df[grouping_column].unique()
+    normality_results = []
+
+    for column in data_columns:
+        for group in unique_groups:
+            data = df.loc[df[grouping_column] == group, column].dropna()
+            n_samples = len(data)
+
+            if n_samples < 3:
+                # Skip test if there aren't enough data points
+                print(f"Skipping normality test for group '{group}' on column '{column}' - Not enough data.")
+                normality_results.append({
+                    'Comparison': f'Normality test for {group} on {column}',
+                    'Test Statistic': None,
+                    'p-value': None,
+                    'Test Name': 'Skipped',
+                    'Column': column,
+                    'n': n_samples
+                })
+                continue
+
+            # Choose the appropriate normality test based on the sample size
+            if n_samples >= 8:
+                stat, p_value = normaltest(data)
+                test_name = "D'Agostino-Pearson test"
+            else:
+                stat, p_value = shapiro(data)
+                test_name = "Shapiro-Wilk test"
+
+            normality_results.append({
+                'Comparison': f'Normality test for {group} on {column}',
+                'Test Statistic': stat,
+                'p-value': p_value,
+                'Test Name': test_name,
+                'Column': column,
+                'n': n_samples
+            })
+
+        # Check if all groups are normally distributed (p > 0.05)
+        normal_p_values = [result['p-value'] for result in normality_results if result['Column'] == column and result['p-value'] is not None]
+        is_normal = all(p > 0.05 for p in normal_p_values)
+
+    return is_normal, normality_results
+
+
+def perform_levene_test(df, grouping_column, data_column):
+    """Perform Levene's test for equal variance."""
+    unique_groups = df[grouping_column].unique()
+    grouped_data = [df.loc[df[grouping_column] == group, data_column].dropna() for group in unique_groups]
+    stat, p_value = levene(*grouped_data)
+    return stat, p_value
+
+def perform_statistical_tests(df, grouping_column, data_columns, paired=False):
+    """Perform statistical tests for each data column."""
+    unique_groups = df[grouping_column].unique()
+    test_results = []
+
+    for column in data_columns:
+        grouped_data = [df.loc[df[grouping_column] == group, column].dropna() for group in unique_groups]
+        if len(unique_groups) == 2:  # For two groups
+            if paired:
+                print("Performing paired tests (not implemented in this template).")
+                continue  # Extend as needed
+            else:
+                # Check normality for two groups
+                is_normal, _ = perform_normality_tests(df, grouping_column, [column])
+                if is_normal:
+                    stat, p = ttest_ind(grouped_data[0], grouped_data[1])
+                    test_name = 'T-test'
+                else:
+                    stat, p = mannwhitneyu(grouped_data[0], grouped_data[1])
+                    test_name = 'Mann-Whitney U test'
+        else:
+            # Check normality for multiple groups
+            is_normal, _ = perform_normality_tests(df, grouping_column, [column])
+            if is_normal:
+                stat, p = f_oneway(*grouped_data)
+                test_name = 'One-way ANOVA'
+            else:
+                stat, p = kruskal(*grouped_data)
+                test_name = 'Kruskal-Wallis test'
+
+        test_results.append({
+            'Column': column,
+            'Test Name': test_name,
+            'Test Statistic': stat,
+            'p-value': p,
+            'Groups': len(unique_groups)
+        })
+
+    return test_results
+
+
+def perform_posthoc_tests(df, grouping_column, data_column, is_normal):
+    """Perform post-hoc tests for multiple groups with both original and adjusted p-values."""
+    unique_groups = df[grouping_column].unique()
+    posthoc_results = []
+
+    if len(unique_groups) > 2:
+        num_groups = len(unique_groups)
+        num_data_points = len(df[data_column].dropna()) // num_groups  # Assuming roughly equal data points per group
+        p_adjust_method = choose_p_adjust_method(num_groups, num_data_points)
+
+        if is_normal:
+            # Tukey's HSD automatically adjusts p-values
+            tukey_result = pairwise_tukeyhsd(df[data_column], df[grouping_column], alpha=0.05)
+            for comparison, p_value in zip(tukey_result._results_table.data[1:], tukey_result.pvalues):
+                posthoc_results.append({
+                    'Comparison': f"{comparison[0]} vs {comparison[1]}",
+                    'Original p-value': None,  # Tukey HSD does not provide raw p-values
+                    'Adjusted p-value': p_value,
+                    'Adjusted Method': 'Tukey HSD',
+                    'Test Name': 'Tukey HSD'
+                })
+        else:
+            # Dunn's test with p-value adjustment
+            raw_dunn_result = sp.posthoc_dunn(df, val_col=data_column, group_col=grouping_column, p_adjust=None)
+            adjusted_dunn_result = sp.posthoc_dunn(df, val_col=data_column, group_col=grouping_column, p_adjust=p_adjust_method)
+            for i, group_a in enumerate(adjusted_dunn_result.index):
+                for j, group_b in enumerate(adjusted_dunn_result.columns):
+                    if i < j:  # Only consider unique pairs
+                        posthoc_results.append({
+                            'Comparison': f"{group_a} vs {group_b}",
+                            'Original p-value': raw_dunn_result.iloc[i, j],
+                            'Adjusted p-value': adjusted_dunn_result.iloc[i, j],
+                            'Adjusted Method': p_adjust_method,
+                            'Test Name': "Dunn's Post-hoc"
+                        })
+
+    return posthoc_results
+
+def chi_pairwise(raw_counts, verbose=False):
+    """
+    Perform pairwise chi-square or Fisher's exact tests between all unique group pairs
+    and apply p-value correction.
+
+    Parameters:
+    - raw_counts (DataFrame): Contingency table with group-wise counts.
+    - verbose (bool): Whether to print results for each pair.
+
+    Returns:
+    - pairwise_df (DataFrame): DataFrame with pairwise test results, including corrected p-values.
+    """
+    pairwise_results = []
+    groups = raw_counts.index.unique()  # Use index from raw_counts for group pairs
+    raw_p_values = []  # Store raw p-values for correction later
+    
+    # Calculate the number of groups and average number of data points per group
+    num_groups = len(groups)
+    num_data_points = raw_counts.sum(axis=1).mean()  # Average total data points per group
+    p_adjust_method = choose_p_adjust_method(num_groups, num_data_points)
+
+    for group1, group2 in itertools.combinations(groups, 2):
+        contingency_table = raw_counts.loc[[group1, group2]].values
+        if contingency_table.shape[1] == 2:  # Fisher's Exact Test for 2x2 tables
+            oddsratio, p_value = fisher_exact(contingency_table)
+            test_name = "Fisher's Exact Test"
+        else:  # Chi-Square Test for larger tables
+            chi2_stat, p_value, _, _ = chi2_contingency(contingency_table)
+            test_name = 'Pairwise Chi-Square Test'
+        
+        pairwise_results.append({
+            'Group 1': group1,
+            'Group 2': group2,
+            'Test Name': test_name,
+            'p-value': p_value
+        })
+        raw_p_values.append(p_value)
+
+    # Apply p-value correction
+    corrected_p_values = multipletests(raw_p_values, method=p_adjust_method)[1]
+
+    # Add corrected p-values to results
+    for i, result in enumerate(pairwise_results):
+        result['p-value_adj'] = corrected_p_values[i]
+
+    pairwise_df = pd.DataFrame(pairwise_results)
+    
+    pairwise_df['adj'] = p_adjust_method
+
+    if verbose:
+        # Print pairwise results
+        print("\nPairwise Frequency Analysis Results:")
+        print(pairwise_df.to_string(index=False))
+
+    return pairwise_df

spacr/submodules.py

@@ -847,11 +847,61 @@ def interperate_vision_model(settings={}):
         
     return output
 
+def _plot_proportion_stacked_bars(settings, df, group_column, bin_column, prc_column='prc', level='object'):
+    # Always calculate chi-squared on raw data
+    raw_counts = df.groupby([group_column, bin_column]).size().unstack(fill_value=0)
+    chi2, p, dof, expected = chi2_contingency(raw_counts)
+    print(f"Chi-squared test statistic (raw data): {chi2:.4f}")
+    print(f"p-value (raw data): {p:.4e}")
+
+    # Extract bin labels and indices for formatting the legend in the correct order
+    bin_labels = df[bin_column].cat.categories if pd.api.types.is_categorical_dtype(df[bin_column]) else sorted(df[bin_column].unique())
+    bin_indices = range(1, len(bin_labels) + 1)
+    legend_labels = [f"{index}: {label}" for index, label in zip(bin_indices, bin_labels)]
+
+    # Plot based on level setting
+    if level == 'well':
+        # Aggregate by well for mean ± SD visualization
+        well_proportions = (
+            df.groupby([group_column, prc_column, bin_column])
+            .size()
+            .groupby(level=[0, 1])
+            .apply(lambda x: x / x.sum())
+            .unstack(fill_value=0)
+        )
+        mean_proportions = well_proportions.groupby(group_column).mean()
+        std_proportions = well_proportions.groupby(group_column).std()
+
+        ax = mean_proportions.plot(
+            kind='bar', stacked=True, yerr=std_proportions, capsize=5, colormap='viridis', figsize=(12, 8)
+        )
+        plt.title('Proportion of Volume Bins by Group (Mean ± SD across wells)')
+    else:
+        # Object-level plotting without aggregation
+        group_counts = df.groupby([group_column, bin_column]).size()
+        group_totals = group_counts.groupby(level=0).sum()
+        proportions = group_counts / group_totals
+        proportion_df = proportions.unstack(fill_value=0)
+
+        ax = proportion_df.plot(kind='bar', stacked=True, colormap='viridis', figsize=(12, 8))
+        plt.title('Proportion of Volume Bins by Group')
+
+    plt.xlabel('Group')
+    plt.ylabel('Proportion')
+
+    # Update legend with formatted labels, maintaining correct order
+    volume_unit = "px³" if settings['um_per_px'] is None else "µm³"
+    plt.legend(legend_labels, title=f'Volume Range ({volume_unit})', bbox_to_anchor=(1.05, 1), loc='upper left')
+    plt.ylim(0, 1)
+    fig = plt.gcf() 
+    return chi2, p, dof, expected, raw_counts, fig
+
 def analyze_endodyogeny(settings):
     
     from .utils import annotate_conditions, save_settings
     from .io import _read_and_merge_data
     from .settings import set_analyze_endodyogeny_defaults
+    from .plot import plot_proportion_stacked_bars
 
     def _calculate_volume_bins(df, compartment='pathogen', min_area_bin=500, max_bins=None, verbose=False):
         area_column = f'{compartment}_area'
@@ -890,55 +940,6 @@ def analyze_endodyogeny(settings):
 
         return df
 
-    def _plot_proportion_stacked_bars(settings, df, group_column, bin_column, prc_column='prc', level='object'):
-        # Always calculate chi-squared on raw data
-        raw_counts = df.groupby([group_column, bin_column]).size().unstack(fill_value=0)
-        chi2, p, dof, expected = chi2_contingency(raw_counts)
-        print(f"Chi-squared test statistic (raw data): {chi2:.4f}")
-        print(f"p-value (raw data): {p:.4e}")
-
-        # Extract bin labels and indices for formatting the legend in the correct order
-        bin_labels = df[bin_column].cat.categories if pd.api.types.is_categorical_dtype(df[bin_column]) else sorted(df[bin_column].unique())
-        bin_indices = range(1, len(bin_labels) + 1)
-        legend_labels = [f"{index}: {label}" for index, label in zip(bin_indices, bin_labels)]
-
-        # Plot based on level setting
-        if level == 'well':
-            # Aggregate by well for mean ± SD visualization
-            well_proportions = (
-                df.groupby([group_column, prc_column, bin_column])
-                .size()
-                .groupby(level=[0, 1])
-                .apply(lambda x: x / x.sum())
-                .unstack(fill_value=0)
-            )
-            mean_proportions = well_proportions.groupby(group_column).mean()
-            std_proportions = well_proportions.groupby(group_column).std()
-
-            ax = mean_proportions.plot(
-                kind='bar', stacked=True, yerr=std_proportions, capsize=5, colormap='viridis', figsize=(12, 8)
-            )
-            plt.title('Proportion of Volume Bins by Group (Mean ± SD across wells)')
-        else:
-            # Object-level plotting without aggregation
-            group_counts = df.groupby([group_column, bin_column]).size()
-            group_totals = group_counts.groupby(level=0).sum()
-            proportions = group_counts / group_totals
-            proportion_df = proportions.unstack(fill_value=0)
-
-            ax = proportion_df.plot(kind='bar', stacked=True, colormap='viridis', figsize=(12, 8))
-            plt.title('Proportion of Volume Bins by Group')
-
-        plt.xlabel('Group')
-        plt.ylabel('Proportion')
-
-        # Update legend with formatted labels, maintaining correct order
-        volume_unit = "px³" if settings['um_per_px'] is None else "µm³"
-        plt.legend(legend_labels, title=f'Volume Range ({volume_unit})', bbox_to_anchor=(1.05, 1), loc='upper left')
-        plt.ylim(0, 1)
-        fig = plt.gcf() 
-        return chi2, p, dof, expected, raw_counts, fig
-    
     settings = set_analyze_endodyogeny_defaults(settings)
     save_settings(settings, name='analyze_endodyogeny', show=True)
     output = {}
@@ -951,13 +952,17 @@ def analyze_endodyogeny(settings):
     for s in settings['src']:
         loc = os.path.join(s, 'measurements/measurements.db')
         locs.append(loc)
+        
+    if 'png_list' not in settings['tables']:
+        settings['tables'] = settings['tables'] + ['png_list']
     
     df, _ = _read_and_merge_data(
         locs, 
         tables=settings['tables'], 
         verbose=settings['verbose'], 
         nuclei_limit=settings['nuclei_limit'], 
-        pathogen_limit=settings['pathogen_limit']
+        pathogen_limit=settings['pathogen_limit'],
+        change_plate=settings['change_plate']
     )
     
     if not settings['um_per_px'] is None:
@@ -984,32 +989,40 @@ def analyze_endodyogeny(settings):
     df = df.dropna(subset=[settings['group_column']])
     df = _calculate_volume_bins(df, settings['compartment'], settings['min_area_bin'], settings['max_bins'], settings['verbose'])
     output['data'] = df
+    
+    
+    if settings['level'] == 'plate':
+        prc_column = 'plate'
+    else:
+        prc_column = 'prc'
+    
     # Perform chi-squared test and plot
-    chi2, p, dof, expected, raw_counts, fig = _plot_proportion_stacked_bars(settings, df, settings['group_column'], bin_column=f"{settings['compartment']}_volume_bin", level=settings['level']
-    )
-
-    # Create a DataFrame with chi-squared test results and raw counts
-    results_df = pd.DataFrame({
-        'chi_squared_stat': [chi2],
-        'p_value': [p],
-        'degrees_of_freedom': [dof]
-    })
-
-    # Flatten and add expected counts to results_df
-    expected_df = pd.DataFrame(expected, index=raw_counts.index, columns=raw_counts.columns)
-    expected_flat = expected_df.stack().reset_index()
-    expected_flat.columns = [settings['group_column'], f"{settings['compartment']}_volume_bin", 'expected_count']
-    results_df = results_df.merge(expected_flat, how="cross")
+    results_df, pairwise_results_df, fig = plot_proportion_stacked_bars(settings, df, settings['group_column'], bin_column=f"{settings['compartment']}_volume_bin", prc_column=prc_column, level=settings['level'], cmap=settings['cmap'])
+    
+    # Extract bin labels and indices for formatting the legend in the correct order
+    bin_labels = df[f"{settings['compartment']}_volume_bin"].cat.categories if pd.api.types.is_categorical_dtype(df[f"{settings['compartment']}_volume_bin"]) else sorted(df[f"{settings['compartment']}_volume_bin"].unique())
+    bin_indices = range(1, len(bin_labels) + 1)
+    legend_labels = [f"{index}: {label}" for index, label in zip(bin_indices, bin_labels)]
+    
+    # Update legend with formatted labels, maintaining correct order
+    volume_unit = "px³" if settings['um_per_px'] is None else "µm³"
+    plt.legend(legend_labels, title=f'Volume Range ({volume_unit})', bbox_to_anchor=(1.05, 1), loc='upper left')
+    plt.ylim(0, 1)
+    
     output['chi_squared'] = results_df
 
     if settings['save']:
         # Save DataFrame to CSV
-        output_dir = os.path.join(settings['src'][0], 'results')
+        output_dir = os.path.join(settings['src'][0], 'results', 'analyze_endodyogeny')
         os.makedirs(output_dir, exist_ok=True)
         output_path = os.path.join(output_dir, 'chi_squared_results.csv')
+        output_path_data = os.path.join(output_dir, 'data.csv')
+        output_path_pairwise = os.path.join(output_dir, 'chi_squared_results.csv')
         output_path_fig = os.path.join(output_dir, 'chi_squared_results.pdf')
         fig.savefig(output_path_fig, dpi=300, bbox_inches='tight')
         results_df.to_csv(output_path, index=False)
+        df.to_csv(output_path_data, index=False)
+        pairwise_results_df.to_csv(output_path_pairwise, index=False)
         print(f"Chi-squared results saved to {output_path}")
         
     plt.show()     
@@ -1021,51 +1034,8 @@ def analyze_class_proportion(settings):
     from .utils import annotate_conditions, save_settings
     from .io import _read_and_merge_data
     from .settings import set_analyze_class_proportion_defaults
-    from .plot import plot_plates
-    
-    
-    def _plot_proportion_stacked_bars(settings, df, group_column, bin_column, prc_column='prc', level='object'):
-        # Always calculate chi-squared on raw data
-        raw_counts = df.groupby([group_column, bin_column]).size().unstack(fill_value=0)
-        chi2, p, dof, expected = chi2_contingency(raw_counts)
-        print(f"Chi-squared test statistic (raw data): {chi2:.4f}")
-        print(f"p-value (raw data): {p:.4e}")
-
-        # Plot based on level setting
-        if level == 'well':
-            # Aggregate by well for mean ± SD visualization
-            well_proportions = (
-                df.groupby([group_column, prc_column, bin_column])
-                .size()
-                .groupby(level=[0, 1])
-                .apply(lambda x: x / x.sum())
-                .unstack(fill_value=0)
-            )
-            mean_proportions = well_proportions.groupby(group_column).mean()
-            std_proportions = well_proportions.groupby(group_column).std()
-
-            ax = mean_proportions.plot(
-                kind='bar', stacked=True, yerr=std_proportions, capsize=5, colormap='viridis', figsize=(12, 8)
-            )
-            plt.title('Proportion of Volume Bins by Group (Mean ± SD across wells)')
-        else:
-            # Object-level plotting without aggregation
-            group_counts = df.groupby([group_column, bin_column]).size()
-            group_totals = group_counts.groupby(level=0).sum()
-            proportions = group_counts / group_totals
-            proportion_df = proportions.unstack(fill_value=0)
-
-            ax = proportion_df.plot(kind='bar', stacked=True, colormap='viridis', figsize=(12, 8))
-            plt.title('Proportion of Volume Bins by Group')
-
-        plt.xlabel('Group')
-        plt.ylabel('Proportion')
-
-        # Update legend with formatted labels, maintaining correct order
-        plt.legend(title=f'Classes', bbox_to_anchor=(1.05, 1), loc='upper left')
-        plt.ylim(0, 1)
-        fig = plt.gcf() 
-        return chi2, p, dof, expected, raw_counts, fig
+    from .plot import plot_plates, plot_proportion_stacked_bars
+    from .stats import perform_normality_tests, perform_levene_test, perform_statistical_tests, perform_posthoc_tests
     
     settings = set_analyze_class_proportion_defaults(settings)
     save_settings(settings, name='analyze_class_proportion', show=True)
@@ -1110,25 +1080,20 @@ def analyze_class_proportion(settings):
     output['data'] = df
     
     # Perform chi-squared test and plot
-    chi2, p, dof, expected, raw_counts, fig = _plot_proportion_stacked_bars(settings, df, settings['group_column'], bin_column=settings['class_column'], level=settings['level'])
-    
-    # Create a DataFrame with chi-squared test results and raw counts
-    results_df = pd.DataFrame({
-        'chi_squared_stat': [chi2],
-        'p_value': [p],
-        'degrees_of_freedom': [dof]
-    })
+    results_df, pairwise_results, fig = plot_proportion_stacked_bars(settings, df, settings['group_column'], bin_column=settings['class_column'], level=settings['level'])
     
     output['chi_squared'] = results_df
     
     if settings['save']:
-        output_dir = os.path.join(settings['src'][0], 'results')
+        output_dir = os.path.join(settings['src'][0], 'results', 'analyze_class_proportion')
         os.makedirs(output_dir, exist_ok=True)
         output_path_chi = os.path.join(output_dir, 'class_chi_squared_results.csv')
+        output_path_chi_pairwise = os.path.join(output_dir, 'class_frequency_test.csv')
         output_path_data = os.path.join(output_dir, 'class_chi_squared_data.csv')
         output_path_fig = os.path.join(output_dir, 'class_chi_squared.pdf')
         fig.savefig(output_path_fig, dpi=300, bbox_inches='tight')
         results_df.to_csv(output_path_chi, index=False)
+        pairwise_results.to_csv(output_path_chi_pairwise, index=False)
         df.to_csv(output_path_data, index=False)
         print(f"Chi-squared results saved to {output_path_chi}")
         print(f"Annotated data saved to {output_path_data}")
@@ -1141,4 +1106,29 @@ def analyze_class_proportion(settings):
         fig2.savefig(output_path_fig2, dpi=300, bbox_inches='tight')
     
     plt.show()
+    
+    # Perform normality, variance, and statistical tests
+    is_normal, normality_results = perform_normality_tests(df, settings['group_column'], [settings['class_column']])
+    variance_stat, variance_p = perform_levene_test(df, settings['group_column'], settings['class_column'])
+
+    print(f"Levene's test statistic: {variance_stat:.4f}, p-value: {variance_p:.4e}")
+    variance_results = {
+        'Test Statistic': variance_stat,
+        'p-value': variance_p,
+        'Test Name': "Levene's Test"
+    }
+
+    test_results = perform_statistical_tests(df, settings['group_column'], [settings['class_column']])
+    posthoc_results = perform_posthoc_tests(
+        df, settings['group_column'], settings['class_column'], is_normal=is_normal
+    )
+
+    # Save additional results
+    if settings['save']:
+        pd.DataFrame(normality_results).to_csv(os.path.join(output_dir, 'normality_results.csv'), index=False)
+        pd.DataFrame([variance_results]).to_csv(os.path.join(output_dir, 'variance_results.csv'), index=False)
+        pd.DataFrame(test_results).to_csv(os.path.join(output_dir, 'statistical_test_results.csv'), index=False)
+        pd.DataFrame(posthoc_results).to_csv(os.path.join(output_dir, 'posthoc_results.csv'), index=False)
+        print("Statistical analysis results saved.")
+
     return output

spacr/utils.py

@@ -5156,29 +5156,6 @@ def control_filelist(folder, mode='column', values=['01','02']):
     if mode is 'row_name':
         filtered_files = [file for file in files if file.split('_')[1][:1] in values]
     return filtered_files
-
-def choose_p_adjust_method(num_groups, num_data_points):
-    """
-    Selects the most appropriate p-value adjustment method based on data characteristics.
-    
-    Parameters:
-    - num_groups: Number of unique groups being compared
-    - num_data_points: Number of data points per group (assuming balanced groups)
-    
-    Returns:
-    - A string representing the recommended p-adjustment method
-    """
-    num_comparisons = (num_groups * (num_groups - 1)) // 2  # Number of pairwise comparisons
-
-    # Decision logic for choosing the adjustment method
-    if num_comparisons <= 10 and num_data_points > 5:
-        return 'holm'  # Balanced between power and Type I error control
-    elif num_comparisons > 10 and num_data_points <= 5:
-        return 'fdr_bh'  # FDR control for large number of comparisons and small sample size
-    elif num_comparisons <= 10:
-        return 'sidak'  # Less conservative than Bonferroni, good for independent comparisons
-    else:
-        return 'bonferroni'  # Very conservative, use for strict control of Type I errors
     
 def rename_columns_in_db(db_path):
     with sqlite3.connect(db_path) as conn:

{spacr-0.3.64.dist-info → spacr-0.3.66.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.3.64
+Version: 0.3.66
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson

{spacr-0.3.64.dist-info → spacr-0.3.66.dist-info}/RECORD

@@ -1,4 +1,4 @@
-spacr/__init__.py,sha256=CZtAdU5etLcb9dVmz-4Y7Hjhw3ubjMzfjG0L5ybyFVA,1592
+spacr/__init__.py,sha256=fvk5JfLpOqUA1W0yPcsVZnS9qbpXFOceFk09LKolVfw,1627
 spacr/__main__.py,sha256=bkAJJD2kjIqOP-u1kLvct9jQQCeUXzlEjdgitwi1Lm8,75
 spacr/app_annotate.py,sha256=W9eLPa_LZIvXsXx_-0iDFEU938LBDvRy6prXo0qF4KQ,2533
 spacr/app_classify.py,sha256=urTP_wlZ58hSyM5a19slYlBxN0PdC-9-ga0hvq8CGWc,165
@@ -15,20 +15,21 @@ spacr/gui.py,sha256=ARyn9Q_g8HoP-cXh1nzMLVFCKqthY4v2u9yORyaQqQE,8230
 spacr/gui_core.py,sha256=N7R7yvfK_dJhOReM_kW3Ci8Bokhi1OzsxeKqvSGdvV4,41460
 spacr/gui_elements.py,sha256=EKlvEg_4_je7jciEdR3NTgPrcTraowa2e2RUt-xqd6M,138254
 spacr/gui_utils.py,sha256=u9RoIOWpAXFEOnUlLpMQZrc1pWSg6omZsJMIhJdRv_g,41211
-spacr/io.py,sha256=YlJAT6H8l4ipunMyKzjqoPcf-1AXgUmSyR1YN9WxmDI,142857
+spacr/io.py,sha256=SLJKVqe5c3dFa6a7tXA5KMGhNGjhvLbyqsPlD1AqM3g,142962
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
 spacr/measure.py,sha256=2lK-ZcTxLM-MpXV1oZnucRD9iz5aprwahRKw9IEqshg,55085
 spacr/mediar.py,sha256=FwLvbLQW5LQzPgvJZG8Lw7GniA2vbZx6Jv6vIKu7I5c,14743
 spacr/ml.py,sha256=GOQJH8jdTrJQwiLlDrcc9-yCxLFaMx4YD4OJs0-R5YI,77947
 spacr/openai.py,sha256=5vBZ3Jl2llYcW3oaTEXgdyCB2aJujMUIO5K038z7w_A,1246
-spacr/plot.py,sha256=0fne2Msy6niN80oiuwt9ZYw1QwXVnghaUmrwvEZN9-8,161992
+spacr/plot.py,sha256=XPAabtZjzurL6zlG3KfqLEQTnH_jjo-k2jVajJt9om8,165166
 spacr/sequencing.py,sha256=ClUfwPPK6rNUbUuiEkzcwakzVyDKKUMv9ricrxT8qQY,25227
-spacr/settings.py,sha256=LSoDNuz1m7rySh7MWXEL1xlUU4rFiCRVlGvZCSCOqzU,80085
+spacr/settings.py,sha256=wZcqdTWaRus27wn9P0EGyftcJn_i0IwlM9pyeCVqxr8,80173
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
-spacr/submodules.py,sha256=X1OI0Dsc1qU4lqKFdF2EnloNkLkDzA1hDn7CYbkBmFc,55473
+spacr/stats.py,sha256=mbhwsyIqt5upsSD346qGjdCw7CFBa0tIS7zHU9e0jNI,9536
+spacr/submodules.py,sha256=SK8YEs850LAx30YAiwap7ecLpp1_p-bci6H-Or0GLoA,55500
 spacr/timelapse.py,sha256=KGfG4L4-QnFfgbF7L6C5wL_3gd_rqr05Foje6RsoTBg,39603
 spacr/toxo.py,sha256=z2nT5aAze3NUIlwnBQcnkARihDwoPfqOgQIVoUluyK0,25087
-spacr/utils.py,sha256=vvciLh1gH0nsrCWQw3taUcDjxP59wme3gqrejeNO05w,222943
+spacr/utils.py,sha256=zojZlZtGwwDVDY0fgRt5XViVuJLuxadRO1IYctWm_SQ,221885
 spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
 spacr/resources/MEDIAR/.gitignore,sha256=Ff1q9Nme14JUd-4Q3jZ65aeQ5X4uttptssVDgBVHYo8,152
 spacr/resources/MEDIAR/LICENSE,sha256=yEj_TRDLUfDpHDNM0StALXIt6mLqSgaV2hcCwa6_TcY,1065
@@ -151,9 +152,9 @@ spacr/resources/icons/umap.png,sha256=dOLF3DeLYy9k0nkUybiZMe1wzHQwLJFRmgccppw-8b
 spacr/resources/images/plate1_E01_T0001F001L01A01Z01C02.tif,sha256=Tl0ZUfZ_AYAbu0up_nO0tPRtF1BxXhWQ3T3pURBCCRo,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A02Z01C01.tif,sha256=m8N-V71rA1TT4dFlENNg8s0Q0YEXXs8slIn7yObmZJQ,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A03Z01C03.tif,sha256=Pbhk7xn-KUP6RSIhJsxQcrHFImBm3GEpLkzx7WOc-5M,7958528
-spacr-0.3.64.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.3.64.dist-info/METADATA,sha256=_07fLYI8eMAYJzOEcAVOemN4TFJAuzAvUrdX1T136T0,6032
-spacr-0.3.64.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-spacr-0.3.64.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.3.64.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.3.64.dist-info/RECORD,,
+spacr-0.3.66.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.3.66.dist-info/METADATA,sha256=A5XJI5cR864WLb08NonbMW2BEUHYn-fQgl8RMcdIK8M,6032
+spacr-0.3.66.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+spacr-0.3.66.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.3.66.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.3.66.dist-info/RECORD,,