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

spacr/submodules.py

@@ -0,0 +1,348 @@
+import seaborn as sns
+import os, random, sqlite3
+import pandas as pd
+import numpy as np
+import cellpose
+from skimage.measure import regionprops, label
+from cellpose import models as cp_models
+from cellpose import train as train_cp
+from IPython.display import display
+
+def analyze_recruitment(settings={}):
+    """
+    Analyze recruitment data by grouping the DataFrame by well coordinates and plotting controls and recruitment data.
+
+    Parameters:
+    settings (dict): settings.
+
+    Returns:
+    None
+    """
+    
+    from .io import _read_and_merge_data, _results_to_csv
+    from .plot import plot_image_mask_overlay, _plot_controls, _plot_recruitment
+    from .utils import _object_filter, annotate_conditions, _calculate_recruitment, _group_by_well, save_settings
+    from .settings import get_analyze_recruitment_default_settings
+
+    settings = get_analyze_recruitment_default_settings(settings=settings)
+    save_settings(settings, name='recruitment')
+
+    print(f"Cell(s): {settings['cell_types']}, in {settings['cell_plate_metadata']}")
+    print(f"Pathogen(s): {settings['pathogen_types']}, in {settings['pathogen_plate_metadata']}")
+    print(f"Treatment(s): {settings['treatments']}, in {settings['treatment_plate_metadata']}")
+    
+    mask_chans=[settings['nucleus_chann_dim'], settings['pathogen_chann_dim'], settings['cell_chann_dim']]
+    
+    sns.color_palette("mako", as_cmap=True)
+    print(f"channel:{settings['channel_of_interest']} = {settings['target']}")
+    
+    df, _ = _read_and_merge_data(db_loc=[settings['src']+'/measurements/measurements.db'], 
+                                 tables=['cell', 'nucleus', 'pathogen','cytoplasm'], 
+                                 verbose=True, 
+                                 nuclei_limit=settings['nuclei_limit'], 
+                                 pathogen_limit=settings['pathogen_limit'], 
+                                 uninfected=settings['uninfected'])
+    
+    df = annotate_conditions(df, 
+                             cells=settings['cell_types'], 
+                             cell_loc=settings['cell_plate_metadata'], 
+                             pathogens=settings['pathogen_types'],
+                             pathogen_loc=settings['pathogen_plate_metadata'],
+                             treatments=settings['treatments'], 
+                             treatment_loc=settings['treatment_plate_metadata'])
+      
+    df = df.dropna(subset=['condition'])
+    print(f'After dropping non-annotated wells: {len(df)} rows')
+
+    files = df['file_name'].tolist()
+    print(f'found: {len(files)} files')
+
+    files = [item + '.npy' for item in files]
+    random.shuffle(files)
+
+    _max = 10**100
+    if settings['cell_size_range'] is None:
+        settings['cell_size_range'] = [0,_max]
+    if settings['nucleus_size_range'] is None:
+        settings['nucleus_size_range'] = [0,_max]
+    if settings['pathogen_size_range'] is None:
+        settings['pathogen_size_range'] = [0,_max]
+
+    if settings['plot']:
+        merged_path = os.path.join(settings['src'],'merged')
+        if os.path.exists(merged_path):
+            try:
+                for idx, file in enumerate(os.listdir(merged_path)):
+                    file_path = os.path.join(merged_path,file)
+                    if idx <= settings['plot_nr']:
+                        plot_image_mask_overlay(file_path, 
+                                                settings['channel_dims'],
+                                                settings['cell_chann_dim'],
+                                                settings['nucleus_chann_dim'],
+                                                settings['pathogen_chann_dim'],
+                                                figuresize=10,
+                                                normalize=True,
+                                                thickness=3,
+                                                save_pdf=True)
+            except Exception as e:
+                print(f'Failed to plot images with outlines, Error: {e}')
+        
+    if not settings['cell_chann_dim'] is None:
+        df = _object_filter(df, 'cell', settings['cell_size_range'], settings['cell_intensity_range'], mask_chans, 0)
+        if not settings['target_intensity_min'] is None:
+            df = df[df[f"cell_channel_{settings['channel_of_interest']}_percentile_95'] > settings['target_intensity_min"]]
+            print(f"After channel {settings['channel_of_interest']} filtration", len(df))
+    if not settings['nucleus_chann_dim'] is None:
+        df = _object_filter(df, 'nucleus', settings['nucleus_size_range'], settings['nucleus_intensity_range'], mask_chans, 1)
+    if not settings['pathogen_chann_dim'] is None:
+        df = _object_filter(df, 'pathogen', settings['pathogen_size_range'], settings['pathogen_intensity_range'], mask_chans, 2)
+       
+    df['recruitment'] = df[f"pathogen_channel_{settings['channel_of_interest']}_mean_intensity']/df[f'cytoplasm_channel_{settings['channel_of_interest']}_mean_intensity"]
+    for chan in settings['channel_dims']:
+        df = _calculate_recruitment(df, channel=chan)
+    print(f'calculated recruitment for: {len(df)} rows')
+    
+    df_well = _group_by_well(df)
+    print(f'found: {len(df_well)} wells')
+    
+    df_well = df_well[df_well['cells_per_well'] >= settings['cells_per_well']]
+    prc_list = df_well['prc'].unique().tolist()
+    df = df[df['prc'].isin(prc_list)]
+    print(f"After cells per well filter: {len(df)} cells in {len(df_well)} wells left wth threshold {settings['cells_per_well']}")
+    
+    if settings['plot_control']:
+        _plot_controls(df, mask_chans, settings['channel_of_interest'], figuresize=5)
+
+    print(f'PV level: {len(df)} rows')
+    _plot_recruitment(df, 'by PV', settings['channel_of_interest'], settings['target'], settings['figuresize'])
+    print(f'well level: {len(df_well)} rows')
+    _plot_recruitment(df_well, 'by well', settings['channel_of_interest'], settings['target'], settings['figuresize'])
+    cells,wells = _results_to_csv(settings['src'], df, df_well)
+
+    return [cells,wells]
+
+def analyze_plaques(folder):
+    summary_data = []
+    details_data = []
+    stats_data = []
+    
+    for filename in os.listdir(folder):
+        filepath = os.path.join(folder, filename)
+        if os.path.isfile(filepath):
+            # Assuming each file is a NumPy array file (.npy) containing a 16-bit labeled image
+            #image = np.load(filepath)
+            image = cellpose.io.imread(filepath)
+            labeled_image = label(image)
+            regions = regionprops(labeled_image)
+            
+            object_count = len(regions)
+            sizes = [region.area for region in regions]
+            average_size = np.mean(sizes) if sizes else 0
+            std_dev_size = np.std(sizes) if sizes else 0
+            
+            summary_data.append({'file': filename, 'object_count': object_count, 'average_size': average_size})
+            stats_data.append({'file': filename, 'plaque_count': object_count, 'average_size': average_size, 'std_dev_size': std_dev_size})
+            for size in sizes:
+                details_data.append({'file': filename, 'plaque_size': size})
+    
+    # Convert lists to pandas DataFrames
+    summary_df = pd.DataFrame(summary_data)
+    details_df = pd.DataFrame(details_data)
+    stats_df = pd.DataFrame(stats_data)
+    
+    # Save DataFrames to a SQLite database
+    db_name = os.path.join(folder, 'plaques_analysis.db')
+    conn = sqlite3.connect(db_name)
+    
+    summary_df.to_sql('summary', conn, if_exists='replace', index=False)
+    details_df.to_sql('details', conn, if_exists='replace', index=False)
+    stats_df.to_sql('stats', conn, if_exists='replace', index=False)
+    
+    conn.close()
+    
+    print(f"Analysis completed and saved to database '{db_name}'.")
+
+def train_cellpose(settings):
+    
+    from .io import _load_normalized_images_and_labels, _load_images_and_labels
+    from .settings import get_train_cellpose_default_settings
+    from .utils import save_settings
+
+    settings = get_train_cellpose_default_settings(settings)
+
+    img_src = settings['img_src'] 
+    mask_src = os.path.join(img_src, 'masks')
+    test_img_src = settings['test_img_src']
+    test_mask_src = settings['test_mask_src']
+
+    if settings['resize']:
+        target_height = settings['width_height'][1]
+        target_width = settings['width_height'][0]
+
+    if settings['test']:
+        test_img_src = os.path.join(os.path.dirname(settings['img_src']), 'test')
+        test_mask_src = os.path.join(settings['test_img_src'], 'mask')
+
+    test_images, test_masks, test_image_names, test_mask_names = None,None,None,None
+    print(settings)
+
+    if settings['from_scratch']:
+        model_name=f"scratch_{settings['model_name']}_{settings['model_type']}_e{settings['n_epochs']}_X{target_width}_Y{target_height}.CP_model"
+    else:
+        if settings['resize']:
+            model_name=f"{settings['model_name']}_{settings['model_type']}_e{settings['n_epochs']}_X{target_width}_Y{target_height}.CP_model"
+        else:
+            model_name=f"{settings['model_name']}_{settings['model_type']}_e{settings['n_epochs']}.CP_model"
+
+    model_save_path = os.path.join(settings['mask_src'], 'models', 'cellpose_model')
+    print(model_save_path)
+    os.makedirs(model_save_path, exist_ok=True)
+
+    save_settings(settings, name=model_name)
+    
+    if settings['from_scratch']:
+        model = cp_models.CellposeModel(gpu=True, model_type=settings['model_type'], diam_mean=settings['diameter'], pretrained_model=None)
+    else:
+        model = cp_models.CellposeModel(gpu=True, model_type=settings['model_type'])
+        
+    if settings['normalize']:
+
+        image_files = [os.path.join(img_src, f) for f in os.listdir(img_src) if f.endswith('.tif')]
+        label_files = [os.path.join(mask_src, f) for f in os.listdir(mask_src) if f.endswith('.tif')]
+        images, masks, image_names, mask_names, orig_dims = _load_normalized_images_and_labels(image_files, 
+                                                                                               label_files, 
+                                                                                               settings['channels'], 
+                                                                                               settings['percentiles'],  
+                                                                                               settings['circular'], 
+                                                                                               settings['invert'], 
+                                                                                               settings['verbose'], 
+                                                                                               settings['remove_background'], 
+                                                                                               settings['background'], 
+                                                                                               settings['Signal_to_noise'], 
+                                                                                               settings['target_height'], 
+                                                                                               settings['target_width'])        
+        images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
+        
+        if settings['test']:
+            test_image_files = [os.path.join(test_img_src, f) for f in os.listdir(test_img_src) if f.endswith('.tif')]
+            test_label_files = [os.path.join(test_mask_src, f) for f in os.listdir(test_mask_src) if f.endswith('.tif')]
+            test_images, test_masks, test_image_names, test_mask_names = _load_normalized_images_and_labels(test_image_files, 
+                                                                                                            test_label_files, 
+                                                                                                            settings['channels'], 
+                                                                                                            settings['percentiles'],  
+                                                                                                            settings['circular'], 
+                                                                                                            settings['invert'], 
+                                                                                                            settings['verbose'], 
+                                                                                                            settings['remove_background'], 
+                                                                                                            settings['background'], 
+                                                                                                            settings['Signal_to_noise'], 
+                                                                                                            settings['target_height'], 
+                                                                                                            settings['target_width'])
+            test_images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in test_images]
+            
+    else:
+        images, masks, image_names, mask_names = _load_images_and_labels(img_src, mask_src, settings['circular'], settings['invert'])
+        images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
+        
+        if settings['test']:
+            test_images, test_masks, test_image_names, test_mask_names = _load_images_and_labels(test_img_src, 
+                                                                                                 test_mask_src, 
+                                                                                                 settings['circular'], 
+                                                                                                 settings['invert'])
+            
+            test_images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in test_images]
+    
+    #if resize:
+    #    images, masks = resize_images_and_labels(images, masks, target_height, target_width, show_example=True)
+
+    if settings['model_type'] == 'cyto':
+        cp_channels = [0,1]
+    if settings['model_type'] == 'cyto2':
+        cp_channels = [0,2]
+    if settings['model_type'] == 'nucleus':
+        cp_channels = [0,0]
+    if settings['grayscale']:
+        cp_channels = [0,0]
+        images = [np.squeeze(img) if img.ndim == 3 and 1 in img.shape else img for img in images]
+    
+    masks = [np.squeeze(mask) if mask.ndim == 3 and 1 in mask.shape else mask for mask in masks]
+
+    print(f'image shape: {images[0].shape}, image type: images[0].shape mask shape: {masks[0].shape}, image type: masks[0].shape')
+    save_every = int(settings['n_epochs']/10)
+    if save_every < 10:
+        save_every = settings['n_epochs']
+
+    train_cp.train_seg(model.net,
+                    train_data=images,
+                    train_labels=masks,
+                    train_files=image_names,
+                    train_labels_files=mask_names,
+                    train_probs=None,
+                    test_data=test_images,
+                    test_labels=test_masks,
+                    test_files=test_image_names,
+                    test_labels_files=test_mask_names, 
+                    test_probs=None,
+                    load_files=True,
+                    batch_size=settings['batch_size'],
+                    learning_rate=settings['learning_rate'],
+                    n_epochs=settings['n_epochs'],
+                    weight_decay=settings['weight_decay'],
+                    momentum=0.9,
+                    SGD=False,
+                    channels=cp_channels,
+                    channel_axis=None,
+                    #rgb=False,
+                    normalize=False, 
+                    compute_flows=False,
+                    save_path=model_save_path,
+                    save_every=save_every,
+                    nimg_per_epoch=None,
+                    nimg_test_per_epoch=None,
+                    rescale=settings['rescale'],
+                    #scale_range=None,
+                    #bsize=224,
+                    min_train_masks=1,
+                    model_name=settings['model_name'])
+
+    return print(f"Model saved at: {model_save_path}/{model_name}")
+
+def count_phenotypes(settings):
+    from .io import _read_db
+
+    if not settings['src'].endswith('/measurements/measurements.db'):
+        settings['src'] = os.path.join(settings['src'], 'measurements/measurements.db')
+
+    df = _read_db(loc=settings['src'], tables=['png_list'])
+
+    unique_values_count = df[settings['annotation_column']].nunique(dropna=True)
+    print(f"Unique values in {settings['annotation_column']} (excluding NaN): {unique_values_count}")
+
+    # Count unique values in 'value' column, grouped by 'plate', 'row', 'column'
+    grouped_unique_count = df.groupby(['plate', 'row', 'column'])[settings['annotation_column']].nunique(dropna=True).reset_index(name='unique_count')
+    display(grouped_unique_count)
+
+    save_path = os.path.join(settings['src'], 'phenotype_counts.csv')
+
+    # Group by plate, row, and column, then count the occurrences of each unique value
+    grouped_counts = df.groupby(['plate', 'row', 'column', 'value']).size().reset_index(name='count')
+
+    # Pivot the DataFrame so that unique values are columns and their counts are in the rows
+    pivot_df = grouped_counts.pivot_table(index=['plate', 'row', 'column'], columns='value', values='count', fill_value=0)
+
+    # Flatten the multi-level columns
+    pivot_df.columns = [f"value_{int(col)}" for col in pivot_df.columns]
+
+    # Reset the index so that plate, row, and column form a combined index
+    pivot_df.index = pivot_df.index.map(lambda x: f"{x[0]}_{x[1]}_{x[2]}")
+
+    # Saving the DataFrame to a SQLite .db file
+    output_dir = os.path.join('src', 'results')  # Replace 'src' with the actual base directory
+    os.makedirs(output_dir, exist_ok=True)
+
+    output_dir = os.path.dirname(settings['src'])
+    output_path = os.path.join(output_dir, 'phenotype_counts.csv')
+
+    pivot_df.to_csv(output_path)
+
+    return 

