spacr 0.3.32__py3-none-any.whl → 0.3.34__py3-none-any.whl

spacr/gui_utils.py

@@ -508,7 +508,7 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
         imports = 1
     elif settings_type == 'ml_analyze':
         function = generate_ml_scores
-        imports = 2
+        imports = 1
     elif settings_type == 'cellpose_masks':
         function = identify_masks_finetune
         imports = 1

spacr/ml.py

@@ -730,7 +730,7 @@ def process_scores(df, dependent_variable, plate, min_cell_count=25, agg_type='m
 
 def generate_ml_scores(settings):
     
-    from .io import _read_and_merge_data
+    from .io import _read_and_merge_data, _read_db
     from .plot import plot_plates
     from .utils import get_ml_results_paths
     from .settings import set_default_analyze_screen
@@ -753,6 +753,38 @@ def generate_ml_scores(settings):
                                  nuclei_limit,
                                  pathogen_limit,
                                  uninfected)
+
+    if settings['annotation_column'] is not None:
+
+        settings['location_column'] = settings['annotation_column']
+        
+        png_list_df = _read_db(db_loc[0], tables=['png_list'])[0]
+        if not {'prcfo', settings['annotation_column']}.issubset(png_list_df.columns):
+            raise ValueError("The 'png_list_df' DataFrame must contain 'prcfo' and 'test' columns.")
+        annotated_df = png_list_df[['prcfo', settings['annotation_column']]].set_index('prcfo')
+        df = annotated_df.merge(df, left_index=True, right_index=True)
+        display(df)
+        unique_values = df[settings['annotation_column']].dropna().unique()
+        if len(unique_values) == 1:
+            unannotated_rows = df[df[settings['annotation_column']].isna()].index
+            existing_value = unique_values[0]
+            next_value = existing_value + 1
+
+            settings['positive_control'] = str(existing_value)
+            settings['negative_control'] = str(next_value)
+
+            existing_count = df[df[settings['annotation_column']] == existing_value].shape[0]
+            num_to_select = min(existing_count, len(unannotated_rows))
+            selected_rows = np.random.choice(unannotated_rows, size=num_to_select, replace=False)
+            df.loc[selected_rows, settings['annotation_column']] = next_value
+
+            # Print the counts for existing_value and next_value
+            existing_count_final = df[df[settings['annotation_column']] == existing_value].shape[0]
+            next_count_final = df[df[settings['annotation_column']] == next_value].shape[0]
+
+            print(f"Number of rows with value {existing_value}: {existing_count_final}")
+            print(f"Number of rows with value {next_value}: {next_count_final}")
+            df[settings['annotation_column']] = df[settings['annotation_column']].apply(str)
     
     if settings['channel_of_interest'] in [0,1,2,3]:
 
