spacr 0.3.42__tar.gz → 0.3.45__tar.gz

{spacr-0.3.42/spacr.egg-info → spacr-0.3.45}/PKG-INFO

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

{spacr-0.3.42 → spacr-0.3.45}/setup.py

@@ -67,7 +67,7 @@ dependencies = [
 
 setup(
     name="spacr",
-    version="0.3.42",
+    version="0.3.45",
     author="Einar Birnir Olafsson",
     author_email="olafsson@med.umich.com",
     description="Spatial phenotype analysis of crisp screens (SpaCr)",

{spacr-0.3.42 → spacr-0.3.45}/spacr/cellpose.py

@@ -5,50 +5,23 @@ from cellpose import models as cp_models
 from IPython.display import display
 from multiprocessing import Pool
 from skimage.transform import resize as resizescikit
+from scipy.ndimage import binary_fill_holes
 
 def identify_masks_finetune(settings):
     
     from .plot import print_mask_and_flows
-    from .utils import resize_images_and_labels, print_progress
+    from .utils import resize_images_and_labels, print_progress, save_settings, fill_holes_in_mask
     from .io import _load_normalized_images_and_labels, _load_images_and_labels
     from .settings import get_identify_masks_finetune_default_settings
 
     settings = get_identify_masks_finetune_default_settings(settings)
-    src=settings['src']
-    dst=settings['dst']
-    model_name=settings['model_name']
-    custom_model=settings['custom_model']
-    channels = settings['channels']
-    background = settings['background']
-    remove_background=settings['remove_background']
-    Signal_to_noise = settings['Signal_to_noise']
-    CP_prob = settings['CP_prob']
-    diameter=settings['diameter']
-    batch_size=settings['batch_size']
-    flow_threshold=settings['flow_threshold']
-    save=settings['save']
-    verbose=settings['verbose']
-
-    # static settings
-    normalize = settings['normalize']
-    percentiles = settings['percentiles']
-    circular = settings['circular']
-    invert = settings['invert']
-    resize = settings['resize']
-
-    if resize:
-        target_height = settings['target_height']
-        target_width = settings['target_width']
-
-    rescale = settings['rescale']
-    resample = settings['resample']
-    grayscale = settings['grayscale']
-
+    save_settings(settings, name='generate_cellpose_masks', show=True)
+    dst = os.path.join(settings['src'], 'masks')
     os.makedirs(dst, exist_ok=True)
 
-    if not custom_model is None:
-        if not os.path.exists(custom_model):
-            print(f'Custom model not found: {custom_model}')
+    if not settings['custom_model'] is None:
+        if not os.path.exists(settings['custom_model']):
+            print(f"Custom model not found: {settings['custom_model']}")
             return 
 
     if not torch.cuda.is_available():
@@ -56,43 +29,60 @@ def identify_masks_finetune(settings):
     
     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
     
-    if custom_model == None:
-        model = cp_models.CellposeModel(gpu=True, model_type=model_name, device=device)
-        print(f'Loaded model: {model_name}')
+    if settings['custom_model'] == None:
+        model = cp_models.CellposeModel(gpu=True, model_type=settings['model_name'], device=device)
+        print(f"Loaded model: {settings['model_name']}")
     else:
-        model = cp_models.CellposeModel(gpu=torch.cuda.is_available(), model_type=None, pretrained_model=custom_model, diam_mean=diameter, device=device)
+        model = cp_models.CellposeModel(gpu=torch.cuda.is_available(), model_type=None, pretrained_model=settings['custom_model'], diam_mean=settings['diameter'], device=device)
         print("Pretrained Model Loaded:", model.pretrained_model)
 
-    chans = [2, 1] if model_name == 'cyto2' else [0,0] if model_name == 'nucleus' else [1,0] if model_name == 'cyto' else [2, 0]
+    chans = [2, 1] if settings['model_name'] == 'cyto2' else [0,0] if settings['model_name'] == 'nucleus' else [1,0] if settings['model_name'] == 'cyto' else [2, 0]
     
-    if grayscale:
+    if settings['grayscale']:
         chans=[0, 0]
     
-    print(f'Using channels: {chans} for model of type {model_name}')
+    print(f"Using channels: {chans} for model of type {settings['model_name']}")
     
-    if verbose == True:
-        print(f'Cellpose settings: Model: {model_name}, channels: {channels}, cellpose_chans: {chans}, diameter:{diameter}, flow_threshold:{flow_threshold}, cellprob_threshold:{CP_prob}')
+    if settings['verbose'] == True:
+        print(f"Cellpose settings: Model: {settings['model_name']}, channels: {settings['channels']}, cellpose_chans: {chans}, diameter:{settings['diameter']}, flow_threshold:{settings['flow_threshold']}, cellprob_threshold:{settings['CP_prob']}")
         
-    all_image_files = [os.path.join(src, f) for f in os.listdir(src) if f.endswith('.tif')]
-    mask_files = set(os.listdir(os.path.join(src, 'masks')))
-    all_image_files = [f for f in all_image_files if os.path.basename(f) not in mask_files]
+    image_files = [os.path.join(settings['src'], f) for f in os.listdir(settings['src']) if f.endswith('.tif')]
+    mask_files = set(os.listdir(os.path.join(settings['src'], 'masks')))
+    all_image_files = [f for f in image_files if os.path.basename(f) not in mask_files]
     random.shuffle(all_image_files)
+
+    print(f"Found {len(image_files)} Images with {len(mask_files)} masks. Generating masks for {len(all_image_files)} images")
+
+    if len(all_image_files) == 0:
+        print(f"Either no images were found in {settings['src']} or all images have masks in {settings['dst']}")
+        return
+
     
     time_ls = []
-    for i in range(0, len(all_image_files), batch_size):
+    for i in range(0, len(all_image_files), settings['batch_size']):
         gc.collect()
-        image_files = all_image_files[i:i+batch_size]
+        image_files = all_image_files[i:i+settings['batch_size']]
         
-        if normalize:
-            images, _, image_names, _, orig_dims = _load_normalized_images_and_labels(image_files=image_files, label_files=None, channels=channels, percentiles=percentiles,  circular=circular, invert=invert, visualize=verbose, remove_background=remove_background, background=background, Signal_to_noise=Signal_to_noise, target_height=target_height, target_width=target_width)
+        if settings['normalize']:
+            images, _, image_names, _, orig_dims = _load_normalized_images_and_labels(image_files=image_files,
+                                                                                      label_files=None,
+                                                                                      channels=settings['channels'],
+                                                                                      percentiles=settings['percentiles'],
+                                                                                      invert=settings['invert'],
+                                                                                      visualize=settings['verbose'],
+                                                                                      remove_background=settings['remove_background'],
+                                                                                      background=settings['background'],
+                                                                                      Signal_to_noise=settings['Signal_to_noise'],
+                                                                                      target_height=settings['target_height'],
+                                                                                      target_width=settings['target_width'])
+            
             images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
-            #orig_dims = [(image.shape[0], image.shape[1]) for image in images]
         else:
-            images, _, image_names, _ = _load_images_and_labels(image_files=image_files, label_files=None, circular=circular, invert=invert) 
+            images, _, image_names, _ = _load_images_and_labels(image_files=image_files, label_files=None, invert=settings['invert']) 
             images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
             orig_dims = [(image.shape[0], image.shape[1]) for image in images]
-            if resize:
-                images, _ = resize_images_and_labels(images, None, target_height, target_width, True)
+            if settings['resize']:
+                images, _ = resize_images_and_labels(images, None, settings['target_height'], settings['target_width'], True)
 
         for file_index, stack in enumerate(images):
             start = time.time()
@@ -100,11 +90,11 @@ def identify_masks_finetune(settings):
                          normalize=False,
                          channels=chans,
                          channel_axis=3,
-                         diameter=diameter,
-                         flow_threshold=flow_threshold,
-                         cellprob_threshold=CP_prob,
-                         rescale=rescale,
-                         resample=resample,
+                         diameter=settings['diameter'],
+                         flow_threshold=settings['flow_threshold'],
+                         cellprob_threshold=settings['CP_prob'],
+                         rescale=settings['rescale'],
+                         resample=settings['resample'],
                          progress=True)
 
             if len(output) == 4:
@@ -113,8 +103,11 @@ def identify_masks_finetune(settings):
                 mask, flows, _ = output
             else:
                 raise ValueError("Unexpected number of return values from model.eval()")
+            
+            if settings['fill_in']:
+                mask = fill_holes_in_mask(mask).astype(mask.dtype)
 
-            if resize:
+            if settings['resize']:
                 dims = orig_dims[file_index]
                 mask = resizescikit(mask, dims, order=0, preserve_range=True, anti_aliasing=False).astype(mask.dtype)
 
@@ -123,15 +116,13 @@ def identify_masks_finetune(settings):
             time_ls.append(duration)
             files_processed = len(images)
             files_to_process = file_index+1            
-            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls)
-            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="")
-            
+            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="generate cellpose masks")
             
