spacr 0.3.22__py3-none-any.whl → 0.3.31__py3-none-any.whl

spacr/gui_utils.py

@@ -77,7 +77,7 @@ def load_app(root, app_name, app_func):
     else:
         proceed_with_app(root, app_name, app_func)
     
-def parse_list(value):
+def parse_list_v1(value):
     """
     Parses a string representation of a list and returns the parsed list.
 
@@ -98,6 +98,34 @@ def parse_list(value):
                 return parsed_value
             elif all(isinstance(item, str) for item in parsed_value):
                 return parsed_value
+            elif all(isinstance(item, float) for item in parsed_value):
+                return parsed_value
+            else:
+                raise ValueError("List contains mixed types or unsupported types")
+        else:
+            raise ValueError(f"Expected a list but got {type(parsed_value).__name__}")
+    except (ValueError, SyntaxError) as e:
+        raise ValueError(f"Invalid format for list: {value}. Error: {e}")
+    
+def parse_list(value):
+    """
+    Parses a string representation of a list and returns the parsed list.
+
+    Args:
+        value (str): The string representation of the list.
+
+    Returns:
+        list: The parsed list, which can contain integers, floats, or strings.
+
+    Raises:
+        ValueError: If the input value is not a valid list format or contains mixed types or unsupported types.
+    """
+    try:
+        parsed_value = ast.literal_eval(value)
+        if isinstance(parsed_value, list):
+            # Check if all elements are homogeneous (either all int, float, or str)
+            if all(isinstance(item, (int, float, str)) for item in parsed_value):
+                return parsed_value
             else:
                 raise ValueError("List contains mixed types or unsupported types")
         else:
@@ -225,7 +253,7 @@ def annotate(settings):
 
     root = tk.Tk()
     root.geometry(settings['geom'])
-    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], grid_rows=settings['rows'], grid_cols=settings['columns'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'])
+    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], grid_rows=settings['rows'], grid_cols=settings['columns'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'], normalize_channels=settings['normalize_channels'])
     next_button = tk.Button(root, text="Next", command=app.next_page)
     next_button.grid(row=app.grid_rows, column=app.grid_cols - 1)
     back_button = tk.Button(root, text="Back", command=app.previous_page)
@@ -256,7 +284,6 @@ def generate_annotate_fields(frame):
     # Arrange input fields and labels
     for row, (name, data) in enumerate(vars_dict.items()):
         tk.Label(frame, text=f"{name.replace('_', ' ').capitalize()}:", bg=style_out['bg_color'], fg=style_out['fg_color'], font=font_loader.get_font(size=font_size)).grid(row=row, column=0)
-        #ttk.Label(frame, text=f"{name.replace('_', ' ').capitalize()}:", background="black", foreground="white").grid(row=row, column=0)
         if isinstance(data['value'], list):
             # Convert lists to comma-separated strings
             data['entry'].insert(0, ','.join(map(str, data['value'])))
@@ -272,6 +299,7 @@ def run_annotate_app(vars_dict, parent_frame):
     settings['img_size'] = list(map(int, settings['img_size'].split(',')))  # Convert string to list of integers
     settings['percentiles'] = list(map(int, settings['percentiles'].split(',')))  # Convert string to list of integers
     settings['normalize'] = settings['normalize'].lower() == 'true'
+    settings['normalize_channels'] = settings['channels'].split(',')
     settings['rows'] = int(settings['rows'])
     settings['columns'] = int(settings['columns'])
     settings['measurement'] = settings['measurement'].split(',')
@@ -292,6 +320,7 @@ def annotate_app(parent_frame, settings):
     global global_image_refs
     global_image_refs.clear()
     root = parent_frame.winfo_toplevel()
+    print('annotate_app',settings)
     annotate_with_image_refs(settings, root, lambda: load_next_app(root))
 
 def load_next_app(root):
@@ -313,46 +342,6 @@ def load_next_app(root):
             new_root.title("SpaCr Application")
             next_app_func(new_root, *next_app_args)
 
-def annotate_with_image_refs(settings, root, shutdown_callback):
-    #from .gui_utils import proceed_with_app
-    from .gui import gui_app
-    from .settings import set_annotate_default_settings
-
-    settings = set_annotate_default_settings(settings)
-    src = settings['src']
-
-    db = os.path.join(src, 'measurements/measurements.db')
-    conn = sqlite3.connect(db)
-    c = conn.cursor()
-    c.execute('PRAGMA table_info(png_list)')
-    cols = c.fetchall()
-    if settings['annotation_column'] not in [col[1] for col in cols]:
-        c.execute(f"ALTER TABLE png_list ADD COLUMN {settings['annotation_column']} integer")
-    conn.commit()
-    conn.close()
-
-    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], grid_rows=settings['rows'], grid_cols=settings['columns'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'])
-
-    # Set the canvas background to black
-    root.configure(bg='black')
-
-    next_button = tk.Button(root, text="Next", command=app.next_page, background='black', foreground='white')
-    next_button.grid(row=app.grid_rows, column=app.grid_cols - 1)
-    back_button = tk.Button(root, text="Back", command=app.previous_page, background='black', foreground='white')
-    back_button.grid(row=app.grid_rows, column=app.grid_cols - 2)
-    exit_button = tk.Button(root, text="Exit", command=lambda: [app.shutdown(), shutdown_callback()], background='black', foreground='white')
-    exit_button.grid(row=app.grid_rows, column=app.grid_cols - 3)
-
-    #app.load_images()
-
-    # Store the shutdown function and next app details in the root
-    root.current_app_exit_func = lambda: [app.shutdown(), shutdown_callback()]
-    root.next_app_func = proceed_with_app
-    root.next_app_args = ("Main App", gui_app)
-
-    # Call load_images after setting up the root window
-    app.load_images()
-
 def annotate_with_image_refs(settings, root, shutdown_callback):
     from .settings import set_annotate_default_settings
 
@@ -373,7 +362,7 @@ def annotate_with_image_refs(settings, root, shutdown_callback):
     screen_height = root.winfo_screenheight()
     root.geometry(f"{screen_width}x{screen_height}")
 
-    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'])
+    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'], normalize_channels=settings['normalize_channels'])
 
     # Set the canvas background to black
     root.configure(bg='black')

spacr/io.py

@@ -2861,10 +2861,10 @@ def generate_dataset(settings={}):
     date_name = datetime.date.today().strftime('%y%m%d')
     if len(settings['src']) > 1:
         date_name = f"{date_name}_combined"
-    if not settings['file_metadata'] is None:
-        tar_name = f"{date_name}_{settings['experiment']}_{settings['file_metadata']}.tar"
-    else:
-        tar_name = f"{date_name}_{settings['experiment']}.tar"
+    #if not settings['file_metadata'] is None:
+    #    tar_name = f"{date_name}_{settings['experiment']}_{settings['file_metadata']}.tar"
+    #else:
+    tar_name = f"{date_name}_{settings['experiment']}.tar"
     tar_name = os.path.join(dst, tar_name)
     if os.path.exists(tar_name):
         number = random.randint(1, 100)

spacr/measure.py

@@ -652,43 +652,6 @@ def img_list_to_grid(grid, titles=None):
     plt.tight_layout(pad=0.1)
     return fig
 
-def filepaths_to_database(img_paths, settings, source_folder, crop_mode):
-    from. utils import _map_wells_png
-    png_df = pd.DataFrame(img_paths, columns=['png_path'])
-
-    png_df['file_name'] = png_df['png_path'].apply(lambda x: os.path.basename(x))
-
-    parts = png_df['file_name'].apply(lambda x: pd.Series(_map_wells_png(x, timelapse=settings['timelapse'])))
-
-    columns = ['plate', 'row', 'col', 'field']
-
-    if settings['timelapse']:
-        columns = columns + ['time_id']
-
-    columns = columns + ['prcfo']
-
-    if crop_mode == 'cell':
-        columns = columns + ['cell_id']
-
-    if crop_mode == 'nucleus':
-        columns = columns + ['nucleus_id']
-
-    if crop_mode == 'pathogen':
-        columns = columns + ['pathogen_id']
-
-    if crop_mode == 'cytoplasm':
-        columns = columns + ['cytoplasm_id']
-
-    png_df[columns] = parts
-
-    try:
-        conn = sqlite3.connect(f'{source_folder}/measurements/measurements.db', timeout=5)
-        png_df.to_sql('png_list', conn, if_exists='append', index=False)
-        conn.commit()
-    except sqlite3.OperationalError as e:
-        print(f"SQLite error: {e}", flush=True)
-        traceback.print_exc()
-
 #@log_function_call
 def _measure_crop_core(index, time_ls, file, settings):
 
@@ -711,7 +674,7 @@ def _measure_crop_core(index, time_ls, file, settings):
     """
     
     from .plot import _plot_cropped_arrays