spacr/timelapse.py

@@ -13,8 +13,6 @@ from scipy.optimize import curve_fit
 from scipy.integrate import trapz
 import matplotlib.pyplot as plt
 
-from .logger import log_function_call
-
 def _npz_to_movie(arrays, filenames, save_path, fps=10):
     """
     Convert a list of numpy arrays to a movie file.

spacr/toxo.py

@@ -0,0 +1,233 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+from adjustText import adjust_text
+import pandas as pd
+from scipy.stats import fisher_exact
+
+def custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location', string_list=[], point_size=50, figsize=20):
+    """
+    Create a volcano plot with the ability to control the shape of points based on a categorical column, 
+    color points based on a string list, annotate specific points based on p-value and coefficient thresholds,
+    and control the size of points.
+    
+    Parameters:
+    - data_path: Path to the data CSV file.
+    - metadata_path: Path to the metadata CSV file.
+    - metadata_column: Column name in the metadata to control point shapes.
+    - string_list: List of strings to color points differently if present in 'coefficient' names.
+    - point_size: Fixed value to control the size of points.
+    - figsize: Width of the plot (height is half the width).
+    """
+    
+    filename = 'volcano_plot.pdf'
+    
+    # Load the data
+
+    if isinstance(data_path, pd.DataFrame):
+        data = data_path
+    else:
+        data = pd.read_csv(data_path)
+    data['variable'] = data['feature'].str.extract(r'\[(.*?)\]')
+    data['variable'].fillna(data['feature'], inplace=True)
+    split_columns = data['variable'].str.split('_', expand=True)
+    data['gene_nr'] = split_columns[0]
+    
+    # Load metadata
+    if isinstance(metadata_path, pd.DataFrame):
+        metadata = metadata_path
+    else:
+        metadata = pd.read_csv(metadata_path)
+        
+    metadata['gene_nr'] = metadata['gene_nr'].astype(str)
+    data['gene_nr'] = data['gene_nr'].astype(str)
+
+    # Merge data and metadata on 'gene_nr'
+    merged_data = pd.merge(data, metadata[['gene_nr', 'tagm_location']], on='gene_nr', how='left')
+    
+    # Controls handling
+    controls = ['000000', '000001', '000002', '000003', '000004', '000005', '000006', '000007', '000008', '000009', '000010', '000011']
+    merged_data.loc[merged_data['gene_nr'].isin(controls), metadata_column] = 'control'
+    merged_data.loc[merged_data['gene_nr'].str.startswith('4'), metadata_column] = 'GT1_gene'
+    merged_data.loc[merged_data['gene_nr'] == 'Intercept', metadata_column] = 'Intercept'
+    
+    # Create a 'highlight_color' column based on the string_list
+    merged_data['highlight_color'] = merged_data['gene_nr'].apply(lambda x: 'red' if any(s in x for s in string_list) else 'blue')
+    
+    # Create the volcano plot
+    figsize_2 = figsize / 2
+    plt.figure(figsize=(figsize_2, figsize))
+    
+    # Create the scatter plot with fixed point size
+    sns.scatterplot(
+        data=merged_data, 
+        x='coefficient', 
+        y='-log10(p_value)', 
+        hue='highlight_color',
+        style=metadata_column if metadata_column else None,  # Control point shape with metadata_column
+        s=point_size,  # Fixed size for all points
+        palette={'red': 'red', 'blue': 'blue'}
+    )
+    
+    # Set the plot title and labels
+    plt.title('Custom Volcano Plot of Coefficients')
+    plt.xlabel('Coefficient')
+    plt.ylabel('-log10(p-value)')
+    
+    # Horizontal line at p-value threshold (0.05)
+    plt.axhline(y=-np.log10(0.05), color='red', linestyle='--')
+    
+    # Annotate points where p_value <= 0.05 and coefficient >= 0.25
+    texts = []
+    for i, row in merged_data.iterrows():
+        if row['p_value'] <= 0.05 and row['coefficient'] >= 0.25:
+            texts.append(plt.text(row['coefficient'], -np.log10(row['p_value']), row['gene_nr'], fontsize=9))
+    
+    # Adjust text positions to avoid overlap
+    adjust_text(texts, arrowprops=dict(arrowstyle='-', color='black'))
+    
+    # Move the legend outside the plot
+    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)
+    
+    # Save the plot
+    plt.savefig(filename, format='pdf', bbox_inches='tight')  # bbox_inches ensures the legend doesn't get cut off
+    print(f'Saved Volcano plot: {filename}')
+    
+    # Show the plot
+    plt.show()
+
+def go_term_enrichment_by_column(significant_df, metadata_path, go_term_columns=['Computed GO Processes', 'Curated GO Components', 'Curated GO Functions', 'Curated GO Processes']):
+    """
+    Perform GO term enrichment analysis for each GO term column and generate plots.
+
+    Parameters:
+    - significant_df: DataFrame containing the significant genes from the screen.
+    - metadata_path: Path to the metadata file containing GO terms.
+    - go_term_columns: List of columns in the metadata corresponding to GO terms.
+
+    For each GO term column, this function will:
+    - Split the GO terms by semicolons.
+    - Count the occurrences of GO terms in the hits and in the background.
+    - Perform Fisher's exact test for enrichment.
+    - Plot the enrichment score vs -log10(p-value).
+    """
+    
+    significant_df['variable'].fillna(significant_df['feature'], inplace=True)
+    split_columns = significant_df['variable'].str.split('_', expand=True)
+    significant_df['gene_nr'] = split_columns[0]
+    gene_list = significant_df['gene_nr'].to_list()
+
+    # Load metadata
+    metadata = pd.read_csv(metadata_path)
+    split_columns = metadata['Gene ID'].str.split('_', expand=True)
+    metadata['gene_nr'] = split_columns[1]
+
+    # Create a subset of metadata with only the rows that contain genes in gene_list (hits)
+    hits_metadata = metadata[metadata['gene_nr'].isin(gene_list)]
+
+    # Create a list to hold results from all columns
+    combined_results = []
+
+    for go_term_column in go_term_columns:
+        # Initialize lists to store results
+        go_terms = []
+        enrichment_scores = []
+        p_values = []
+
+        # Split the GO terms in the entire metadata and hits
+        metadata[go_term_column] = metadata[go_term_column].fillna('')
+        hits_metadata[go_term_column] = hits_metadata[go_term_column].fillna('')
+
+        all_go_terms = metadata[go_term_column].str.split(';').explode()
+        hit_go_terms = hits_metadata[go_term_column].str.split(';').explode()
+
+        # Count occurrences of each GO term in hits and total metadata
+        all_go_term_counts = all_go_terms.value_counts()
+        hit_go_term_counts = hit_go_terms.value_counts()
+
+        # Perform enrichment analysis for each GO term
+        for go_term in all_go_term_counts.index:
+            total_with_go_term = all_go_term_counts.get(go_term, 0)
+            hits_with_go_term = hit_go_term_counts.get(go_term, 0)
+
+            # Calculate the total number of genes and hits
+            total_genes = len(metadata)
+            total_hits = len(hits_metadata)
+
+            # Perform Fisher's exact test
+            contingency_table = [[hits_with_go_term, total_hits - hits_with_go_term],
+                                 [total_with_go_term - hits_with_go_term, total_genes - total_hits - (total_with_go_term - hits_with_go_term)]]
+            
+            _, p_value = fisher_exact(contingency_table)
+            
+            # Calculate enrichment score (hits with GO term / total hits with GO term)
+            if total_with_go_term > 0 and total_hits > 0:
+                enrichment_score = (hits_with_go_term / total_hits) / (total_with_go_term / total_genes)
+            else:
+                enrichment_score = 0.0
+
+            # Store the results only if enrichment score is non-zero
+            if enrichment_score > 0.0:
+                go_terms.append(go_term)
+                enrichment_scores.append(enrichment_score)
+                p_values.append(p_value)
+
+        # Create a results DataFrame for this GO term column
+        results_df = pd.DataFrame({
+            'GO Term': go_terms,
+            'Enrichment Score': enrichment_scores,
+            'P-value': p_values,
+            'GO Column': go_term_column  # Track the GO term column for final combined plot
+        })
+
+        # Sort by enrichment score
+        results_df = results_df.sort_values(by='Enrichment Score', ascending=False)
+
+        # Append this DataFrame to the combined list
+        combined_results.append(results_df)
+
+        # Plot the enrichment results for each individual column
+        plt.figure(figsize=(10, 6))
+        
+        # Create a scatter plot of Enrichment Score vs -log10(p-value)
+        sns.scatterplot(data=results_df, x='Enrichment Score', y=-np.log10(results_df['P-value']), hue='GO Term', size='Enrichment Score', sizes=(50, 200))
+        
+        # Set plot labels and title
+        plt.title(f'GO Term Enrichment Analysis for {go_term_column}')
+        plt.xlabel('Enrichment Score')
+        plt.ylabel('-log10(P-value)')
+        
+        # Move the legend to the right of the plot
+        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)
+        
+        # Show the plot
+        plt.tight_layout()  # Ensure everything fits in the figure area
+        plt.show()
+
+        # Optionally return or save the results for each column
+        print(f'Results for {go_term_column}')
+
+    # Combine results from all columns into a single DataFrame
+    combined_df = pd.concat(combined_results)
+
+    # Plot the combined results with text labels
+    plt.figure(figsize=(12, 8))
+    sns.scatterplot(data=combined_df, x='Enrichment Score', y=-np.log10(combined_df['P-value']),
+                    style='GO Column', size='Enrichment Score', sizes=(50, 200))
+
+    # Set plot labels and title for the combined graph
+    plt.title('Combined GO Term Enrichment Analysis')
+    plt.xlabel('Enrichment Score')
+    plt.ylabel('-log10(P-value)')
+    
+    # Annotate the points with labels and connecting lines
+    texts = []
+    for i, row in combined_df.iterrows():
+        texts.append(plt.text(row['Enrichment Score'], -np.log10(row['P-value']), row['GO Term'], fontsize=9))
+    
+    # Adjust text to avoid overlap
+    adjust_text(texts, arrowprops=dict(arrowstyle='-', color='black'))
+    
+    # Show the combined plot
+    plt.tight_layout()
+    plt.show()