-            if verbose:
-                if resize:
+            if settings['verbose']:
+                if settings['resize']:
                     stack = resizescikit(stack, dims, preserve_range=True, anti_aliasing=False).astype(stack.dtype)
-                print_mask_and_flows(stack, mask, flows, overlay=True)
-            if save:
+                print_mask_and_flows(stack, mask, flows)
+            if settings['save']:
                 os.makedirs(dst, exist_ok=True)
                 output_filename = os.path.join(dst, image_names[file_index])
                 cv2.imwrite(output_filename, mask)
@@ -139,7 +130,7 @@ def identify_masks_finetune(settings):
         gc.collect()
     return
 
-def generate_masks_from_imgs(src, model, model_name, batch_size, diameter, cellprob_threshold, flow_threshold, grayscale, save, normalize, channels, percentiles, circular, invert, plot, resize, target_height, target_width, remove_background, background, Signal_to_noise, verbose):
+def generate_masks_from_imgs(src, model, model_name, batch_size, diameter, cellprob_threshold, flow_threshold, grayscale, save, normalize, channels, percentiles, invert, plot, resize, target_height, target_width, remove_background, background, Signal_to_noise, verbose):
     
     from .io import _load_images_and_labels, _load_normalized_images_and_labels
     from .utils import resize_images_and_labels, resizescikit, print_progress
