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

spacr/timelapse.py

@@ -7,9 +7,9 @@ from IPython.display import display
 from IPython.display import Image as ipyimage
 import trackpy as tp
 from btrack import datasets as btrack_datasets
-from skimage.measure import regionprops
+from skimage.measure import regionprops, regionprops_table
 from scipy.signal import find_peaks
-from scipy.optimize import curve_fit
+from scipy.optimize import curve_fit, linear_sum_assignment
 from scipy.integrate import trapz
 import matplotlib.pyplot as plt
 
@@ -255,7 +255,7 @@ def _relabel_masks_based_on_tracks(masks, tracks, mode='btrack'):
 
     return relabeled_masks
 
-def _prepare_for_tracking(mask_array):
+def _prepare_for_tracking_v1(mask_array):
     """
     Prepare the mask array for object tracking.
 
@@ -286,6 +286,87 @@ def _prepare_for_tracking(mask_array):
             })
     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')
+        )
+        df = pd.DataFrame(props)
+        df = df.rename(columns={
+            '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.
+    Returns a DataFrame with columns [frame, original_label, track_id].
+    """
+    n_frames = masks.shape[0]
+    # 1) initialize: every label in frame 0 starts its own track
+    labels0 = np.unique(masks[0])[1:]
+    next_track = 1
+    track_map = {}  # (frame,label) -> track_id
+    for L in labels0:
+        track_map[(0, L)] = next_track
+        next_track += 1
+
+    # 2) iterate through frames
+    for t in range(1, n_frames):
+        prev, curr = masks[t-1], masks[t]
+        matches = link_by_iou(prev, curr, iou_threshold=iou_threshold)
+        used_curr = set()
+        # a) assign matched labels to existing tracks
+        for L_prev, L_curr in matches:
+            tid = track_map[(t-1, L_prev)]
+            track_map[(t, L_curr)] = tid
+            used_curr.add(L_curr)
+        # b) any label in curr not matched → new track
+        for L in np.unique(curr)[1:]:
+            if L not in used_curr:
+                track_map[(t, L)] = next_track
+                next_track += 1
+
+    # 3) flatten into DataFrame
+    records = []
+    for (frame, label), tid in track_map.items():
+        records.append({'frame': frame, 'original_label': label, 'track_id': tid})
+    return pd.DataFrame(records)
+
+def link_by_iou(mask_prev, mask_next, iou_threshold=0.1):
+    # Get labels
+    labels_prev = np.unique(mask_prev)[1:]
+    labels_next = np.unique(mask_next)[1:]
+    # Precompute masks as boolean
+    bool_prev = {L: mask_prev==L for L in labels_prev}
+    bool_next = {L: mask_next==L for L in labels_next}
+    # Cost matrix = 1 - IoU
+    cost = np.ones((len(labels_prev), len(labels_next)), dtype=float)
+    for i, L1 in enumerate(labels_prev):
+        m1 = bool_prev[L1]
+        for j, L2 in enumerate(labels_next):
+            m2 = bool_next[L2]
+            inter = np.logical_and(m1, m2).sum()
+            union = np.logical_or(m1, m2).sum()
+            if union > 0:
+                cost[i, j] = 1 - inter/union
+    # Solve assignment
+    row_ind, col_ind = linear_sum_assignment(cost)
+    matches = []
+    for i, j in zip(row_ind, col_ind):
+        if cost[i,j] <= 1 - iou_threshold:
+            matches.append((labels_prev[i], labels_next[j]))
+    return matches
+
 def _find_optimal_search_range(features, initial_search_range=500, increment=10, max_attempts=49, memory=3):
     """
     Find the optimal search range for linking features.
@@ -336,7 +417,94 @@ def _remove_objects_from_first_frame(masks, percentage=10):
             masks[0][first_frame == label] = 0
         return masks
 
-def _facilitate_trackin_with_adaptive_removal(masks, search_range=500, max_attempts=100, memory=3):
+def _track_by_iou(masks, iou_threshold=0.1):
+    """
+    Build a track table by linking masks frame→frame via IoU.
+    Returns a DataFrame with columns [frame, original_label, track_id].
+    """
+    n_frames = masks.shape[0]
+    # 1) initialize: every label in frame 0 starts its own track
+    labels0 = np.unique(masks[0])[1:]
+    next_track = 1
+    track_map = {}  # (frame,label) -> track_id
+    for L in labels0:
+        track_map[(0, L)] = next_track
+        next_track += 1
+
+    # 2) iterate through frames
+    for t in range(1, n_frames):
+        prev, curr = masks[t-1], masks[t]
+        matches = link_by_iou(prev, curr, iou_threshold=iou_threshold)
+        used_curr = set()
+        # a) assign matched labels to existing tracks
+        for L_prev, L_curr in matches:
+            tid = track_map[(t-1, L_prev)]
+            track_map[(t, L_curr)] = tid
+            used_curr.add(L_curr)
+        # b) any label in curr not matched → new track
+        for L in np.unique(curr)[1:]:
+            if L not in used_curr:
+                track_map[(t, L)] = next_track
+                next_track += 1
+
+    # 3) flatten into DataFrame
+    records = []
+    for (frame, label), tid in track_map.items():
+        records.append({'frame': frame, 'original_label': label, 'track_id': tid})
+    return pd.DataFrame(records)
+
+
+def _facilitate_trackin_with_adaptive_removal(masks, search_range=None, max_attempts=5, memory=3, min_mass=50, track_by_iou=False):
+    """
+    Facilitates object tracking with deterministic initial filtering and
+    trackpy’s constant-velocity prediction.
+
+    Args:
+        masks (np.ndarray): integer‐labeled masks (frames × H × W).
+        search_range (int|None): max displacement; if None, auto‐computed.
+        max_attempts (int): how many times to retry with smaller search_range.
+        memory (int): trackpy memory parameter.
+        min_mass (float): drop any object in frame 0 with area < min_mass.
+
+    Returns:
+        masks, features_df, tracks_df
+
+    Raises:
+        RuntimeError if linking fails after max_attempts.
+    """
+    # 1) initial features & filter frame 0 by area
+    features = _prepare_for_tracking(masks)
+    f0 = features[features['frame'] == 0]
+    valid = f0.loc[f0['mass'] >= min_mass, 'original_label'].unique()
+    masks[0] = np.where(np.isin(masks[0], valid), masks[0], 0)
+
+    # 2) recompute features on filtered masks
+    features = _prepare_for_tracking(masks)
+
+    # 3) default search_range = 2×sqrt(99th‑pct area)
+    if search_range is None:
+        a99 = f0['mass'].quantile(0.99)
+        search_range = max(1, int(2 * np.sqrt(a99)))
+
+    # 4) attempt linking, shrinking search_range on failure
+    for attempt in range(1, max_attempts + 1):
+        try:
+            if track_by_iou:
+                tracks_df = _track_by_iou(masks, iou_threshold=0.1)
+            else:
+                tracks_df = tp.link_df(features,search_range=search_range, memory=memory, predict=True)
+                print(f"Linked on attempt {attempt} with search_range={search_range}")
+            return masks, features, tracks_df
+
+        except Exception as e:
+            search_range = max(1, int(search_range * 0.8))
+            print(f"Attempt {attempt} failed ({e}); reducing search_range to {search_range}")
+
+    raise RuntimeError(
+        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.
 
@@ -533,14 +701,14 @@ def exponential_decay(x, a, b, c):
 
 def preprocess_pathogen_data(pathogen_df):
     # Group by identifiers and count the number of parasites
-    parasite_counts = pathogen_df.groupby(['plate', 'row_name', 'column_name', 'field', 'timeid', 'pathogen_cell_id']).size().reset_index(name='parasite_count')
+    parasite_counts = pathogen_df.groupby(['plateID', 'rowID', 'column_name', 'fieldID', 'timeid', 'pathogen_cell_id']).size().reset_index(name='parasite_count')
 
     # Aggregate numerical columns and take the first of object columns
-    agg_funcs = {col: 'mean' if np.issubdtype(pathogen_df[col].dtype, np.number) else 'first' for col in pathogen_df.columns if col not in ['plate', 'row_name', 'column_name', 'field', 'timeid', 'pathogen_cell_id', 'parasite_count']}
-    pathogen_agg = pathogen_df.groupby(['plate', 'row_name', 'column_name', 'field', 'timeid', 'pathogen_cell_id']).agg(agg_funcs).reset_index()
+    agg_funcs = {col: 'mean' if np.issubdtype(pathogen_df[col].dtype, np.number) else 'first' for col in pathogen_df.columns if col not in ['plateID', 'rowID', 'column_name', 'fieldID', 'timeid', 'pathogen_cell_id', 'parasite_count']}
+    pathogen_agg = pathogen_df.groupby(['plateID', 'rowID', 'column_name', 'fieldID', 'timeid', 'pathogen_cell_id']).agg(agg_funcs).reset_index()
 
     # Merge the counts back into the aggregated data
-    pathogen_agg = pathogen_agg.merge(parasite_counts, on=['plate', 'row_name', 'column_name', 'field', 'timeid', 'pathogen_cell_id'])
+    pathogen_agg = pathogen_agg.merge(parasite_counts, on=['plateID', 'rowID', 'column_name', 'fieldID', 'timeid', 'pathogen_cell_id'])
 
     # Remove the object_label column as it corresponds to the pathogen ID not the cell ID
     if 'object_label' in pathogen_agg.columns:
@@ -604,10 +772,10 @@ def save_results_dataframe(df, src, results_name):
 def summarize_per_well(peak_details_df):
     # Step 1: Split the 'ID' column
     split_columns = peak_details_df['ID'].str.split('_', expand=True)
-    peak_details_df[['plate', 'row_name', 'column', 'field', 'object_number']] = split_columns
+    peak_details_df[['plateID', 'rowID', 'columnID', 'fieldID', 'object_number']] = split_columns
 
-    # Step 2: Create 'well_ID' by combining 'row_name' and 'column'
-    peak_details_df['well_ID'] = peak_details_df['row_name'] + '_' + peak_details_df['column']
+    # Step 2: Create 'well_ID' by combining 'rowID' and 'columnID'
+    peak_details_df['well_ID'] = peak_details_df['rowID'] + '_' + peak_details_df['columnID']
 
     # Filter entries where 'amplitude' is not null
     filtered_df = peak_details_df[peak_details_df['amplitude'].notna()]
@@ -635,10 +803,10 @@ def summarize_per_well(peak_details_df):
 def summarize_per_well_inf_non_inf(peak_details_df):
     # Step 1: Split the 'ID' column
     split_columns = peak_details_df['ID'].str.split('_', expand=True)
-    peak_details_df[['plate', 'row_name', 'column', 'field', 'object_number']] = split_columns
+    peak_details_df[['plateID', 'rowID', 'columnID', 'fieldID', 'object_number']] = split_columns
 
-    # Step 2: Create 'well_ID' by combining 'row_name' and 'column'
-    peak_details_df['well_ID'] = peak_details_df['row_name'] + '_' + peak_details_df['column']
+    # Step 2: Create 'well_ID' by combining 'rowID' and 'columnID'
+    peak_details_df['well_ID'] = peak_details_df['rowID'] + '_' + peak_details_df['columnID']
 
     # Assume 'pathogen_count' indicates infection if > 0
     # Add an 'infected_status' column to classify cells
@@ -669,7 +837,7 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
         pathogen_df = pd.read_sql("SELECT * FROM pathogen", conn)
         pathogen_df['pathogen_cell_id'] = pathogen_df['pathogen_cell_id'].astype(float).astype('Int64')
         pathogen_df = preprocess_pathogen_data(pathogen_df)
-        cell_df = cell_df.merge(pathogen_df, on=['plate', 'row_name', 'column_name', 'field', 'timeid', 'object_label'], how='left', suffixes=('', '_pathogen'))
+        cell_df = cell_df.merge(pathogen_df, on=['plateID', 'rowID', 'column_name', 'fieldID', 'timeid', 'object_label'], how='left', suffixes=('', '_pathogen'))
         cell_df['parasite_count'] = cell_df['parasite_count'].fillna(0)
         print(f'After pathogen merge: {len(cell_df)} objects')
 
@@ -677,7 +845,7 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
     if cytoplasm:
         cytoplasm_df = pd.read_sql(f"SELECT * FROM {'cytoplasm'}", conn)
         # Merge on specified columns
-        cell_df = cell_df.merge(cytoplasm_df, on=['plate', 'row_name', 'column_name', 'field', 'timeid', 'object_label'], how='left', suffixes=('', '_cytoplasm'))
+        cell_df = cell_df.merge(cytoplasm_df, on=['plateID', 'rowID', 'column_name', 'fieldID', 'timeid', 'object_label'], how='left', suffixes=('', '_cytoplasm'))
 
         print(f'After cytoplasm merge: {len(cell_df)} objects')
     
@@ -686,13 +854,13 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
     # Continue with your existing processing on cell_df now containing merged data...
     # Prepare DataFrame (use cell_df instead of df)
     prcf_components = cell_df['prcf'].str.split('_', expand=True)
-    cell_df['plate'] = prcf_components[0]
-    cell_df['row_name'] = prcf_components[1]
-    cell_df['column'] = prcf_components[2]
-    cell_df['field'] = prcf_components[3]
+    cell_df['plateID'] = prcf_components[0]
+    cell_df['rowID'] = prcf_components[1]
+    cell_df['columnID'] = prcf_components[2]
+    cell_df['fieldID'] = prcf_components[3]
     cell_df['time'] = prcf_components[4].str.extract('t(\d+)').astype(int)
     cell_df['object_number'] = cell_df['object_label']
-    cell_df['plate_row_column_field_object'] = cell_df['plate'].astype(str) + '_' + cell_df['row_name'].astype(str) + '_' + cell_df['column'].astype(str) + '_' + cell_df['field'].astype(str) + '_' + cell_df['object_label'].astype(str)
+    cell_df['plate_row_column_field_object'] = cell_df['plateID'].astype(str) + '_' + cell_df['rowID'].astype(str) + '_' + cell_df['columnID'].astype(str) + '_' + cell_df['fieldID'].astype(str) + '_' + cell_df['object_label'].astype(str)
 
     df = cell_df.copy()
 
@@ -752,10 +920,10 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
             if len(peaks) == 0:
                 peak_details_list.append({
                     'ID': unique_id,
-                    'plate': group['plate'].iloc[0],
-                    'row_name': group['row_name'].iloc[0],
-                    'column': group['column'].iloc[0],
-                    'field': group['field'].iloc[0],
+                    'plateID': group['plateID'].iloc[0],
+                    'rowID': group['rowID'].iloc[0],
+                    'columnID': group['columnID'].iloc[0],
+                    'fieldID': group['fieldID'].iloc[0],
                     'object_number': group['object_number'].iloc[0],
                     'time': np.nan,  # The time of the peak
                     'amplitude': np.nan,
@@ -783,10 +951,10 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
 
                 peak_details_list.append({
                     'ID': unique_id,
-                    'plate': group['plate'].iloc[0],
-                    'row_name': group['row_name'].iloc[0],
-                    'column': group['column'].iloc[0],
-                    'field': group['field'].iloc[0],
+                    'plateID': group['plateID'].iloc[0],
+                    'rowID': group['rowID'].iloc[0],
+                    'columnID': group['columnID'].iloc[0],
+                    'fieldID': group['fieldID'].iloc[0],
                     'object_number': group['object_number'].iloc[0],
                     'time': peak_time,  # The time of the peak
                     'amplitude': amplitude,

spacr/toxo.py

@@ -494,25 +494,25 @@ def generate_score_heatmap(settings):
         if 'column_name' in df.columns:
             df = df[df['column_name']==column]
         elif 'column' in df.columns:
-            df['column_name'] = df['column']
+            df['columnID'] = df['column']
             df = df[df['column_name']==column]
         if not plate is None:
-            df['plate'] = f"plate{plate}"
-        grouped_df = df.groupby(['plate', 'row_name', 'column_name'])[data_column].mean().reset_index()
-        grouped_df['prc'] = grouped_df['plate'].astype(str) + '_' + grouped_df['row_name'].astype(str) + '_' + grouped_df['column_name'].astype(str)
+            df['plateID'] = f"plate{plate}"
+        grouped_df = df.groupby(['plateID', 'rowID', 'column_name'])[data_column].mean().reset_index()
+        grouped_df['prc'] = grouped_df['plateID'].astype(str) + '_' + grouped_df['rowID'].astype(str) + '_' + grouped_df['column_name'].astype(str)
         return grouped_df
 
     def calculate_fraction_mixed_condition(csv, plate=1, column='c3', control_sgrnas = ['TGGT1_220950_1', 'TGGT1_233460_4']):
         df = pd.read_csv(csv)  
         df = df[df['column_name']==column]
         if plate not in df.columns:
-            df['plate'] = f"plate{plate}"
+            df['plateID'] = f"plate{plate}"
         df = df[df['grna_name'].str.match(f'^{control_sgrnas[0]}$|^{control_sgrnas[1]}$')]
-        grouped_df = df.groupby(['plate', 'row_name', 'column_name'])['count'].sum().reset_index()
+        grouped_df = df.groupby(['plateID', 'rowID', 'column_name'])['count'].sum().reset_index()
         grouped_df = grouped_df.rename(columns={'count': 'total_count'})
-        merged_df = pd.merge(df, grouped_df, on=['plate', 'row_name', 'column_name'])
+        merged_df = pd.merge(df, grouped_df, on=['plateID', 'rowID', 'column_name'])
         merged_df['fraction'] = merged_df['count'] / merged_df['total_count']
-        merged_df['prc'] = merged_df['plate'].astype(str) + '_' + merged_df['row_name'].astype(str) + '_' + merged_df['column_name'].astype(str)
+        merged_df['prc'] = merged_df['plateID'].astype(str) + '_' + merged_df['rowID'].astype(str) + '_' + merged_df['column_name'].astype(str)
         return merged_df
 
     def plot_multi_channel_heatmap(df, column='c3'):
@@ -524,17 +524,17 @@ def generate_score_heatmap(settings):
         - column: Column to filter by (default is 'c3').
         """
         # Extract row number and convert to integer for sorting