@@ -847,6 +879,7 @@ def ml_analysis(df, channel_of_interest=3, location_column='col', positive_contr
     if verbose:
         print(f'Found {len(features)} numerical features in the dataframe')
         print(f'Features used in training: {features}')
+
     df = pd.concat([df, df_metadata[location_column]], axis=1)
 
     # Subset the dataframe based on specified column values

spacr/plot.py

@@ -23,6 +23,9 @@ import pingouin as pg
 from ipywidgets import IntSlider, interact
 from IPython.display import Image as ipyimage
 
+import matplotlib.patches as patches
+from collections import defaultdict
+
 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."""
 
@@ -1930,7 +1933,7 @@ def jitterplot_by_annotation(src, x_column, y_column, plot_title='Jitter Plot',
 
     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'):
+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_lim=None, error_bar_type='std'):
     """
     Create a grouped plot, perform statistical tests, and optionally export the results along with the plot.
 
@@ -1944,7 +1947,7 @@ def create_grouped_plot(df, grouping_column, data_column, graph_type='bar', summ
     - 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.
+    - y_lim: Optional y-axis min and max.
     - error_bar_type: Type of error bars to plot, either 'std' for standard deviation or 'sem' for standard error of the mean.
 
     Outputs:
@@ -2068,10 +2071,8 @@ def create_grouped_plot(df, grouping_column, data_column, graph_type='bar', summ
     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 isinstance(y_lim, list) and len(y_lim) == 2:
+        plt.ylim(y_lim)
 
     # If save is True, save the plot and results as PNG and CSV
     if save:
@@ -2095,22 +2096,23 @@ def create_grouped_plot(df, grouping_column, data_column, graph_type='bar', summ
     
 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, 
+                 order=None, colors=None, output_dir='./output', save=False, y_lim=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.data_column = data_column if isinstance(data_column, list) else [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
@@ -2118,14 +2120,15 @@ class spacrGraph:
         self.paired = paired
         self.all_to_all = all_to_all
         self.compare_group = compare_group
-
+        self.y_lim = y_lim
         self.results_df = pd.DataFrame()
         self.sns_palette = None
-        self.fig = None  # To store the generated figure
+        self.fig = None
+
+        self.results_name = str(self.data_column[0])+'_'+str(self.grouping_column)+'_'+str(self.graph_type)
         
-        # Preprocess and set palette
         self._set_theme()
-        self.raw_df = self.df.copy()  # Preserve the raw data for n_object count
+        self.raw_df = self.df.copy()
         self.df = self.preprocess_data()
         
     def _set_theme(self):
@@ -2148,17 +2151,15 @@ class spacrGraph:
 
     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])
-
+        # Remove NaNs in both the grouping column and each data column
+        df = self.df.dropna(subset=[self.grouping_column] + self.data_column)  # Handle multiple data columns
         # 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):
@@ -2176,26 +2177,24 @@ class spacrGraph:
         return filtered_df
 
     def perform_normality_tests(self):
-        """Perform normality tests for each group."""
+        """Perform normality tests for each group and each data column."""
         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
+        normality_results = []
+        for column in self.data_column:
+            grouped_data = [self.df.loc[self.df[self.grouping_column] == group, 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 if all groups are normal
+            for group, stat, p_value in zip(unique_groups, normal_stats, normal_p_values):
+                normality_results.append({
+                    'Comparison': f'Normality test for {group} on {column}',
+                    'Test Statistic': stat,
+                    'p-value': p_value,
+                    'Test Name': 'Normality test',
+                    'Column': column,
+                    'n': len(self.df[self.df[self.grouping_column] == group])  # Sample size
+                })
+        return is_normal, normality_results
 
     def perform_levene_test(self, unique_groups):
         """Perform Levene's test for equal variance."""
@@ -2204,57 +2203,48 @@ class spacrGraph:
         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'
+        """Perform statistical tests separately for each data column."""
+        test_results = []
+        for column in self.data_column:  # Iterate over each data column
+            grouped_data = [self.df.loc[self.df[self.grouping_column] == group, column] for group in unique_groups]
+            if len(unique_groups) == 2:  # For two groups: class_0 vs class_1
+                if is_normal:
+                    if self.paired:
+                        stat, p = pg.ttest(grouped_data[0], grouped_data[1], paired=True).iloc[0][['T', 'p-val']]
+                        test_name = 'Paired T-test'
+                    else:
+                        stat, p = ttest_ind(grouped_data[0], grouped_data[1])
+                        test_name = 'T-test'
                 else:
-                    stat_test = ttest_ind
-                    test_name = 'T-test'
+                    if self.paired:
+                        stat, p = pg.wilcoxon(grouped_data[0], grouped_data[1]).iloc[0][['T', 'p-val']]
+                        test_name = 'Paired Wilcoxon test'
+                    else:
+                        stat, p = mannwhitneyu(grouped_data[0], grouped_data[1])
+                        test_name = 'Mann-Whitney U test'
             else:
-                if self.paired:
-                    stat_test = pg.wilcoxon  # Paired Wilcoxon test
-                    test_name = 'Paired Wilcoxon test'
+                if is_normal:
+                    stat, p = f_oneway(*grouped_data)
+                    test_name = 'One-way ANOVA'
                 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)
+                    stat, p = kruskal(*grouped_data)
+                    test_name = 'Kruskal-Wallis test'
 
             test_results.append({
-                'Comparison': f'{group1} vs {group2}',
+                'Comparison': f'{unique_groups[0]} vs {unique_groups[1]} ({column})',
                 '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)
-            })
+                'Column': column,
+                'n_object': len(grouped_data[0]) + len(grouped_data[1]),
+                'n_well': len(self.df[self.df[self.grouping_column] == unique_groups[0]]) + 
+                          len(self.df[self.df[self.grouping_column] == unique_groups[1]])})
+
         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):
@@ -2267,12 +2257,10 @@ class spacrGraph:
                     '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]])
-                })
+                    '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():
@@ -2283,138 +2271,379 @@ class spacrGraph:
                         'p-value': row['p-val'],
                         'Test Name': 'Dunn’s Post-hoc',
                         'n_object': None,
