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

spacr/timelapse.py

@@ -533,14 +533,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 +604,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 +635,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 +669,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 +677,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 +686,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 +752,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 +783,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')