-        df['row_num'] = df['row_name'].str.extract(r'(\d+)').astype(int)
+        df['row_num'] = df['rowID'].str.extract(r'(\d+)').astype(int)
 
         # Filter and sort by plate, row, and column
         df = df[df['column_name'] == column]
-        df = df.sort_values(by=['plate', 'row_num', 'column_name'])
+        df = df.sort_values(by=['plateID', 'row_num', 'column_name'])
 
         # Drop temporary 'row_num' column after sorting
         df = df.drop('row_num', axis=1)
 
         # Create a new column combining plate, row, and column for the index
-        df['plate_row_col'] = df['plate'] + '-' + df['row_name'] + '-' + df['column_name']
+        df['plate_row_col'] = df['plateID'] + '-' + df['rowID'] + '-' + df['column_name']
 
         # Set 'plate_row_col' as the index
         df.set_index('plate_row_col', inplace=True)
@@ -593,9 +593,9 @@ def generate_score_heatmap(settings):
             df = pd.read_csv(csv_file)  # Read CSV into DataFrame
             df = df[df['column_name']==column]
             if not plate is None:
-                df['plate'] = f"plate{plate}"
-            # Group the data by 'plate', 'row_name', and 'column_name'
-            grouped_df = df.groupby(['plate', 'row_name', 'column_name'])[data_column].mean().reset_index()
+                df['plateID'] = f"plate{plate}"
+            # Group the data by 'plateID', 'rowID', and 'column_name'
+            grouped_df = df.groupby(['plateID', 'rowID', 'column_name'])[data_column].mean().reset_index()
             # Use the CSV filename to create a new column name
             folder_name = os.path.dirname(csv_file).replace(".csv", "")
             new_column_name = os.path.basename(f"{folder_name}_{data_column}")
