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

spacr/core.py

@@ -11,7 +11,7 @@ def preprocess_generate_masks(settings):
 
     from .io import preprocess_img_data, _load_and_concatenate_arrays
     from .plot import plot_image_mask_overlay, plot_arrays
-    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks, print_progress, save_settings, delete_intermedeate_files
+    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks, print_progress, save_settings, delete_intermedeate_files, format_path_for_system, normalize_src_path
     from .settings import set_default_settings_preprocess_generate_masks
     
     
@@ -23,6 +23,8 @@ def preprocess_generate_masks(settings):
         ValueError(f'src is a required parameter')
         return
     
+    settings['src'] = normalize_src_path(settings['src'])
+    
     if isinstance(settings['src'], str):
         settings['src'] = [settings['src']]
 
@@ -30,6 +32,7 @@ def preprocess_generate_masks(settings):
         source_folders = settings['src']
         for source_folder in source_folders:
             print(f'Processing folder: {source_folder}')
+            source_folder = format_path_for_system(source_folder)            
             settings['src'] = source_folder
             src = source_folder
             settings = set_default_settings_preprocess_generate_masks(settings)

spacr/gui_core.py

@@ -170,49 +170,22 @@ def display_figure(fig):
             #flash_feedback("right")
             show_next_figure()
 
-    def zoom_v1(event):
-        nonlocal scale_factor
-
-        zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
-
-        # Determine the zoom direction based on the scroll event
-        if event.num == 4 or event.delta > 0:  # Scroll up (zoom in)
-            scale_factor /= (1 + zoom_speed)  # Divide to zoom in
-        elif event.num == 5 or event.delta < 0:  # Scroll down (zoom out)
-            scale_factor *= (1 + zoom_speed)  # Multiply to zoom out
-
-        # Adjust the axes limits based on the new scale factor
-        for ax in canvas.figure.get_axes():
-            xlim = ax.get_xlim()
-            ylim = ax.get_ylim()
-
-            x_center = (xlim[1] + xlim[0]) / 2
-            y_center = (ylim[1] + ylim[0]) / 2
-
-            x_range = (xlim[1] - xlim[0]) * scale_factor
-            y_range = (ylim[1] - ylim[0]) * scale_factor
-
-            # Set the new limits
-            ax.set_xlim([x_center - x_range / 2, x_center + x_range / 2])
-            ax.set_ylim([y_center - y_range / 2, y_center + y_range / 2])
-
-        # Redraw the figure efficiently
-        canvas.draw_idle()
-        
     def zoom_test(event):
         if event.num == 4:  # Scroll up
             print("zoom in")
         elif event.num == 5: # Scroll down
             print("zoom out")
-            
-    def zoom_2(event):
-        zoom_speed = 0.1  # Change this to control how fast you zoom
+        
+    def zoom_v1(event):
+        # Fixed zoom factors (adjust these if you want faster or slower zoom)
+        zoom_in_factor = 0.9   # When zooming in, ranges shrink by 10%
+        zoom_out_factor = 1.1  # When zooming out, ranges increase by 10%
 
         # Determine the zoom direction based on the scroll event
         if event.num == 4 or (hasattr(event, 'delta') and event.delta > 0):  # Scroll up = zoom in
-            factor = 1 - zoom_speed
+            factor = zoom_in_factor
         elif event.num == 5 or (hasattr(event, 'delta') and event.delta < 0): # Scroll down = zoom out
-            factor = 1 + zoom_speed
+            factor = zoom_out_factor
         else:
             return  # No recognized scroll direction
 
@@ -247,23 +220,28 @@ def display_figure(fig):
             return  # No recognized scroll direction
 
         for ax in canvas.figure.get_axes():
+            # Get the current mouse position in pixel coordinates
+            mouse_x, mouse_y = event.x, event.y
+
+            # Convert pixel coordinates to data coordinates
+            inv = ax.transData.inverted()
+            data_x, data_y = inv.transform((mouse_x, mouse_y))
+
+            # Get the current axis limits
             xlim = ax.get_xlim()
             ylim = ax.get_ylim()
 
-            x_center = (xlim[1] + xlim[0]) / 2
-            y_center = (ylim[1] + ylim[0]) / 2
-
+            # Calculate the zooming range around the cursor position
             x_range = (xlim[1] - xlim[0]) * factor
             y_range = (ylim[1] - ylim[0]) * factor
 
-            # Set the new limits
-            ax.set_xlim([x_center - x_range / 2, x_center + x_range / 2])
-            ax.set_ylim([y_center - y_range / 2, y_center + y_range / 2])
+            # Adjust the limits while keeping the mouse position fixed
+            ax.set_xlim([data_x - (data_x - xlim[0]) * factor, data_x + (xlim[1] - data_x) * factor])
+            ax.set_ylim([data_y - (data_y - ylim[0]) * factor, data_y + (ylim[1] - data_y) * factor])
 
         # Redraw the figure efficiently
         canvas.draw_idle()
 
-
     # Bind events for hover, click interactions, and zoom
     canvas_widget.bind("<Motion>", on_hover)
     canvas_widget.bind("<Leave>", on_leave)

spacr/gui_utils.py