-                        'n_well': 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()
+        def _generate_tabels(unique_groups):
+            """Generate row labels and a symbol table for multi-level grouping."""
+            # Create row labels: Include the grouping column and data columns
+            row_labels = [self.grouping_column] + self.data_column
+
+            # Initialize table data
+            table_data = []
+
+            # Create the grouping row: Alternate each group for every data column
+            grouping_row = []
+            for _ in self.data_column:
+                for group in unique_groups:
+                    grouping_row.append(group)
+            table_data.append(grouping_row)  # Add the grouping row to the table
+
+            # Create symbol rows for each data column
+            for column in self.data_column:
+                column_row = []  # Initialize a row for this column
+                for data_col in self.data_column:  # Iterate over data columns to align with the structure
+                    for group in unique_groups:
+                        # Assign '+' if the column matches, otherwise assign '-'
+                        if column == data_col:
+                            column_row.append('+')
+                        else:
+                            column_row.append('-')
+                table_data.append(column_row)  # Add this row to the table
+
+            # Transpose the table to align with the plot layout
+            transposed_table = list(map(list, zip(*table_data)))
+            return row_labels, transposed_table
+
+        def _place_symbols(row_labels, transposed_table, x_positions, ax):            
+            
+            # Get the bottom of the y-axis (y=0) in data coordinates and convert to display coordinates
+            y_axis_min = ax.get_ylim()[0]  # Minimum y-axis value (usually 0)
+            symbol_start_y = ax.transData.transform((0, y_axis_min))[1] - 30  # Slightly below the x-axis line
+        
+            # Convert to figure coordinates
+            symbol_start_y_fig = ax.transAxes.inverted().transform((0, symbol_start_y))[1]
+        
+            # Calculate y-spacing for the table rows (adjust as needed)
+            y_spacing = 0.02 # Control vertical spacing between elements
+        
+            # X-coordinate for the row labels at the y-axis and x-axis intersection
+            label_x_pos = ax.get_xlim()[0] - 0.5  # Slightly offset from the y-axis
+        
+            # Place the row titles at the y-axis intersection
+            for row_idx, title in enumerate(row_labels):
+                y_pos = symbol_start_y_fig - (row_idx * y_spacing)  # Align with row index
+                ax.text(label_x_pos, y_pos, title, ha='right', va='center', fontsize=12, fontweight='regular')
+        
+            # Place the symbols under each bar
+            for idx, (x_pos, column_data) in enumerate(zip(x_positions, transposed_table)):
+                for row_idx, text in enumerate(column_data):
+                    y_pos = symbol_start_y_fig - (row_idx * y_spacing)
+                    ax.text(x_pos, y_pos, text, ha='center', va='center', fontsize=12)
+                    
+        def _get_positions(self, ax):
+            if self.graph_type == 'bar': 
+                x_positions = [np.mean(bar.get_paths()[0].vertices[:, 0]) for bar in ax.collections if hasattr(bar, 'get_paths')]
+
+            elif self.graph_type == 'violin':
+                x_positions = [np.mean(violin.get_paths()[0].vertices[:, 0]) for violin in ax.collections if hasattr(violin, 'get_paths')]
+
+            elif self.graph_type == 'box':
+                x_positions = list(set(line.get_xdata().mean() for line in ax.lines if line.get_linestyle() == '-'))                
+
+            elif self.graph_type == 'jitter': 
+                x_positions = [np.mean(collection.get_offsets()[:, 0]) for collection in ax.collections if collection.get_offsets().size > 0]
+            return x_positions
+        
+        def _draw_comparison_lines(ax, x_positions):
+            """Draw comparison lines and annotate significance based on results_df."""
+            if self.results_df.empty:
+                print("No comparisons available to annotate.")
+                return
+
+            y_max = max([bar.get_height() for bar in ax.patches])
+            ax.set_ylim(0, y_max * 1.3)
+
+            for idx, row in self.results_df.iterrows():
+                group1, group2 = row['Comparison'].split(' vs ')
+                p_value = row['p-value']
+
+                # Determine significance marker
+                if p_value <= 0.001:
+                    significance = '***'
+                elif p_value <= 0.01:
+                    significance = '**'
+                elif p_value <= 0.05:
+                    significance = '*'
+                else:
+                    significance = 'ns'
 