@@ -606,8 +606,8 @@ def generate_score_heatmap(settings):
             if combined_df is None:
                 combined_df = grouped_df
             else:
-                combined_df = pd.merge(combined_df, grouped_df, on=['plate', 'row_name', 'column_name'], how='outer')
-        combined_df['prc'] = combined_df['plate'].astype(str) + '_' + combined_df['row_name'].astype(str) + '_' + combined_df['column_name'].astype(str)
+                combined_df = pd.merge(combined_df, grouped_df, on=['plateID', 'rowID', 'column_name'], how='outer')
+        combined_df['prc'] = combined_df['plateID'].astype(str) + '_' + combined_df['rowID'].astype(str) + '_' + combined_df['column_name'].astype(str)
         return combined_df
     
     def calculate_mae(df):
@@ -629,16 +629,16 @@ def generate_score_heatmap(settings):
         mae_df = pd.DataFrame(mae_data)
         return mae_df
 
-    result_df = combine_classification_scores(settings['folders'], settings['csv_name'], settings['data_column'], settings['plate'], settings['column'], )
-    df = calculate_fraction_mixed_condition(settings['csv'], settings['plate'], settings['column'], settings['control_sgrnas'])
+    result_df = combine_classification_scores(settings['folders'], settings['csv_name'], settings['data_column'], settings['plateID'], settings['columnID'], )
+    df = calculate_fraction_mixed_condition(settings['csv'], settings['plateID'], settings['columnID'], settings['control_sgrnas'])
     df = df[df['grna_name']==settings['fraction_grna']]
     fraction_df = df[['fraction', 'prc']]
     merged_df = pd.merge(fraction_df, result_df, on=['prc'])