@@ -106,7 +106,6 @@ def parse_list(value):
     except (ValueError, SyntaxError) as e:
         raise ValueError(f"Invalid format for list: {value}. Error: {e}")
 
-# Usage example in your create_input_field function
 def create_input_field(frame, label_text, row, var_type='entry', options=None, default_value=None):
     """
     Create an input field in the specified frame.
@@ -365,13 +364,16 @@ def convert_settings_dict_for_gui(settings):
     from torchvision import models as torch_models
     torchvision_models = [name for name, obj in torch_models.__dict__.items() if callable(obj)]
     chans = ['0', '1', '2', '3', '4', '5', '6', '7', '8', None]
+    chan_list = ['[0,1,2,3,4,5,6,7,8]','[0,1,2,3,4,5,6,7]','[0,1,2,3,4,5,6]','[0,1,2,3,4,5]','[0,1,2,3,4]','[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]', '[0,0]']
     chans_v2 = [0, 1, 2, 3, None]
+    chans_v3 = list(range(0, 21, 1)) + [None]
+    chans_v4 = [0, 1, 2, 3, None]
     variables = {}
     special_cases = {
         'metadata_type': ('combo', ['cellvoyager', 'cq1', 'nikon', 'zeis', 'custom'], 'cellvoyager'),
-        'channels': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]', '[0,0]'], '[0,1,2,3]'),
+        'channels': ('combo', chan_list, '[0,1,2,3]'),
         'train_channels': ('combo', ["['r','g','b']", "['r','g']", "['r','b']", "['g','b']", "['r']", "['g']", "['b']"], "['r','g','b']"),
-        'channel_dims': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'channel_dims': ('combo', chan_list, '[0,1,2,3]'),
         'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'metadata'),
         'cov_type': ('combo', ['HC0', 'HC1', 'HC2', 'HC3', None], None),
         'cell_mask_dim': ('combo', chans, None),
@@ -380,12 +382,12 @@ def convert_settings_dict_for_gui(settings):
         'nucleus_chann_dim': ('combo', chans, None),
         'pathogen_mask_dim': ('combo', chans, None),
         'pathogen_chann_dim': ('combo', chans, None),
-        'crop_mode': ('combo', [['cell'], ['nucleus'], ['pathogen'], ['cell', 'nucleus'], ['cell', 'pathogen'], ['nucleus', 'pathogen'], ['cell', 'nucleus', 'pathogen']], ['cell']),
-        'magnification': ('combo', [20, 40, 60], 20),
-        'nucleus_channel': ('combo', chans_v2, None),
-        'cell_channel': ('combo', chans_v2, None),
-        'channel_of_interest': ('combo', chans_v2, None),
-        'pathogen_channel': ('combo', chans_v2, None),
+        'crop_mode': ('combo', ["['cell']", "['nucleus']", "['pathogen']", "['cell', 'nucleus']", "['cell', 'pathogen']", "['nucleus', 'pathogen']", "['cell', 'nucleus', 'pathogen']"], "['cell']"),
+         #'magnification': ('combo', [20, 40, 60], 20),
+        'nucleus_channel': ('combo', chans_v3, None),
+        'cell_channel': ('combo', chans_v3, None),
+        'channel_of_interest': ('combo', chans_v3, None),
+        'pathogen_channel': ('combo', chans_v3, None),
         'timelapse_mode': ('combo', ['trackpy', 'btrack'], 'trackpy'),
         'train_mode': ('combo', ['erm', 'irm'], 'erm'),
         'clustering': ('combo', ['dbscan', 'kmean'], 'dbscan'),

spacr/io.py

@@ -891,11 +891,16 @@ def _merge_channels(src, plot=False):
     from .utils import print_progress
     
     stack_dir = os.path.join(src, 'stack')
-    allowed_names = ['01', '02', '03', '04', '00', '1', '2', '3', '4', '0']
+    #allowed_names = ['01', '02', '03', '04', '00', '1', '2', '3', '4', '0']
+    
+    string_list = [str(i) for i in range(101)]+[f"{i:02d}" for i in range(10)]
+    allowed_names = sorted(string_list, key=lambda x: int(x))
     
     # List directories that match the allowed names
     chan_dirs = [d for d in os.listdir(src) if os.path.isdir(os.path.join(src, d)) and d in allowed_names]
     chan_dirs.sort()
+    
+    num_matching_folders = len(chan_dirs)
 
     print(f'List of folders in src: {chan_dirs}. Single channel folders.')
     
@@ -925,7 +930,7 @@ def _merge_channels(src, plot=False):
     if plot:
         plot_arrays(os.path.join(src, 'stack'))
 
-    return
+    return num_matching_folders
 
 def _mip_all(src, include_first_chan=True):
     
@@ -1584,10 +1589,6 @@ def preprocess_img_data(settings):
     else:
         print(f'Could not find any {valid_ext} files in {src} only found {extension_counts[0]}')
         
-        
-        
-        
-        
         if os.path.exists(os.path.join(src,'stack')):
             print('Found existing stack folder.')
         if os.path.exists(os.path.join(src,'channel_stack')):
@@ -1644,7 +1645,13 @@ def preprocess_img_data(settings):
                             print(f"all images: {all_imgs},  full batch: {full_batches}, last batch: {last_batch_size}")
                             raise ValueError("Last batch of size 1 detected. Adjust the batch size.")
         
-                _merge_channels(src, plot=False)
+                nr_channel_folders = _merge_channels(src, plot=False)
+                
+                if len(settings['channels']) != nr_channel_folders:
+                    print(f"Number of channels does not match number of channel folders. channels: {settings['channels']} channel folders: {nr_channel_folders}")
+                    new_channels = list(range(nr_channel_folders))
+                    print(f"Setting channels to {new_channels}")
+                    settings['channels'] = new_channels
 
                 if timelapse:
                     _create_movies_from_npy_per_channel(stack_path, fps=2)

spacr/measure.py

@@ -945,20 +945,25 @@ def measure_crop(settings):
 
     from .io import _save_settings_to_db
     from .timelapse import _timelapse_masks_to_gif
-    from .utils import measure_test_mode, print_progress, delete_intermedeate_files, save_settings
+    from .utils import measure_test_mode, print_progress, delete_intermedeate_files, save_settings, format_path_for_system, normalize_src_path
     from .settings import get_measure_crop_settings
 
     if not isinstance(settings['src'], (str, list)):
         ValueError(f'src must be a string or a list of strings')
         return
     
+    settings['src'] = normalize_src_path(settings['src'])
+    
     if isinstance(settings['src'], str):
         settings['src'] = [settings['src']]
 
     if isinstance(settings['src'], list):
         source_folders = settings['src']
+        
         for source_folder in source_folders:
             print(f'Processing folder: {source_folder}')
+            
+            source_folder = format_path_for_system(source_folder)
             settings['src'] = source_folder
             src = source_folder
 
@@ -966,15 +971,12 @@ def measure_crop(settings):
             settings = measure_test_mode(settings)
 
             src_fldr = settings['src']
+            
             if not os.path.basename(src_fldr).endswith('merged'):
                 print(f"WARNING: Source folder, settings: src: {src_fldr} should end with '/merged'")
                 src_fldr = os.path.join(src_fldr, 'merged')
+                settings['src'] = src_fldr
                 print(f"Changed source folder to: {src_fldr}")
-
-            #if settings['save_measurements']:
-                #source_folder = os.path.dirname(settings['src'])
-                #os.makedirs(source_folder+'/measurements', exist_ok=True)
-                #_create_database(source_folder+'/measurements/measurements.db')
             
             if settings['cell_mask_dim'] is None:
                 settings['uninfected'] = True
@@ -995,12 +997,9 @@ def measure_crop(settings):
                 print(f'Warning reserving 6 CPU cores for other processes, setting n_jobs to {spacr_cores}')
                 settings['n_jobs'] = spacr_cores
 
-            #dirname = os.path.dirname(settings['src'])
-            #settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
-            #settings_csv = os.path.join(dirname,'settings','measure_crop_settings.csv')
-            #os.makedirs(os.path.join(dirname,'settings'), exist_ok=True)
-            #settings_df.to_csv(settings_csv, index=False)
-            save_settings(settings, name='measure_crop_settings', show=True)
+            settings_save = settings.copy()
+            settings_save['src'] = os.path.dirname(settings['src'])
+            save_settings(settings_save, name='measure_crop_settings', show=True)
 
             if settings['timelapse_objects'] == 'nucleus':
                 if not settings['cell_mask_dim'] is None:

spacr/settings.py

@@ -86,7 +86,7 @@ def set_default_settings_preprocess_generate_masks(settings={}):
     settings.setdefault('fps', 2)
     settings.setdefault('timelapse_displacement', None)
     settings.setdefault('timelapse_memory', 3)
-    settings.setdefault('timelapse_frame_limits', None)
+    settings.setdefault('timelapse_frame_limits', [5,60])
     settings.setdefault('timelapse_remove_transient', False)
     settings.setdefault('timelapse_mode', 'trackpy')
     settings.setdefault('timelapse_objects', None)
@@ -256,7 +256,13 @@ def get_measure_crop_settings(settings={}):
     settings.setdefault('homogeneity', True)
     settings.setdefault('homogeneity_distances', [8,16,32])
 
-    # Cropping settings
+    # Cropping settings    # Cropping settings
+    settings.setdefault('save_arrays', False)
+    settings.setdefault('save_png',True)
+    settings.setdefault('use_bounding_box',False)
+    settings.setdefault('png_size',[224,224])
+    settings.setdefault('png_dims',[0,1,2])
+    settings.setdefault('normalize',False)    # Cropping settings
     settings.setdefault('save_arrays', False)
     settings.setdefault('save_png',True)
     settings.setdefault('use_bounding_box',False)
@@ -277,9 +283,79 @@ def get_measure_crop_settings(settings={}):
     settings.setdefault('n_jobs', os.cpu_count()-2)
 
     # Object settings
-    settings.setdefault('cell_mask_dim',None)
-    settings.setdefault('nucleus_mask_dim',None)
-    settings.setdefault('pathogen_mask_dim',None)
+    settings.setdefault('cell_mask_dim',4)
+    settings.setdefault('nucleus_mask_dim',5)
+    settings.setdefault('pathogen_mask_dim',6)
+    settings.setdefault('cytoplasm',False)
+    settings.setdefault('uninfected',True)
+    settings.setdefault('cell_min_size',0)
+    settings.setdefault('nucleus_min_size',0)
+    settings.setdefault('pathogen_min_size',0)
+    settings.setdefault('cytoplasm_min_size',0)
+    settings.setdefault('merge_edge_pathogen_cells', True)
+
+    if settings['test_mode']:
+        settings['verbose'] = True
+        settings['plot'] = True
+        test_imgs = settings['test_nr']
+        print(f'Test mode enabled with {test_imgs} images, plotting set to True')
+
+    return settings
+    settings.setdefault('normalize_by','png')
+    settings.setdefault('crop_mode',['cell'])
+    settings.setdefault('dialate_pngs', False)
+    settings.setdefault('dialate_png_ratios', [0.2])
+
+    # Timelapsed settings
+    settings.setdefault('timelapse', False)
+    settings.setdefault('timelapse_objects', 'cell')
+
+    # Operational settings
+    settings.setdefault('plot',False)
+    settings.setdefault('n_jobs', os.cpu_count()-2)
+
+    # Object settings
+    settings.setdefault('cell_mask_dim',4)
+    settings.setdefault('nucleus_mask_dim',5)
+    settings.setdefault('pathogen_mask_dim',6)
+    settings.setdefault('cytoplasm',False)
+    settings.setdefault('uninfected',True)
+    settings.setdefault('cell_min_size',0)
+    settings.setdefault('nucleus_min_size',0)
+    settings.setdefault('pathogen_min_size',0)
+    settings.setdefault('cytoplasm_min_size',0)
+    settings.setdefault('merge_edge_pathogen_cells', True)
+
+    if settings['test_mode']:
+        settings['verbose'] = True
+        settings['plot'] = True
+        test_imgs = settings['test_nr']
+        print(f'Test mode enabled with {test_imgs} images, plotting set to True')
+
+    return settings
+    settings.setdefault('save_arrays', False)
+    settings.setdefault('save_png',True)
+    settings.setdefault('use_bounding_box',False)
+    settings.setdefault('png_size',[224,224])
+    settings.setdefault('png_dims',[0,1,2])
+    settings.setdefault('normalize',False)
+    settings.setdefault('normalize_by','png')
+    settings.setdefault('crop_mode',['cell'])
+    settings.setdefault('dialate_pngs', False)
+    settings.setdefault('dialate_png_ratios', [0.2])
+
+    # Timelapsed settings
+    settings.setdefault('timelapse', False)
+    settings.setdefault('timelapse_objects', 'cell')
+
+    # Operational settings
+    settings.setdefault('plot',False)
+    settings.setdefault('n_jobs', os.cpu_count()-2)
+
+    # Object settings
+    settings.setdefault('cell_mask_dim',4)
+    settings.setdefault('nucleus_mask_dim',5)
+    settings.setdefault('pathogen_mask_dim',6)
     settings.setdefault('cytoplasm',False)
     settings.setdefault('uninfected',True)
     settings.setdefault('cell_min_size',0)
@@ -473,7 +549,7 @@ def get_train_test_model_settings(settings):
      return settings
 
 def get_analyze_recruitment_default_settings(settings):
-    settings.setdefault('src','path')
+    settings.setdefault('src', 'path')
     settings.setdefault('target','protein')
     settings.setdefault('cell_types',['HeLa'])
     settings.setdefault('cell_plate_metadata',None)
@@ -672,6 +748,7 @@ expected_types = {
     "timelapse_displacement": int,
     "timelapse_memory": int,
     "timelapse_frame_limits": (list, type(None)),  # This can be a list of lists
+    #"timelapse_frame_limits": (list, type(None)),  # This can be a list of lists
     "timelapse_remove_transient": bool,
     "timelapse_mode": str,
     "timelapse_objects": list,
@@ -944,13 +1021,13 @@ expected_types = {
 }
 
 categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv", "metadata_files", "score_data","count_data"],
-             "General": ["metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "segmentation_mode", "delete_intermediate"],
+             "General": ["cell_mask_dim", "cytoplasm", "cell_chann_dim", "cell_channel", "nucleus_chann_dim", "nucleus_channel", "nucleus_mask_dim", "pathogen_mask_dim", "pathogen_chann_dim", "pathogen_channel", "test_mode", "plot", "metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "segmentation_mode", "delete_intermediate", "uninfected", ],
              "Cellpose":["fill_in","from_scratch", "n_epochs", "width_height", "model_name", "custom_model", "resample", "rescale", "CP_prob", "flow_threshold", "percentiles", "invert", "diameter", "grayscale", "Signal_to_noise", "resize", "target_height", "target_width"],
-             "Cell": ["cell_diamiter","cell_intensity_range", "cell_size_range", "cell_chann_dim", "cell_channel", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cell_mask_dim", "cytoplasm", "cytoplasm_min_size", "uninfected", "merge_edge_pathogen_cells", "adjust_cells", "cells", "cell_loc"],
-             "Nucleus": ["nucleus_diamiter","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_diamiter","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", ],
+             "Cell": ["cell_diamiter","cell_intensity_range", "cell_size_range", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cytoplasm_min_size", "adjust_cells", "cells", "cell_loc"],
+             "Nucleus": ["nucleus_diamiter","nucleus_intensity_range", "nucleus_size_range", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_loc"],
+             "Pathogen": ["pathogen_diamiter","pathogen_intensity_range", "pathogen_size_range", "pathogen_background", "pathogen_Signal_to_noise", "pathogen_CP_prob", "pathogen_FT", "pathogen_model", "remove_background_pathogen", "pathogen_min_size", "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", "normalize", "use_bounding_box"],
+             "Object Image": ["save_png", "dialate_pngs", "dialate_png_ratios", "png_size", "png_dims", "save_arrays", "normalize_by", "crop_mode", "use_bounding_box"],
              "Sequencing": ["outlier_detection","offset_start","chunk_size","single_direction", "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"],
@@ -959,11 +1036,10 @@ categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset
              "Hyperparamiters (Regression)":["cross_validation","prune_features","reg_lambda","reg_alpha","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", "overlay", "correlation", "target_layer", "normalize_input"],
              "Annotation": ["filter_column", "filter_value","volcano", "toxo", "controls", "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", "split_axis_lims", "x_lim","log_x","log_y", "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"],
+             "Plot": ["split_axis_lims", "x_lim","log_x","log_y", "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"],
              "Timelapse": ["timelapse", "fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
-             "Advanced": ["target_unique_count","threshold_multiplier", "threshold_method", "min_n","shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "background", "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"]
+             "Advanced": ["merge_edge_pathogen_cells", "test_images", "random_test", "test_nr", "test", "test_split", "normalize", "target_unique_count","threshold_multiplier", "threshold_method", "min_n","shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "background", "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"],
+             "Beta": ["all_to_mip", "pick_slice", "skip_mode", "upscale", "upscale_factor"]
              }
 
 
@@ -984,22 +1060,28 @@ def check_settings(vars_dict, expected_types, q=None):
                 q.put(f"Key {key} not found in expected types.")
                 continue
 
-        value = var.get()
-        if value == 'None':
+        value = var.get()            
+        if value in ['None', '']:
             value = None
 
         expected_type = expected_types.get(key, str)
 
         try:
-            if key in ["cell_plate_metadata", "timelapse_frame_limits", "png_size", "pathogen_loc", "treatment_loc", "pathogen_plate_metadata", "treatment_plate_metadata", "barcode_coordinates", "class_metadata"]:
-                parsed_value = ast.literal_eval(value) if value else None
+            #if key in ["cell_plate_metadata", "timelapse_frame_limits", "png_size", "pathogen_loc", "treatment_loc", "pathogen_plate_metadata", "treatment_plate_metadata", "barcode_coordinates", "class_metadata"]:
+            if key in ["cell_plate_metadata", "timelapse_frame_limits", "png_size", "png_dims", "pathogen_plate_metadata", "treatment_plate_metadata", "class_metadata", "crop_mode"]:
+
+                if value is None:
+                        parsed_value = None
+                else:
+                    parsed_value = ast.literal_eval(value) if isinstance(value, str) and value.strip() else None
+                        
+                #parsed_value = ast.literal_eval(value) if value else None
+                
                 if isinstance(parsed_value, list):
                     if all(isinstance(i, list) for i in parsed_value) or all(not isinstance(i, list) for i in parsed_value):
                         settings[key] = parsed_value
                     else:
                         raise ValueError("Invalid format: Mixed list and list of lists")
-                #elif parsed_value == None:
-                #    settings[key] = None
                 else:
                     raise ValueError("Invalid format for list or list of lists")
                 
@@ -1180,30 +1262,7 @@ def generate_fields(variables, scrollable_frame):
         "n_epochs": "(int) - Number of epochs for training the Cellpose model.",
         "n_jobs": "(int) - The number of n_jobs to use for processing the images. This will determine how many images are processed in parallel. Increase to speed up processing.",
         "n_neighbors": "(int) - Number of neighbors for UMAP.",
-        "n_repeats": "(int) - Number of repeats for cross-validation.",
-        "normalize": "(list) - The percentiles to use for normalizing the images. This will be used to determine the range of intensities to normalize images to. If None, no normalization is done.",
-        "normalize_by": "(str) - Whether to normalize the images by field of view (fov) or by PNG image (png).",
-        "normalize_plots": "(bool) - Whether to normalize the plots.",
-        "nr_imgs": "(int) - The number of images to plot.",
-        "nucleus_CP_prob": "(float) - The cellpose probability threshold for the nucleus channel. This will be used to segment the nucleus.",
-        "nucleus_FT": "(float) - The flow threshold for nucleus objects. This will be used in nucleus segmentation.",
-        "nucleus_background": "(float) - The background intensity for the nucleus channel. This will be used to remove background noise.",
-        "nucleus_chann_dim": "(int) - Dimension of the channel to use for nucleus segmentation.",
-        "nucleus_channel": "(int) - The channel to use for the nucleus. If None, the nucleus will not be segmented.",
-        "nucleus_intensity_range": "(list) - Intensity range for nucleus segmentation.",
-        "nucleus_loc": "(str) - Location of the nucleus in the images.",
-        "nucleus_mask_dim": "(int) - The dimension of the array the nucleus mask is saved in.",
-        "nucleus_min_size": "(int) - The minimum size of nucleus objects in pixels^2.",
-        "nucleus_Signal_to_noise": "(float) - The signal-to-noise ratio for the nucleus channel. This will be used to determine the range of intensities to normalize images to for nucleus segmentation.",
-        "nucleus_size_range": "(list) - Size range for nucleus segmentation.",
-        "optimizer_type": "(str) - Type of optimizer to use.",
-        "other": "(dict) - Additional parameters for the regression analysis.",
-        "pathogen_CP_prob": "(float) - The cellpose probability threshold for the pathogen channel. This will be used to segment the pathogen.",
-        "pathogen_FT": "(float) - The flow threshold for pathogen objects. This will be used in pathogen segmentation.",
-        "pathogen_background": "(float) - The background intensity for the pathogen channel. This will be used to remove background noise.",
-        "pathogen_chann_dim": "(int) - Dimension of the channel to use for pathogen segmentation.",
-        "pathogen_channel": "(int) - The channel to use for the pathogen. If None, the pathogen will not be segmented.",
-        "pathogen_intensity_range": "(str) - Metadata for the pathogen plate.",
+        "n_repeats": "(int) - Number of repeats for the pathogen plate.",
         "pathogen_Signal_to_noise": "(float) - The signal-to-noise ratio for the pathogen channel. This will be used to determine the range of intensities to normalize images to for pathogen segmentation.",
         "pathogen_size_range": "(list) - Size range for pathogen segmentation.",
         "pathogen_types": "(list) - Types of pathogens to include in the analysis.",
@@ -1222,7 +1281,7 @@ def generate_fields(variables, scrollable_frame):
         "plot_nr": "(int) - Number of plots to generate.",
         "plot_outlines": "(bool) - Whether to plot outlines of segmented objects.",
         "png_dims": "(list) - The dimensions of the PNG images to save. This will determine the dimensions of the saved images. Maximum of 3 dimensions e.g. [1,2,3].",
-        "png_size": "(int) - The size of the PNG images to save. This will determine the size of the saved images.",
+        "png_size": "(list) - The size of the PNG images to save. This will determine the size of the saved images.",
         "positive_control": "(str) - Identifier for the positive control.",
         "preprocess": "(bool) - Whether to preprocess the images before segmentation. This includes background removal and normalization. Set to False only if this step has already been done.",
         "radial_dist": "(list) - Radial distances for measuring features.",

spacr/submodules.py

@@ -21,7 +21,7 @@ from sklearn.metrics import mean_absolute_error
 import matplotlib.pyplot as plt
 from natsort import natsorted
 
-def analyze_recruitment(settings={}):
+def analyze_recruitment(settings):
     """
     Analyze recruitment data by grouping the DataFrame by well coordinates and plotting controls and recruitment data.
 

