spacr 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

spacr/core.py

@@ -9,7 +9,7 @@ warnings.filterwarnings("ignore", message="3D stack used, but stitch_threshold=0
 
 def preprocess_generate_masks(settings):
 
-    from .io import preprocess_img_data, _load_and_concatenate_arrays, convert_to_yokogawa
+    from .io import preprocess_img_data, _load_and_concatenate_arrays, convert_to_yokogawa, convert_separate_files_to_yokogawa
     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, format_path_for_system, normalize_src_path
     from .settings import set_default_settings_preprocess_generate_masks
@@ -30,16 +30,34 @@ def preprocess_generate_masks(settings):
     if isinstance(settings['src'], list):
         source_folders = settings['src']
         for source_folder in source_folders:
-            print(f'Processing folder: {source_folder}')
             
-            if settings['metadata_type'] == 'auto':
-                convert_to_yokogawa(folder=source_folder)
+            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)
             
+            if settings['metadata_type'] == 'auto':
+                if settings['custom_regex'] != None:
+                    try:
+                        print(f"using regex: {settings['custom_regex']}")
+                        convert_separate_files_to_yokogawa(folder=source_folder, regex=settings['custom_regex'])
+                    except:
+                        try:
+                            convert_to_yokogawa(folder=source_folder)
+                        except Exception as e:
+                            print(f"Error: Tried to convert image files and image file name metadata with regex {settings['custom_regex']} then without regex but failed both.")
+                            print(f'Error: {e}')
+                            return
+                else:
+                    try:
+                        convert_to_yokogawa(folder=source_folder)
+                    except Exception as e:
+                        print(f"Error: Tried to convert image files and image file name metadata without regex but failed.")
+                        print(f'Error: {e}')
+                        return
+            
             if settings['cell_channel'] is None and settings['nucleus_channel'] is None and settings['pathogen_channel'] is None:
                 print(f'Error: At least one of cell_channel, nucleus_channel or pathogen_channel must be defined')
                 return

spacr/gui_core.py

@@ -913,34 +913,52 @@ def check_src_folders_files(settings, settings_type, q):
             conditions = [pictures_continue, folder_chan_continue, folder_stack_continue, folder_npz_continue]
             
         if settings_type == 'measure':
+            if not os.path.basename(path) == 'merged':
+                path = os.path.join(path, "merged")
             npy_continue = _folder_has_images(path, image_extensions={".npy"})
             conditions = [npy_continue]
             
-        if settings_type == 'recruitment':
-            db_continue = _folder_has_images(path, image_extensions={".db"})
-            conditions = [db_continue]
+        #if settings_type == 'recruitment':
+        #    if not os.path.basename(path) == 'measurements':
+        #        path = os.path.join(path, "measurements")
+        #    db_continue = _folder_has_images(path, image_extensions={".db"})
+        #    conditions = [db_continue]
             
-        if settings_type == 'umap':
-            db_continue = _folder_has_images(path, image_extensions={".db"})
-            conditions = [db_continue]
+        #if settings_type == 'umap':
+        #    if not os.path.basename(path) == 'measurements':
+        #        path = os.path.join(path, "measurements")
+        #    db_continue = _folder_has_images(path, image_extensions={".db"})
+        #    conditions = [db_continue]
             
-        if settings_type == 'analyze_plaques':
-            conditions = [True]
+        #if settings_type == 'analyze_plaques':
+        #    if not os.path.basename(path) == 'measurements':
+        #        path = os.path.join(path, "measurements")
+        #    db_continue = _folder_has_images(path, image_extensions={".db"})
+        #    conditions = [db_continue]
         
-        if settings_type == 'map_barcodes':
-            conditions = [True]
+        #if settings_type == 'map_barcodes':
+        #    if not os.path.basename(path) == 'measurements':
+        #        path = os.path.join(path, "measurements")
+        #    db_continue = _folder_has_images(path, image_extensions={".db"})
+        #    conditions = [db_continue]
         
-        if settings_type == 'regression':
-            db_continue = _folder_has_images(path, image_extensions={".db"})
-            conditions = [db_continue]
+        #if settings_type == 'regression':
+        #    if not os.path.basename(path) == 'measurements':
+        #        path = os.path.join(path, "measurements")
+        #    db_continue = _folder_has_images(path, image_extensions={".db"})
+        #    conditions = [db_continue]
             