-        # 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'
-        }
+                # Find the x positions of the compared groups
+                x1 = x_positions[unique_groups.tolist().index(group1)]
+                x2 = x_positions[unique_groups.tolist().index(group2)]
 
-        # Perform statistical tests
-        stat_results = self.perform_statistical_tests(unique_groups, is_normal)
+                # Stagger lines to avoid overlap
+                line_y = y_max + (0.1 * y_max) * (idx + 1)
 
-        # Perform post-hoc tests if applicable
-        posthoc_results = self.perform_posthoc_tests(is_normal, unique_groups)
+                # Draw the comparison line
+                ax.plot([x1, x1, x2, x2], [line_y - 0.02, line_y, line_y, line_y - 0.02], lw=1.5, c='black')
 
-        # Combine all test results
-        self.results_df = pd.DataFrame(normality_results + [levene_result] + stat_results + posthoc_results)
+                # Add the significance marker
+                ax.text((x1 + x2) / 2, line_y, significance, ha='center', va='bottom', fontsize=12)
 
-        # 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)
-        )
+        # Optional: Remove outliers for plotting
+        if self.remove_outliers:
+            self.df = self.remove_outliers_from_plot()
 
-        # 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
+        self.df_melted = pd.melt(self.df, id_vars=[self.grouping_column], value_vars=self.data_column,var_name='Data Column', value_name='Value')
+        unique_groups = self.df[self.grouping_column].unique()
+        is_normal, normality_results = self.perform_normality_tests()
+        levene_stat, levene_p = self.perform_levene_test(unique_groups)
+        test_results = self.perform_statistical_tests(unique_groups, is_normal)
+        posthoc_results = self.perform_posthoc_tests(is_normal, unique_groups)
+        self.results_df = pd.DataFrame(normality_results + test_results + posthoc_results)
 
-        fig_width = num_groups * (bar_width + spacing_between_groups)  # Dynamically calculate the figure width
-        fig_height = 6  # Fixed height for the plot
+        num_groups = len(self.data_column)*len(self.grouping_column)
+        num_data_columns = len(self.data_column)
+        self.bar_width = 0.4
+        spacing_between_groups = self.bar_width/0.5
 
+        self.fig_width = (num_groups * self.bar_width) + (spacing_between_groups * num_groups)
+        self.fig_height = self.fig_width/2
+        
         if ax is None:
-            self.fig, ax = plt.subplots(figsize=(fig_width, fig_height))  # Store the figure in self.fig
+            self.fig, ax = plt.subplots(figsize=(self.fig_height, self.fig_width))
         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
+            self.fig = ax.figure
 
-        # 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)
+        if len(self.data_column) == 1:
+            self.hue=self.grouping_column
+            self.jitter_bar_dodge = False
+        else:
+            self.hue='Data Column'
+            self.jitter_bar_dodge = True
+        
+        # Handle the different plot types based on `graph_type`
+        if self.graph_type == 'bar':
+            self._create_bar_plot(ax)
+        elif self.graph_type == 'jitter':
+            self._create_jitter_plot(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'.")
-
+            raise ValueError(f"Unknown graph type: {self.graph_type}") 
+        
         # 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 isinstance(self.y_lim, list):
+            if len(self.y_lim) == 2:
+                ax.set_ylim(self.y_lim[0], self.y_lim[1])
+            elif len(self.y_lim) == 1:
+                ax.set_ylim(self.y_lim[0], None)
 
+        sns.despine(ax=ax, top=True, right=True)
+        ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), title='Data Column') # Move the legend outside the plot
+        ax.set_xlabel('')
+        x_positions = _get_positions(self, ax)
+        
+        if len(self.data_column) == 1:
+            ax.legend().remove()
+            ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha='right')
+
+        elif len(self.data_column) > 1:
+            ax.set_xticks([])
+            ax.tick_params(bottom=False)
+            ax.set_xticklabels([])
+            legend_ax = self.fig.add_axes([0.1, -0.2, 0.62, 0.2])  # Position the table closer to the graph
+            legend_ax.set_axis_off()
+
+            row_labels, table_data = _generate_tabels(unique_groups)
+            _place_symbols(row_labels, table_data, x_positions, ax)
+            
+        #_draw_comparison_lines(ax, x_positions)    
+        
         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
