spacr 0.3.50__py3-none-any.whl → 0.3.55__py3-none-any.whl

spacr/plot.py

@@ -16,6 +16,7 @@ from skimage import measure
 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
 
 import tifffile as tiff
 
@@ -365,146 +366,6 @@ def plot_image_mask_overlay(
 
     return fig
 
-def plot_image_mask_overlay_v1(file, channels, cell_channel, nucleus_channel, pathogen_channel, figuresize=10, percentiles=(2,98), thickness=3, save_pdf=True, mode='outlines', export_tiffs=False):   
-    """Plot image and mask overlays."""
-
-    def _plot_merged_plot(image, outlines, outline_colors, figuresize, thickness, percentiles, mode='outlines'):
-        """Plot the merged plot with overlay, image channels, and masks."""
-
-        def _generate_colored_mask(mask, alpha):
-            """ Generate a colored mask with transparency using the given colormap. """
-            cmap = generate_mask_random_cmap(mask)
-            rgba_mask = cmap(mask / mask.max())  # Normalize mask and map to colormap (RGBA)
-            rgba_mask[..., 3] = np.where(mask > 0, alpha, 0)  # Apply transparency only where mask is present
-            return rgba_mask
-        
-        def _overlay_mask(image, mask):
-            """Overlay the colored mask onto the original image."""
-            combined = np.clip(image + mask[..., :3] * mask[..., 3:4], 0, 1)  # Ensure pixel values stay in [0, 1]
-            return combined
-            
-        def _normalize_image(image, percentiles=(2, 98)):
-            """Normalize the image to the given percentiles."""
-            v_min, v_max = np.percentile(image, percentiles)
-            image_normalized = np.clip((image - v_min) / (v_max - v_min), 0, 1)
-            return image_normalized
-
-        def _generate_contours(mask):
-            """Generate contours for the given mask using OpenCV."""
-            contours, _ = cv2.findContours(mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-            return contours
-
-        def _apply_contours(image, mask, color, thickness):
-            """Apply the contours to the RGB image for each unique label."""
-            unique_labels = np.unique(mask)
-            for label in unique_labels:
-                if label == 0:
-                    continue  # Skip background
-                label_mask = np.where(mask == label, 1, 0).astype(np.uint8)
-                contours = _generate_contours(label_mask)
-                for contour in contours:
-                    cv2.drawContours(image, [contour], -1, mpl.colors.to_rgb(color), thickness)
-            return image
-
-        num_channels = image.shape[-1]
-        fig, ax = plt.subplots(1, num_channels + 1, figsize=(4 * figuresize, figuresize))
-
-        # Plot each channel with its corresponding outlines
-        for v in range(num_channels):
-            channel_image = image[..., v]
-            channel_image_normalized = _normalize_image(channel_image, percentiles)
-            channel_image_rgb = np.dstack((channel_image_normalized, channel_image_normalized, channel_image_normalized))
-
-            for outline, color in zip(outlines, outline_colors):
-                if mode == 'outlines':
-                    channel_image_rgb = _apply_contours(channel_image_rgb, outline, color, thickness)
-                else:
-                    mask = _generate_colored_mask(outline, alpha=0.5)
-                    channel_image_rgb = _overlay_mask(channel_image_rgb, mask)
-
-            ax[v].imshow(channel_image_rgb)
-            ax[v].set_title(f'Image - Channel {v}')
-
-        # Plot the combined RGB image with all outlines
-        rgb_image = np.zeros((*image.shape[:2], 3), dtype=float)
-        rgb_channels = min(3, num_channels)
-        for i in range(rgb_channels):
-            channel_image = image[..., i]
-            channel_image_normalized = _normalize_image(channel_image, percentiles)
-            rgb_image[..., i] = channel_image_normalized
-
-        for outline, color in zip(outlines, outline_colors):
-            if mode == 'outlines':
-                rgb_image = _apply_contours(rgb_image, outline, color, thickness)
-            else:
-                mask = _generate_colored_mask(outline, alpha=0.5)
-                rgb_image = _overlay_mask(rgb_image, mask)
-
-        ax[-1].imshow(rgb_image)
-        ax[-1].set_title('Combined RGB Image')
-
-        plt.tight_layout()
-
-        # Save the figure as a PDF
-        if save_pdf:
-            pdf_dir = os.path.join(os.path.dirname(os.path.dirname(file)), 'results', 'overlay')
-            os.makedirs(pdf_dir, exist_ok=True)
-            pdf_path = os.path.join(pdf_dir, os.path.basename(file).replace('.npy', '.pdf'))
-            fig.savefig(pdf_path, format='pdf')
-
-        plt.show()
-        return fig
-    
-    def _save_channels_as_tiff(stack, save_dir, filename):
-        """Save each channel in the stack as a grayscale TIFF."""
-        os.makedirs(save_dir, exist_ok=True)
-        for i in range(stack.shape[-1]):
-            channel = stack[..., i]
-            tiff_path = os.path.join(save_dir, f"{filename}_channel_{i}.tiff")
-            tiff.imwrite(tiff_path, channel, photometric='minisblack')
-            print(f"Saved {tiff_path}")
-    
-    stack = np.load(file)
-
-    if export_tiffs:
-        save_dir = os.path.join(os.path.dirname(os.path.dirname(file)), 'results', os.path.splitext(os.path.basename(file))[0], 'tiff')
-        filename = os.path.splitext(os.path.basename(file))[0]
-        _save_channels_as_tiff(stack, save_dir, filename)
-
-    # Convert to float for normalization and ensure correct handling of both 8-bit and 16-bit arrays
-    if stack.dtype == np.uint16:
-        stack = stack.astype(np.float32)
-    elif stack.dtype == np.uint8:
-        stack = stack.astype(np.float32)
-
-    image = stack[..., channels]
-    outlines = []
-    outline_colors = []
-
-    if pathogen_channel is not None:
-        pathogen_mask_dim = -1  # last dimension
-        outlines.append(np.take(stack, pathogen_mask_dim, axis=2))
-        outline_colors.append('blue')
-
-    if nucleus_channel is not None:
-        nucleus_mask_dim = -2 if pathogen_channel is not None else -1
-        outlines.append(np.take(stack, nucleus_mask_dim, axis=2))
-        outline_colors.append('green')
-
-    if cell_channel is not None:
-        if nucleus_channel is not None and pathogen_channel is not None:
-            cell_mask_dim = -3
-        elif nucleus_channel is not None or pathogen_channel is not None:
-            cell_mask_dim = -2
-        else:
-            cell_mask_dim = -1
-        outlines.append(np.take(stack, cell_mask_dim, axis=2))
-        outline_colors.append('red')
-
-    fig = _plot_merged_plot(image=image, outlines=outlines, outline_colors=outline_colors, figuresize=figuresize, thickness=thickness, percentiles=percentiles, mode=mode)
-
-    return fig
-
 def plot_masks(batch, masks, flows, cmap='inferno', figuresize=10, nr=1, file_type='.npz', print_object_number=True):
     """
     Plot the masks and flows for a given batch of images.
@@ -1792,25 +1653,40 @@ def generate_plate_heatmap(df, plate_number, variable, grouping, min_max, min_co
     if not isinstance(min_count, (int, float)):
         min_count = 0
 
-    df = df.copy()  # Work on a copy to avoid SettingWithCopyWarning
-    df['plate'], df['row'], df['col'] = zip(*df['prc'].str.split('_'))
+    # Check the number of parts in 'prc'
+    num_parts = len(df['prc'].iloc[0].split('_'))
+    if num_parts == 4:
+        split = df['prc'].str.split('_', expand=True)
+        df['row_name'] = split[2]
+        df['prc'] = f"{plate_number}" + '_' + split[2] + '_' + split[3]
+        
+    # Construct 'prc' based on 'plate', 'row_name', and 'column' columns
+    #df['prc'] = df['plate'].astype(str) + '_' + df['row_name'].astype(str) + '_' + df['column'].astype(str)
+
+    if 'column_name' not in df.columns:
+        if 'column' in df.columns:
+            df['column_name'] = df['column']
+        if 'column_name' in df.columns:
+            df['column_name'] = df['column_name']
+                
+    df['plate'], df['row_name'], df['column_name'] = zip(*df['prc'].str.split('_'))
     
     # Filtering the dataframe based on the plate_number
     df = df[df['plate'] == plate_number].copy()  # Create another copy after filtering
-
+    
     # Ensure proper ordering
     row_order = [f'r{i}' for i in range(1, 17)]
     col_order = [f'c{i}' for i in range(1, 28)]  # Exclude c15 as per your earlier code
     
-    df['row'] = pd.Categorical(df['row'], categories=row_order, ordered=True)
-    df['col'] = pd.Categorical(df['col'], categories=col_order, ordered=True)
-    df['count'] = df.groupby(['row', 'col'])['row'].transform('count')
+    df['row_name'] = pd.Categorical(df['row_name'], categories=row_order, ordered=True)
+    df['column_name'] = pd.Categorical(df['column_name'], categories=col_order, ordered=True)
+    df['count'] = df.groupby(['row_name', 'column_name'])['row_name'].transform('count')
 
     if min_count > 0:
         df = df[df['count'] >= min_count]
 
     # Explicitly set observed=True to avoid FutureWarning
-    grouped = df.groupby(['row', 'col'], observed=True) # Group by row and column
+    grouped = df.groupby(['row_name', 'column_name'], observed=True) # Group by row and column
     
     if grouping == 'mean':
         plate = grouped[variable].mean().reset_index()
@@ -1822,7 +1698,7 @@ def generate_plate_heatmap(df, plate_number, variable, grouping, min_max, min_co
     else:
         raise ValueError(f"Unsupported grouping: {grouping}")
         
-    plate_map = pd.pivot_table(plate, values=variable, index='row', columns='col').fillna(0)
+    plate_map = pd.pivot_table(plate, values=variable, index='row_name', columns='column_name').fillna(0)
     
     if min_max == 'all':
         min_max = [plate_map.min().min(), plate_map.max().max()]
@@ -1964,81 +1840,6 @@ def print_mask_and_flows(stack, mask, flows, overlay=True, max_size=1000, thickn
 
     fig.tight_layout()
     plt.show()
-
-def print_mask_and_flows_v1(stack, mask, flows, overlay=False, max_size=1000):
-    """
-    Display the original image, mask, and flow with optional resizing for large images.
-    
-    Args:
-        stack (np.array): Original image or stack.
-        mask (np.array): Mask image.
-        flows (list): List of flow images.
-        overlay (bool): Whether to overlay the mask on the original image.
-        max_size (int): Maximum allowed size for any dimension of the images.
-    """
-
-    def resize_if_needed(image, max_size):
-        """Resize image if any dimension exceeds max_size while maintaining aspect ratio."""
-        if max(image.shape[:2]) > max_size:
-            scale = max_size / max(image.shape[:2])
-            new_shape = (int(image.shape[0] * scale), int(image.shape[1] * scale))
-            if image.ndim == 3:
-                new_shape += (image.shape[2],)
-            return skimage.transform.resize(image, new_shape, preserve_range=True, anti_aliasing=True).astype(image.dtype)
-        return image
-
-    # Resize if necessary
-    stack = resize_if_needed(stack, max_size)
-    mask = resize_if_needed(mask, max_size)
-    flows = [resize_if_needed(flow, max_size) for flow in flows]
-
-    fig, axs = plt.subplots(1, 3, figsize=(12, 4))  # Adjust subplot layout
-    
-    if stack.shape[-1] == 1:
-        stack = np.squeeze(stack)
-    
-    # Display original image or its first channel
-    if stack.ndim == 2:
-        axs[0].imshow(stack, cmap='gray')
-    elif stack.ndim == 3:
-        axs[0].imshow(stack)
-    else:
-        raise ValueError("Unexpected stack dimensionality.")
-
-    axs[0].set_title('Original Image')
-    axs[0].axis('off')
-    
-
-    # Overlay mask on original image if overlay is True
-    if overlay:
-        mask_cmap = generate_mask_random_cmap(mask)  # Generate random colormap for mask
-        mask_overlay = np.ma.masked_where(mask == 0, mask)  # Mask background
-        outlines = find_boundaries(mask, mode='thick')  # Find mask outlines
-
-        if stack.ndim == 2 or stack.ndim == 3:
-            axs[1].imshow(stack, cmap='gray' if stack.ndim == 2 else None)
-            axs[1].imshow(mask_overlay, cmap=mask_cmap, alpha=0.5)  # Overlay mask
-            axs[1].contour(outlines, colors='r', linewidths=2)  # Add red outlines with thickness 2
-    else:
-        axs[1].imshow(mask, cmap='gray')
-    
-    axs[1].set_title('Mask with Overlay' if overlay else 'Mask')
-    axs[1].axis('off')
-
-    # Display flow image or its first channel
-    if flows and isinstance(flows, list) and flows[0].ndim in [2, 3]:
-        flow_image = flows[0]
-        if flow_image.ndim == 3:
-            flow_image = flow_image[:, :, 0]  # Use first channel for 3D
-        axs[2].imshow(flow_image, cmap='jet')
-    else:
-        raise ValueError("Unexpected flow dimensionality or structure.")
-    
-    axs[2].set_title('Flows')
-    axs[2].axis('off')
-
-    fig.tight_layout()
-    plt.show()
     
 def plot_resize(images, resized_images, labels, resized_labels):
     # Display an example image and label before and after resizing
@@ -2296,48 +2097,6 @@ def plot_lorenz_curves(csv_files, name_column='grna_name', value_column='count',
         print(f"Saved Lorenz Curve: {save_file_path}")
         plt.show()
 
-def plot_lorenz_curves_v1(csv_files, remove_keys=['TGGT1_220950_1', 'TGGT1_233460_4']):
-    
-    def lorenz_curve(data):
-        """Calculate Lorenz curve."""
-        sorted_data = np.sort(data)
-        cumulative_data = np.cumsum(sorted_data)
-        lorenz_curve = cumulative_data / cumulative_data[-1]
-        lorenz_curve = np.insert(lorenz_curve, 0, 0)
-        return lorenz_curve
-    
-    combined_data = []
-
-    plt.figure(figsize=(10, 6))
-
-    for idx, csv_file in enumerate(csv_files):
-        if idx == 1:
-            save_fldr = os.path.dirname(csv_file)
-            save_path = os.path.join(save_fldr, 'lorenz_curve.pdf')
-            
-        df = pd.read_csv(csv_file)
-        for remove in remove_keys:
-            df = df[df['key'] != remove]
-        
-        values = df['value'].values
-        combined_data.extend(values)
-        
-        lorenz = lorenz_curve(values)
-        name = os.path.basename(csv_file)[:3]
-        plt.plot(np.linspace(0, 1, len(lorenz)), lorenz, label=name)
-
-    # Plot combined Lorenz curve
-    combined_lorenz = lorenz_curve(np.array(combined_data))
-    plt.plot(np.linspace(0, 1, len(combined_lorenz)), combined_lorenz, label="Combined Lorenz Curve", linestyle='--', color='black')
-    
-    plt.title('Lorenz Curves')
-    plt.xlabel('Cumulative Share of Individuals')
-    plt.ylabel('Cumulative Share of Value')
-    plt.legend()
-    plt.grid(False)
-    plt.savefig(save_path)
-    plt.show()
-
 def plot_permutation(permutation_df):
     num_features = len(permutation_df)
     fig_height = max(8, num_features * 0.3)  # Set a minimum height of 8 and adjust height based on number of features
@@ -2844,9 +2603,13 @@ class spacrGraph:
                           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."""
+
+        from .utils import choose_p_adjust_method
+
+        posthoc_results = []
         if is_normal and len(unique_groups) > 2 and self.all_to_all:
             tukey_result = pairwise_tukeyhsd(self.df[self.data_column], self.df[self.grouping_column], alpha=0.05)
             posthoc_results = []
@@ -2862,22 +2625,40 @@ class spacrGraph:
                     'n_object': len(raw_data1) + len(raw_data2),
                     'n_well': len(self.df[self.df[self.grouping_column] == comparison[0]]) + len(self.df[self.df[self.grouping_column] == comparison[1]])})
             return posthoc_results
