spacr 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

spacr/openai.py

@@ -0,0 +1,37 @@
+#from openai import OpenAI, APIError, OpenAIError 
+#import openai
+#
+#class Chatbot:
+#    def __init__(self, api_key):
+#        openai.api_key = api_key
+#
+#    def ask_question(self, question):
+#        try:
+#            # Sending the request to the gpt-4o-mini model
+#            response = openai.chat.completions.create(
+#                model="gpt-3.5-turbo",  # Correct model name for your setup
+#                messages=[
+#                    {"role": "user", "content": question}
+#                ],
+#                max_tokens=150
+#            )
+#            # Extracting the response from the model and returning it
+#            return response.choices[0].message['content'].strip()
+#        except (APIError, OpenAIError) as e:
+#            return f"Error: {str(e)}"
+#        
+#def list_available_models():
+#    try:
+#        # List available models
+#        models = openai.models.list()  
+#        
+#        # Iterate through models directly
+#        for model in models:
+#            print(model.id)  # Print the model ID
+#    except (APIError, OpenAIError) as e:
+#        print(f"Error: {str(e)}")
+
+# Replace with your actual API key or ensure it's set as an environment variable
+
+#openai.api_key = api_key
+#list_available_models()

spacr/plot.py

@@ -1,4 +1,4 @@
-import os,re, random, cv2, glob, time, math, torch
+import os, random, cv2, glob, math, torch
 
 import numpy as np
 import pandas as pd
@@ -14,11 +14,14 @@ from skimage.segmentation import find_boundaries
 from skimage import measure
 from skimage.measure import find_contours, label, regionprops
 
+from scipy.stats import normaltest, ttest_ind, mannwhitneyu, f_oneway, kruskal
+from statsmodels.stats.multicomp import pairwise_tukeyhsd
+import itertools
+
+
 from ipywidgets import IntSlider, interact
 from IPython.display import Image as ipyimage
 
-from .logger import log_function_call
-
 def plot_image_mask_overlay(file, channels, cell_channel, nucleus_channel, pathogen_channel, figuresize=10, normalize=True, thickness=3, save_pdf=True):
     """Plot image and mask overlays."""
 