+        ax.margins(x=0.12) 
 
-    def _create_bar_plot(self, bar_width, ax):
+    def _create_bar_plot(self, 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']
+        # Flatten DataFrame: Combine grouping column and data column into one group if needed
+        if len(self.data_column) > 1:
+            self.df_melted['Combined Group'] = (self.df_melted[self.grouping_column].astype(str) + " - " + self.df_melted['Data Column'].astype(str))
+            x_axis_column = 'Combined Group'
+            hue = None
+            ax.set_ylabel('Value')
         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)
+            x_axis_column = self.grouping_column
+            ax.set_ylabel(self.data_column[0])
+            hue = None
+    
+        summary_df = self.df_melted.groupby([x_axis_column]).agg(mean=('Value', 'mean'),std=('Value', 'std'),sem=('Value', 'sem')).reset_index()
+        error_bars = summary_df[self.error_bar_type] if self.error_bar_type in ['std', 'sem'] else None
+        sns.barplot(data=self.df_melted, x=x_axis_column, y='Value', hue=self.hue, palette=self.sns_palette, ax=ax, dodge=self.jitter_bar_dodge, ci=None)
+        
+        # Adjust the bar width manually
+        if len(self.data_column) > 1:
+            bars = [bar for bar in ax.patches if isinstance(bar, plt.Rectangle)]
+            target_width = self.bar_width * 2
+            for bar in bars:
+                bar.set_width(target_width)  # Set new width
+                # Center the bar on its x-coordinate
+                bar.set_x(bar.get_x() - target_width / 2)
+            
+        # Adjust error bars alignment with bars
+        bars = [bar for bar in ax.patches if isinstance(bar, plt.Rectangle)]
+        for bar, (_, row) in zip(bars, summary_df.iterrows()):
+            x_bar = bar.get_x() + bar.get_width() / 2
+            err = row[self.error_bar_type]
+            ax.errorbar(x=x_bar, y=bar.get_height(), yerr=err, fmt='none', c='black', capsize=5, lw=2)
+    
+        # Set legend and labels
+        ax.set_xlabel(self.grouping_column)
 
     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)
-
+        """Helper method to create a jitter plot (strip plot) with consistent spacing."""
+        # Combine grouping column and data column if needed
+        if len(self.data_column) > 1:
+            self.df_melted['Combined Group'] = (self.df_melted[self.grouping_column].astype(str)  + " - " + self.df_melted['Data Column'].astype(str))
+            x_axis_column = 'Combined Group'
+            hue = None  # Disable hue to avoid two-level grouping
+            ax.set_ylabel('Value')
+        else:
+            x_axis_column = self.grouping_column
+            ax.set_ylabel(self.data_column[0])
+            hue = None
+    
+        # Create the jitter plot
+        sns.stripplot(data=self.df_melted,x=x_axis_column,y='Value',hue=self.hue, palette=self.sns_palette, dodge=self.jitter_bar_dodge, jitter=self.bar_width, ax=ax,alpha=0.6)
+    
+        # Adjust legend and labels
+        ax.set_xlabel(self.grouping_column)
+       
+        # Manage the legend
+        handles, labels = ax.get_legend_handles_labels()
+        unique_labels = dict(zip(labels, handles))
+        ax.legend(unique_labels.values(), unique_labels.keys(), loc='best')
+    
     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)
+        """Helper method to create a box plot with consistent spacing."""
+        # Combine grouping column and data column if needed
+        if len(self.data_column) > 1:
+            self.df_melted['Combined Group'] = (self.df_melted[self.grouping_column].astype(str) + " - " + self.df_melted['Data Column'].astype(str))
+            x_axis_column = 'Combined Group'
+            hue = None
+            ax.set_ylabel('Value')
+        else:
+            x_axis_column = self.grouping_column
+            ax.set_ylabel(self.data_column[0])
+            hue = None
+    
+        # Create the box plot
+        sns.boxplot(data=self.df_melted,x=x_axis_column,y='Value',hue=self.hue,palette=self.sns_palette,ax=ax)
+    
+        # Adjust legend and labels
+        ax.set_xlabel(self.grouping_column)
 
