spacr 0.3.42__py3-none-any.whl → 0.3.45__py3-none-any.whl

spacr/submodules.py

@@ -8,6 +8,9 @@ from cellpose import models as cp_models
 from cellpose import train as train_cp
 from IPython.display import display
 
+import matplotlib.pyplot as plt
+from natsort import natsorted
+
 def analyze_recruitment(settings={}):
     """
     Analyze recruitment data by grouping the DataFrame by well coordinates and plotting controls and recruitment data.
@@ -122,16 +125,39 @@ def analyze_recruitment(settings={}):
 
     return [cells,wells]
 
-def analyze_plaques(folder):
+def analyze_plaques(settings):
+
+    from .cellpose import identify_masks_finetune
+    from .settings import get_analyze_plaque_settings
+    from .utils import save_settings, download_models
+    from spacr import __file__ as spacr_path
+
+    download_models()
+    package_dir = os.path.dirname(spacr_path)
+    models_dir = os.path.join(package_dir, 'resources', 'models', 'cp')
+    model_path = os.path.join(models_dir, 'toxo_plaque_cyto_e25000_X1120_Y1120.CP_model')
+    settings['custom_model'] = model_path
+    print('custom_model',settings['custom_model'])
+
+    settings = get_analyze_plaque_settings(settings)
+    save_settings(settings, name='analyze_plaques', show=True)
+    settings['dst'] = os.path.join(settings['src'], 'masks')
+
+    if settings['masks']:
+        identify_masks_finetune(settings)
+        folder = settings['dst']
+    else:
+        folder = settings['dst']
+
     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)
+
+        if filepath.endswith('.tif') and os.path.isfile(filepath):
+            print(f"Analyzing: {filepath}")
             image = cellpose.io.imread(filepath)
             labeled_image = label(image)
             regions = regionprops(labeled_image)
@@ -214,7 +240,6 @@ def train_cellpose(settings):
                                                                                                label_files, 
                                                                                                settings['channels'], 
                                                                                                settings['percentiles'],  
-                                                                                               settings['circular'], 
                                                                                                settings['invert'], 
                                                                                                settings['verbose'], 
                                                                                                settings['remove_background'], 
@@ -231,7 +256,6 @@ def train_cellpose(settings):
                                                                                                             test_label_files, 
                                                                                                             settings['channels'], 
                                                                                                             settings['percentiles'],  
-                                                                                                            settings['circular'], 
                                                                                                             settings['invert'], 
                                                                                                             settings['verbose'], 
                                                                                                             settings['remove_background'], 
@@ -242,13 +266,12 @@ def train_cellpose(settings):
             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, masks, image_names, mask_names = _load_images_and_labels(img_src, mask_src, 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]
@@ -293,7 +316,6 @@ def train_cellpose(settings):
                     SGD=False,
                     channels=cp_channels,
                     channel_axis=None,
-                    #rgb=False,
                     normalize=False, 
                     compute_flows=False,
                     save_path=model_save_path,
@@ -346,4 +368,186 @@ def count_phenotypes(settings):
 
     pivot_df.to_csv(output_path)
 
-    return 
+    return
+
+def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),'r2':(90,10),'r3':(80,20),'r4':(80,20),'r5':(70,30),'r6':(70,30),'r7':(60,40),'r8':(60,40),'r9':(50,50),'r10':(50,50),'r11':(40,60),'r12':(40,60),'r13':(30,70),'r14':(30,70),'r15':(20,80),'r16':(20,80)},
+                            pc_grna='TGGT1_220950_1', nc_grna='TGGT1_233460_4', 
+                            y_columns=['class_1_fraction', 'TGGT1_220950_1_fraction', 'nc_fraction'], 
+                            column='column', value='c3', plate=None, save_paths=None):
+
+    def calculate_well_score_fractions(df, class_columns='cv_predictions'):
+        if all(col in df.columns for col in ['plate', 'row', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row'] + '_' + df['column']
+        else:
+            raise ValueError("Cannot find 'plate', 'row', or 'column' in df.columns")
+        prc_summary = df.groupby(['plate', 'row', 'column', 'prc']).size().reset_index(name='total_rows')
+        well_counts = (df.groupby(['plate', 'row', 'column', 'prc', class_columns])
+                       .size()
+                       .unstack(fill_value=0)
+                       .reset_index()
+                       .rename(columns={0: 'class_0', 1: 'class_1'}))
+        summary_df = pd.merge(prc_summary, well_counts, on=['plate', 'row', 'column', 'prc'], how='left')
+        summary_df['class_0_fraction'] = summary_df['class_0'] / summary_df['total_rows']
+        summary_df['class_1_fraction'] = summary_df['class_1'] / summary_df['total_rows']
+        return summary_df
+        
+    def plot_line(df, x_column, y_columns, group_column=None, xlabel=None, ylabel=None, 
+                  title=None, figsize=(10, 6), save_path=None, theme='deep'):
+        """
+        Create a line plot that can handle multiple y-columns, each becoming a separate line.
+        """
+
+        def _set_theme(theme):
+            """Set the Seaborn theme and reorder colors if necessary."""
+
+            def __set_reordered_theme(theme='deep', order=None, n_colors=100, show_theme=False):
+                """Set and reorder the Seaborn color palette."""
+                palette = sns.color_palette(theme, n_colors)
+                if order:
+                    reordered_palette = [palette[i] for i in order]
+                else:
+                    reordered_palette = palette
+                if show_theme:
+                    sns.palplot(reordered_palette)
+                    plt.show()
+                return reordered_palette
+
+            integer_list = list(range(1, 81))
+            color_order = [7, 9, 4, 0, 3, 6, 2] + integer_list
+            sns_palette = __set_reordered_theme(theme, color_order, 100)
+            return sns_palette
+
+        sns_palette = _set_theme(theme)
+
+        # Sort the DataFrame based on the x_column
+        df = df.loc[natsorted(df.index, key=lambda x: df.loc[x, x_column])]
+        
+        fig, ax = plt.subplots(figsize=figsize)
+
+        # Handle multiple y-columns, each as a separate line
+        if isinstance(y_columns, list):
+            for idx, y_col in enumerate(y_columns):
+                sns.lineplot(
+                    data=df, x=x_column, y=y_col, ax=ax, label=y_col, 
+                    color=sns_palette[idx % len(sns_palette)], linewidth=1
+                )
+        else:
+            sns.lineplot(
+                data=df, x=x_column, y=y_columns, hue=group_column, ax=ax, 
+                palette=sns_palette, linewidth=2
+            )
+
+        # Set axis labels and title
+        ax.set_xlabel(xlabel if xlabel else x_column)
+        ax.set_ylabel(ylabel if ylabel else 'Value')
+        ax.set_title(title if title else 'Line Plot')
+
+        # Remove top and right spines
+        sns.despine(ax=ax)
+
+        # Ensure legend only appears when needed and place it to the right
+        if group_column or isinstance(y_columns, list):
+            ax.legend(title='Legend', loc='center left', bbox_to_anchor=(1, 0.5))
+
+        plt.tight_layout()
+
+        # Save the plot if a save path is provided
+        if save_path:
+            plt.savefig(save_path, format='pdf', dpi=600, bbox_inches='tight')
+            print(f"Plot saved to {save_path}")
+
+        plt.show()
+        return fig
+    
+    def calculate_grna_fraction_ratio(df, grna1='TGGT1_220950_1', grna2='TGGT1_233460_4'):
+        # Filter relevant grna_names within each prc and group them
+        grouped = df[df['grna_name'].isin([grna1, grna2])] \
+            .groupby(['prc', 'grna_name']) \
+            .agg({'fraction': 'sum', 'count': 'sum'}) \
+            .unstack(fill_value=0)
+        grouped.columns = ['_'.join(col).strip() for col in grouped.columns.values]
+        grouped['fraction_ratio'] = grouped[f'fraction_{grna1}'] / grouped[f'fraction_{grna2}']
+        grouped = grouped.assign(
+            fraction_ratio=lambda x: x['fraction_ratio'].replace([float('inf'), -float('inf')], 0)
+        ).fillna({'fraction_ratio': 0})
+        grouped = grouped.rename(columns={
+            f'count_{grna1}': f'{grna1}_count',
+            f'count_{grna2}': f'{grna2}_count'
+        })
+        result = grouped.reset_index()[['prc', f'{grna1}_count', f'{grna2}_count', 'fraction_ratio']]
+        result['total_reads'] = result[f'{grna1}_count'] + result[f'{grna2}_count']
+        result[f'{grna1}_fraction'] = result[f'{grna1}_count'] / result['total_reads']
+        result[f'{grna2}_fraction'] = result[f'{grna2}_count'] / result['total_reads']
+        return result
+
+    def calculate_well_read_fraction(df, count_column='count'):
+        if all(col in df.columns for col in ['plate', 'row', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row'] + '_' + df['column']
+        else:
+            raise ValueError("Cannot find plate, row or column in df.columns")
+        grouped_df = df.groupby('prc')[count_column].sum().reset_index()
+        grouped_df = grouped_df.rename(columns={count_column: 'total_counts'})
+        df = pd.merge(df, grouped_df, on='prc')
+        df['fraction'] = df['count'] / df['total_counts']
+        return df
+    
+    if isinstance(reads_csv, list):
+        if len(reads_csv) == len(scores_csv):
+            reads_ls = []
+            scores_ls = []
+            for i, reads_csv_temp in enumerate(reads_csv):
+                reads_df_temp = pd.read_csv(reads_csv_temp)
+                scores_df_temp = pd.read_csv(scores_csv[i])
+                reads_df_temp['plate'] = f"plate{i+1}"
+                scores_df_temp['plate'] = f"plate{i+1}"
+                
+                if 'col' in reads_df_temp.columns:
+                    reads_df_temp = reads_df_temp.rename(columns={'col': 'column'})
+                if 'column_name' in reads_df_temp.columns:
+                    reads_df_temp = reads_df_temp.rename(columns={'column_name': 'column'})
+                if 'col' in scores_df_temp.columns:
+                    scores_df_temp = scores_df_temp.rename(columns={'col': 'column'})
+                if 'column_name' in scores_df_temp.columns:
+                    scores_df_temp = scores_df_temp.rename(columns={'column_name': 'column'})
+                if 'row_name' in reads_df_temp.columns:
+                    reads_df_temp = reads_df_temp.rename(columns={'row_name': 'row'})
+                if 'row_name' in scores_df_temp.columns:
+                    scores_df_temp = scores_df_temp.rename(columns={'row_name': 'row'})
+                    
+                reads_ls.append(reads_df_temp)
+                scores_ls.append(scores_df_temp)
+                    
+            reads_df = pd.concat(reads_ls, axis=0)
+            scores_df = pd.concat(scores_ls, axis=0)
+            print(f"Reads: {len(reads_df)} Scores: {len(scores_df)}")
+        else:
+            print(f"reads_csv and scores_csv must contain the same number of elements if reads_csv is a list")
+    else:
+        reads_df = pd.read_csv(reads_csv)
+        scores_df = pd.read_csv(scores_csv)
+        if plate != None:
+            reads_df['plate'] = plate
+            scores_df['plate'] = plate
+        
+    reads_df = calculate_well_read_fraction(reads_df)
+    scores_df = calculate_well_score_fractions(scores_df)
+    reads_col_df = reads_df[reads_df[column]==value]
+    scores_col_df = scores_df[scores_df[column]==value]
+    
+    reads_col_df = calculate_grna_fraction_ratio(reads_col_df, grna1=pc_grna, grna2=nc_grna)
+    df = pd.merge(reads_col_df, scores_col_df, on='prc')
+    
+    df_emp = pd.DataFrame([(key, val[0], val[1], val[0] / (val[0] + val[1]), val[1] / (val[0] + val[1])) for key, val in empirical_dict.items()],columns=['key', 'value1', 'value2', 'pc_fraction', 'nc_fraction'])
+    
+    df = pd.merge(df, df_emp, left_on='row', right_on='key')
+    
+    if any in y_columns not in df.columns:
+        print(f"columns in dataframe:")
+        for col in df.columns:
+            print(col)
+        return
+    display(df)
+    fig_1 = plot_line(df, x_column = 'pc_fraction', y_columns=y_columns, group_column=None, xlabel=None, ylabel='Fraction', title=None, figsize=(10, 6), save_path=save_paths[0])
+    fig_2 = plot_line(df, x_column = 'nc_fraction', y_columns=y_columns, group_column=None, xlabel=None, ylabel='Fraction', title=None, figsize=(10, 6), save_path=save_paths[1])
+    
+    return [fig_1, fig_2]

spacr/toxo.py

@@ -1,3 +1,4 @@
+import os
 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
@@ -6,125 +7,13 @@ import pandas as pd
 from scipy.stats import fisher_exact
 from IPython.display import display
 
-def custom_volcano_plot_v1(data_path, metadata_path, metadata_column='tagm_location', point_size=50, figsize=20, threshold=0):
-    """
-    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')
-
-    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 the volcano plot
-    figsize_2 = figsize / 2
-    plt.figure(figsize=(figsize_2, figsize))
-
-    palette = {
-        'pc': 'red',
-        'nc': 'green',
-        'control': 'black',
-        'other': 'gray'
-    }
-
-    merged_data['condition'] = pd.Categorical(
-        merged_data['condition'], 
-        categories=['pc', 'nc', 'control', 'other'], 
-        ordered=True
-    )
-    
-    display(merged_data)
-
-    # Create the scatter plot with fixed point size
-    sns.scatterplot(
-        data=merged_data, 
-        x='coefficient', 
-        y='-log10(p_value)', 
-        hue='condition',  # Controls color
-        style=metadata_column if metadata_column else None,  # Controls point shape
-        s=point_size,  # Fixed size for all points
-        palette=palette,  # Color palette
-        alpha=1.0  # Transparency
-    )
-    
-    # Set the plot title and labels
-    plt.title('Custom Volcano Plot of Coefficients')
-    plt.xlabel('Coefficient')
-    plt.ylabel('-log10(p-value)')
-
-    if threshold > 0:
-        plt.gca().axvline(x=-abs(threshold), linestyle='--', color='black')
-        plt.gca().axvline(x=abs(threshold), linestyle='--', color='black')
-    
-    # Horizontal line at p-value threshold (0.05)
-    plt.axhline(y=-np.log10(0.05), color='black', linestyle='--')
-    
-    texts = []
-    for i, row in merged_data.iterrows():
-        if row['p_value'] <= 0.05 and abs(row['coefficient']) >= abs(threshold):
-            texts.append(plt.text(
-                row['coefficient'], 
-                -np.log10(row['p_value']), 
-                row['variable'], 
-                fontsize=8
-            ))
-    
-    # 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 custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location', point_size=50, figsize=20, threshold=0, split_axis_lims = [10, None, None, 10]):
+def custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location', point_size=50, figsize=20, threshold=0, split_axis_lims = [10, None, None, 10], save_path=None):
     """
     Create a volcano plot with the ability to control the shape of points based on a categorical column,
     color points based on a condition, annotate specific points based on p-value and coefficient thresholds,
     and control the size of points.
     """