@@ -164,11 +155,11 @@ def generate_masks_from_imgs(src, model, model_name, batch_size, diameter, cellp
         image_files = all_image_files[i:i+batch_size]
 
         if normalize:
-            images, _, image_names, _, orig_dims = _load_normalized_images_and_labels(image_files, None, channels, percentiles,  circular, invert, plot, remove_background, background, Signal_to_noise, target_height, target_width)
+            images, _, image_names, _, orig_dims = _load_normalized_images_and_labels(image_files, None, channels, percentiles, invert, plot, remove_background, background, Signal_to_noise, target_height, target_width)
             images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
             orig_dims = [(image.shape[0], image.shape[1]) for image in images]
         else:
-            images, _, image_names, _ = _load_images_and_labels(image_files, None, circular, invert) 
+            images, _, image_names, _ = _load_images_and_labels(image_files, None, invert) 
             images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
             orig_dims = [(image.shape[0], image.shape[1]) for image in images]
         if resize:
@@ -209,12 +200,11 @@ def generate_masks_from_imgs(src, model, model_name, batch_size, diameter, cellp
             if plot:
                 if resize:
                     stack = resizescikit(stack, dims, preserve_range=True, anti_aliasing=False).astype(stack.dtype)
-                print_mask_and_flows(stack, mask, flows, overlay=True)
+                print_mask_and_flows(stack, mask, flows)
             if save:
                 output_filename = os.path.join(dst, image_names[file_index])
                 cv2.imwrite(output_filename, mask)
 
-
 def check_cellpose_models(settings):
 
     from .settings import get_check_cellpose_models_default_settings
@@ -233,7 +223,7 @@ def check_cellpose_models(settings):
 
         model = cp_models.CellposeModel(gpu=True, model_type=model_name, device=device)
         print(f'Using {model_name}')
-        generate_masks_from_imgs(src, model, model_name, settings['batch_size'], settings['diameter'], settings['CP_prob'], settings['flow_threshold'], settings['grayscale'], settings['save'], settings['normalize'], settings['channels'], settings['percentiles'], settings['circular'], settings['invert'], settings['plot'], settings['resize'], settings['target_height'], settings['target_width'], settings['remove_background'], settings['background'], settings['Signal_to_noise'], settings['verbose'])
+        generate_masks_from_imgs(src, model, model_name, settings['batch_size'], settings['diameter'], settings['CP_prob'], settings['flow_threshold'], settings['grayscale'], settings['save'], settings['normalize'], settings['channels'], settings['percentiles'], settings['invert'], settings['plot'], settings['resize'], settings['target_height'], settings['target_width'], settings['remove_background'], settings['background'], settings['Signal_to_noise'], settings['verbose'])
 
     return
 

{spacr-0.3.42 → spacr-0.3.45}/spacr/gui_core.py

@@ -384,8 +384,8 @@ def import_settings(settings_type='mask'):
     from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
     from .settings import generate_fields, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model
     from .settings import set_default_generate_barecode_mapping, set_default_umap_image_settings, get_analyze_recruitment_default_settings
-    from .settings import get_default_generate_activation_map_settings
-    #activation
+    from .settings import get_default_generate_activation_map_settings, get_analyze_plaque_settings
+
     def read_settings_from_csv(csv_file_path):
         settings = {}
         with open(csv_file_path, newline='') as csvfile:
@@ -428,7 +428,7 @@ def import_settings(settings_type='mask'):
     elif settings_type == 'activation':
         settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
-        settings = {}
+        settings = get_analyze_plaque_settings(settings={})
     elif settings_type == 'convert':
         settings = {}
     else:
@@ -443,7 +443,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     global vars_dict, scrollable_frame
     from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks
     from .settings import get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings
-    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings, get_analyze_plaque_settings
     from .settings import generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_default_generate_activation_map_settings
     from .gui_utils import convert_settings_dict_for_gui
     from .gui_elements import set_element_size
@@ -490,7 +490,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'activation':
         settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
-        settings = {'src':'path to images'}
+        settings = get_analyze_plaque_settings(settings={})
     elif settings_type == 'convert':
         settings = {'src':'path to images'}
     else:

{spacr-0.3.42 → spacr-0.3.45}/spacr/gui_utils.py

@@ -380,7 +380,7 @@ def convert_settings_dict_for_gui(settings):
     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,1,2,3]'),
+        'channels': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]', '[0,0]'], '[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]'),
         'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'metadata'),