+        # Manage the legend
+        handles, labels = ax.get_legend_handles_labels()
+        unique_labels = dict(zip(labels, handles))
+        ax.legend(unique_labels.values(), unique_labels.keys(), loc='best')
+    
     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)
+        """Helper method to create a violin plot with consistent spacing."""
+        # Combine grouping column and data column if needed
+        if len(self.data_column) > 1:
+            self.df_melted['Combined Group'] = (self.df_melted[self.grouping_column].astype(str) + " - " + self.df_melted['Data Column'].astype(str))
+            x_axis_column = 'Combined Group'
+            hue = None
+            ax.set_ylabel('Value')
+        else:
+            x_axis_column = self.grouping_column
+            ax.set_ylabel(self.data_column[0])
+            hue = None
+    
+        # Create the violin plot
+        sns.violinplot(data=self.df_melted,x=x_axis_column,y='Value', hue=self.hue,palette=self.sns_palette,ax=ax)
+    
+        # Adjust legend and labels
+        ax.set_xlabel(self.grouping_column)
+        ax.set_ylabel('Value')
+    
+        # Manage the legend
+        handles, labels = ax.get_legend_handles_labels()
+        unique_labels = dict(zip(labels, handles))
+        ax.legend(unique_labels.values(), unique_labels.keys(), loc='best')
 
     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')
