spacr 0.5.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

spacr/plot.py

@@ -1241,103 +1241,6 @@ def _display_gif(path):
     """
     with open(path, 'rb') as file:
         display(ipyimage(file.read()))
-
-def _plot_recruitment_v2(df, df_type, channel_of_interest, columns=[], figuresize=10):
-    """
-    Plot recruitment data for different conditions and pathogens.
-
-    Args:
-        df (DataFrame): The input DataFrame containing the recruitment data.
-        df_type (str): The type of DataFrame (e.g., 'train', 'test').
-        channel_of_interest (str): The channel of interest for plotting.
-        target (str): The target variable for plotting.
-        columns (list, optional): Additional columns to plot. Defaults to an empty list.
-        figuresize (int, optional): The size of the figure. Defaults to 50.
-
-    Returns:
-        None
-    """
-
-    color_list = [(55/255, 155/255, 155/255), 
-                  (155/255, 55/255, 155/255), 
-                  (55/255, 155/255, 255/255), 
-                  (255/255, 55/255, 155/255)]
-
-    sns.set_palette(sns.color_palette(color_list))
-    font = figuresize/2
-    width=figuresize
-    height=figuresize/4
-
-    # Create the subplots
-    fig, axes = plt.subplots(nrows=1, ncols=4, figsize=(width, height))
-
-    # Plot for 'cell_channel' on axes[0]
-    plotter_cell = spacrGraph(df,grouping_column='condition', data_column=f'cell_channel_{channel_of_interest}_mean_intensity')
-    plotter_cell.create_plot(ax=axes[0])
-    axes[0].set_xlabel(f'pathogen {df_type}', fontsize=font)
-    axes[0].set_ylabel(f'cell_channel_{channel_of_interest}_mean_intensity', fontsize=font)
-
-    # Plot for 'nucleus_channel' on axes[1]
-    plotter_nucleus = spacrGraph(df,grouping_column='condition', data_column=f'nucleus_channel_{channel_of_interest}_mean_intensity')
-    plotter_nucleus.create_plot(ax=axes[1])
-    axes[1].set_xlabel(f'pathogen {df_type}', fontsize=font)
-    axes[1].set_ylabel(f'nucleus_channel_{channel_of_interest}_mean_intensity', fontsize=font)
-
-    # Plot for 'cytoplasm_channel' on axes[2]
-    plotter_cytoplasm = spacrGraph(df, grouping_column='condition', data_column=f'cytoplasm_channel_{channel_of_interest}_mean_intensity')
-    plotter_cytoplasm.create_plot(ax=axes[2])
-    axes[2].set_xlabel(f'pathogen {df_type}', fontsize=font)
-    axes[2].set_ylabel(f'cytoplasm_channel_{channel_of_interest}_mean_intensity', fontsize=font)
-
-    # Plot for 'pathogen_channel' on axes[3]
-    plotter_pathogen = spacrGraph(df, grouping_column='condition', data_column=f'pathogen_channel_{channel_of_interest}_mean_intensity')
-    plotter_pathogen.create_plot(ax=axes[3])
-    axes[3].set_xlabel(f'pathogen {df_type}', fontsize=font)
-    axes[3].set_ylabel(f'pathogen_channel_{channel_of_interest}_mean_intensity', fontsize=font)
-
-    #axes[0].legend_.remove()
-    #axes[1].legend_.remove()
-    #axes[2].legend_.remove()
-    #axes[3].legend_.remove()
-
-    handles, labels = axes[3].get_legend_handles_labels()
-    axes[3].legend(handles, labels, bbox_to_anchor=(1.05, 0.5), loc='center left')
-    for i in [0,1,2,3]:
-        axes[i].tick_params(axis='both', which='major', labelsize=font)
-        axes[i].set_xticklabels(axes[i].get_xticklabels(), rotation=45)
-
-    plt.tight_layout()
-    plt.show()
-
-    columns = columns + ['pathogen_cytoplasm_mean_mean', 'pathogen_cytoplasm_q75_mean', 'pathogen_periphery_cytoplasm_mean_mean', 'pathogen_outside_cytoplasm_mean_mean', 'pathogen_outside_cytoplasm_q75_mean']
-    #columns = columns + [f'pathogen_slope_channel_{channel_of_interest}', f'pathogen_cell_distance_channel_{channel_of_interest}', f'nucleus_cell_distance_channel_{channel_of_interest}']
-
-    width = figuresize*2
-    columns_per_row = math.ceil(len(columns) / 2)
-    height = (figuresize*2)/columns_per_row
-
-    fig, axes = plt.subplots(nrows=2, ncols=columns_per_row, figsize=(width, height * 2))
-    axes = axes.flatten()
-
-    print(f'{columns}')
-    for i, col in enumerate(columns):
-        ax = axes[i]
-        plotter_col = spacrGraph(df, grouping_column='condition', data_column=col)
-        plotter_col.create_plot(ax=ax)
-        ax.set_xlabel(f'pathogen {df_type}', fontsize=font)
-        ax.set_ylabel(f'{col}', fontsize=int(font * 2))
-        #ax.legend_.remove()
-        ax.tick_params(axis='both', which='major', labelsize=font)
-        ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
-        if i <= 5:
-            ax.set_ylim(1, None)
-
-    # Turn off any unused axes
-    for i in range(len(columns), len(axes)):
-        axes[i].axis('off')
-
-    plt.tight_layout()
-    plt.show()
         
 def _plot_recruitment(df, df_type, channel_of_interest, columns=[], figuresize=10):
     """