-
-    filename = 'volcano_plot.pdf'
+    volcano_path = save_path
 
     # Load the data
     if isinstance(data_path, pd.DataFrame):
@@ -297,8 +186,8 @@ def custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location
     fig.suptitle('Custom Volcano Plot of Coefficients', y=1.02, fontsize=16)  # Title above the top plot
 
     # Save the plot as PDF
-    plt.savefig(filename, format='pdf', bbox_inches='tight')
-    print(f'Saved Volcano plot: {filename}')
+    plt.savefig(volcano_path, format='pdf', bbox_inches='tight')
+    print(f'Saved Volcano plot: {volcano_path}')
 
     # Show the plot
     plt.show()

spacr/utils.py

@@ -51,7 +51,8 @@ from scipy.stats import fisher_exact, f_oneway, kruskal
 from scipy.ndimage.filters import gaussian_filter
 from scipy.spatial import ConvexHull
 from scipy.interpolate import splprep, splev
-from scipy.ndimage import binary_dilation
+from scipy import ndimage
+from scipy.ndimage import binary_dilation, binary_fill_holes
 
 from skimage.exposure import rescale_intensity
 from sklearn.metrics import auc, precision_recall_curve
@@ -64,6 +65,7 @@ from sklearn.decomposition import PCA
 from sklearn.ensemble import RandomForestClassifier
 
 from huggingface_hub import list_repo_files