+        plot_path = os.path.join(self.output_dir, f"{self.results_name}.pdf")
+        self.fig.savefig(plot_path, bbox_inches='tight', dpi=600, transparent=True, format='pdf')
+        results_path = os.path.join(self.output_dir, f"{self.results_name}.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
+        return self.results_df
+    
+    def get_figure(self):
+        """Return the generated figure."""
+        return self.fig
+
+def plot_data_from_db(settings):
+    from .io import _read_db
+    from .utils import annotate_conditions
+    """
+    Extracts the specified table from the SQLite database and plots a specified column.
+
+    Args:
+        db_path (str): The path to the SQLite database.
+        table_name (str): The name of the table to extract.
+        column_name (str): The column to plot from the table.
+
+    Returns:
+        df (pd.DataFrame): The extracted table as a DataFrame.
+    """
+    
+    db_loc = os.path.join(settings['src'], 'measurements',settings['database'])
+    
+    [df] = _read_db(db_loc, tables=[settings['table_name']])
+        
+    df = annotate_conditions(df, 
+                             cells=settings['cell_types'], 
+                             cell_loc=settings['cell_plate_metadata'], 
+                             pathogens=settings['pathogen_types'],
+                             pathogen_loc=settings['pathogen_plate_metadata'],
+                             treatments=settings['treatments'], 
+                             treatment_loc=settings['treatment_plate_metadata'])
+    
+    df['prc'] = df['plate'].astype(str) + '_' + df['row'].astype(str) + '_' + df['col'].astype(str)
+    df = df.dropna(subset=settings['column_name'])
+    df['class'] = df['png_path'].apply(lambda x: 'class_1' if 'class_1' in x else ('class_0' if 'class_0' in x else None))
+    
+    spacr_graph = spacrGraph(
+        df=df,                                       # Your DataFrame
+        grouping_column=settings['grouping_column'], # Column for grouping the data (x-axis)
+        data_column=settings['column_name'],         # Column for the data (y-axis)
+        graph_type=settings['graph_type'],           # Type of plot ('bar', 'box', 'violin', 'jitter')
+        summary_func='mean',                         # Function to summarize data (e.g., 'mean', 'median')
+        colors=None,                                 # Custom colors for the plot (optional)
+        output_dir=settings['dst'],                  # Directory to save the plot and results
+        save=settings['save'],                       # Whether to save the plot and results
+        y_lim=settings['y_lim'],                     # Starting point for y-axis (optional)
+        error_bar_type='std',                        # Type of error bar ('std' or 'sem')
+        representation='well',
+        theme=settings['theme'],                     # Seaborn color palette theme (e.g., 'pastel', 'muted')
+    )
+
+    # Create the plot
+    spacr_graph.create_plot()
+
+    # Get the figure object if needed
+    fig = spacr_graph.get_figure()
+    plt.show()
+
+    # Optional: Get the results DataFrame containing statistical test results
+    results_df = spacr_graph.get_results()
+    
+    return fig, results_df

spacr/settings.py

@@ -278,6 +278,7 @@ def get_measure_crop_settings(settings={}):
 
 def set_default_analyze_screen(settings):
     settings.setdefault('src', 'path')
+    settings.setdefault('annotation_column', None)
     settings.setdefault('model_type_ml','xgboost')
     settings.setdefault('heatmap_feature','predictions')
     settings.setdefault('grouping','mean')

{spacr-0.3.32.dist-info → spacr-0.3.34.dist-info}/METADATA

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

{spacr-0.3.32.dist-info → spacr-0.3.34.dist-info}/RECORD

@@ -13,16 +13,16 @@ spacr/deep_spacr.py,sha256=HdOcNU8cHcE_19nP7_5uTz-ih3E169ffr2Hm--NvMvA,43255
 spacr/gui.py,sha256=ARyn9Q_g8HoP-cXh1nzMLVFCKqthY4v2u9yORyaQqQE,8230
 spacr/gui_core.py,sha256=LV_HX5zreu3Bye6sQFDbOuk8Dfj4StMoohy6hsrDEXA,41363
 spacr/gui_elements.py,sha256=puDqf7PJJ_UMA01fjqODk-zsfSmvzVXpvaZ1BYV988w,136554
-spacr/gui_utils.py,sha256=cZ_EEr1SE1zJFLmYrDJB896u_reTL_FJbP6fSY5Xx6U,45454
+spacr/gui_utils.py,sha256=7e9DsZIuV7-jh97kEf7v1In_cFzlFueV4SGcGYGpTxw,45454
 spacr/io.py,sha256=AARmqn1fMmTgVDwWy8bEYK6SjH-6DZIulgCSPdBTyf0,143370
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
 spacr/measure.py,sha256=BThn_sALgKrwGKnLOGpT4FyoJeRVoTZoP9SXbCtCMRw,54857
 spacr/mediar.py,sha256=FwLvbLQW5LQzPgvJZG8Lw7GniA2vbZx6Jv6vIKu7I5c,14743
-spacr/ml.py,sha256=3XiQUfhhseCz9cZXhaVkCCv_qfqoZCdXGnO_p3ulwo4,47131
+spacr/ml.py,sha256=8i2D9YEC9rSYdbgkuuMLl6adwivWn2Z5BEUjPRsW4t4,48983
 spacr/openai.py,sha256=5vBZ3Jl2llYcW3oaTEXgdyCB2aJujMUIO5K038z7w_A,1246
-spacr/plot.py,sha256=Lv-QFD_NwP9pdsUIiJ--XHJN-jQBkFz_AI9y4i36jEA,105506
+spacr/plot.py,sha256=PtCSoBmLFlGC7ebmsk-vMlyd7q2ahXgRVaTtAq3w_po,116513
 spacr/sequencing.py,sha256=t18mgpK6rhWuB1LtFOsPxqgpFXxuUmrD06ecsaVQ0Gw,19655
-spacr/settings.py,sha256=uTTR6pmwBHbZ_uLLWE4cXplGK7q6K_OmZnsXH-HAFW0,75828
+spacr/settings.py,sha256=7rAvzPkfyfbpY6JQqcTe6PcCghEvLebUgsfKMVBtNyU,75879
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
 spacr/submodules.py,sha256=AB7s6-cULsaqz-haAaCtXfGEIi8uPZGT4xoCslUJC3Y,18391
 spacr/timelapse.py,sha256=FSYpUtAVy6xc3lwprRYgyDTT9ysUhfRQ4zrP9_h2mvg,39465
@@ -150,9 +150,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.32.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.3.32.dist-info/METADATA,sha256=zmqGrPPpr-pTpLbwPpCl0zwLA2oaZ1kGNo90t-nUF5g,5949
-spacr-0.3.32.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-spacr-0.3.32.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.3.32.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.3.32.dist-info/RECORD,,
+spacr-0.3.34.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.3.34.dist-info/METADATA,sha256=6C9_x3YSb9ycM9cXRufcPTJG809Cf-hkNYDOdEVXMT0,5949
+spacr-0.3.34.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+spacr-0.3.34.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.3.34.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.3.34.dist-info/RECORD,,