spacr 0.3.50__py3-none-any.whl → 0.3.55__py3-none-any.whl

spacr/settings.py

@@ -198,7 +198,7 @@ def set_default_umap_image_settings(settings={}):
     settings.setdefault('smooth_lines', True)
     settings.setdefault('clustering', 'dbscan')
     settings.setdefault('exclude', None)
-    settings.setdefault('col_to_compare', 'col')
+    settings.setdefault('col_to_compare', 'column_name')
     settings.setdefault('pos', 'c1')
     settings.setdefault('neg', 'c2')
     settings.setdefault('embedding_by_controls', False)
@@ -246,7 +246,7 @@ def get_measure_crop_settings(settings={}):
     settings.setdefault('normalize_by','png')
     settings.setdefault('crop_mode',['cell'])
     settings.setdefault('dialate_pngs', False)
-    settings.setdefault('dialate_png_ratios', [0.2,0.2])
+    settings.setdefault('dialate_png_ratios', [0.2])
 
     # Timelapsed settings
     settings.setdefault('timelapse', False)
@@ -289,7 +289,7 @@ def set_default_analyze_screen(settings):
     settings.setdefault('minimum_cell_count',25)
     settings.setdefault('n_estimators',100)
     settings.setdefault('test_size',0.2)
-    settings.setdefault('location_column','col')
+    settings.setdefault('location_column','column_name')
     settings.setdefault('positive_control','c2')
     settings.setdefault('negative_control','c1')
     settings.setdefault('exclude',None)
@@ -337,8 +337,9 @@ def set_default_train_test_model(settings):
     return settings
 
 def set_generate_training_dataset_defaults(settings):
-
+    
     settings.setdefault('src','path')
+    settings.setdefault('tables',['cell', 'nucleus', 'pathogen', 'cytoplasm'])
     settings.setdefault('dataset_mode','metadata')
     settings.setdefault('annotation_column','test')
     settings.setdefault('annotated_classes',[1,2])
@@ -346,7 +347,7 @@ def set_generate_training_dataset_defaults(settings):
     settings.setdefault('size',224)
     settings.setdefault('test_split',0.1)
     settings.setdefault('class_metadata',[['c1'],['c2']])
-    settings.setdefault('metadata_type_by','col')
+    settings.setdefault('metadata_type_by','column_name')
     settings.setdefault('channel_of_interest',3)
     settings.setdefault('custom_measurement',None)
     settings.setdefault('tables',None)
@@ -369,7 +370,7 @@ def deep_spacr_defaults(settings):
     settings.setdefault('size',224)
     settings.setdefault('test_split',0.1)
     settings.setdefault('class_metadata',[['c1'],['c2']])
-    settings.setdefault('metadata_type_by','col')
+    settings.setdefault('metadata_type_by','column_name')
     settings.setdefault('channel_of_interest',3)
     settings.setdefault('custom_measurement',None)
     settings.setdefault('tables',None)
@@ -453,7 +454,7 @@ def get_analyze_recruitment_default_settings(settings):
     settings.setdefault('pathogen_plate_metadata',[['c1', 'c2', 'c3'],['c4','c5', 'c6']])
     settings.setdefault('treatments',['cm', 'lovastatin'])
     settings.setdefault('treatment_plate_metadata',[['r1', 'r2','r3'], ['r4', 'r5','r6']])
-    settings.setdefault('metadata_types',['col', 'col', 'row'])
+    settings.setdefault('metadata_types',['column_name', 'column_name', 'row_name'])
     settings.setdefault('channel_dims',[0,1,2,3])
     settings.setdefault('cell_chann_dim',3)
     settings.setdefault('cell_mask_dim',4)
@@ -531,18 +532,22 @@ def get_perform_regression_default_settings(settings):
     settings.setdefault('score_data','list of paths')
     settings.setdefault('positive_control','239740')
     settings.setdefault('negative_control','233460')
+    settings.setdefault('min_n',0)
     settings.setdefault('controls',['000000_1','000000_10','000000_11','000000_12','000000_13','000000_14','000000_15','000000_16','000000_17','000000_18','000000_19','000000_20','000000_21','000000_22','000000_23','000000_24','000000_25','000000_26','000000_27','000000_28','000000_29','000000_3','000000_30','000000_31','000000_32','000000_4','000000_5','000000_6','000000_8','000000_9'])
-    settings.setdefault('fraction_threshold',0.12)
+    settings.setdefault('fraction_threshold',None)
     settings.setdefault('dependent_variable','pred')
     settings.setdefault('threshold_method','std')
     settings.setdefault('threshold_multiplier',3)