spacr/utils.py

@@ -328,14 +328,13 @@ def save_settings(settings, name='settings', show=False):
     
     if isinstance(settings['src'], list):
         src = settings['src'][0]
-        #if os.path.exists(src):
-
         name = f"{name}_list"
     else:
         src = settings['src']
 
     settings_csv = os.path.join(src,'settings',f'{name}.csv')
     os.makedirs(os.path.join(src,'settings'), exist_ok=True)
+    print(f"Saving settings to {settings_csv}")
     settings_df.to_csv(settings_csv, index=False)
 
 def print_progress(files_processed, files_to_process, n_jobs, time_ls=None, batch_size=None, operation_type=""):
@@ -1145,7 +1144,7 @@ def _masks_to_masks_stack(masks):
         mask_stack.append(mask)
     return mask_stack
     
-def _get_diam(mag, obj):
+def _get_diam_v1(mag, obj):
 
     if mag == 20:
         if obj == 'cell':
@@ -1176,11 +1175,28 @@ def _get_diam(mag, obj):
             diamiter = 60
         else:
             raise ValueError("Invalid magnification: Use 20, 40 or 60")
+
     else:
         raise ValueError("Invalid magnification: Use 20, 40 or 60")
     
     return diamiter
 
+def _get_diam(mag, obj):
+
+    if obj == 'cell':
+        diamiter = 2 * mag + 80
+        
+    if obj == 'cell_large':
+        diamiter = 2 * mag + 120
+                                
+    if obj == 'nucleus':
+        diamiter = 0.75 * mag + 45
+                                
+    if obj == 'pathogen':
+        diamiter = mag
+                                
+    return int(diamiter)
+
 def _get_object_settings(object_type, settings):
     object_settings = {}
 