-       
-        elif len(unique_groups) > 2 and not self.all_to_all and self.compare_group:
-            dunn_result = pg.pairwise_tests(data=self.df, dv=self.data_column, between=self.grouping_column, padjust='bonf', test='dunn')
-            posthoc_results = []
-            for idx, row in dunn_result.iterrows():
-                if row['A'] == self.compare_group or row['B'] == self.compare_group:
-                    posthoc_results.append({
-                        'Comparison': f"{row['A']} vs {row['B']}",
-                        'Test Statistic': row['T'],  # Test statistic from Dunn's test
-                        'p-value': row['p-val'],
-                        'Test Name': 'Dunn’s Post-hoc',
-                        'n_object': None,
-                        'n_well': None})
-                    
+        
+        elif len(unique_groups) > 2 and self.all_to_all:
+            print('performing_dunns')
+
+            # Prepare data for Dunn's test in long format
+            long_data = self.df[[self.data_column[0], self.grouping_column]].dropna()
+
+            p_adjust_method = choose_p_adjust_method(num_groups=len(long_data[self.grouping_column].unique()),num_data_points=len(long_data) // len(long_data[self.grouping_column].unique()))
+
+            # Perform Dunn's test with Bonferroni correction
+            dunn_result = sp.posthoc_dunn(
+                long_data, 
+                val_col=self.data_column[0], 
+                group_col=self.grouping_column, 
+                p_adjust=p_adjust_method
+            )
+
+            for group_a, group_b in zip(*np.triu_indices_from(dunn_result, k=1)):
+                raw_data1 = self.raw_df[self.raw_df[self.grouping_column] == dunn_result.index[group_a]][self.data_column]
+                raw_data2 = self.raw_df[self.raw_df[self.grouping_column] == dunn_result.columns[group_b]][self.data_column]
+
+                posthoc_results.append({
+                    'Comparison': f"{dunn_result.index[group_a]} vs {dunn_result.columns[group_b]}",
+                    'Test Statistic': None,  # Dunn's test does not return a specific test statistic
+                    'p-value': dunn_result.iloc[group_a, group_b],  # Extract the p-value from the matrix
+                    'Test Name': "Dunn's Post-hoc",
+                    'p_adjust_method': p_adjust_method,
+                    'n_object': len(raw_data1) + len(raw_data2),  # Total objects
+                    'n_well': len(self.df[self.df[self.grouping_column] == dunn_result.index[group_a]]) +
+                            len(self.df[self.grouping_column] == dunn_result.columns[group_b])})
+
             return posthoc_results
-        return []
+
+        return posthoc_results
     
     def create_plot(self, ax=None):
         """Create and display the plot based on the chosen graph type."""
@@ -2913,31 +2694,40 @@ class spacrGraph:
             transposed_table = list(map(list, zip(*table_data)))
             return row_labels, transposed_table
 
-        def _place_symbols(row_labels, transposed_table, x_positions, ax):            
+
+        def _place_symbols(row_labels, transposed_table, x_positions, ax):
+            """
+            Places symbols and row labels aligned under the bars or jitter points on the graph.
             
-            # Get the bottom of the y-axis (y=0) in data coordinates and convert to display coordinates
+            Parameters:
+            - row_labels: List of row titles to be displayed along the y-axis.
+            - transposed_table: Data to be placed under each bar/jitter as symbols.
+            - x_positions: X-axis positions for each group to align the symbols.
+            - ax: The matplotlib Axes object where the plot is drawn.
+            """
+            # Get plot dimensions and adjust for different plot sizes
             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
+            symbol_start_y = y_axis_min - 0.05 * (ax.get_ylim()[1] - y_axis_min)  # Adjust a bit below the x-axis
+
+            # Calculate spacing for the table rows (adjust as needed)
+            y_spacing = 0.04  # Adjust this for better spacing between rows
+
+            # Determine the leftmost x-position for row labels (align with the y-axis)
+            label_x_pos = ax.get_xlim()[0] - 0.3  # Adjust offset from the y-axis
+
+            # Place row labels vertically aligned with symbols
             for row_idx, title in enumerate(row_labels):
-                y_pos = symbol_start_y_fig - (row_idx * y_spacing)  # Align with row index
+                y_pos = symbol_start_y - (row_idx * y_spacing)  # Calculate vertical position for each label
                 ax.text(label_x_pos, y_pos, title, ha='right', va='center', fontsize=12, fontweight='regular')
-        
-            # Place the symbols under each bar
+
+            # Place symbols under each bar or jitter point based on x-positions
             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)