-    from .utils import _merge_overlapping_objects, _filter_object, _relabel_parent_with_child_labels, _exclude_objects, normalize_to_dtype
+    from .utils import _merge_overlapping_objects, _filter_object, _relabel_parent_with_child_labels, _exclude_objects, normalize_to_dtype, filepaths_to_database
     from .utils import _merge_and_save_to_database, _crop_center, _find_bounding_box, _generate_names, _get_percentiles
 
     figs = {}

spacr/plot.py

@@ -1020,8 +1020,6 @@ def _plot_recruitment_v2(df, df_type, channel_of_interest, columns=[], figuresiz
         None
     """
 
-    from .plot import spacrGraph
-
     color_list = [(55/255, 155/255, 155/255), 
                   (155/255, 55/255, 155/255), 
                   (55/255, 155/255, 255/255), 

spacr/settings.py

@@ -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,0.2])
 
     # Timelapsed settings
     settings.setdefault('timelapse', False)
@@ -859,7 +859,7 @@ expected_types = {
     'dataset':str,
     'score_threshold':float,
     'sample':None,
-    'file_metadata':None,
+    'file_metadata':(str, type(None), list),
     'apply_model_to_dataset':False,
     "train":bool,
     "test":bool,
@@ -880,6 +880,11 @@ expected_types = {
     "generate_training_dataset":bool,
     "segmentation_mode":str,
     "train_DL_model":bool,
+    "normalize":bool,
+    "overlay":bool,
+    "correlate":bool,
+    "target_layer":str,
+    "normalize_input":bool,
 }
 
 categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv"],
@@ -889,18 +894,19 @@ 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", "dialate_png_ratios", "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", "dialate_pngs", "normalize", "use_bounding_box"],
              "Sequencing": ["signal_direction","mode","comp_level","comp_type","save_h5","expected_end","offset","target_sequence","regex", "highlight"],
              "Generate Dataset":["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"],
              "Hyperparamiters (Embedding)": ["visualize","n_neighbors","min_dist","metric","resnet_features","reduction_method","embedding_by_controls","col_to_compare","log_data"],
              "Hyperparamiters (Clustering)": ["eps","min_samples","analyze_clusters","clustering","remove_cluster_noise"],
              "Hyperparamiters (Regression)":["cov_type", "class_1_threshold", "plate", "other", "fraction_threshold", "alpha", "random_row_column_effects", "regression_type", "min_cell_count", "agg_type", "transform", "dependent_variable"],
+             "Hyperparamiters (Activation)":["cam_type", "normalize", "overlay", "correlation", "target_layer", "normalize_input"],
              "Annotation": ["nc_loc", "pc_loc", "nc", "pc", "cell_plate_metadata","treatment_plate_metadata", "metadata_types", "cell_types", "target","positive_control","negative_control", "location_column", "treatment_loc", "channel_of_interest", "measurement", "treatments", "um_per_pixel", "nr_imgs", "exclude", "exclude_conditions", "mix", "pos", "neg"],
              "Plot": ["plot", "plot_control", "plot_nr", "examples_to_plot", "normalize_plots", "cmap", "figuresize", "plot_cluster_grids", "img_zoom", "row_limit", "color_by", "plot_images", "smooth_lines", "plot_points", "plot_outlines", "black_background", "plot_by_cluster", "heatmap_feature","grouping","min_max","cmap","save_figure"],
              "Test": ["test_mode", "test_images", "random_test", "test_nr", "test", "test_split"],
              "Timelapse": ["timelapse", "fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
-             "Advanced": ["target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "uninfected", "backgrounds", "schedule", "test_size","exclude","n_repeats","top_features", "model_type_ml", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs"],
+             "Advanced": ["shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "uninfected", "backgrounds", "schedule", "test_size","exclude","n_repeats","top_features", "model_type_ml", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs"],
              "Miscellaneous": ["all_to_mip", "pick_slice", "skip_mode", "upscale", "upscale_factor"]
              }
 
@@ -949,6 +955,14 @@ def check_settings(vars_dict, expected_types, q=None):
                 settings[key] = float(value) if '.' in value else int(value)
             elif expected_type == (str, type(None)):
                 settings[key] = str(value) if value else None
+            elif expected_type == (str, type(None), list):
+                if isinstance(value, list):
+                    settings[key] = parse_list(value) if value else None
+                elif isinstance(value, str):
+                    settings[key] = str(value) 
+                else:
+                    settings[key] = None
+            
             elif expected_type == dict:
                 try:
                     # Ensure that the value is a string that can be converted to a dictionary
@@ -1206,7 +1220,7 @@ def generate_fields(variables, scrollable_frame):
         "dataset": "str - file name of the tar file with image dataset",
         "score_threshold": "float - threshold for classification",
         "sample": "str - number of images to sample for tar dataset (including both classes). Default: None",
-        "file_metadata": "str - string that must be present in image path to be included in the dataset",
+        "file_metadata": "str or list of strings - string(s) that must be present in image path to be included in the dataset",
         "apply_model_to_dataset": "bool - whether to apply model to the dataset",
         "train_channels": "list - channels to use for training",
         "dataset_mode": "str - How to generate train/test dataset.",
@@ -1247,6 +1261,13 @@ def generate_fields(variables, scrollable_frame):
         "mode": "(str) - Mode to use for sequence analysis (either single for R1 or R2 fastq files or paired for the combination of R1 and R2).",
         "signal_direction": "(str) - Direction of fastq file (R1 or R2). only relevent when mode is single.",
         "custom_model_path": "(str) - Path to the custom model to finetune.",
+        "cam_type": "(str) - Choose between: gradcam, gradcam_pp, saliency_image, saliency_channel to generate activateion maps of DL models",
+        "target_layer": "(str) - Only used for gradcam and gradcam_pp. The layer to use for the activation map.",
+        "normalize": "(bool) - Normalize images before overlayng the activation maps.",
+        "overlay": "(bool) - Overlay activation maps on the images.",
+        "shuffle": "(bool) - Shuffle the dataset bufore generating the activation maps",
+        "correlation": "(bool) - Calculate correlation between image channels and activation maps. Data is saved to .db.",
+        "normalize_input": "(bool) - Normalize the input images before passing them to the model.",
     }
     
     for key, (var_type, options, default_value) in variables.items():
@@ -1282,6 +1303,8 @@ descriptions = {
 
     'regression': "Perform regression analysis on your data. Function: regression_tools from spacr.analysis.\n\nKey Features:\n- Statistical Analysis: Conduct various types of regression analysis to identify relationships within your data.\n- Flexible Options: Supports multiple regression models and configurations.\n- Data Insight: Gain deeper insights into your dataset through advanced regression techniques.",
     
+    'activation': "",
+
     'recruitment': "Analyze recruitment data to understand sample recruitment dynamics. Function: recruitment_analysis_tools from spacr.analysis.\n\nKey Features:\n- Recruitment Analysis: Investigate and analyze the recruitment of samples over time or conditions.\n- Visualization: Generate visualizations to represent recruitment trends and patterns.\n- Integration: Utilize data from various sources for a comprehensive recruitment analysis."
 }
 
@@ -1292,6 +1315,7 @@ def set_annotate_default_settings(settings):
     settings.setdefault('img_size', 200)
     settings.setdefault('annotation_column', 'test')
     settings.setdefault('normalize', 'False')
+    settings.setdefault('normalize_channels', "r,g,b")
     settings.setdefault('percentiles', [2, 98])
     settings.setdefault('measurement', '')#'cytoplasm_channel_3_mean_intensity,pathogen_channel_3_mean_intensity')
     settings.setdefault('threshold', '')#'2')
@@ -1314,4 +1338,25 @@ def set_default_generate_barecode_mapping(settings={}):
     settings.setdefault('mode', 'paired')
     settings.setdefault('single_direction', 'R1')
     settings.setdefault('test', False)
+    return settings
+
+def get_default_generate_activation_map_settings(settings):
+    settings.setdefault('dataset', 'path')
+    settings.setdefault('model_type', 'maxvit')
+    settings.setdefault('model_path', 'path')
+    settings.setdefault('image_size', 224)
+    settings.setdefault('batch_size', 64)
+    settings.setdefault('normalize', True)
+    settings.setdefault('cam_type', 'gradcam')
+    settings.setdefault('target_layer', None)
+    settings.setdefault('plot', False)
+    settings.setdefault('save', True)
+    settings.setdefault('normalize_input', True)
+    settings.setdefault('channels', [1,2,3])
+    settings.setdefault('overlay', True)
+    settings.setdefault('shuffle', True)
+    settings.setdefault('correlation', True)
+    settings.setdefault('manders_thresholds', [15,50, 75])
+    settings.setdefault('n_jobs', None)
+    
     return settings