-        if settings_type == 'classify':
-            db_continue = _folder_has_images(path, image_extensions={".db"})
-            conditions = [db_continue]
+        #if settings_type == 'classify':
+        #    if not os.path.basename(path) == 'measurements':
+        #        path = os.path.join(path, "measurements")
+        #    db_continue = _folder_has_images(path, image_extensions={".db"})
+        #    conditions = [db_continue]
             
-        if settings_type == 'analyze_plaques':
-            db_continue = _folder_has_images(path, image_extensions={".db"})
-            conditions = [db_continue]
+        #if settings_type == 'analyze_plaques':
+        #    if not os.path.basename(path) == 'measurements':
+        #        path = os.path.join(path, "measurements")
+        #    db_continue = _folder_has_images(path, image_extensions={".db"})
+        #    conditions = [db_continue]
             
     if not any(conditions):
         q.put(f"Error: The following path(s) is missing images or folders: {path}")

spacr/io.py

@@ -647,7 +647,7 @@ def load_images_from_paths(images_by_key):
     
     return images_dict
 
-#@log_function_call
+#@log_function_call 
 def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=False, skip_mode='01', metadata_type='', img_format='.tif'):
     """
     Convert z-stack images to maximum intensity projection (MIP) images.
@@ -664,13 +664,16 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
         None
     """
     
+    if isinstance(img_format, str):
+        img_format = [img_format]
+    
     from .utils import _extract_filename_metadata, print_progress
     
     regular_expression = re.compile(regex)
     stack_path = os.path.join(src, 'stack')
     files_processed = 0
     if not os.path.exists(stack_path) or (os.path.isdir(stack_path) and len(os.listdir(stack_path)) == 0):
-        all_filenames = [filename for filename in os.listdir(src) if filename.endswith(img_format)]
+        all_filenames = [filename for filename in os.listdir(src) if any(filename.endswith(ext) for ext in img_format)]
         print(f'All files: {len(all_filenames)} in {src}')
         time_ls = []
         image_paths_by_key = _extract_filename_metadata(all_filenames, src, regular_expression, metadata_type, pick_slice, skip_mode)