@@ -1333,20 +1349,25 @@ def annotate_conditions(df, cells=None, cell_loc=None, pathogens=None, pathogen_
     def _map_or_default(column_name, values, loc, df):
         """
         Consolidates the logic for mapping values or assigning defaults when loc is None.
-
+    
         Args:
             column_name (str): The column in the DataFrame to annotate.
             values (list/str): The list of values or a single string to annotate.
             loc (list of lists): Location mapping for the values, or None if not used.
             df (pandas.DataFrame): The DataFrame to modify.
         """
-        if isinstance(values, str) or (isinstance(values, list) and loc is None):
-            # Assign all rows the first value in the list or the single string
-            df[column_name] = values if isinstance(values, str) else values[0]
+        if isinstance(values, str) and loc is None:
+            # If a single string is provided and loc is None, assign the value to all rows
+            df[column_name] = values  
+    
+        elif isinstance(values, list) and loc is None:
+            # If a list of values is provided but no loc, assign the first value to all rows
+            df[column_name] = values[0]
+    
         elif values is not None and loc is not None:
-            # Perform the location-based mapping
+            # Perform location-based mapping
             value_dict = {val: key for key, loc_list in zip(values, loc) for val in loc_list}
-            df[column_name] = np.nan
+            df[column_name] = np.nan  # Start with NaN
             for val, key in value_dict.items():
                 loc_type = _get_type(val)
                 if loc_type:
@@ -4945,7 +4966,7 @@ def download_models(repo_id="einarolafsson/models", retries=5, delay=5):
     if not os.path.exists(local_dir):
         os.makedirs(local_dir)
     elif len(os.listdir(local_dir)) > 0:
-        print(f"Models already downloaded to: {local_dir}")
+        #print(f"Models already downloaded to: {local_dir}")
         return local_dir
 
     attempt = 0
@@ -5337,3 +5358,63 @@ def calculate_shortest_distance(df, object1, object2):
     df[f'{object1}_{object2}_shortest_distance'] = np.maximum(shortest_distance, 0)
 
     return df
+
+def format_path_for_system(path):
+    """
+    Takes a file path and reformats it to be compatible with the current operating system.
+    
+    Args:
+        path (str): The file path to be formatted.
+
+    Returns:
+        str: The formatted path for the current operating system.
+    """
+    system = platform.system()
+    
+    # Convert Windows-style paths to Unix-style (Linux/macOS)
+    if system in ["Linux", "Darwin"]:  # Darwin is macOS
+        formatted_path = path.replace("\\", "/")
+    
+    # Convert Unix-style paths to Windows-style
+    elif system == "Windows":
+        formatted_path = path.replace("/", "\\")
+    
+    else:
+        raise ValueError(f"Unsupported OS: {system}")
+    
+    # Normalize path to ensure consistency
+    new_path = os.path.normpath(formatted_path)
+    if os.path.exists(new_path):
+        print(f"Found path: {new_path}")
+    else:
+        print(f"Path not found: {new_path}")
+        
+    return new_path
+
+
+def normalize_src_path(src):
+    """
+    Ensures that the 'src' value is properly formatted as either a list of strings or a single string.
+
+    Args:
+        src (str or list): The input source path(s).
+
+    Returns:
+        list or str: A correctly formatted list if the input was a list (or string representation of a list),
+                     otherwise a single string.
+    """
+    if isinstance(src, list):
+        return src  # Already a list, return as-is
+
+    if isinstance(src, str):
+        try:
+            # Check if it is a string representation of a list
+            evaluated_src = ast.literal_eval(src)
+            if isinstance(evaluated_src, list) and all(isinstance(item, str) for item in evaluated_src):
+                return evaluated_src  # Convert to real list
+        except (SyntaxError, ValueError):
+            pass  # Not a valid list, treat as a string
+
+        return src  # Return as a string if not a list
+
+    raise ValueError(f"Invalid type for 'src': {type(src).__name__}, expected str or list")

{spacr-0.4.12.dist-info → spacr-0.4.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.4.12
+Version: 0.4.15
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson

{spacr-0.4.12.dist-info → spacr-0.4.15.dist-info}/RECORD

@@ -9,28 +9,28 @@ spacr/app_sequencing.py,sha256=DjG26jy4cpddnV8WOOAIiExtOe9MleVMY4MFa5uTo5w,157
 spacr/app_umap.py,sha256=ZWAmf_OsIKbYvolYuWPMYhdlVe-n2CADoJulAizMiEo,153
 spacr/cellpose.py,sha256=RBHMs2vwXcfkj0xqAULpALyzJYXddSRycgZSzmwI7v0,14755
 spacr/chat_bot.py,sha256=n3Fhqg3qofVXHmh3H9sUcmfYy9MmgRnr48663MVdY9E,1244
-spacr/core.py,sha256=lKeqmsVrGQ8cPU_WkoNGNBWrk-gtR1RkRkwDdnJ0u64,48829
+spacr/core.py,sha256=JfeXuLa-IR0Qn5SfNPj2NCyxRkVXE3MDy0ywPFLIFVY,49014
 spacr/deep_spacr.py,sha256=WN64EaQqF87JZg3Uan46t5Y28xsAGD2KMjr2ht6CyDs,54563
 spacr/gui.py,sha256=ARyn9Q_g8HoP-cXh1nzMLVFCKqthY4v2u9yORyaQqQE,8230
-spacr/gui_core.py,sha256=U0A7waKgWq_Es9fMwcZbXUZYGzCqt2bgfY3HbxiFXnw,47466
+spacr/gui_core.py,sha256=DFzYiauhLJF7koEeKSXZAoUeUHd74LRgdt6Xktqi254,46892
 spacr/gui_elements.py,sha256=HmITDncklKwtdFhxLhtYXOwndsRfgwWIPVi83VlXHB4,146419
-spacr/gui_utils.py,sha256=0rDF23BUGcmjSJvfCiLoxhlGJdHkio1jTxyCzrMXr-g,41211
-spacr/io.py,sha256=oqJwDJWksVdWE0bRAwytTOsjlL0o-J9lr_pQaw2cQ4Y,138288
+spacr/gui_utils.py,sha256=ZiRMYSBj1w5jIjoTBw9_kf9RbAZD9D0DYCNHUmxNrh8,41342
+spacr/io.py,sha256=BtmxZcA_fr8jFsuwisnG95E5DS14JGA9isqiI-iYdII,138923
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
-spacr/measure.py,sha256=jmOnLBudq3TuY723Cfo1EJBn67P6rlEvL6I-2FSkUgI,55315
+spacr/measure.py,sha256=Z3u4BU5RzcY82IZuboQ0OsxuXaPVwOlH65Rw6FrL5z4,55045
 spacr/mediar.py,sha256=FwLvbLQW5LQzPgvJZG8Lw7GniA2vbZx6Jv6vIKu7I5c,14743
 spacr/ml.py,sha256=MrIAtUUxMOibWVL1SjCUnYlizawCp3l3SeY4Y9yEsPw,97251
 spacr/openai.py,sha256=5vBZ3Jl2llYcW3oaTEXgdyCB2aJujMUIO5K038z7w_A,1246
 spacr/plot.py,sha256=Q5TbsR2NUWhA7z4HyF_2_FAEBFSNMU-G3UNDbRzW6mM,169485
 spacr/sequencing.py,sha256=ClUfwPPK6rNUbUuiEkzcwakzVyDKKUMv9ricrxT8qQY,25227
-spacr/settings.py,sha256=fEk-9LSSvV1wGsn6xTaJWY7wF7_u8Fc-S1DaDHqZU3I,83997
+spacr/settings.py,sha256=7NAW69yE9FNzsQlLE2lTnDFNL4042AI4c-y20ikPlxc,84793
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
 spacr/sp_stats.py,sha256=mbhwsyIqt5upsSD346qGjdCw7CFBa0tIS7zHU9e0jNI,9536
 spacr/stats.py,sha256=mbhwsyIqt5upsSD346qGjdCw7CFBa0tIS7zHU9e0jNI,9536
-spacr/submodules.py,sha256=mb2g0igUTws7y6xW1zIJw1E7eQyxsjEj5mk2Z-Qd8uw,67629
+spacr/submodules.py,sha256=jFlJeVNuIEf63TtCOpTlOZ4iiSLr238kRBiGAAAgKE4,67626
 spacr/timelapse.py,sha256=KGfG4L4-QnFfgbF7L6C5wL_3gd_rqr05Foje6RsoTBg,39603
 spacr/toxo.py,sha256=TmuhejSIPLBvsgeblsUgSvBFCR1gOkApyTKidooJ5Us,26044
-spacr/utils.py,sha256=of2t5Tq_RKdJ1QRDo4nJ3oEVev_6s2Oko3-lBxl4ScU,226293
+spacr/utils.py,sha256=Cyy0pS-dwvMbH8cn6gu8OG1C-Kg6yUOAEacng-vkDgk,228837
 spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
 spacr/resources/MEDIAR/.gitignore,sha256=Ff1q9Nme14JUd-4Q3jZ65aeQ5X4uttptssVDgBVHYo8,152
 spacr/resources/MEDIAR/LICENSE,sha256=yEj_TRDLUfDpHDNM0StALXIt6mLqSgaV2hcCwa6_TcY,1065
@@ -153,9 +153,9 @@ spacr/resources/icons/umap.png,sha256=dOLF3DeLYy9k0nkUybiZMe1wzHQwLJFRmgccppw-8b
 spacr/resources/images/plate1_E01_T0001F001L01A01Z01C02.tif,sha256=Tl0ZUfZ_AYAbu0up_nO0tPRtF1BxXhWQ3T3pURBCCRo,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A02Z01C01.tif,sha256=m8N-V71rA1TT4dFlENNg8s0Q0YEXXs8slIn7yObmZJQ,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A03Z01C03.tif,sha256=Pbhk7xn-KUP6RSIhJsxQcrHFImBm3GEpLkzx7WOc-5M,7958528
-spacr-0.4.12.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.4.12.dist-info/METADATA,sha256=mSEI7oQQ8wHvVWQwzELtk2bpV_Bil3OhhteOJ3SoY68,6073
-spacr-0.4.12.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-spacr-0.4.12.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.4.12.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.4.12.dist-info/RECORD,,
+spacr-0.4.15.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.4.15.dist-info/METADATA,sha256=S7GQ5vQOQmp_uZPNThj1d29xrjSf_joXTOUVX96UDCY,6073
+spacr-0.4.15.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+spacr-0.4.15.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.4.15.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.4.15.dist-info/RECORD,,