+    settings.setdefault('target_unique_count',5)
     settings.setdefault('transform',None)
+    settings.setdefault('log_x',False)
+    settings.setdefault('log_y',False)
+    settings.setdefault('x_lim',None)
     settings.setdefault('agg_type','mean')
-    settings.setdefault('min_cell_count',25)
+    settings.setdefault('min_cell_count',None)
     settings.setdefault('regression_type','ols')
     settings.setdefault('random_row_column_effects',False)
     settings.setdefault('split_axis_lims','')
-    settings.setdefault('plate','')
     settings.setdefault('cov_type',None)
     settings.setdefault('alpha',1)
     settings.setdefault('filter_value',['c1', 'c2', 'c3'])
@@ -557,6 +562,7 @@ def get_perform_regression_default_settings(settings):
         print(f"Using alpha as quantile for quantile regression, alpha: {settings['alpha']}")
         settings['agg_type'] = None
         print(f'agg_type set to None for quantile regression')
+        
     return settings
 
 def get_check_cellpose_models_default_settings(settings):
@@ -697,16 +703,6 @@ expected_types = {
     "overlay_chans": list,
     "overlay": bool,
     "normalization_percentiles": list,
-    "print_object_number": bool,
-    "nr": int,
-    "figuresize": int,
-    "cmap": str,
-    "test_mode": bool,
-    "test_images": int,
-    "remove_background_cell": bool,
-    "remove_background_nucleus": bool,
-    "remove_background_pathogen": bool,
-    "pathogen_model": (str, type(None)),
     "filter": bool,
     "fill_in":bool,
     "upscale": bool,
@@ -825,18 +821,6 @@ expected_types = {
     "transform": (str, type(None)),
     "agg_type": str,
     "min_cell_count": int,
-    "regression_type": str,
-    "random_row_column_effects": bool,
-    "alpha": float,
-    "fraction_threshold": float,
-    "class_1_threshold": (float, type(None)),
-    "batch_size": int,
-    "CP_prob": float,
-    "flow_threshold": float,
-    "percentiles": (list, type(None)),
-    "invert": bool,
-    "diameter": int,
-    "grayscale": bool,
     "resize": bool,
     "target_height": (int, type(None)),
     "target_width": (int, type(None)),
@@ -881,9 +865,6 @@ expected_types = {
     "metadata_type_by":str,
     "custom_measurement":str,
     "custom_model":bool,
-    "size":int,
-    "test_split":float,
-    "class_metadata":list, # This is a list of lists 
     "png_type":str,
     "custom_model_path":str,
     "generate_training_dataset":bool,
@@ -894,6 +875,7 @@ expected_types = {
     "correlate":bool,
     "target_layer":str,
     "save_to_db":bool,
+    "test_mode":bool,
     "normalize_input":bool,
 }
 
@@ -904,7 +886,7 @@ categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset
              "Nucleus": ["nucleus_intensity_range", "nucleus_size_range", "nucleus_chann_dim", "nucleus_channel", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_mask_dim", "nucleus_loc"],
              "Pathogen": ["pathogen_intensity_range", "pathogen_size_range", "pathogen_chann_dim", "pathogen_channel", "pathogen_background", "pathogen_Signal_to_noise", "pathogen_CP_prob", "pathogen_FT", "pathogen_model", "remove_background_pathogen", "pathogen_min_size", "pathogen_mask_dim", "pathogens", "pathogen_loc", "pathogen_types", "pathogen_plate_metadata", ],
              "Measurements": ["remove_image_canvas", "remove_highly_correlated", "homogeneity", "homogeneity_distances", "radial_dist", "calculate_correlation", "manders_thresholds", "save_measurements", "tables", "image_nr", "dot_size", "filter_by", "remove_highly_correlated_features", "remove_low_variance_features", "channel_of_interest"],
-             "Object Image": ["save_png", "dialate_pngs", "dialate_png_ratios", "png_size", "png_dims", "save_arrays", "normalize_by", "crop_mode", "dialate_pngs", "normalize", "use_bounding_box"],
+             "Object Image": ["save_png", "dialate_pngs", "dialate_png_ratios", "png_size", "png_dims", "save_arrays", "normalize_by", "crop_mode", "normalize", "use_bounding_box"],
              "Sequencing": ["signal_direction","mode","comp_level","comp_type","save_h5","expected_end","offset","target_sequence","regex", "highlight"],
              "Generate Dataset":["save_to_db","file_metadata","class_metadata", "annotation_column","annotated_classes", "dataset_mode", "metadata_type_by","custom_measurement", "sample", "size"],
              "Hyperparamiters (Training)": ["png_type", "score_threshold","file_type", "train_channels", "epochs", "loss_type", "optimizer_type","image_size","val_split","learning_rate","weight_decay","dropout_rate", "init_weights", "train", "classes", "augment", "amsgrad","use_checkpoint","gradient_accumulation","gradient_accumulation_steps","intermedeate_save","pin_memory"],
@@ -939,6 +921,9 @@ def check_settings(vars_dict, expected_types, q=None):
                 continue
 
         value = var.get()
+        if value == 'None':
+            value = None
+
         expected_type = expected_types.get(key, str)
 
         try:
@@ -953,14 +938,19 @@ def check_settings(vars_dict, expected_types, q=None):
                 #    settings[key] = None
                 else:
                     raise ValueError("Invalid format for list or list of lists")
+                
             elif expected_type == list:
                 settings[key] = parse_list(value) if value else None
+
+                if isinstance(settings[key], list) and len(settings[key]) == 1:
+                    settings[key] = settings[key][0]
+
             elif expected_type == bool:
                 settings[key] = value if isinstance(value, bool) else value.lower() in ['true', '1', 't', 'y', 'yes']
             elif expected_type == (int, type(None)):
-                settings[key] = int(value) if value else None
+                settings[key] = settings[key] = int(value) if isinstance(value, int) or str(value).isdigit() else None
             elif expected_type == (float, type(None)):
-                settings[key] = float(value) if value else None
+                settings[key] = float(value) if isinstance(value, float) or (isinstance(value, str) and value.replace(".", "", 1).isdigit()) else None
             elif expected_type == (int, float):
                 settings[key] = float(value) if '.' in value else int(value)
             elif expected_type == (str, type(None)):
@@ -1000,7 +990,7 @@ def check_settings(vars_dict, expected_types, q=None):
                 settings[key] = expected_type(value) if value else None
         except (ValueError, SyntaxError) as e:
             expected_type_name = ' or '.join([t.__name__ for t in expected_type]) if isinstance(expected_type, tuple) else expected_type.__name__
-            q.put(f"Error: Invalid format for {key}. Expected type: {expected_type_name}. Error: {e}")
+            q.put(f"Error: Invalid format for {key}. Expected type: {expected_type_name}. Error: {e}, Value entered: {value}")
             return
 
     return settings

spacr/submodules.py

@@ -341,17 +341,17 @@ def count_phenotypes(settings):
     unique_values_count = df[settings['annotation_column']].nunique(dropna=True)
     print(f"Unique values in {settings['annotation_column']} (excluding NaN): {unique_values_count}")
 
-    # Count unique values in 'value' column, grouped by 'plate', 'row', 'column'
-    grouped_unique_count = df.groupby(['plate', 'row', 'column'])[settings['annotation_column']].nunique(dropna=True).reset_index(name='unique_count')
+    # Count unique values in 'value' column, grouped by 'plate', 'row_name', 'column'
+    grouped_unique_count = df.groupby(['plate', 'row_name', 'column'])[settings['annotation_column']].nunique(dropna=True).reset_index(name='unique_count')
     display(grouped_unique_count)
 
     save_path = os.path.join(settings['src'], 'phenotype_counts.csv')
 
     # Group by plate, row, and column, then count the occurrences of each unique value
-    grouped_counts = df.groupby(['plate', 'row', 'column', 'value']).size().reset_index(name='count')
+    grouped_counts = df.groupby(['plate', 'row_name', 'column', 'value']).size().reset_index(name='count')
 
     # Pivot the DataFrame so that unique values are columns and their counts are in the rows
-    pivot_df = grouped_counts.pivot_table(index=['plate', 'row', 'column'], columns='value', values='count', fill_value=0)
+    pivot_df = grouped_counts.pivot_table(index=['plate', 'row_name', 'column'], columns='value', values='count', fill_value=0)
 
     # Flatten the multi-level columns
     pivot_df.columns = [f"value_{int(col)}" for col in pivot_df.columns]
@@ -376,17 +376,17 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
                             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']
+        if all(col in df.columns for col in ['plate', 'row_name', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row_name'] + '_' + 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])
+            raise ValueError("Cannot find 'plate', 'row_name', or 'column' in df.columns")
+        prc_summary = df.groupby(['plate', 'row_name', 'column', 'prc']).size().reset_index(name='total_rows')
+        well_counts = (df.groupby(['plate', 'row_name', '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 = pd.merge(prc_summary, well_counts, on=['plate', 'row_name', '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
@@ -481,8 +481,8 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
         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']
+        if all(col in df.columns for col in ['plate', 'row_name', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row_name'] + '_' + df['column']
         else:
             raise ValueError("Cannot find plate, row or column in df.columns")
         grouped_df = df.groupby('prc')[count_column].sum().reset_index()
@@ -501,18 +501,18 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
                 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 reads_df_temp.columns:
+                    reads_df_temp = reads_df_temp.rename(columns={'column_name': 'column'})
+                if 'column_name' in scores_df_temp.columns:
+                    scores_df_temp = scores_df_temp.rename(columns={'column_name': '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'})
+                    reads_df_temp = reads_df_temp.rename(columns={'row_name': 'row_name'})
                 if 'row_name' in scores_df_temp.columns:
-                    scores_df_temp = scores_df_temp.rename(columns={'row_name': 'row'})
+                    scores_df_temp = scores_df_temp.rename(columns={'row_name': 'row_name'})
                     
                 reads_ls.append(reads_df_temp)
                 scores_ls.append(scores_df_temp)
@@ -539,7 +539,7 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
     
     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')
+    df = pd.merge(df, df_emp, left_on='row_name', right_on='key')
     
     if any in y_columns not in df.columns:
         print(f"columns in dataframe:")

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', 'col', 'field', 'timeid', 'pathogen_cell_id']).size().reset_index(name='parasite_count')
+    parasite_counts = pathogen_df.groupby(['plate', 'row_name', 'column_name', 'field', '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', 'col', 'field', 'timeid', 'pathogen_cell_id', 'parasite_count']}
-    pathogen_agg = pathogen_df.groupby(['plate', 'row', 'col', '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 ['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()
 
     # Merge the counts back into the aggregated data
-    pathogen_agg = pathogen_agg.merge(parasite_counts, on=['plate', 'row', 'col', 'field', 'timeid', 'pathogen_cell_id'])
+    pathogen_agg = pathogen_agg.merge(parasite_counts, on=['plate', 'row_name', 'column_name', 'field', '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', 'column', 'field', 'object_number']] = split_columns
+    peak_details_df[['plate', 'row_name', 'column', 'field', 'object_number']] = split_columns
 
-    # Step 2: Create 'well_ID' by combining 'row' and 'column'
-    peak_details_df['well_ID'] = peak_details_df['row'] + '_' + peak_details_df['column']
+    # 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']
 
     # 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', 'column', 'field', 'object_number']] = split_columns
+    peak_details_df[['plate', 'row_name', 'column', 'field', 'object_number']] = split_columns
 
-    # Step 2: Create 'well_ID' by combining 'row' and 'column'
-    peak_details_df['well_ID'] = peak_details_df['row'] + '_' + peak_details_df['column']
+    # 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']
 
     # 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', 'col', 'field', 'timeid', 'object_label'], how='left', suffixes=('', '_pathogen'))
+        cell_df = cell_df.merge(pathogen_df, on=['plate', 'row_name', 'column_name', 'field', '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', 'col', 'field', 'timeid', 'object_label'], how='left', suffixes=('', '_cytoplasm'))
+        cell_df = cell_df.merge(cytoplasm_df, on=['plate', 'row_name', 'column_name', 'field', 'timeid', 'object_label'], how='left', suffixes=('', '_cytoplasm'))
 
         print(f'After cytoplasm merge: {len(cell_df)} objects')
     
@@ -687,12 +687,12 @@ def analyze_calcium_oscillations(db_loc, measurement='cell_channel_1_mean_intens
     # 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'] = prcf_components[1]
+    cell_df['row_name'] = prcf_components[1]
     cell_df['column'] = prcf_components[2]
     cell_df['field'] = 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'].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['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)
 
     df = cell_df.copy()
 
@@ -753,7 +753,7 @@ 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': group['row'].iloc[0],
+                    'row_name': group['row_name'].iloc[0],
                     'column': group['column'].iloc[0],
                     'field': group['field'].iloc[0],
                     'object_number': group['object_number'].iloc[0],
@@ -784,7 +784,7 @@ 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': group['row'].iloc[0],
+                    'row_name': group['row_name'].iloc[0],
                     'column': group['column'].iloc[0],
                     'field': group['field'].iloc[0],
                     'object_number': group['object_number'].iloc[0],

spacr/toxo.py

@@ -10,6 +10,17 @@ from matplotlib.legend import Legend
 from matplotlib.transforms import Bbox
 from brokenaxes import brokenaxes
 
+import os
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from scipy.spatial.distance import cosine
+from scipy.stats import pearsonr
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import mean_absolute_error
+
 
 from matplotlib.gridspec import GridSpec
 
@@ -450,4 +461,172 @@ def plot_gene_heatmaps(data, gene_list, columns, x_column='Gene ID', normalize=F
         plt.savefig(save_path, format='pdf', dpi=600, bbox_inches='tight')
         print(f"Figure saved to {save_path}")
 
-    plt.show()
+    plt.show()
+
+def generate_score_heatmap(settings):
+    
+    def group_cv_score(csv, plate=1, column='c3', data_column='pred'):
+        
+        df = pd.read_csv(csv)
+        if 'column_name' in df.columns:
+            df = df[df['column_name']==column]
+        elif 'column' in df.columns:
+            df['column_name'] = 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)
+        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 = 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 = grouped_df.rename(columns={'count': 'total_count'})
+        merged_df = pd.merge(df, grouped_df, on=['plate', 'row_name', '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)
+        return merged_df
+
+    def plot_multi_channel_heatmap(df, column='c3'):
+        """
+        Plot a heatmap with multiple channels as columns.
+
+        Parameters:
+        - df: DataFrame with scores for different channels.
+        - 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)
+
+        # Filter and sort by plate, row, and column
+        df = df[df['column_name'] == column]
+        df = df.sort_values(by=['plate', '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']
+
+        # Set 'plate_row_col' as the index
+        df.set_index('plate_row_col', inplace=True)
+
+        # Extract only numeric data for the heatmap
+        heatmap_data = df.select_dtypes(include=[float, int])
+
+        # Plot heatmap with square boxes, no annotations, and 'viridis' colormap
+        plt.figure(figsize=(12, 8))
+        sns.heatmap(
+            heatmap_data,
+            cmap="viridis",
+            cbar=True,
+            square=True,
+            annot=False
+        )
+
+        plt.title("Heatmap of Prediction Scores for All Channels")
+        plt.xlabel("Channels")
+        plt.ylabel("Plate-Row-Column")
+        plt.tight_layout()
+
+        # Save the figure object and return it
+        fig = plt.gcf()
+        plt.show()
+
+        return fig
+
+
+    def combine_classification_scores(folders, csv_name, data_column, plate=1, column='c3'):
+        # Ensure `folders` is a list
+        if isinstance(folders, str):
+            folders = [folders]
+
+        ls = []  # Initialize ls to store found CSV file paths
+
+        # Iterate over the provided folders
+        for folder in folders:
+            sub_folders = os.listdir(folder)  # Get sub-folder list
+            for sub_folder in sub_folders:  # Iterate through sub-folders
+                path = os.path.join(folder, sub_folder)  # Join the full path
+
+                if os.path.isdir(path):  # Check if it’s a directory
+                    csv = os.path.join(path, csv_name)  # Join path to the CSV file
+                    if os.path.exists(csv):  # If CSV exists, add to list
+                        ls.append(csv)
+                    else:
+                        print(f'No such file: {csv}')
+
+        # Initialize combined DataFrame
+        combined_df = None
+        print(f'Found {len(ls)} CSV files')
+
+        # Loop through all collected CSV files and process them
+        for csv_file in ls:
+            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()
+            # 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}")
+            print(new_column_name)
+            grouped_df = grouped_df.rename(columns={data_column: new_column_name})
+
+            # Merge into the combined DataFrame
+            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)
+        return combined_df
+    
+    def calculate_mae(df):
+        """
+        Calculate the MAE between each channel's predictions and the fraction column for all rows.
+        """
+        # Extract numeric columns excluding 'fraction' and 'prc'
+        channels = df.drop(columns=['fraction', 'prc']).select_dtypes(include=[float, int])
+
+        mae_data = []
+
+        # Compute MAE for each channel with 'fraction' for all rows
+        for column in channels.columns:
+            for index, row in df.iterrows():
+                mae = mean_absolute_error([row['fraction']], [row[column]])
+                mae_data.append({'Channel': column, 'MAE': mae, 'Row': row['prc']})
+
+        # Convert the list of dictionaries to a DataFrame
+        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'])
+    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 = 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'])
+    if 'row_number' in merged_df.columns:
+        merged_df = merged_df.drop('row_num', axis=1)
+    mae_df = calculate_mae(merged_df)
+    if 'row_number' in mae_df.columns:
+        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_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')
+    return merged_df