@@ -1414,7 +1317,8 @@ def _plot_recruitment(df, df_type, channel_of_interest, columns=[], figuresize=1
         sns.barplot(ax=ax, data=df, x='condition', y=f'{col}', hue='pathogen', capsize=.1, ci='sd', dodge=False)
         ax.set_xlabel(f'pathogen {df_type}', fontsize=font)
         ax.set_ylabel(f'{col}', fontsize=int(font*2))
-        ax.legend_.remove()
+        if ax.get_legend() is not None:
+            ax.legend_.remove()
         ax.tick_params(axis='both', which='major', labelsize=font)
         ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
         if i <= 5:
@@ -1842,31 +1746,6 @@ def print_mask_and_flows(stack, mask, flows, overlay=True, max_size=1000, thickn
     fig.tight_layout()
     plt.show()
     
-def plot_resize_v1(images, resized_images, labels, resized_labels):
-    # Display an example image and label before and after resizing
-    fig, ax = plt.subplots(2, 2, figsize=(20, 20))
-    
-    # Check if the image is grayscale; if so, add a colormap and keep dimensions correct
-    if images[0].ndim == 2:  # Grayscale image
-        ax[0, 0].imshow(images[0], cmap='gray')
-    else:  # RGB or RGBA image
-        ax[0, 0].imshow(images[0])
-    ax[0, 0].set_title('Original Image')
-
-    if resized_images[0].ndim == 2:  # Grayscale image
-        ax[0, 1].imshow(resized_images[0], cmap='gray')
-    else:  # RGB or RGBA image
-        ax[0, 1].imshow(resized_images[0])
-    ax[0, 1].set_title('Resized Image')
-
-    # Assuming labels are always grayscale (most common scenario)
-    ax[1, 0].imshow(labels[0], cmap='gray')
-    ax[1, 0].set_title('Original Label')
-    ax[1, 1].imshow(resized_labels[0], cmap='gray')
-    ax[1, 1].set_title('Resized Label')
-    plt.show()
-    
-
 def plot_resize(images, resized_images, labels, resized_labels):
     def prepare_image(img):
         if img.ndim == 2:
@@ -2031,7 +1910,7 @@ def plot_comparison_results(comparison_results):
 def plot_object_outlines(src, objects=['nucleus','cell','pathogen'], channels=[0,1,2], max_nr=10):
     
     for object_, channel in zip(objects, channels):
-        folders = [os.path.join(src, 'norm_channel_stack', f'{object_}_mask_stack'),
+        folders = [os.path.join(src, 'masks', f'{object_}_mask_stack'),
                    os.path.join(src,f'{channel+1}')]
         print(folders)
         plot_images_and_arrays(folders,
@@ -2597,7 +2476,7 @@ class spacrGraph:
             # Group by ['prc', grouping_column]
             group_cols = ['prc', self.grouping_column]
 
-        elif self.representation == 'plateID':
+        elif self.representation == 'plate':
             # Make sure 'plateID' exists (split from 'prc' if needed)
             if 'plateID' not in df.columns:
                 if 'prc' in df.columns:
@@ -2930,6 +2809,7 @@ class spacrGraph:
         self.df_melted = pd.melt(self.df, id_vars=[self.grouping_column], value_vars=self.data_column,var_name='Data Column', value_name='Value')
         unique_groups = self.df[self.grouping_column].unique()
         is_normal, normality_results = self.perform_normality_tests()
+        is_normal = True
         levene_stat, levene_p = self.perform_levene_test(unique_groups)
         test_results = self.perform_statistical_tests(unique_groups, is_normal)
         posthoc_results = self.perform_posthoc_tests(is_normal, unique_groups)
@@ -3371,8 +3251,11 @@ class spacrGraph:
         return self.fig
 
 def plot_data_from_db(settings):
+    
     from .io import _read_db, _read_and_merge_data
     from .utils import annotate_conditions, save_settings
+    from .settings import set_default_plot_data_from_db
+    
     """
     Extracts the specified table from the SQLite database and plots a specified column.
 
@@ -3385,8 +3268,8 @@ def plot_data_from_db(settings):
         df (pd.DataFrame): The extracted table as a DataFrame.
     """
 
-
-
+    settings = set_default_plot_data_from_db(settings)
+    
     if isinstance(settings['src'], str):
         srcs = [settings['src']]
     elif isinstance(settings['src'], list):
@@ -3403,7 +3286,6 @@ def plot_data_from_db(settings):
 
     dfs = []
     for i, src in enumerate(srcs):
-
         db_loc = os.path.join(src, 'measurements', settings['database'][i])
         print(f"Database: {db_loc}")
         if settings['table_names'] in ['saliency_image_correlations']:
@@ -3415,7 +3297,7 @@ def plot_data_from_db(settings):
                                     verbose=settings['verbose'],
                                     nuclei_limit=settings['nuclei_limit'],
                                     pathogen_limit=settings['pathogen_limit'])
-     
+            
         dft = annotate_conditions(df1, 
                                 cells=settings['cell_types'], 
                                 cell_loc=settings['cell_plate_metadata'], 
@@ -3436,12 +3318,27 @@ def plot_data_from_db(settings):
 
     if settings['treatment_plate_metadata'] !=  None:
         df = df.dropna(subset='treatment')
-
+        
+    if settings['data_column'] == 'recruitment':
+        pahtogen_measurement = df[f"pathogen_channel_{settings['channel_of_interest']}_mean_intensity"]
+        cytoplasm_measurement = df[f"cytoplasm_channel_{settings['channel_of_interest']}_mean_intensity"]
+        df['recruitment'] = pahtogen_measurement / cytoplasm_measurement
+        
+    if settings['data_column'] not in df.columns:
+        print(f"Data column {settings['data_column']} not found in DataFrame.")
+        print(f'Please use one of the following columns:')
+        for col in df.columns:
+            print(col)
+        display(df)
+        return None
+    
     df = df.dropna(subset=settings['data_column'])
         
     if settings['grouping_column'] not in df.columns:
         print(f"Grouping column {settings['grouping_column']} not found in DataFrame.")
-        print(f'Please use one of the following columns: {df.columns}')
+        print(f'Please use one of the following columns:')
+        for col in df.columns:
+            print(col)
         display(df)
         return None
     
@@ -3480,7 +3377,8 @@ def plot_data_from_db(settings):
 
 def plot_data_from_csv(settings):
     from .io import _read_db, _read_and_merge_data
-    from .utils import annotate_conditions, save_settings
+    from .utils import annotate_conditions, save_settings, remove_outliers_by_group
+    from .settings import get_plot_data_from_csv_default_settings
     """
     Extracts the specified table from the SQLite database and plots a specified column.
 
@@ -3492,7 +3390,12 @@ def plot_data_from_csv(settings):
     Returns:
         df (pd.DataFrame): The extracted table as a DataFrame.
     """
+    
 
+    def filter_rows_by_column_values(df: pd.DataFrame, column: str, values: list) -> pd.DataFrame:
+        """Return a filtered DataFrame where only rows with the column value in the list are kept."""
+        return df[df[column].isin(values)].copy()
+    
     if isinstance(settings['src'], str):
         srcs = [settings['src']]
     elif isinstance(settings['src'], list):
@@ -3519,15 +3422,27 @@ def plot_data_from_csv(settings):
             except Exception as e:
                 print(f"Could not split the prc column: {e}")
 
-                
-    display(df)
-
+    if 'keep_groups' in settings.keys():
+        if isinstance(settings['keep_groups'], str):
+            settings['keep_groups'] = [settings['keep_groups']]
+        elif isinstance(settings['keep_groups'], list):
+            df = filter_rows_by_column_values(df, settings['grouping_column'], settings['keep_groups'])
+            
+    if settings['remove_outliers']:
+        df = remove_outliers_by_group(df, settings['grouping_column'], settings['data_column'], method='iqr', threshold=1.5)
+    
+    if settings['verbose']:       
+        display(df)
+    
     df = df.dropna(subset=settings['data_column'])
     df = df.dropna(subset=settings['grouping_column'])
     src = srcs[0] 
     dst = os.path.join(os.path.dirname(src), 'results', settings['graph_name'])
     os.makedirs(dst, exist_ok=True)
     
+    #data_csv = os.path.join(dst, f"{settings['graph_name']}_data.csv")
+    #df.to_csv(data_csv, index=False)
+    
     spacr_graph = spacrGraph(
         df=df,                                       # Your DataFrame
         grouping_column=settings['grouping_column'], # Column for grouping the data (x-axis)

spacr/settings.py

@@ -29,7 +29,6 @@ def set_default_settings_preprocess_generate_masks(settings={}):
     settings.setdefault('denoise', False)
     settings.setdefault('src', 'path')
     settings.setdefault('delete_intermediate', False)
-    settings.setdefault('segmentation_mode', 'cellpose')
     settings.setdefault('preprocess', True)
     settings.setdefault('masks', True)
     settings.setdefault('save', True)
@@ -100,30 +99,30 @@ def set_default_settings_preprocess_generate_masks(settings={}):
     settings.setdefault('adjust_cells', False)
     return settings
 
-def set_default_settings_preprocess_img_data_v1(settings):
-
-    metadata_type = settings.setdefault('metadata_type', 'cellvoyager')
-    custom_regex = settings.setdefault('custom_regex', None)
-    nr = settings.setdefault('nr', 1)
-    plot = settings.setdefault('plot', True)
-    batch_size = settings.setdefault('batch_size', 50)
-    timelapse = settings.setdefault('timelapse', False)
-    lower_percentile = settings.setdefault('lower_percentile', 2)
-    randomize = settings.setdefault('randomize', True)
-    all_to_mip = settings.setdefault('all_to_mip', False)
-    pick_slice = settings.setdefault('pick_slice', False)
-    skip_mode = settings.setdefault('skip_mode', False)
-
-    cmap = settings.setdefault('cmap', 'inferno')
-    figuresize = settings.setdefault('figuresize', 10)
-    normalize = settings.setdefault('normalize', True)
-    save_dtype = settings.setdefault('save_dtype', 'uint16')
-    
-    test_mode = settings.setdefault('test_mode', False)
-    test_images = settings.setdefault('test_images', 10)
-    random_test = settings.setdefault('random_test', True)
-
-    return settings, metadata_type, custom_regex, nr, plot, batch_size, timelapse, lower_percentile, randomize, all_to_mip, pick_slice, skip_mode, cmap, figuresize, normalize, save_dtype, test_mode, test_images, random_test
+def set_default_plot_data_from_db(settings):
+    settings.setdefault('src', 'path')
+    settings.setdefault('database', 'measurements.db')
+    settings.setdefault('graph_name', 'Figure_1')
+    settings.setdefault('table_names', ['cell', 'cytoplasm', 'nucleus', 'pathogen'])
+    settings.setdefault('data_column', 'recruitment')
+    settings.setdefault('grouping_column', 'condition')
+    settings.setdefault('cell_types', ['Hela'])
+    settings.setdefault('cell_plate_metadata', None)
+    settings.setdefault('pathogen_types', None)
+    settings.setdefault('pathogen_plate_metadata', None)
+    settings.setdefault('treatments', None)
+    settings.setdefault('treatment_plate_metadata', None)
+    settings.setdefault('graph_type', 'jitter')
+    settings.setdefault('theme', 'deep')
+    settings.setdefault('save', True)
+    settings.setdefault('y_lim', [1,1.5])
+    settings.setdefault('verbose', False)
+    settings.setdefault('channel_of_interest', 1)
+    settings.setdefault('nuclei_limit', 2)
+    settings.setdefault('pathogen_limit', 3)
+    settings.setdefault('representation', 'well')
+    settings.setdefault('uninfected', False)
+    return settings
 
 def set_default_settings_preprocess_img_data(settings):
 
@@ -955,7 +954,6 @@ expected_types = {
     "png_type":str,
     "custom_model_path":str,
     "generate_training_dataset":bool,
-    "segmentation_mode":str,
     "train_DL_model":bool,
     "normalize":bool,
     "overlay":bool,
@@ -1006,7 +1004,7 @@ expected_types = {
 }
 
 categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv", "metadata_files", "score_data","count_data"],
-             "General": ["cell_mask_dim", "cytoplasm", "cell_chann_dim", "cell_channel", "nucleus_chann_dim", "nucleus_channel", "nucleus_mask_dim", "pathogen_mask_dim", "pathogen_chann_dim", "pathogen_channel", "test_mode", "plot", "metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "segmentation_mode", "delete_intermediate", "uninfected", ],
+             "General": ["cell_mask_dim", "cytoplasm", "cell_chann_dim", "cell_channel", "nucleus_chann_dim", "nucleus_channel", "nucleus_mask_dim", "pathogen_mask_dim", "pathogen_chann_dim", "pathogen_channel", "test_mode", "plot", "metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "delete_intermediate", "uninfected", ],
              "Cellpose":["denoise","fill_in","from_scratch", "n_epochs", "width_height", "model_name", "custom_model", "resample", "rescale", "CP_prob", "flow_threshold", "percentiles", "invert", "diameter", "grayscale", "Signal_to_noise", "resize", "target_height", "target_width"],
              "Cell": ["cell_diamiter","cell_intensity_range", "cell_size_range", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cytoplasm_min_size", "adjust_cells", "cells", "cell_loc"],
              "Nucleus": ["nucleus_diamiter","nucleus_intensity_range", "nucleus_size_range", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_loc"],
@@ -1217,7 +1215,7 @@ def generate_fields(variables, scrollable_frame):
         "nucleus_min_size": "(int) - The minimum size of nucleus objects in pixels^2.",
         "normalize_by": "(str) - Normalize cropped png images by png or by field of view.",
         "dependent_variable": "(str) - The dependent variable for the regression analysis.",
-        "delete_intermediate": "(bool) - Delete intermediate folders (stack, channel, norm_channel_stack).",
+        "delete_intermediate": "(bool) - Delete intermediate folders (stack, channel, masks).",
         "diameter": "(float) - Diameter of the objects to segment.",
         "dialate_png_ratios": "(list) - The ratios to use for dilating the PNG images. This will determine the amount of dilation applied to the images before cropping.",
         "dialate_pngs": "(bool) - Whether to dilate the PNG images before saving.",
@@ -1337,7 +1335,6 @@ def generate_fields(variables, scrollable_frame):
         "skip_mode": "(str) - The mode to use for skipping images. This will determine how to handle images that cannot be processed.",
         "smooth_lines": "(bool) - Whether to smooth lines in the plots.",
         "src": "(str, path) - Path to source directory.",
-        "segmentation_mode": "(str) - Algorithm to use for segmentation (cellpose or mediar).",
         "target": "(str) - Target variable for the analysis.",
         "target_height": "(int) - Target height for resizing the images.",
         "target_intensity_min": "(float) - Minimum intensity for the target objects.",
@@ -1376,7 +1373,6 @@ def generate_fields(variables, scrollable_frame):
         "dataset_mode": "str - How to generate train/test dataset.",
         "annotated_classes": "list - list of numbers in annotation column.",
         "um_per_pixel": "(float) - The micrometers per pixel for the images.",
-        "segmentation_model": "(str) - The segmentation model to use, either cellpose or mediar.",
         "pathogen_model": "(str) - use a custom cellpose model to detect pathogen objects.",
         "timelapse_displacement": "(int) - Displacement for timelapse tracking.",
         "timelapse_memory": "(int) - Memory for timelapse tracking.",
@@ -1596,4 +1592,20 @@ def set_analyze_class_proportion_defaults(settings):
     settings.setdefault('level','well')
     settings.setdefault('save',False)
     settings.setdefault('verbose', False)
+    return settings
+
+def get_plot_data_from_csv_default_settings(settings):
+    settings.setdefault('src','path')
+    settings.setdefault('data_column','choose column')
+    settings.setdefault('grouping_column','choose column')
+    settings.setdefault('graph_type','violin')
+    settings.setdefault('save',False)
+    settings.setdefault('y_lim',None)
+    settings.setdefault('log_y',False)
+    settings.setdefault('log_x',False)
+    settings.setdefault('keep_groups',None)
+    settings.setdefault('representation','well')
+    settings.setdefault('theme','dark')
+    settings.setdefault('remove_outliers',False)
+    settings.setdefault('verbose',False)
     return settings

spacr/submodules.py

@@ -1,5 +1,5 @@
 import seaborn as sns
-import os, random, sqlite3, re, shap, string, time
+import os, random, sqlite3, re, shap, string, time, shutil
 import pandas as pd
 import numpy as np
 
@@ -580,6 +580,16 @@ def analyze_recruitment(settings):
     from .settings import get_analyze_recruitment_default_settings
 
     settings = get_analyze_recruitment_default_settings(settings=settings)
+    
+    if settings['src'].endswith('/measurements.db'):
+        src_orig = settings['src']
+        settings['src'] = os.path.dirname(settings['src'])
+        if not settings['src'].endswith('/measurements'):
+            src_mes = os.path.join(settings['src'], 'measurements')
+            if not os.path.exists(src_mes):
+                os.makedirs(src_mes)
+                shutil.move(src_orig, os.path.join(src_mes, 'measurements.db'))
+
     save_settings(settings, name='recruitment')
 
     print(f"Cell(s): {settings['cell_types']}, in {settings['cell_plate_metadata']}")

spacr/timelapse.py

@@ -255,57 +255,25 @@ def _relabel_masks_based_on_tracks(masks, tracks, mode='btrack'):
 
     return relabeled_masks
 
-def _prepare_for_tracking_v1(mask_array):
-    """
-    Prepare the mask array for object tracking.
-
-    Args:
-        mask_array (ndarray): Array of binary masks representing objects.
-
-    Returns:
-        DataFrame: DataFrame containing information about each object in the mask array.
-            The DataFrame has the following columns:
-            - frame: The frame number.
-            - y: The y-coordinate of the object's centroid.
-            - x: The x-coordinate of the object's centroid.
-            - mass: The area of the object.
-            - original_label: The original label of the object.
-
-    """
-    frames = []
-    for t, frame in enumerate(mask_array):
-        props = regionprops(frame)
-        for obj in props:
-            # Include 'label' in the dictionary to capture the original label of the object
-            frames.append({
-                'frame': t, 
-                'y': obj.centroid[0], 
-                'x': obj.centroid[1], 
-                'mass': obj.area,
-                'original_label': obj.label  # Capture the original label
-            })
-    return pd.DataFrame(frames)
-
 def _prepare_for_tracking(mask_array):
     frames = []
     for t, frame in enumerate(mask_array):
         props = regionprops_table(
             frame,
-            properties=('label', 'centroid-0', 'centroid-1', 'area',
-                        'bbox-0', 'bbox-1', 'bbox-2', 'bbox-3',
-                        'eccentricity')
+            properties=('label', 'centroid', 'area', 'bbox', 'eccentricity')
         )
         df = pd.DataFrame(props)
         df = df.rename(columns={
-            'centroid-0': 'y', 'centroid-1': 'x', 'area': 'mass',
-            'label': 'original_label'
+            'centroid-0': 'y',
+            'centroid-1': 'x',
+            'area':       'mass',
+            'label':      'original_label'
         })
         df['frame'] = t
         frames.append(df[['frame','y','x','mass','original_label',
                           'bbox-0','bbox-1','bbox-2','bbox-3','eccentricity']])
     return pd.concat(frames, ignore_index=True)
 
-
 def _track_by_iou(masks, iou_threshold=0.1):
     """
     Build a track table by linking masks frame→frame via IoU.
@@ -504,47 +472,7 @@ def _facilitate_trackin_with_adaptive_removal(masks, search_range=None, max_atte
         f"Failed to track after {max_attempts} attempts; last search_range={search_range}"
     )
 
-def _facilitate_trackin_with_adaptive_removal_v1(masks, search_range=500, max_attempts=100, memory=3):
-    """
-    Facilitates object tracking with adaptive removal.
-
-    Args:
-        masks (numpy.ndarray): Array of binary masks representing objects in each frame.
-        search_range (int, optional): Maximum distance objects can move between frames. Defaults to 500.
-        max_attempts (int, optional): Maximum number of attempts to track objects. Defaults to 100.
-        memory (int, optional): Number of frames to remember when linking tracks. Defaults to 3.
-
-    Returns:
-        tuple: A tuple containing the updated masks, features, and tracks_df.
-            masks (numpy.ndarray): Updated array of binary masks.
-            features (pandas.DataFrame): DataFrame containing features for object tracking.
-            tracks_df (pandas.DataFrame): DataFrame containing the tracked object trajectories.
-
-    Raises:
-        Exception: If tracking fails after the maximum number of attempts.
-
-    """
-    attempts = 0
-    first_frame = masks[0]
-    starting_objects = np.unique(first_frame[first_frame != 0])
-    while attempts < max_attempts:
-        try:
-            masks = _remove_objects_from_first_frame(masks, 10)
-            first_frame = masks[0]
-            objects = np.unique(first_frame[first_frame != 0])
-            print(len(objects))
-            features = _prepare_for_tracking(masks)
-            tracks_df = tp.link(features, search_range=search_range, memory=memory)
-            print(f"Success with {len(objects)} objects, started with {len(starting_objects)} objects")
-            return masks, features, tracks_df
-        except Exception as e:  # Consider catching a more specific exception if possible
-            print(f"Retrying with fewer objects. Exception: {e}", flush=True)
-        finally:
-            attempts += 1
-    print(f"Failed to track objects after {max_attempts} attempts. Consider adjusting parameters.")
-    return None, None, None
-
-def _trackpy_track_cells(src, name, batch_filenames, object_type, masks, timelapse_displacement, timelapse_memory, timelapse_remove_transient, plot, save, mode):
+def _trackpy_track_cells(src, name, batch_filenames, object_type, masks, timelapse_displacement, timelapse_memory, timelapse_remove_transient, plot, save, mode, track_by_iou):
         """
         Track cells using the Trackpy library.
 
@@ -577,7 +505,7 @@ def _trackpy_track_cells(src, name, batch_filenames, object_type, masks, timelap
             if timelapse_displacement is None:
                 timelapse_displacement = 50
 
-        masks, features, tracks_df = _facilitate_trackin_with_adaptive_removal(masks, search_range=timelapse_displacement, max_attempts=100, memory=timelapse_memory)
+        masks, features, tracks_df = _facilitate_trackin_with_adaptive_removal(masks, search_range=timelapse_displacement, max_attempts=100, memory=timelapse_memory, track_by_iou=track_by_iou)
 
         tracks_df['particle'] += 1