{spacr-0.3.42 → spacr-0.3.45}/spacr/io.py

@@ -129,7 +129,7 @@ def process_non_tif_non_2D_images(folder):
             except Exception as e:
                 print(f"Error processing {filename}: {str(e)}")
 
-def _load_images_and_labels(image_files, label_files, circular=False, invert=False):
+def _load_images_and_labels(image_files, label_files, invert=False):
     
     from .utils import invert_image, apply_mask
     
@@ -151,8 +151,6 @@ def _load_images_and_labels(image_files, label_files, circular=False, invert=Fal
             image = cellpose.io.imread(img_file)
             if invert:
                 image = invert_image(image)
-            if circular:
-                image = apply_mask(image, output_value=0)
             label = cellpose.io.imread(lbl_file)
             if image.max() > 1:
                 image = image / image.max()
@@ -163,16 +161,12 @@ def _load_images_and_labels(image_files, label_files, circular=False, invert=Fal
             image = cellpose.io.imread(img_file)
             if invert:
                 image = invert_image(image)
-            if circular:
-                image = apply_mask(image, output_value=0)
             if image.max() > 1:
                 image = image / image.max()
             images.append(image)
     elif not image_files is None:
             for lbl_file in label_files:
                 label = cellpose.io.imread(lbl_file)
-                if circular:
-                    label = apply_mask(label, output_value=0)
             labels.append(label)
             
     if not image_files is None:
@@ -191,107 +185,127 @@ def _load_images_and_labels(image_files, label_files, circular=False, invert=Fal
         print(f'image shape: {images[0].shape}, image type: images[0].shape mask shape: {labels[0].shape}, image type: labels[0].shape')
     return images, labels, image_names, label_names
 
-def _load_normalized_images_and_labels_v1(image_files, label_files, channels=None, percentiles=None,  circular=False, invert=False, visualize=False, remove_background=False, background=0, Signal_to_noise=10):
+def _load_normalized_images_and_labels(image_files, label_files, channels=None, percentiles=None,  
+                                       invert=False, visualize=False, remove_background=False, 
+                                       background=0, Signal_to_noise=10, target_height=None, target_width=None):
     
-    from .plot import normalize_and_visualize
+    from .plot import normalize_and_visualize, plot_resize
     from .utils import invert_image, apply_mask
+    from skimage.transform import resize as resizescikit
+
+    # Ensure percentiles are valid
+    if isinstance(percentiles, list) and len(percentiles) == 2:
+        try:
+            percentiles = [int(percentiles[0]), int(percentiles[1])]
+        except ValueError:
+            percentiles = None
+    else:
+        percentiles = None
 
-    signal_thresholds = background*Signal_to_noise
+    signal_thresholds = float(background) * float(Signal_to_noise)
     lower_percentile = 2
 
-    images = []
-    labels = []
-    
+    images, labels, orig_dims = [], [], []
     num_channels = 4
     percentiles_1 = [[] for _ in range(num_channels)]
     percentiles_99 = [[] for _ in range(num_channels)]
 
     image_names = [os.path.basename(f) for f in image_files]
-    
+    image_dir = os.path.dirname(image_files[0])
+
     if label_files is not None:
         label_names = [os.path.basename(f) for f in label_files]
         label_dir = os.path.dirname(label_files[0])
+    else:
+        label_names, label_dir = [], None
 
-    # Load images and check percentiles
-    for i,img_file in enumerate(image_files):
+    # Load, normalize, and resize images
+    for i, img_file in enumerate(image_files):
         image = cellpose.io.imread(img_file)
+        orig_dims.append((image.shape[0], image.shape[1]))
+
         if invert:
             image = invert_image(image)
-        if circular:
-            image = apply_mask(image, output_value=0)
 
-        # If specific channels are specified, select them
+        # Select specific channels if needed
         if channels is not None and image.ndim == 3:
             image = image[..., channels]
 
         if remove_background:
-            image[image < background] = 0
-        
+            image = np.where(image < background, 0, image)
+
         if image.ndim < 3:
             image = np.expand_dims(image, axis=-1)
-        
-        images.append(image)
+
+        # Calculate percentiles if not provided
         if percentiles is None:
             for c in range(image.shape[-1]):
                 p1 = np.percentile(image[..., c], lower_percentile)
                 percentiles_1[c].append(p1)
+
+                # Ensure `signal_thresholds` and `p` are floats for comparison
                 for percentile in [98, 99, 99.9, 99.99, 99.999]:
                     p = np.percentile(image[..., c], percentile)
-                    if p > signal_thresholds:
+                    if float(p) > signal_thresholds:
                         percentiles_99[c].append(p)
                         break
-                    
-    if not percentiles is None:
-        normalized_images = []
-        for image in images:
-            normalized_image = np.zeros_like(image, dtype=np.float32)
-            for c in range(image.shape[-1]):
-                low_p = np.percentile(image[..., c], percentiles[0])
-                high_p = np.percentile(image[..., c], percentiles[1])
-                normalized_image[..., c] = rescale_intensity(image[..., c], in_range=(low_p, high_p), out_range=(0, 1))
-            normalized_images.append(normalized_image)
-            if visualize:
-                normalize_and_visualize(image, normalized_image, title=f"Channel {c+1} Normalized")
-            
+
+        # Resize image if required
+        if target_height and target_width:
+            image_shape = (target_height, target_width) if image.ndim == 2 else (target_height, target_width, image.shape[-1])
+            image = resizescikit(image, image_shape, preserve_range=True, anti_aliasing=True).astype(image.dtype)
+
+        images.append(image)
+
+    # Calculate average percentiles if needed
     if percentiles is None:
-        # Calculate average percentiles for normalization
         avg_p1 = [np.mean(p) for p in percentiles_1]
-        avg_p99 = [np.mean(p) if len(p) > 0 else np.mean(percentiles_1[i]) for i, p in enumerate(percentiles_99)]
+        avg_p99 = [np.mean(p) if p else avg_p1[i] for i, p in enumerate(percentiles_99)]
 
         print(f'Average 1st percentiles: {avg_p1}, Average 99th percentiles: {avg_p99}')
 
-        normalized_images = []
-        for image in images:
-            normalized_image = np.zeros_like(image, dtype=np.float32)
-            for c in range(image.shape[-1]):
-                normalized_image[..., c] = rescale_intensity(image[..., c], in_range=(avg_p1[c], avg_p99[c]), out_range=(0, 1))
-            normalized_images.append(normalized_image)
-            if visualize:
-                normalize_and_visualize(image, normalized_image, title=f"Channel {c+1} Normalized")
-            
-    if not image_files is None:
-        image_dir = os.path.dirname(image_files[0])
+        normalized_images = [
+            np.stack([rescale_intensity(img[..., c], in_range=(avg_p1[c], avg_p99[c]), out_range=(0, 1))
+                      for c in range(img.shape[-1])], axis=-1) for img in images
+        ]
 
     else:
-        image_dir = None
-            
+        normalized_images = [
+            np.stack([rescale_intensity(img[..., c], 
+                                        in_range=(np.percentile(img[..., c], percentiles[0]),
+                                                  np.percentile(img[..., c], percentiles[1])), 
+                                        out_range=(0, 1)) for c in range(img.shape[-1])], axis=-1) 
+            for img in images
+        ]
+
+    # Load and resize labels if provided
     if label_files is not None:
-        for lbl_file in label_files:
-            labels.append(cellpose.io.imread(lbl_file))
-    else:
-        label_names = []
-        label_dir = None
+        labels = [resizescikit(cellpose.io.imread(lbl_file), 
+                               (target_height, target_width) if target_height and target_width else orig_dims[i], 
+                               order=0, preserve_range=True, anti_aliasing=False).astype(np.uint8)
+                  for i, lbl_file in enumerate(label_files)]
 
     print(f'Loaded and normalized {len(normalized_images)} images and {len(labels)} labels from {image_dir} and {label_dir}')
-    
-    return normalized_images, labels, image_names, label_names
 
-def _load_normalized_images_and_labels(image_files, label_files, channels=None, percentiles=None,  circular=False, invert=False, visualize=False, remove_background=False, background=0, Signal_to_noise=10, target_height=None, target_width=None):
+    if visualize and images and labels:
+        plot_resize(images, normalized_images, labels, labels)
+
+    return normalized_images, labels, image_names, label_names, orig_dims
+
+def _load_normalized_images_and_labels_v1(image_files, label_files, channels=None, percentiles=None, invert=False, visualize=False, remove_background=False, background=0, Signal_to_noise=10, target_height=None, target_width=None):
     
     from .plot import normalize_and_visualize, plot_resize
     from .utils import invert_image, apply_mask
     from skimage.transform import resize as resizescikit
 
+    if isinstance(percentiles, list):
+        if len(percentiles) !=2:
+            percentiles = None
+        if not percentiles[0] is int:
+            percentiles = None
+        if not percentiles[1] is int:
+            percentiles = None
+    
     signal_thresholds = background * Signal_to_noise
     lower_percentile = 2
 
@@ -316,8 +330,6 @@ def _load_normalized_images_and_labels(image_files, label_files, channels=None,
         orig_dims.append((image.shape[0], image.shape[1]))
         if invert:
             image = invert_image(image)
-        if circular:
-            image = apply_mask(image, output_value=0)
 
         # If specific channels are specified, select them
         if channels is not None and image.ndim == 3:
@@ -2123,7 +2135,8 @@ def _load_and_concatenate_arrays(src, channels, cell_chann_dim, nucleus_chann_di
                 # For each of the other folders, load the array and add it to 'stack_ls'
                 for folder in folder_paths[1:]:
                     array_path = os.path.join(folder, filename)
-                    array = np.load(array_path)
+                    #array = np.load(array_path)
+                    array = np.load(array_path, allow_pickle=True)
                     if array.ndim == 2:
                         array = np.expand_dims(array, axis=-1)  # Add an extra dimension if the array is 2D
                     stack_ls.append(array)

{spacr-0.3.42 → spacr-0.3.45}/spacr/ml.py

@@ -450,13 +450,14 @@ def perform_regression(settings):
         else:
             return df
         
-
-    
     settings = get_perform_regression_default_settings(settings)
     count_data_df, score_data_df = _perform_regression_read_data(settings)
     results_path, results_path_gene, results_path_grna, hits_path, res_folder, csv_path = _perform_regression_set_paths(settings)
     save_settings(settings, name='regression', show=True)
 
+    count_source = os.path.dirname(settings['count_data'][0])
+    volcano_path = os.path.join(count_source, 'volcano_plot.pdf')
+
     if isinstance(settings['filter_value'], list):
         filter_value = settings['filter_value']
     else:
@@ -548,7 +549,7 @@ def perform_regression(settings):
         base_dir = os.path.dirname(os.path.abspath(__file__))
         metadata_path = os.path.join(base_dir, 'resources', 'data', 'lopit.csv')
         
-        custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location', point_size=200, figsize=20, threshold=reg_threshold, split_axis_lims=settings['split_axis_lims'])
+        custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location', point_size=200, figsize=20, threshold=reg_threshold, split_axis_lims=settings['split_axis_lims'], save_path=volcano_path)
         #custom_volcano_plot(data_path_gene, metadata_path, metadata_column='tagm_location', point_size=50, figsize=20, threshold=reg_threshold)
         #custom_volcano_plot(data_path_grna, metadata_path, metadata_column='tagm_location', point_size=50, figsize=20, threshold=reg_threshold)