+from spacr import __file__ as spacr_path
 
 import umap.umap_ as umap
 #import umap
@@ -705,6 +707,7 @@ def _update_database_with_merged_info(db_path, df, table='png_list', columns=['p
         conn.close()
 
 def _generate_representative_images(db_path, cells=['HeLa'], cell_loc=None, pathogens=['rh'], pathogen_loc=None, treatments=['cm'], treatment_loc=None, channel_of_interest=1, compartments = ['pathogen','cytoplasm'], measurement = 'mean_intensity', nr_imgs=16, channel_indices=[0,1,2], um_per_pixel=0.1, scale_bar_length_um=10, plot=False, fontsize=12, show_filename=True, channel_names=None, update_db=True):
+    
     """
     Generates representative images based on the provided parameters.
 
@@ -4479,6 +4482,7 @@ def cluster_feature_analysis(all_df, cluster_col='cluster'):
     return combined_df
 
 def _merge_cells_based_on_parasite_overlap(parasite_mask, cell_mask, nuclei_mask, overlap_threshold=5, perimeter_threshold=30):
+    
     """
     Merge cells in cell_mask if a parasite in parasite_mask overlaps with more than one cell,
     and if cells share more than a specified perimeter percentage.
@@ -4606,9 +4610,9 @@ def adjust_cell_masks(parasite_folder, cell_folder, nuclei_folder, overlap_thres
         if not (os.path.exists(cell_path) and os.path.exists(nuclei_path)):
             raise ValueError(f"Corresponding cell or nuclei mask file for {file_name} not found.")
         # Load the masks
-        parasite_mask = np.load(parasite_path)
-        cell_mask = np.load(cell_path)
-        nuclei_mask = np.load(nuclei_path)
+        parasite_mask = np.load(parasite_path, allow_pickle=True)
+        cell_mask = np.load(cell_path, allow_pickle=True)
+        nuclei_mask = np.load(nuclei_path, allow_pickle=True)
         # Merge and relabel cells
         merged_cell_mask = _merge_cells_based_on_parasite_overlap(parasite_mask, cell_mask, nuclei_mask, overlap_threshold, perimeter_threshold)
         
@@ -4963,7 +4967,71 @@ def map_condition(col_value, neg='c1', pos='c2', mix='c3'):
     else:
         return 'screen'
     
-def download_models(repo_id="einarolafsson/models", local_dir=None, retries=5, delay=5):
+def download_models(repo_id="einarolafsson/models", retries=5, delay=5):
+    """
+    Downloads all model files from Hugging Face and stores them in the `resources/models` directory 
+    within the installed `spacr` package.
+
+    Args:
+        repo_id (str): The repository ID on Hugging Face (default is 'einarolafsson/models').
+        retries (int): Number of retry attempts in case of failure.
+        delay (int): Delay in seconds between retries.
+
+    Returns:
+        str: The local path to the downloaded models.
+    """
+    # Construct the path to the `resources/models` directory in the installed `spacr` package
+    package_dir = os.path.dirname(spacr_path)
+    local_dir = os.path.join(package_dir, 'resources', 'models')
+
+    # Create the local directory if it doesn't exist
+    if not os.path.exists(local_dir):
+        os.makedirs(local_dir)
+    elif len(os.listdir(local_dir)) > 0:
+        print(f"Models already downloaded to: {local_dir}")
+        return local_dir
+
+    attempt = 0
+    while attempt < retries:
+        try:
+            # List all files in the repo
+            files = list_repo_files(repo_id, repo_type="dataset")
+            print(f"Files in repository: {files}")  # Debugging print to check file list
+
+            # Download each file
+            for file_name in files:
+                for download_attempt in range(retries):
+                    try:
+                        url = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{file_name}?download=true"
+                        print(f"Downloading file from: {url}")  # Debugging
+
+                        response = requests.get(url, stream=True)
+                        print(f"HTTP response status: {response.status_code}")  # Debugging
+                        response.raise_for_status()
+
+                        # Save the file locally
+                        local_file_path = os.path.join(local_dir, os.path.basename(file_name))
+                        with open(local_file_path, 'wb') as file:
+                            for chunk in response.iter_content(chunk_size=8192):
+                                file.write(chunk)
+                        print(f"Downloaded model file: {file_name} to {local_file_path}")
+                        break  # Exit the retry loop if successful
+                    except (requests.HTTPError, requests.Timeout) as e:
+                        print(f"Error downloading {file_name}: {e}. Retrying in {delay} seconds...")
+                        time.sleep(delay)
+                else:
+                    raise Exception(f"Failed to download {file_name} after multiple attempts.")
+
+            return local_dir  # Return the directory where models are saved
+
+        except (requests.HTTPError, requests.Timeout) as e:
+            print(f"Error downloading files: {e}. Retrying in {delay} seconds...")
+            attempt += 1
+            time.sleep(delay)
+
+    raise Exception("Failed to download model files after multiple attempts.")
+
+def download_models_v1(repo_id="einarolafsson/models", local_dir=None, retries=5, delay=5):
     """
     Downloads all model files from Hugging Face and stores them in the specified local directory.
 
@@ -5112,4 +5180,33 @@ def add_column_to_database(settings):
     conn.commit()
     conn.close()
 
-    print(f"Updated '{new_column_name}' in '{settings['table_name']}' using '{settings['match_column']}'.")
+    print(f"Updated '{new_column_name}' in '{settings['table_name']}' using '{settings['match_column']}'.")
+
+def fill_holes_in_mask(mask):
+    """
+    Fill holes in each object in the mask while keeping objects separated.
+    
+    Args:
+        mask (np.ndarray): A labeled mask where each object has a unique integer value.
+    
+    Returns:
+        np.ndarray: A mask with holes filled and original labels preserved.
+    """
+    # Ensure the mask is integer-labeled
+    labeled_mask, num_features = ndimage.label(mask)
+
+    # Create an empty mask to store the result
+    filled_mask = np.zeros_like(labeled_mask)
+
+    # Fill holes for each labeled object independently
+    for i in range(1, num_features + 1):
+        # Create a binary mask for the current object
+        object_mask = (labeled_mask == i)
+
+        # Fill holes within this object
+        filled_object = binary_fill_holes(object_mask)
+
+        # Assign the original label back to the filled object
+        filled_mask[filled_object] = i
+
+    return filled_mask

{spacr-0.3.42.dist-info → spacr-0.3.45.dist-info}/METADATA

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

{spacr-0.3.42.dist-info → spacr-0.3.45.dist-info}/RECORD

@@ -7,27 +7,27 @@ spacr/app_mask.py,sha256=l-dBY8ftzCMdDe6-pXc2Nh_u-idNL9G7UOARiLJBtds,153
 spacr/app_measure.py,sha256=_K7APYIeOKpV6e_LcqabBjvEi7mfq9Fch8175x1x0k8,162
 spacr/app_sequencing.py,sha256=DjG26jy4cpddnV8WOOAIiExtOe9MleVMY4MFa5uTo5w,157
 spacr/app_umap.py,sha256=ZWAmf_OsIKbYvolYuWPMYhdlVe-n2CADoJulAizMiEo,153
-spacr/cellpose.py,sha256=zv4BzhaP2O-mtQ-pUfYvpOyxgn1ke_bDWgdHD5UWm9I,13942
+spacr/cellpose.py,sha256=RBHMs2vwXcfkj0xqAULpALyzJYXddSRycgZSzmwI7v0,14755
 spacr/core.py,sha256=dW9RrAKFLfVsFhX0-kaVMc2T7b47Ky0pTXK-CEVOeWQ,48235
 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_core.py,sha256=N7R7yvfK_dJhOReM_kW3Ci8Bokhi1OzsxeKqvSGdvV4,41460
 spacr/gui_elements.py,sha256=w-S1MZdyxt5O3DsNAHNNXy_WGfwBPg0NhwQtCsJeiao,137071
-spacr/gui_utils.py,sha256=7e9DsZIuV7-jh97kEf7v1In_cFzlFueV4SGcGYGpTxw,45454
-spacr/io.py,sha256=LN_gJq_oqjbf8y-lBtLLZtJi8DLbNdyoGEcBYyOjbhQ,143606
+spacr/gui_utils.py,sha256=KDWDWsi7UdZVhXk1ZWGx3ZqJMIxCUm3lGfjrVhbk52s,45463
+spacr/io.py,sha256=1rIdJ_8dyn7W4D2zXjaOqlgyo_Y5Z7X86aRp4hNYWCU,144194
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
 spacr/measure.py,sha256=KdboGXoi85BO5-_6er7932FgjFI7G7tuaQDnWSiEuew,54817
 spacr/mediar.py,sha256=FwLvbLQW5LQzPgvJZG8Lw7GniA2vbZx6Jv6vIKu7I5c,14743
-spacr/ml.py,sha256=vzuEnbQd96mn7T8h3GRsEDnpWSSpxd3ApGMXTiG6b2o,50507
+spacr/ml.py,sha256=bPcKVk1camnOhv8jQglj6EYyipAxxmiB1QJ2Fdo3dEM,50654
 spacr/openai.py,sha256=5vBZ3Jl2llYcW3oaTEXgdyCB2aJujMUIO5K038z7w_A,1246
-spacr/plot.py,sha256=TDGMwiIHjvk6v94WFlIvemU-6JfEik_GmSez51vyvCc,135869
+spacr/plot.py,sha256=c7PYi4p-ARjHjHCoSn-8ZEXAit0WcTRVxAcAs47tLms,145287
 spacr/sequencing.py,sha256=t18mgpK6rhWuB1LtFOsPxqgpFXxuUmrD06ecsaVQ0Gw,19655
-spacr/settings.py,sha256=x3zcOpVbsxGvq4neW-H08CxzNl8thacy4WOxcIG4TAc,76607
+spacr/settings.py,sha256=3ygnAY6uLtkzFQdK8TMBbWV6zXEX-G_wV19YLyjCBeM,77668
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
-spacr/submodules.py,sha256=AB7s6-cULsaqz-haAaCtXfGEIi8uPZGT4xoCslUJC3Y,18391
+spacr/submodules.py,sha256=3C5M4UbI9Ral1MX4PTpucaAaqhL3RADuCOCqaHhMyUg,28048
 spacr/timelapse.py,sha256=FSYpUtAVy6xc3lwprRYgyDTT9ysUhfRQ4zrP9_h2mvg,39465
-spacr/toxo.py,sha256=MVDfkfTl6fhbzg3izLWdtr2arARYIhI1TdScnHtPVqI,16770
-spacr/utils.py,sha256=Z8lmQJc8sdPvHi0ZmYOahuKtUmDcrYtRYlT4qNZORXU,216396
+spacr/toxo.py,sha256=X62hKFcSzFhIxFYlhL2AZb0qNpvtjLs3y1HldReAQEY,12880
+spacr/utils.py,sha256=K36BxYr4GN956V4S7IkNty2sP4Y265WS7yMzAw8Tqeg,220451
 spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
 spacr/resources/MEDIAR/.gitignore,sha256=Ff1q9Nme14JUd-4Q3jZ65aeQ5X4uttptssVDgBVHYo8,152
 spacr/resources/MEDIAR/LICENSE,sha256=yEj_TRDLUfDpHDNM0StALXIt6mLqSgaV2hcCwa6_TcY,1065
@@ -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.42.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.3.42.dist-info/METADATA,sha256=_nbP3IjQELrampyAYyt6hfrQBukDHuhlS7CApsMPsQ0,5949
-spacr-0.3.42.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-spacr-0.3.42.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.3.42.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.3.42.dist-info/RECORD,,
+spacr-0.3.45.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.3.45.dist-info/METADATA,sha256=eUCjysKj_sil9xg7E1ZQzIUGN8mCTYd1uw64MEY7cbo,5949
+spacr-0.3.45.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+spacr-0.3.45.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.3.45.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.3.45.dist-info/RECORD,,