spacr 0.3.33__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,12 +2096,14 @@ 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 if isinstance(data_column, list) else [data_column]
@@ -2110,7 +2113,6 @@ class spacrGraph:
         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):
@@ -2150,19 +2153,15 @@ class spacrGraph:
         """Preprocess the data: remove NaNs, sort/order the grouping column, and optionally group by 'prc'."""
         # Remove NaNs in both the grouping column and each data column
         df = self.df.dropna(subset=[self.grouping_column] + self.data_column)  # 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):
         """Remove outliers from the plot but keep them in the data."""
         filtered_df = self.df.copy()
@@ -2181,13 +2180,11 @@ class spacrGraph:
         """Perform normality tests for each group and each data column."""
         unique_groups = self.df[self.grouping_column].unique()
         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}',
@@ -2197,10 +2194,8 @@ class spacrGraph:
                     '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."""
         grouped_data = [self.df.loc[self.df[self.grouping_column] == group, self.data_column] for group in unique_groups]
@@ -2208,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):
@@ -2271,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():
@@ -2287,38 +2271,146 @@ 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."""
+
+        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'
+
+                # Find the x positions of the compared groups
+                x1 = x_positions[unique_groups.tolist().index(group1)]
+                x2 = x_positions[unique_groups.tolist().index(group2)]
+
+                # Stagger lines to avoid overlap
+                line_y = y_max + (0.1 * y_max) * (idx + 1)
+
+                # 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')
+
+                # Add the significance marker
+                ax.text((x1 + x2) / 2, line_y, significance, ha='center', va='bottom', fontsize=12)
+
         # Optional: Remove outliers for plotting
         if self.remove_outliers:
             self.df = self.remove_outliers_from_plot()
 
-        # Get the unique groups from the grouping column
+        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)
 
-        # Flatten the DataFrame to handle multiple `data_column` values in a single plot
-        self.df_melted = pd.melt(self.df, id_vars=[self.grouping_column], value_vars=self.data_column,
-                            var_name='Data Column', value_name='Value')
-
-        # Dynamically set figure dimensions based on the number of unique groups and data columns
-        num_groups = len(self.df_melted[self.grouping_column].unique())
+        num_groups = len(self.data_column)*len(self.grouping_column)
         num_data_columns = len(self.data_column)
-        bar_width = 2.0 / num_data_columns
-        spacing_between_groups = 0.1
-
-        fig_width = (num_groups * num_data_columns * bar_width) + (spacing_between_groups * num_groups)
-        fig_height = 10
+        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))
+            self.fig, ax = plt.subplots(figsize=(self.fig_height, self.fig_width))
         else:
             self.fig = ax.figure
-            
+
         if len(self.data_column) == 1:
             self.hue=self.grouping_column
             self.jitter_bar_dodge = False
@@ -2328,9 +2420,8 @@ class spacrGraph:
         
         # Handle the different plot types based on `graph_type`
         if self.graph_type == 'bar':
-            self._create_bar_plot(bar_width, ax)
+            self._create_bar_plot(ax)
         elif self.graph_type == 'jitter':
-            #transparent_palette = [(r, g, b, 0.6) for (r, g, b) in sns.color_palette(self.sns_palette, n_colors=len(df_melted[hue].unique()))]
             self._create_jitter_plot(ax)
         elif self.graph_type == 'box':
             self._create_box_plot(ax)
@@ -2339,159 +2430,154 @@ class spacrGraph:
         else:
             raise ValueError(f"Unknown graph type: {self.graph_type}") 
         
-        if ax is None:
-            self.fig, ax = plt.subplots(figsize=(fig_width, fig_height))
-        else:
-            self.fig = ax.figure
-
-
         # Set y-axis start
-        if self.y_axis_start is not None:
-            ax.set_ylim(bottom=self.y_axis_start)
+        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)
 
-        # Remove top and right spines
         sns.despine(ax=ax, top=True, right=True)
-
-        # Adjust the position of the plot to move it closer to the table
-        ax.set_position([0.1, 0.25, 0.8, 0.45])  # Adjust the height of the plot, leaving more space for the table
-
-        # Move the legend outside the plot
-        ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), title='Data Column')
-        
+        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')
 
-        # Create the grid with '+' and '-' symbols
-        if len(self.data_column) > 1:
+        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.02, 0.8, 0.2])  # Position the table closer to the graph
+            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()
 
-            # Prepare the rows and symbols
-            row_labels = self.data_column
-            table_data = []
-
-            # Ensure the rows for each data column match the number of unique bars
-            for column in self.data_column:
-                column_bars = []
-                for group in unique_groups:
-                    # For each group and data column, assign a '+' or '-'
-                    for bar_position in range(num_data_columns):  # Loop through each data_column position
-                        if bar_position == self.data_column.index(column):
-                            column_bars.append('+')
-                        else:
-                            column_bars.append('-')
-                table_data.append(column_bars)
-
-            # Display the table directly below the graph with white background and thicker row height
-            legend_table = legend_ax.table(cellText=table_data,
-                                           rowLabels=row_labels,
-                                           loc='center',
-                                           cellLoc='center',
-                                           rowColours=['white'] * len(row_labels),  # Set background to white
-                                           cellColours=[['white'] * len(column_bars) for _ in table_data],  # White cell background
-                                           edges='closed',  # Show edges around cells
-                                           bbox=[0, 0, 1, 1])
-
-            # Adjust the row height for readability
-            for key, cell in legend_table.get_celld().items():
-                cell.set_height(0.5)  # Increase row height
-                cell.set_edgecolor('white')  # Set grid color to white
-                cell.set_linewidth(2)  # Set line thickness
-
+            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.tight_layout()  # Ensure the layout is tight
-        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."""
-
-        # Melt the dataframe for easier use with seaborn's hue functionality
-        df_melted = pd.melt(self.df, id_vars=[self.grouping_column], value_vars=self.data_column,
-                            var_name='Data Column', value_name=self.summary_func)
-
-        # Group the melted DataFrame by grouping column and data column for error bars calculation
-        summary_df = df_melted.groupby([self.grouping_column, 'Data Column']).agg({self.summary_func: ['mean', 'std', 'sem']}).reset_index()
-        summary_df.columns = ['_'.join(col).strip() if isinstance(col, tuple) else col for col in summary_df.columns]
-
-        # Determine which type of error bars to show (std or sem)
-        if self.error_bar_type == 'std':
-            error_bars = summary_df[f'{self.summary_func}_std']
-        elif self.error_bar_type == 'sem':
-            error_bars = summary_df[f'{self.summary_func}_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'.")
-
-        # Set the hue to 'Data Column' if there are multiple data columns
-        hue = 'Data Column' if len(self.data_column) > 1 else None
-
-        # Create the bar plot with dodge=True to ensure bars for different data columns are side by side
-        barplot = sns.barplot(
-            data=df_melted, 
-            x=self.grouping_column, 
-            y=self.summary_func, 
-            hue=hue, 
-            palette=self.sns_palette, 
-            dodge=self.jitter_bar_dodge,  # Ensure bars are separated
-            ax=ax,
-            ci=None  # Disable Seaborn's internal error bars
-        )
-
-        # Sort summary_df to match the order of bars in the plot
-        summary_df_sorted = summary_df.sort_values([f'{self.grouping_column}_', 'Data Column_'])
-
-        # Get the positions of the bars
-        bars = [patch for patch in ax.patches if isinstance(patch, plt.Rectangle)]
-
-        # Ensure error bars are aligned with correct bars
-        for bar, (_, row) in zip(bars, summary_df_sorted.iterrows()):
-            x_bar = bar.get_x() + bar.get_width() / 2  # Center of the bar
-            err = row[f'{self.summary_func}_{self.error_bar_type}']  # Get the correct error value for this bar
-
+            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 the legend outside the plot
-        if hue:
-            ax.legend(title="Data Column", loc='center left', bbox_to_anchor=(1, 0.5))
-        else:
-            if len(self.data_column) > 1:
-                ax.legend_.remove()
-
-        # Set labels
+    
+        # Set legend and labels
         ax.set_xlabel(self.grouping_column)
-        ax.set_ylabel(self.summary_func)
-
 
     def _create_jitter_plot(self, ax):
-        """Helper method to create a jitter plot (strip plot) for a specified column."""
-        sns.stripplot(data=self.df_melted, x=self.grouping_column, y='Value', hue=self.hue, palette=self.sns_palette, dodge=self.jitter_bar_dodge, jitter=True, ax=ax, alpha=0.6)
-
+        """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 for a specified column."""
-        sns.boxplot(data=self.df_melted, x=self.grouping_column, y='Value', hue=self.hue, 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 for a specified column."""
-        sns.violinplot(data=self.df_melted, x=self.grouping_column, y='Value', hue=self.hue, 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}")
@@ -2500,9 +2586,13 @@ class spacrGraph:
         """Return the results dataframe."""
         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 spacr.utils import annotate_conditions
+    from .utils import annotate_conditions
     """
     Extracts the specified table from the SQLite database and plots a specified column.
 
@@ -2530,18 +2620,17 @@ def plot_data_from_db(settings):
     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))
-    #display(df)
-    # Initialize the spacrGraph class with your DataFrame and desired parameters
+    
     spacr_graph = spacrGraph(
-        df=df,                           # Your DataFrame
+        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_axis_start=0,                              # Starting point for y-axis (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')
@@ -2552,8 +2641,9 @@ def plot_data_from_db(settings):
 
     # 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()
-    display(results_df)
-    return fig
+    
+    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.33.dist-info → spacr-0.3.34.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.3.33
+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.33.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=7ZeiOlFHDD3Yp9_qrCycEpnuaFVPvRwXgQH_h7YZ94E,111792
+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.33.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.3.33.dist-info/METADATA,sha256=sO_89AozvIDEHWwzCw9s8zfwlWGQLLdgrbyC-PVKKTY,5949
-spacr-0.3.33.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-spacr-0.3.33.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.3.33.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.3.33.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,,