+                    y_pos = symbol_start_y - (row_idx * y_spacing)  # Adjust vertical spacing for symbols
+                    ax.text(x_pos, y_pos, text, ha='center', va='center', fontsize=12, fontweight='regular')
+
+            # Redraw to apply changes
+            ax.figure.canvas.draw()
                     
         def _get_positions(self, ax):
             if self.graph_type in ['bar','jitter_bar']: 
@@ -3048,6 +2838,10 @@ class spacrGraph:
         else:
             raise ValueError(f"Unknown graph type: {self.graph_type}") 
         
+        if len(self.data_column) == 1:
+            num_groups = len(self.df[self.grouping_column].unique())
+            self._standerdize_figure_format(ax=ax, num_groups=num_groups, graph_type=self.graph_type)
+
         # Set y-axis start
         if isinstance(self.y_lim, list):
             if len(self.y_lim) == 2:
@@ -3082,7 +2876,73 @@ class spacrGraph:
         if self.save:
             self._save_results()
 
-        ax.margins(x=0.12) 
+        ax.margins(x=0.12)
+
+    def _standerdize_figure_format(self, ax, num_groups, graph_type):
+        """
+        Adjusts the figure layout (size, bar width, jitter, and spacing) based on the number of groups.
+
+        Parameters:
+        - ax: The matplotlib Axes object.
+        - num_groups: Number of unique groups.
+        - graph_type: The type of graph (e.g., 'bar', 'jitter', 'box', etc.).
+
+        Returns:
+        - None. Modifies the figure and Axes in place.
+        """
+        if graph_type in ['line', 'line_std']:
+            print("Skipping layout adjustment for line graphs.")
+            return  # Skip layout adjustment for line graphs
+        
+        correction_factor = 4
+
+        # Set figure size to ensure it remains square with a minimum size
+        fig_size = max(6, num_groups * 2)  / correction_factor
+        ax.figure.set_size_inches(fig_size, fig_size)
+
+        # Configure layout based on the number of groups
+        bar_width = min(0.8, 1.5 / num_groups) / correction_factor
+        jitter_amount = min(0.1, 0.2 / num_groups) / correction_factor
+        jitter_size = max(50 / num_groups, 200)
+
+        # Adjust axis limits to ensure bars are centered with respect to group labels
+        ax.set_xlim(-0.5, num_groups - 0.5)
+
+        # Set ticks to match the group labels in your DataFrame
+        group_labels = self.df[self.grouping_column].unique()
+        ax.set_xticks(range(len(group_labels)))
+        ax.set_xticklabels(group_labels, rotation=45, ha='right')
+
+        # Customize elements based on the graph type
+        if graph_type == 'bar':
+            # Adjust bars' width and position
+            for bar in ax.patches:
+                bar.set_width(bar_width)
+                bar.set_x(bar.get_x() - bar_width / 2)
+
+        elif graph_type in ['jitter', 'jitter_bar', 'jitter_box']:
+            # Adjust jitter points' position and size
+            for coll in ax.collections:
+                offsets = coll.get_offsets()
+                offsets[:, 0] += jitter_amount  # Shift jitter points slightly
+                coll.set_offsets(offsets)
+                coll.set_sizes([jitter_size]  * len(offsets))  # Adjust point size dynamically
+
+        elif graph_type in ['box', 'violin']:
+            # Adjust box width for consistent spacing
+            for artist in ax.artists:
+                artist.set_width(bar_width)
+
+        # Adjust legend and axis labels
+        ax.tick_params(axis='x', labelsize=max(10, 15 - num_groups // 2))
+        ax.tick_params(axis='y', labelsize=max(10, 15 - num_groups // 2))
+
+        if ax.get_legend():
+            ax.get_legend().set_bbox_to_anchor((1.05, 1)) #loc='upper left',borderaxespad=0.
+            ax.get_legend().prop.set_size(max(8, 12 - num_groups // 3))
+
+        # Redraw the figure to apply changes
+        ax.figure.canvas.draw()
 
     def _create_bar_plot(self, ax):
         """Helper method to create a bar plot with consistent bar thickness and centered error bars."""
@@ -3301,11 +3161,11 @@ class spacrGraph:
                 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)
+        #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)
@@ -3420,7 +3280,7 @@ def plot_data_from_db(settings):
         dfs.append(dft)
         
     df = pd.concat(dfs, axis=0)
-    df['prc'] = df['plate'].astype(str) + '_' + df['row'].astype(str) + '_' + df['col'].astype(str)
+    df['prc'] = df['plate'].astype(str) + '_' + df['row_name'].astype(str) + '_' + df['column_name'].astype(str)
     #df['recruitment'] = df['pathogen_channel_1_mean_intensity'] / df['cytoplasm_channel_1_mean_intensity']
     #df['recruitment'] = df['pathogen_channel_1_mean_intensity'] / df['cytoplasm_channel_1_mean_intensity']
     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/sequencing.py

@@ -125,7 +125,7 @@ def process_chunk(chunk_data):
                         consensus_sequences.append(consensus_seq)
                         column_sequence = match.group('column')
                         grna_sequence = match.group('grna')
-                        row_sequence = match.group('row')
+                        row_sequence = match.group('row_name')
                         columns.append(column_sequence)
                         grnas.append(grna_sequence)
                         rows.append(row_sequence)
@@ -176,7 +176,7 @@ def process_chunk(chunk_data):
                         consensus_sequences.append(consensus_seq)
                         column_sequence = match.group('column')
                         grna_sequence = match.group('grna')
-                        row_sequence = match.group('row')
+                        row_sequence = match.group('row_name')
                         columns.append(column_sequence)
                         grnas.append(grna_sequence)
                         rows.append(row_sequence)
@@ -532,7 +532,7 @@ def graph_sequencing_stats(settings):
         # Iterate through the fraction thresholds
         for threshold in fraction_thresholds:
             filtered_df = df[df['fraction'] >= threshold]
-            unique_count = filtered_df.groupby(['plate', 'row', 'column'])['grna'].nunique().mean()
+            unique_count = filtered_df.groupby(['plate', 'row_name', 'column'])['grna'].nunique().mean()
             results.append((threshold, unique_count))
 
         results_df = pd.DataFrame(results, columns=['fraction_threshold', 'unique_count'])
@@ -588,17 +588,21 @@ def graph_sequencing_stats(settings):
     # Apply the closest threshold to the DataFrame
     df = df[df['fraction'] >= closest_threshold]
 
-    # Group by 'plate', 'row', 'column' and compute unique counts of 'grna'
-    unique_counts = df.groupby(['plate', 'row', 'column'])['grna'].nunique().reset_index(name='unique_counts')
-    unique_count_mean = df.groupby(['plate', 'row', 'column'])['grna'].nunique().mean()
-    unique_count_std = df.groupby(['plate', 'row', 'column'])['grna'].nunique().std()
+    # Group by 'plate', 'row_name', 'column' and compute unique counts of 'grna'
+    unique_counts = df.groupby(['plate', 'row_name', 'column'])['grna'].nunique().reset_index(name='unique_counts')
+    unique_count_mean = df.groupby(['plate', 'row_name', 'column'])['grna'].nunique().mean()
+    unique_count_std = df.groupby(['plate', 'row_name', 'column'])['grna'].nunique().std()
 
     # Merge the unique counts back into the original DataFrame
-    df = pd.merge(df, unique_counts, on=['plate', 'row', 'column'], how='left')
+    df = pd.merge(df, unique_counts, on=['plate', 'row_name', 'column'], how='left')
 
     print(f"unique_count mean: {unique_count_mean} std: {unique_count_std}")
-    display(df)
     #_plot_density(df, dependent_variable='unique_counts')
+    
+    has_underscore = df['row_name'].str.contains('_').any()
+    if has_underscore:
+        df['row_name'] = df['row_name'].apply(lambda x: x.split('_')[1])
+    
     plot_plates(df=df, variable='unique_counts', grouping='mean', min_max='allq', cmap='viridis',min_count=0, verbose=True, dst=dst)
     
     return closest_threshold