@@ -729,11 +732,11 @@ def _rename_and_organize_image_files(src, regex, batch_size=100, pick_slice=Fals
             images_by_key.clear()
 
         # Move original images to a new directory
-        valid_exts = [img_format]
         newpath = os.path.join(src, 'orig')
         os.makedirs(newpath, exist_ok=True)
         for filename in os.listdir(src):
-            if os.path.splitext(filename)[1] in valid_exts:
+            #print(f"{filename}: {os.path.splitext(filename)[1]}")
+            if os.path.splitext(filename)[1] in img_format:
                 move = os.path.join(newpath, filename)
                 if os.path.exists(move):
                     print(f'WARNING: A file with the same name already exists at location {move}')
@@ -1628,6 +1631,7 @@ def preprocess_img_data(settings):
                 if timelapse:
                     _move_to_chan_folder(src, regex, timelapse, metadata_type)
                 else:
+                    img_format = ['.tif', '.tiff', '.png', '.jpg', '.jpeg', '.bmp', '.nd2', '.czi', '.lif']
                     _rename_and_organize_image_files(src, regex, batch_size, pick_slice, skip_mode, metadata_type, img_format)
                     
                     #Make sure no batches will be of only one image
@@ -3104,160 +3108,96 @@ def generate_dataset_from_lists(dst, class_data, classes, test_split=0.1):
 
     return os.path.join(dst, 'train'), os.path.join(dst, 'test')
 
-def convert_to_yokogawa_v1(folder):
-    """
-    Detects file type in the folder and converts them
-    to Yokogawa-style naming with Maximum Intensity Projection (MIP).
-    """
+def convert_separate_files_to_yokogawa(folder, regex):
     
+    ROWS = "ABCDEFGHIJKLMNOP"
+    COLS = [f"{i:02d}" for i in range(1, 25)]
+    WELLS = [f"{r}{c}" for r in ROWS for c in COLS]
+
     def _get_next_well(used_wells):
-        """
-        Determines the next available well position in a 384-well format.
-        Iterates wells, and after P24, switches to plate2.
-        """
         plate = 1
         for well in WELLS:
             well_name = f"plate{plate}_{well}"
             if well_name not in used_wells:
                 return well_name
-            if well == "P24":  
-                plate += 1  
+            if well == "P24":
+                plate += 1
         return f"plate{plate}_A01"
 
-    # Define 384-well plate format
-    ROWS = "ABCDEFGHIJKLMNOP"
-    COLS = [f"{i:02d}" for i in range(1, 25)]
-    WELLS = [f"{r}{c}" for r in ROWS for c in COLS]
+    pattern = re.compile(regex, re.I)
 
-    filenames = []
+    files_by_region = {}
     rename_log = []
     csv_path = os.path.join(folder, "rename_log.csv")
-    used_wells = set(os.listdir(folder))
+    used_wells = set()
+    region_to_well = {}
 
+    # Group files by (plateID, wellID, fieldID, timeID, chanID)
     for file in os.listdir(folder):
-        path = os.path.join(folder, file)
-        ext = file.lower().split('.')[-1]
-
-        ### **Process Nikon ND2 Files**
-        if ext == 'nd2':
-            nd2 = ND2Reader(path)
-            metadata = nd2.metadata
-
-            timepoints = metadata.get("frames", [0])
-            fields = metadata.get("fields_of_view", [0])
-            z_levels = list(metadata.get("z_levels", range(1)))
-            channels = metadata.get("channels", [])
-
-            for t_idx in timepoints:
-                for f_idx in fields:
-                    for c_idx, channel in enumerate(channels):
-                        well = _get_next_well(used_wells)
-
-                        z_stack = [nd2.get_frame_2D(t=t_idx, v=f_idx, z=z_idx, c=c_idx) for z_idx in z_levels]
-                        mip_image = np.max(np.stack(z_stack), axis=0)
-                        dtype = z_stack[0].dtype
-
-                        filename = f"{well}_T{t_idx+1:04d}F{f_idx+1:03d}L01C{c_idx+1:02d}.tif"
-                        filepath = os.path.join(folder, filename)
-                        tifffile.imwrite(filepath, mip_image.astype(dtype))
-                        used_wells.add(well)
-                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
-
-        ### **Process Zeiss CZI Files**
-        elif ext == 'czi':
-            with czifile.CziFile(path) as czi:
-                shape = czi.shape  
-
-                timepoints = range(shape[0])
-                z_levels = range(shape[1])
-                channels = range(shape[2])
-
-                for t_idx in timepoints:
-                    for c_idx in channels:
-                        well = _get_next_well(used_wells)
-
-                        z_stack = [czi.asarray()[t_idx, z_idx, c_idx] for z_idx in z_levels]
-                        mip_image = np.max(np.stack(z_stack), axis=0)
-                        dtype = z_stack[0].dtype
-
-                        filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
-                        filepath = os.path.join(folder, filename)
-                        tifffile.imwrite(filepath, mip_image.astype(dtype))
-                        used_wells.add(well)
-                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
-
-        ### **Process Leica LIF Files**
-        elif ext == 'lif':
-            lif_file = readlif.Reader(path)
-
-            for image in lif_file.getIterImage():
-                timepoints = range(image.dims.t)
-                z_levels = range(image.dims.z)
-                channels = range(image.dims.c)
-
-                for t_idx in timepoints:
-                    for c_idx in channels:
-                        well = _get_next_well(used_wells)
-
-                        z_stack = [image.getFrame(z=z_idx, t=t_idx, c=c_idx) for z_idx in z_levels]
-                        mip_image = np.max(np.stack(z_stack), axis=0)
-                        dtype = z_stack[0].dtype
-
-                        filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
-                        filepath = os.path.join(folder, filename)
-                        tifffile.imwrite(filepath, mip_image.astype(dtype))
-                        used_wells.add(well)
-                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
-
-        ### **Process Standard Images (.tif, .tiff, .png, .jpg, .bmp, etc.)**
-        elif ext in ['tif', 'tiff', 'png', 'jpg', 'jpeg', 'bmp'] and not file.startswith("plate"):
-            with tifffile.TiffFile(path) as tif:
-                well = _get_next_well(used_wells)
-                num_pages = len(tif.pages)
+        match = pattern.match(file)
+        if not match:
+            print(f"Skipping {file}: does not match regex.")
+            continue
 
-                if num_pages > 1:
-                    # Assume multi-channel or z-stack
-                    images = tif.asarray()
-                    if images.ndim == 4:  # (T, Z, C, Y, X)
-                        timepoints = range(images.shape[0])
-                        z_levels = range(images.shape[1])
-                        channels = range(images.shape[2])
+        meta = match.groupdict()
 
-                        for t_idx in timepoints:
-                            for c_idx in channels:
-                                mip_image = np.max(images[t_idx, :, c_idx], axis=0)
-                                dtype = images.dtype
-
-                                filename = f"{well}_T{t_idx+1:04d}F001L01C{c_idx+1:02d}.tif"
-                                filepath = os.path.join(folder, filename)
-                                tifffile.imwrite(filepath, mip_image.astype(dtype))
-                                used_wells.add(well)
-                                rename_log.append({"Original File": file, "Renamed TIFF": filename})
+        # Mandatory metadata
+        if 'wellID' not in meta or meta['wellID'] is None:
+            print(f"Skipping {file}: missing mandatory wellID.")
+            continue
+        wellID = meta['wellID']
+
+        # Optional metadata with defaults
+        plateID = meta.get('plateID', '1') or '1'
+        fieldID = meta.get('fieldID', '1') or '1'
+        timeID = int(meta.get('timeID', 1) or 1)
+        chanID = int(meta.get('chanID', 1) or 1)
+        sliceID = meta.get('sliceID')
+        sliceID = int(sliceID) if sliceID is not None else None
+
+        region_key = (plateID, wellID, fieldID, timeID, chanID)
+
+        files_by_region.setdefault(region_key, []).append((file, sliceID))
+
+    # Assign wells and process files per region
+    for region, file_list in files_by_region.items():
+        if region[:3] not in region_to_well:
+            next_well = _get_next_well(used_wells)
+            region_to_well[region[:3]] = next_well
+            used_wells.add(next_well)
+
+        assigned_well = region_to_well[region[:3]]
+        plateID, wellID, fieldID, timeID, chanID = region
+
+        # Check if multiple slices exist and are meaningful
+        slice_ids = [sid for _, sid in file_list if sid is not None]
+        unique_slices = set(slice_ids)
+
+        images = []
+        for filename, _ in sorted(file_list, key=lambda x: x[1] or 1):
+            img = tifffile.imread(os.path.join(folder, filename))
+            images.append(img)
+
+        # Perform MIP only if multiple unique slices are present
+        if len(unique_slices) > 1:
+            img_to_save = np.max(np.stack(images), axis=0)
+        else:
+            img_to_save = images[0]
 
-                    elif images.ndim == 3:  # (Z, Y, X) or (C, Y, X)
-                        z_stack = images if images.shape[0] > 1 else [images]
-                        mip_image = np.max(np.stack(z_stack), axis=0)
-                        dtype = images.dtype
+        dtype = img_to_save.dtype
 
-                        filename = f"{well}_T0001F001L01C01.tif"
-                        filepath = os.path.join(folder, filename)
-                        tifffile.imwrite(filepath, mip_image.astype(dtype))
-                        used_wells.add(well)
-                        rename_log.append({"Original File": file, "Renamed TIFF": filename})
-                else:
-                    image = tif.pages[0].asarray()
-                    dtype = image.dtype
+        new_filename = f"{assigned_well}_T{timeID:04d}F{int(fieldID):03d}L01C{chanID:02d}.tif"
+        new_filepath = os.path.join(folder, new_filename)
+        tifffile.imwrite(new_filepath, img_to_save.astype(dtype))
 
-                    filename = f"{well}_T0001F001L01C01.tif"
-                    filepath = os.path.join(folder, filename)
-                    tifffile.imwrite(filepath, image.astype(dtype))
-                    used_wells.add(well)
-                    rename_log.append({"Original File": file, "Renamed TIFF": filename})
+        # Log original filenames involved in MIP or single file rename
+        original_files = ";".join(f[0] for f in file_list)
+        rename_log.append({"Original File(s)": original_files, "Renamed TIFF": new_filename})
 
-    # Save rename log as CSV
     pd.DataFrame(rename_log).to_csv(csv_path, index=False)
     print(f"Processing complete. Files saved in {folder} and rename log saved as {csv_path}.")
 
+
 def convert_to_yokogawa(folder):
     """
     Detects file type in the folder and converts them

spacr/settings.py

@@ -1213,16 +1213,25 @@ def generate_fields(variables, scrollable_frame):
         "black_background": "(bool) - Whether to use a black background for plots.",
         "calculate_correlation": "(bool) - Whether to calculate correlations between features.",
         "cell_CP_prob": "(float) - The cellpose probability threshold for the cell channel. This will be used in cell segmentation.",
+        "nucleus_CP_prob": "(float) - The cellpose probability threshold for the nucleus channel. This will be used in cell segmentation.",
+        "pathogen_CP_prob": "(float) - The cellpose probability threshold for the pathogen channel. This will be used in cell segmentation.",
         "cell_FT": "(float) - The flow threshold for cell objects. This will be used to segment the cells.",
-        "cell_background": "(float) - The background intensity for the cell channel. This will be used to remove background noise.",
+        "nucleus_FT": "(float) - The flow threshold for nucleus objects. This will be used to segment the cells.",
+        "pathogen_FT": "(float) - The flow threshold for pathogen objects. This will be used to segment the cells.",
+        "cell_background": "(int) - The background intensity for the cell channel. This will be used to remove background noise.",
+        "nucleus_background": "(int) - The background intensity for the nucleus channel. This will be used to remove background noise.",
+        "pathogen_background": "(int) - The background intensity for the pathogen channel. This will be used to remove background noise.",
         "cell_chann_dim": "(int) - Dimension of the channel to use for cell segmentation.",
-        "cell_channel": "(int) - The channel to use for the cell. If None, the cell will not be segmented.",
+        "cell_channel": "(int) - The channel to use for generatin cell masks. If None, cell masks will not be generated.",
+        "nucleus_channel": "(int) - The channel to use for generatin nucleus masks. If None, nucleus masks will not be generated.",
+        "pathogen_channel": "(int) - The channel to use for generatin pathogen masks. If None, pathogen masks will not be generated.",
         "cell_intensity_range": "(list) - Intensity range for cell segmentation.",
         "cell_loc": "(list) - The locations of the cell types in the images.",
-        "cell_mask_dim": "(int) - The dimension of the array the cell mask is saved in.",
+        "cell_mask_dim": "(int) - The dimension of the array the cell mask is saved in (array order:channels,cell, nucleus, pathogen, cytoplasm) array starts at dimension 0.",
+        "nucleus_mask_dim": "(int) - The dimension of the array the nucleus mask is saved in (array order:channels,cell, nucleus, pathogen, cytoplasm) array starts at dimension 0.",
         "cell_min_size": "(int) - The minimum size of cell objects in pixels^2.",
         "cell_plate_metadata": "(str) - Metadata for the cell plate.",
-        "cell_Signal_to_noise": "(float) - The signal-to-noise ratio for the cell channel. This will be used to determine the range of intensities to normalize images to for cell segmentation.",
+        "cell_Signal_to_noise": "(int) - The signal-to-noise ratio for the cell channel. This will be used to determine the range of intensities to normalize images to for cell segmentation.",
         "cell_size_range": "(list) - Size range for cell segmentation.",
         "cell_types": "(list) - Types of cells to include in the analysis.",
         "cells": "(list of lists) - The cell types to include in the analysis.",
@@ -1240,10 +1249,13 @@ def generate_fields(variables, scrollable_frame):
         "CP_prob": "(float) - Cellpose probability threshold for segmentation.",
         "crop_mode": "(str) - Mode to use for cropping images (cell, nucleus, pathogen, cytoplasm).",
         "custom_model": "(str) - Path to a custom Cellpose model.",
-        "custom_regex": "(str) - Custom regex pattern to extract metadata from the image names. This will only be used if 'custom' is selected for 'metadata_type'.",
+        "custom_regex": "(str) - Custom regex pattern to extract metadata from the image names. This will only be used if 'custom' or 'auto' is selected for 'metadata_type'.",
         "cytoplasm": "(bool) - Whether to segment the cytoplasm (Cell - Nucleus + Pathogen).",
         "cytoplasm_min_size": "(int) - The minimum size of cytoplasm objects in pixels^2.",
+        "nucleus_min_size": "(int) - The minimum size of nucleus objects in pixels^2.",
+        "normalize_by": "(str) - Normalize cropped png images by png or by field of view.",
         "dependent_variable": "(str) - The dependent variable for the regression analysis.",
+        "delete_intermediate": "(bool) - Delete intermediate folders (stack, channel, norm_channel_stack).",
         "diameter": "(float) - Diameter of the objects to segment.",
         "dialate_png_ratios": "(list) - The ratios to use for dilating the PNG images. This will determine the amount of dilation applied to the images before cropping.",
         "dialate_pngs": "(bool) - Whether to dilate the PNG images before saving.",
@@ -1291,7 +1303,7 @@ def generate_fields(variables, scrollable_frame):
         "manders_thresholds": "(list) - Thresholds for Manders' coefficients.",
         "mask": "(bool) - Whether to generate masks for the segmented objects. If True, masks will be generated for the nucleus, cell, and pathogen.",
         "measurement": "(str) - The measurement to use for the analysis.",
-        "metadata_type": "(str) - Type of metadata to expect in the images. This will determine how the images are processed. If 'custom' is selected, you can provide a custom regex pattern to extract metadata from the image names.",
+        "metadata_type": "(str) - Type of metadata to expect in the images. If 'custom' is selected, you can provide a custom regex pattern to extract metadata from the image names. auto will attempt to automatically extract metadata from the image names. cellvoyager and cq1 will use the default metadata extraction for CellVoyager and CQ1 images.",
         "metadata_types": "(list) - Types of metadata to include in the analysis.",
         "merge_edge_pathogen_cells": "(bool) - Whether to merge cells that share pathogen objects.",
         "merge_pathogens": "(bool) - Whether to merge pathogen objects that share more than 75 percent of their perimeter.",
@@ -1312,7 +1324,8 @@ def generate_fields(variables, scrollable_frame):
         "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 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_Signal_to_noise": "(int) - 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.",
+        "nucleus_Signal_to_noise": "(int) - 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.",
         "pathogen_size_range": "(list) - Size range for pathogen segmentation.",
         "pathogen_types": "(list) - Types of pathogens to include in the analysis.",
         "pc": "(str) - Positive control identifier.",
@@ -1359,10 +1372,11 @@ def generate_fields(variables, scrollable_frame):
         "save_measurements": "(bool) - Whether to save the measurements to disk.",
         "save_png": "(bool) - Whether to save the segmented objects as PNG images.",
         "schedule": "(str) - Schedule for processing the data.",
-        "Signal_to_noise": "(float) - Signal-to-noise ratio for the images.",
+        "Signal_to_noise": "(int) - Signal-to-noise ratio for the images.",
         "skip_mode": "(str) - The mode to use for skipping images. This will determine how to handle images that cannot be processed.",
         "smooth_lines": "(bool) - Whether to smooth lines in the plots.",
         "src": "(str, path) - Path to source directory.",
+        "segmentation_mode": "(str) - Algorithm to use for segmentation (cellpose or mediar).",
         "target": "(str) - Target variable for the analysis.",
         "target_height": "(int) - Target height for resizing the images.",
         "target_intensity_min": "(float) - Minimum intensity for the target objects.",
@@ -1412,7 +1426,7 @@ def generate_fields(variables, scrollable_frame):
         "masks": "(bool) - Whether to generate masks for the segmented objects.",
         "timelapse": "(bool) - Whether to analyze images as a timelapse.",
         "pathogen_min_size": "(int) - The minimum size of pathogen objects in pixels^2.",
-        "pathogen_mask_dim": "(int) - The dimension of the array the pathogen mask is saved in.",
+        "pathogen_mask_dim": "(int) - The dimension of the array the pathogen mask is saved in (array order:channels,cell, nucleus, pathogen, cytoplasm) array starts at dimension 0.",
         "use_bounding_box": "(bool) - Whether to use the bounding box for cropping the images.",
         "plot_points": "(bool) - Whether to plot scatterplot points.",
         "embedding_by_controls": "(bool) - Use the controlls to greate the embedding, then apply this embedding to all of the data.",
@@ -1442,6 +1456,7 @@ def generate_fields(variables, scrollable_frame):
         "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.",
+        "normalize_plots": "(bool) - Normalize images before plotting.",
     }
     
     for key, (var_type, options, default_value) in variables.items():

spacr/utils.py

@@ -554,7 +554,7 @@ def _get_cellpose_batch_size():
 def _extract_filename_metadata(filenames, src, regular_expression, metadata_type='cellvoyager', pick_slice=False, skip_mode='01'):
     
     images_by_key = defaultdict(list)
-    
+
     for filename in filenames:
         match = regular_expression.match(filename)
         if match:
@@ -597,7 +597,7 @@ def _extract_filename_metadata(filenames, src, regular_expression, metadata_type
             except IndexError:
                 print(f"Could not extract information from filename {filename} using provided regex")
         else:
-            print(f"Filename {filename} did not match provided regex")
+            print(f"Filename {filename} did not match provided regex: {regular_expression}")
             continue
         
     return images_by_key

{spacr-0.4.2.dist-info → spacr-0.4.4.dist-info}/METADATA

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

{spacr-0.4.2.dist-info → spacr-0.4.4.dist-info}/RECORD

@@ -9,13 +9,13 @@ 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=KymF-YPvODMkp4J3xva7NwAKBLAUK_Z5x8_pjl9oaP4,49448
+spacr/core.py,sha256=KYPG28Z-AX1nzZ2Fd6F5RrBU_canp_vyEzZINLYpElw,50496
 spacr/deep_spacr.py,sha256=WN64EaQqF87JZg3Uan46t5Y28xsAGD2KMjr2ht6CyDs,54563
 spacr/gui.py,sha256=ARyn9Q_g8HoP-cXh1nzMLVFCKqthY4v2u9yORyaQqQE,8230
-spacr/gui_core.py,sha256=BZpIdNztQn9U2BZxRsmYhr2uhVAm7ZW8-nZxu38QUvs,59027
+spacr/gui_core.py,sha256=qMHQPY7LZEKQ5c7dIQtRyVBy03xNmwYWO8S85btVeEw,60170
 spacr/gui_elements.py,sha256=Or38I_X9-lJRsyIAtbEfZPXzls0IORagf7vEe6IlI5Y,152647
 spacr/gui_utils.py,sha256=dWVPFwDj793Z3ERG4mMC0hI0MKkOrvXJpUYlcjpCBsU,41357
-spacr/io.py,sha256=bOfKwTqo5Z4YtS2E9PB5JVOvn1NkUJKeYxg8nDdGdGE,151762
+spacr/io.py,sha256=bkpBQiLsd69w4GpvrY2NNbZbqHfuRCrbjELlkXBIok8,148414
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
 spacr/measure.py,sha256=Z3u4BU5RzcY82IZuboQ0OsxuXaPVwOlH65Rw6FrL5z4,55045
 spacr/mediar.py,sha256=FwLvbLQW5LQzPgvJZG8Lw7GniA2vbZx6Jv6vIKu7I5c,14743
@@ -23,14 +23,14 @@ 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=72bhOwr0U83uoWwaKtSNZucYhpgwTP1_GItRk9f6A6c,87592
+spacr/settings.py,sha256=mEei8vZXMtUXVRliLGHEXbNWqgrFXA6AX3Tv6s4RmUY,89796
 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=jFlJeVNuIEf63TtCOpTlOZ4iiSLr238kRBiGAAAgKE4,67626
 spacr/timelapse.py,sha256=KGfG4L4-QnFfgbF7L6C5wL_3gd_rqr05Foje6RsoTBg,39603
 spacr/toxo.py,sha256=TmuhejSIPLBvsgeblsUgSvBFCR1gOkApyTKidooJ5Us,26044
-spacr/utils.py,sha256=v13vzgEQwUnQAtQya_akKIkem26-0Nn5j9uhx_NcJXQ,228599
+spacr/utils.py,sha256=jjNCA3O7nF-Y_2c2OsAkAm5WdyD1SZ6eqV7PI3WcLdo,228617
 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.2.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.4.2.dist-info/METADATA,sha256=1yh08ENDvMjQGyCKwh6BX5j78vwd9JyE8JlBzpkYg7o,6095
-spacr-0.4.2.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-spacr-0.4.2.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.4.2.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.4.2.dist-info/RECORD,,
+spacr-0.4.4.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.4.4.dist-info/METADATA,sha256=EhQ8CvDWMbq7bJ18Pt_cAcz2uiRz1X7PH5gzwZdw5gw,6095
+spacr-0.4.4.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+spacr-0.4.4.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.4.4.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.4.4.dist-info/RECORD,,