@@ -123,7 +126,7 @@ def plot_image_mask_overlay(file, channels, cell_channel, nucleus_channel, patho
 
     fig = _plot_merged_plot(image=image, outlines=outlines, outline_colors=outline_colors, figuresize=figuresize, thickness=thickness)
 
-    return
+    return fig
 
 def plot_masks(batch, masks, flows, cmap='inferno', figuresize=10, nr=1, file_type='.npz', print_object_number=True):
     """
@@ -409,7 +412,7 @@ def plot_images_and_arrays(folders, lower_percentile=1, upper_percentile=99, thr
     plot_from_file_dict(file_dict, threshold, lower_percentile, upper_percentile, overlay, save=False)
     return
 
-def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mask_dim, mask_dims, filter_min_max, include_multinucleated, include_multiinfected):
+def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mask_dim, mask_dims, filter_min_max, nuclei_limit, pathogen_limit):
     """
     Filters objects in a plot based on various criteria.
 
@@ -420,8 +423,8 @@ def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mas
         pathogen_mask_dim (int): The dimension index of the pathogen mask.
         mask_dims (list): A list of dimension indices for additional masks.
         filter_min_max (list): A list of minimum and maximum area values for each mask.
-        include_multinucleated (bool): Whether to include multinucleated cells.
-        include_multiinfected (bool): Whether to include multiinfected cells.
+        nuclei_limit (bool): Whether to include multinucleated cells.
+        pathogen_limit (bool): Whether to include multiinfected cells.
 
     Returns:
         numpy.ndarray: The filtered stack of masks.
@@ -451,9 +454,9 @@ def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mas
         total_count_after = len(props_after['label'])
 
         if mask_dim == cell_mask_dim:
-            if include_multinucleated is False and nucleus_mask_dim is not None:
+            if nuclei_limit is False and nucleus_mask_dim is not None:
                 stack = _remove_multiobject_cells(stack, mask_dim, cell_mask_dim, nucleus_mask_dim, pathogen_mask_dim, object_dim=pathogen_mask_dim)
-            if include_multiinfected is False and cell_mask_dim is not None and pathogen_mask_dim is not None:
+            if pathogen_limit is False and cell_mask_dim is not None and pathogen_mask_dim is not None:
                 stack = _remove_multiobject_cells(stack, mask_dim, cell_mask_dim, nucleus_mask_dim, pathogen_mask_dim, object_dim=nucleus_mask_dim)
             cell_area_before = avg_size_before
             cell_count_before = total_count_before
@@ -662,18 +665,18 @@ def plot_merged(src, settings):
         display(settings)
         
     if settings['pathogen_mask_dim'] is None:
-        settings['include_multiinfected'] = True
+        settings['pathogen_limit'] = True
 
     for file in os.listdir(src):
         path = os.path.join(src, file)
         stack = np.load(path)
         print(f'Loaded: {path}')
-        if not settings['include_noninfected']:
+        if not settings['uninfected']:
             if settings['pathogen_mask_dim'] is not None and settings['cell_mask_dim'] is not None:
                 stack = _remove_noninfected(stack, settings['cell_mask_dim'], settings['nucleus_mask_dim'], settings['pathogen_mask_dim'])
 
-        if settings['include_multiinfected'] is not True or settings['include_multinucleated'] is not True or settings['filter_min_max'] is not None:
-            stack = _filter_objects_in_plot(stack, settings['cell_mask_dim'], settings['nucleus_mask_dim'], settings['pathogen_mask_dim'], mask_dims, settings['filter_min_max'], settings['include_multinucleated'], settings['include_multiinfected'])
+        if settings['pathogen_limit'] is not True or settings['nuclei_limit'] is not True or settings['filter_min_max'] is not None:
+            stack = _filter_objects_in_plot(stack, settings['cell_mask_dim'], settings['nucleus_mask_dim'], settings['pathogen_mask_dim'], mask_dims, settings['filter_min_max'], settings['nuclei_limit'], settings['pathogen_limit'])
 
         overlayed_image, image, outlines = _normalize_and_outline(image=stack, 
                                                                   remove_background=settings['remove_background'],
@@ -1359,7 +1362,7 @@ def generate_plate_heatmap(df, plate_number, variable, grouping, min_max, min_co
         
     return plate_map, min_max
 
-def plot_plates(df, variable, grouping, min_max, cmap, min_count=0, verbose=True):
+def plot_plates(df, variable, grouping, min_max, cmap, min_count=0, verbose=True, dst=None):
     plates = df['prc'].str.split('_', expand=True)[0].unique()
     n_rows, n_cols = (len(plates) + 3) // 4, 4
     fig, ax = plt.subplots(n_rows, n_cols, figsize=(40, 5 * n_rows))
@@ -1374,6 +1377,12 @@ def plot_plates(df, variable, grouping, min_max, cmap, min_count=0, verbose=True
         fig.delaxes(ax[i])
     
     plt.subplots_adjust(wspace=0.1, hspace=0.4)
+
+    if not dst is None:
+        filename = os.path.join(dst, 'plate_heatmap.pdf')
+        fig.savefig(filename, format='pdf')
+        print(f'Saved heatmap to {filename}')
+
     if verbose:
         plt.show()
     return fig
@@ -1605,13 +1614,19 @@ def volcano_plot(coef_df, filename='volcano_plot.pdf'):
     print(f'Saved Volcano plot: {filename}')
     plt.show()
 
-def plot_histogram(df, dependent_variable):
+def plot_histogram(df, dependent_variable, dst=None):
     # Plot histogram of the dependent variable
     plt.figure(figsize=(10, 6))
     sns.histplot(df[dependent_variable], kde=True)
     plt.title(f'Histogram of {dependent_variable}')
     plt.xlabel(dependent_variable)
     plt.ylabel('Frequency')
+    
+    if not dst is None:
+        filename = os.path.join(dst, 'dependent_variable_histogram.pdf')
+        plt.savefig(filename, format='pdf')
+        print(f'Saved histogram to {filename}')
+
     plt.show()
 
 def plot_lorenz_curves(csv_files, remove_keys=['TGGT1_220950_1', 'TGGT1_233460_4']):
@@ -1732,4 +1747,254 @@ def read_and_plot__vision_results(base_dir, y_axis='accuracy', name_split='_time
             plt.ylim(y_lim)
         plt.show()
     else:
-        print("No CSV files found in the specified directory.")
+        print("No CSV files found in the specified directory.")
+
+def jitterplot_by_annotation(src, x_column, y_column, plot_title='Jitter Plot', output_path=None, filter_column=None, filter_values=None):
+    """
+    Reads a CSV file and creates a jitter plot of one column grouped by another column.
+    
+    Args:
+    src (str): Path to the source data.
+    x_column (str): Name of the column to be used for the x-axis.
+    y_column (str): Name of the column to be used for the y-axis.
+    plot_title (str): Title of the plot. Default is 'Jitter Plot'.
+    output_path (str): Path to save the plot image. If None, the plot will be displayed. Default is None.
+    
+    Returns:
+    pd.DataFrame: The filtered and balanced DataFrame.
+    """
+
+    def join_measurments_and_annotation(src, tables = ['cell', 'nucleus', 'pathogen','cytoplasm']):
+        from .io import _read_and_merge_data, _read_db
+        db_loc = [src+'/measurements/measurements.db']
+        loc = src+'/measurements/measurements.db'
+        df, _ = _read_and_merge_data(db_loc, 
+                                    tables, 
+                                    verbose=True, 
+                                    nuclei_limit=True, 
+                                    pathogen_limit=True, 
+                                    uninfected=True)
+        paths_df = _read_db(loc, tables=['png_list'])
+        merged_df = pd.merge(df, paths_df[0], on='prcfo', how='left')
+        return merged_df
+
+    # Read the CSV file into a DataFrame
+    df = join_measurments_and_annotation(src, tables=['cell', 'nucleus', 'pathogen', 'cytoplasm'])
+
+    # Print column names for debugging
+    print(f"Generated dataframe with: {df.shape[1]} columns and {df.shape[0]} rows")
+    #print("Columns in DataFrame:", df.columns.tolist())
+
+    # Replace NaN values with a specific label in x_column
+    df[x_column] = df[x_column].fillna('NaN')
+
+    # Filter the DataFrame if filter_column and filter_values are provided
+    if not filter_column is None:
+        if isinstance(filter_column, str):
+            df = df[df[filter_column].isin(filter_values)]
+        if isinstance(filter_column, list):
+            for i,val in enumerate(filter_column):
+                print(f'hello {len(df)}')
+                df = df[df[val].isin(filter_values[i])]
+
+    # Use the correct column names based on your DataFrame
+    required_columns = ['plate_x', 'row_x', 'col_x']
+    if not all(column in df.columns for column in required_columns):
+        raise KeyError(f"DataFrame does not contain the necessary columns: {required_columns}")
+
+    # Filter to retain rows with non-NaN values in x_column and with matching plate, row, col values
+    non_nan_df = df[df[x_column] != 'NaN']
+    retained_rows = df[df[['plate_x', 'row_x', 'col_x']].apply(tuple, axis=1).isin(non_nan_df[['plate_x', 'row_x', 'col_x']].apply(tuple, axis=1))]
+
+    # Determine the minimum count of examples across all groups in x_column
+    min_count = retained_rows[x_column].value_counts().min()
+    print(f'Found {min_count} annotated images')
+
+    # Randomly sample min_count examples from each group in x_column
+    balanced_df = retained_rows.groupby(x_column).apply(lambda x: x.sample(min_count, random_state=42)).reset_index(drop=True)
+
+    # Create the jitter plot
+    plt.figure(figsize=(10, 6))
+    jitter_plot = sns.stripplot(data=balanced_df, x=x_column, y=y_column, hue=x_column, jitter=True, palette='viridis', dodge=False)
+    plt.title(plot_title)
+    plt.xlabel(x_column)
+    plt.ylabel(y_column)
+    
+    # Customize the x-axis labels
+    plt.xticks(rotation=45, ha='right')
+    
+    # Adjust the position of the x-axis labels to be centered below the data
+    ax = plt.gca()
+    ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha='center')
+    
+    # Save the plot to a file or display it
+    if output_path:
+        plt.savefig(output_path, bbox_inches='tight')
+        print(f"Jitter plot saved to {output_path}")
+    else:
+        plt.show()
+
+    return balanced_df
+
+def create_grouped_plot(df, grouping_column, data_column, graph_type='bar', summary_func='mean', order=None, colors=None, output_dir='./output', save=False, y_axis_start=None, error_bar_type='std'):
+    """
+    Create a grouped plot, perform statistical tests, and optionally export the results along with the plot.
+
+    Parameters:
+    - df: DataFrame containing the data.
+    - grouping_column: Column name for the categorical grouping.
+    - data_column: Column name for the data to be grouped and plotted.
+    - graph_type: Type of plot ('bar', 'violin', 'jitter', 'box', 'jitter_box').
+    - summary_func: Summary function to apply to each group ('mean', 'median', etc.).
+    - order: List specifying the order of the groups. If None, groups will be ordered alphabetically.
+    - colors: List of colors for each group.
+    - output_dir: Directory where the figure and test results will be saved if `save=True`.
+    - save: Boolean flag indicating whether to save the plot and results to files.
+    - y_axis_start: Optional starting value for the y-axis.
+    - error_bar_type: Type of error bars to plot, either 'std' for standard deviation or 'sem' for standard error of the mean.
+
+    Outputs:
+    - Figure of the plot.
+    - DataFrame with full statistical test results, including normality tests.
+    """
+    
+    # Remove NaN rows in grouping_column
+    df = df.dropna(subset=[grouping_column])
+    
+    # Ensure the output directory exists if save is True
+    if save:
+        os.makedirs(output_dir, exist_ok=True)
+    
+    # Sorting and ordering
+    if order:
+        df[grouping_column] = pd.Categorical(df[grouping_column], categories=order, ordered=True)
+    else:
+        df[grouping_column] = pd.Categorical(df[grouping_column], categories=sorted(df[grouping_column].unique()), ordered=True)
+    
+    # Get unique groups
+    unique_groups = df[grouping_column].unique()
+    
+    # Initialize test results
+    test_results = []
+
+    # Test normality for each group
+    grouped_data = [df.loc[df[grouping_column] == group, data_column] for group in unique_groups]
+    normal_p_values = [normaltest(data).pvalue for data in grouped_data]
+    normal_stats = [normaltest(data).statistic for data in grouped_data]
+    is_normal = all(p > 0.05 for p in normal_p_values)
+
+    # Add normality test results to the results_df
+    for group, stat, p_value in zip(unique_groups, normal_stats, normal_p_values):
+        test_results.append({
+            'Comparison': f'Normality test for {group}',
+            'Test Statistic': stat,
+            'p-value': p_value,
+            'Test Name': 'Normality test'
+        })
+
+    # Determine statistical test
+    if len(unique_groups) == 2:
+        if is_normal:
+            stat_test = ttest_ind
+            test_name = 'T-test'
+        else:
+            stat_test = mannwhitneyu
+            test_name = 'Mann-Whitney U test'
+    else:
+        if is_normal:
+            stat_test = f_oneway
+            test_name = 'One-way ANOVA'
+        else:
+            stat_test = kruskal
+            test_name = 'Kruskal-Wallis test'
+
+    # Perform pairwise statistical tests
+    comparisons = list(itertools.combinations(unique_groups, 2))
+    p_values = []
+    test_statistics = []
+
+    for (group1, group2) in comparisons:
+        data1 = df[df[grouping_column] == group1][data_column]
+        data2 = df[df[grouping_column] == group2][data_column]
+        stat, p = stat_test(data1, data2)
+        p_values.append(p)
+        test_statistics.append(stat)
+        test_results.append({'Comparison': f'{group1} vs {group2}', 'Test Statistic': stat, 'p-value': p, 'Test Name': test_name})
+    
+    # Post-hoc test (Tukey HSD for ANOVA)
+    posthoc_p_values = None
+    if is_normal and len(unique_groups) > 2:
+        tukey_result = pairwise_tukeyhsd(df[data_column], df[grouping_column], alpha=0.05)
+        posthoc_p_values = tukey_result.pvalues
+        for comparison, p_value in zip(tukey_result._results_table.data[1:], tukey_result.pvalues):
+            test_results.append({
+                'Comparison': f'{comparison[0]} vs {comparison[1]}',
+                'Test Statistic': None,  # Tukey does not provide a test statistic in the same way
+                'p-value': p_value,
+                'Test Name': 'Tukey HSD Post-hoc'
+            })
+
+    # Create plot
+    plt.figure(figsize=(10, 6))
+    sns.set(style="whitegrid")
+
+    if colors:
+        color_palette = colors
+    else:
+        color_palette = sns.color_palette("husl", len(unique_groups))
+    
+    # Choose graph type
+    if graph_type == 'bar':
+        summary_df = df.groupby(grouping_column)[data_column].agg([summary_func, 'std', 'sem'])
+        
+        # Set error bars based on error_bar_type
+        if error_bar_type == 'std':
+            error_bars = summary_df['std']
+        elif error_bar_type == 'sem':
+            error_bars = summary_df['sem']
+        else:
+            raise ValueError(f"Invalid error_bar_type: {error_bar_type}. Choose either 'std' or 'sem'.")
+
+        sns.barplot(x=grouping_column, y=summary_func, data=summary_df.reset_index(), ci=None, order=order, palette=color_palette)
+
+        # Add error bars (standard deviation or standard error of the mean)
+        plt.errorbar(x=np.arange(len(summary_df)), y=summary_df[summary_func], yerr=error_bars, fmt='none', c='black', capsize=5)
+    
+    elif graph_type == 'violin':
+        sns.violinplot(x=grouping_column, y=data_column, data=df, order=order, palette=color_palette)
+    elif graph_type == 'jitter':
+        sns.stripplot(x=grouping_column, y=data_column, data=df, jitter=True, order=order, palette=color_palette)
+    elif graph_type == 'box':
+        sns.boxplot(x=grouping_column, y=data_column, data=df, order=order, palette=color_palette)
+    elif graph_type == 'jitter_box':
+        sns.boxplot(x=grouping_column, y=data_column, data=df, order=order, palette=color_palette)
+        sns.stripplot(x=grouping_column, y=data_column, data=df, jitter=True, color='black', alpha=0.5, order=order)
+
+    # Create a DataFrame to summarize the test results
+    results_df = pd.DataFrame(test_results)
+
+    # Set y-axis start if provided
+    if y_axis_start is not None:
+        plt.ylim(bottom=y_axis_start)
+    else:
+        plt.ylim(0, None)  # Default to starting at 0 if no custom start value is provided
+
+    # If save is True, save the plot and results as PNG and CSV
+    if save:
+        # Save the plot as PNG
+        plot_path = os.path.join(output_dir, 'grouped_plot.png')
+        plt.title(f'{test_name} results for {graph_type} plot')
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        plt.savefig(plot_path)
+        print(f"Plot saved to {plot_path}")
+
+        # Save the test results as a CSV file
+        results_path = os.path.join(output_dir, 'test_results.csv')
+        results_df.to_csv(results_path, index=False)
+        print(f"Test results saved to {results_path}")
+
+    # Show the plot
+    plt.show()
+
+    return plt.gcf(), results_df