-    cv_df = group_cv_score(settings['cv_csv'], settings['plate'], settings['column'], settings['data_column_cv'])
+    cv_df = group_cv_score(settings['cv_csv'], settings['plateID'], settings['columnID'], settings['data_column_cv'])
     cv_df = cv_df[[settings['data_column_cv'], 'prc']]
     merged_df = pd.merge(merged_df, cv_df, on=['prc'])
     
-    fig = plot_multi_channel_heatmap(merged_df, settings['column'])
+    fig = plot_multi_channel_heatmap(merged_df, settings['columnID'])
     if 'row_number' in merged_df.columns:
         merged_df = merged_df.drop('row_num', axis=1)
     mae_df = calculate_mae(merged_df)
@@ -646,9 +646,9 @@ def generate_score_heatmap(settings):
         mae_df = mae_df.drop('row_num', axis=1)
         
     if not settings['dst'] is None:
-        mae_dst = os.path.join(settings['dst'], f"mae_scores_comparison_plate_{settings['plate']}.csv")
-        merged_dst = os.path.join(settings['dst'], f"scores_comparison_plate_{settings['plate']}_data.csv")
-        heatmap_save = os.path.join(settings['dst'], f"scores_comparison_plate_{settings['plate']}.pdf")
+        mae_dst = os.path.join(settings['dst'], f"mae_scores_comparison_plate_{settings['plateID']}.csv")
+        merged_dst = os.path.join(settings['dst'], f"scores_comparison_plate_{settings['plateID']}_data.csv")
+        heatmap_save = os.path.join(settings['dst'], f"scores_comparison_plate_{settings['plateID']}.pdf")
         mae_df.to_csv(mae_dst, index=False)
         merged_df.to_csv(merged_dst, index=False)
         fig.savefig(heatmap_save, format='pdf', dpi=600, bbox_inches='tight')