spacr 0.0.18__py3-none-any.whl → 0.0.21__py3-none-any.whl

spacr/measure.py

@@ -12,6 +12,8 @@ from scipy.ndimage import binary_dilation
 from skimage.segmentation import find_boundaries
 from skimage.feature import graycomatrix, graycoprops
 from mahotas.features import zernike_moments
+from skimage import morphology, measure, filters
+from skimage.util import img_as_bool
 
 from .logger import log_function_call
 
@@ -92,6 +94,70 @@ def _calculate_zernike(mask, df, degree=8):
     else:
         return df
 
+def _analyze_cytoskeleton(array, mask, channel):
+    """
+    Analyzes and extracts skeleton properties from labeled objects in a masked image based on microtubule staining intensities.
+
+    Parameters:
+    image : numpy array
+        Intensity image where the microtubules are stained.
+    mask : numpy array
+        Mask where objects are labeled for analysis. Each label corresponds to a unique object.
+
+    Returns:
+    DataFrame
+        A pandas DataFrame containing the measured properties of each object's skeleton.
+    """
+
+    image = array[:, :, channel]
+
+    properties_list = []
+
+    # Process each object in the mask based on its label
+    for label in np.unique(mask):
+        if label == 0:
+            continue  # Skip background
+
+        # Isolate the object using the label
+        object_region = mask == label
+        region_intensity = np.where(object_region, image, 0)  # Use np.where for more efficient masking
+
+        # Ensure there are non-zero values to process
+        if np.any(region_intensity):
+            # Calculate adaptive offset based on intensity percentiles within the object
+            valid_pixels = region_intensity[region_intensity > 0]
+            if len(valid_pixels) > 1:  # Ensure there are enough pixels to compute percentiles
+                offset = np.percentile(valid_pixels, 90) - np.percentile(valid_pixels, 50)
+                block_size = 35  # Adjust this based on your object sizes and detail needs
+                local_thresh = filters.threshold_local(region_intensity, block_size=block_size, offset=offset)
+                cytoskeleton = region_intensity > local_thresh
+
+                # Skeletonize the thresholded cytoskeleton
+                skeleton = morphology.skeletonize(img_as_bool(cytoskeleton))
+
+                # Measure properties of the skeleton
+                skeleton_props = measure.regionprops(measure.label(skeleton), intensity_image=image)
+                skeleton_length = sum(prop.area for prop in skeleton_props)  # Sum of lengths of all skeleton segments
+                branch_data = morphology.skeleton_branch_analysis(skeleton)
+
+                # Store properties
+                properties = {
+                    "object_label": label,
+                    "skeleton_length": skeleton_length,
+                    "skeleton_branch_points": len(branch_data['branch_points'])
+                }
+                properties_list.append(properties)
+            else:
+                # Handle cases with insufficient pixels
+                properties_list.append({
+                    "object_label": label,
+                    "skeleton_length": 0,
+                    "skeleton_branch_points": 0
+                })
+
+    return pd.DataFrame(properties_list)
+
+@log_function_call
 def _morphological_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, settings, zernike=True, degree=8):
     """
     Calculate morphological measurements for cells, nucleus, pathogens, and cytoplasms based on the given masks.
@@ -435,6 +501,7 @@ def _estimate_blur(image):
     # Compute and return the variance of the Laplacian
     return lap.var()
 
+@log_function_call
 def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, channel_arrays, settings, sizes=[3, 6, 12, 24], periphery=True, outside=True):
     """
     Calculate various intensity measurements for different regions in the image.
@@ -524,6 +591,7 @@ def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_ma
 
 @log_function_call
 def _measure_crop_core(index, time_ls, file, settings):
+
     """
     Measure and crop the images based on specified settings.
 
@@ -622,9 +690,8 @@ def _measure_crop_core(index, time_ls, file, settings):
         if settings['cytoplasm_min_size'] is not None and settings['cytoplasm_min_size'] != 0:
             cytoplasm_mask = _filter_object(cytoplasm_mask, settings['cytoplasm_min_size'])
 
-        if settings['cell_mask_dim'] is not None and settings['pathogen_mask_dim'] is not None:
-            if settings['include_uninfected'] == False:
-                cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask = _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, include_uninfected=False)
+        if settings['cell_mask_dim'] is not None:
+            cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask = _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, include_uninfected=settings['include_uninfected'])
 
         # Update data with the new masks
         if settings['cell_mask_dim'] is not None:
@@ -643,6 +710,10 @@ def _measure_crop_core(index, time_ls, file, settings):
 
             cell_df, nucleus_df, pathogen_df, cytoplasm_df = _morphological_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, settings)
 
+            #if settings['skeleton']:
+                #skeleton_df = _analyze_cytoskeleton(image=channel_arrays, mask=cell_mask, channel=1)
+                #merge skeleton_df with cell_df here
+
             cell_intensity_df, nucleus_intensity_df, pathogen_intensity_df, cytoplasm_intensity_df = _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, channel_arrays, settings, sizes=[1, 2, 3, 4, 5], periphery=True, outside=True)
             if settings['cell_mask_dim'] is not None:
                 cell_merged_df = _merge_and_save_to_database(cell_df, cell_intensity_df, 'cell', source_folder, file_name, settings['experiment'], settings['timelapse'])
@@ -656,7 +727,6 @@ def _measure_crop_core(index, time_ls, file, settings):
             if settings['cytoplasm']:
                 cytoplasm_merged_df = _merge_and_save_to_database(cytoplasm_df, cytoplasm_intensity_df, 'cytoplasm', source_folder, file_name, settings['experiment'], settings['timelapse'])
 
-        
         if settings['save_png'] or settings['save_arrays'] or settings['plot']:
 
             if isinstance(settings['dialate_pngs'], bool):
@@ -676,7 +746,6 @@ def _measure_crop_core(index, time_ls, file, settings):
                 crop_ls = settings['crop_mode']
                 size_ls = settings['png_size']
                 for crop_idx, crop_mode in enumerate(crop_ls):
-                    print(crop_idx, crop_mode)
                     width, height = size_ls[crop_idx]
                     if crop_mode == 'cell':
                         crop_mask = cell_mask.copy()
@@ -730,7 +799,7 @@ def _measure_crop_core(index, time_ls, file, settings):
                             png_channels = data[:, :, settings['png_dims']].astype(data_type)
 
                             if settings['normalize_by'] == 'fov':
-                                percentiles_list = _get_percentiles(png_channels, settings['normalize_percentiles'][0],q2=settings['normalize_percentiles'][1])
+                                percentiles_list = _get_percentiles(png_channels, settings['normalize'][0],q2=settings['normalize'][1])
 
                             png_channels = _crop_center(png_channels, region, new_width=width, new_height=height)
 
@@ -787,6 +856,7 @@ def _measure_crop_core(index, time_ls, file, settings):
                                     conn.commit()
                                 except sqlite3.OperationalError as e:
                                     print(f"SQLite error: {e}", flush=True)
+                                    traceback.print_exc()
 
                             if settings['plot']:
                                 _plot_cropped_arrays(png_channels)
@@ -818,37 +888,31 @@ def _measure_crop_core(index, time_ls, file, settings):
     return average_time, cells
 
 @log_function_call
-def measure_crop(settings, annotation_settings, advanced_settings):
+def measure_crop(settings):
+    
     """
     Measure the crop of an image based on the provided settings.
 
     Args:
         settings (dict): The settings for measuring the crop.
-        annotation_settings (dict): The annotation settings.
-        advanced_settings (dict): The advanced settings.
 
     Returns:
         None
     """
+
+    if settings.get('test_mode', False):
+        if not os.basename(settings['src']) == 'test':
+            src = os.path.join(src, 'test')
+            settings['src'] = src
+            print(f'Changed source folder to {src} for test mode')
+        else:
+            print(f'Test mode enabled, using source folder {settings["src"]}')
     
     from .io import _save_settings_to_db
     from .timelapse import _timelapse_masks_to_gif, _scmovie
     from .plot import _save_scimg_plot
     from .utils import _list_endpoint_subdirectories, _generate_representative_images
     
-    settings = {**settings, **annotation_settings, **advanced_settings}
-    
-    dirname = os.path.dirname(settings['input_folder'])
-    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)
-
-    if settings['timelapse_objects'] == 'nucleus':
-        if not settings['cell_mask_dim'] is None:
-            tlo = settings['timelapse_objects']
-            print(f'timelapse object:{tlo}, cells will be relabeled to nucleus labels to track cells.')
-
     #general settings
     settings['merge_edge_pathogen_cells'] = True
     settings['radial_dist'] = True
@@ -857,6 +921,26 @@ def measure_crop(settings, annotation_settings, advanced_settings):
     settings['homogeneity'] = True
     settings['homogeneity_distances'] = [8,16,32]
     settings['save_arrays'] = False
+
+    settings['dialate_pngs'] = False
+    settings['dialate_png_ratios'] = [0.2]
+    settings['timelapse'] = False
+    settings['representative_images'] = False
+    settings['timelapse_objects'] = 'cell'
+    settings['max_workers'] = os.cpu_count()-2
+    settings['experiment'] = 'test'
+    settings['cells'] = 'HeLa'
+    settings['cell_loc'] = None
+    settings['pathogens'] = ['ME49Dku80WT', 'ME49Dku80dgra8:GRA8', 'ME49Dku80dgra8', 'ME49Dku80TKO']
+    settings['pathogen_loc'] = [['c1', 'c2', 'c3', 'c4', 'c5', 'c6'], ['c7', 'c8', 'c9', 'c10', 'c11', 'c12'], ['c13', 'c14', 'c15', 'c16', 'c17', 'c18'], ['c19', 'c20', 'c21', 'c22', 'c23', 'c24']]
+    settings['treatments'] = ['BR1', 'BR2', 'BR3']
+    settings['treatment_loc'] = [['c1', 'c2', 'c7', 'c8', 'c13', 'c14', 'c19', 'c20'], ['c3', 'c4', 'c9', 'c10', 'c15', 'c16', 'c21', 'c22'], ['c5', 'c6', 'c11', 'c12', 'c17', 'c18', 'c23', 'c24']]
+    settings['channel_of_interest'] = 2
+    settings['compartments'] = ['pathogen', 'cytoplasm']
+    settings['measurement'] = 'mean_intensity'
+    settings['nr_imgs'] = 32
+    settings['um_per_pixel'] = 0.1
+    settings['center_crop'] = True
     
     if settings['cell_mask_dim'] is None:
         settings['include_uninfected'] = True
@@ -869,7 +953,18 @@ def measure_crop(settings, annotation_settings, advanced_settings):
     else:
         settings['cytoplasm'] = False
 
-    settings['center_crop'] = True
+    #settings = {**settings, **annotation_settings, **advanced_settings}
+    
+    dirname = os.path.dirname(settings['input_folder'])
+    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)
+
+    if settings['timelapse_objects'] == 'nucleus':
+        if not settings['cell_mask_dim'] is None:
+            tlo = settings['timelapse_objects']
+            print(f'timelapse object:{tlo}, cells will be relabeled to nucleus labels to track cells.')
 
     int_setting_keys = ['cell_mask_dim', 'nucleus_mask_dim', 'pathogen_mask_dim', 'cell_min_size', 'nucleus_min_size', 'pathogen_min_size', 'cytoplasm_min_size']
     
@@ -913,64 +1008,49 @@ def measure_crop(settings, annotation_settings, advanced_settings):
                 time_left = (((files_to_process-files_processed)*average_time)/max_workers)/60
                 print(f'Progress: {files_processed}/{files_to_process} Time/img {average_time:.3f}sec, Time Remaining {time_left:.3f} min.', end='\r', flush=True)
             result.get()
-            
-    #if settings['save_png']:
-    #    img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
-    #    sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
-    #    for well_src in sc_img_fldrs:
-    #        if len(os.listdir(well_src)) < 16:
-    #            nr_imgs = len(os.listdir(well_src))
-    #            standardize = False
-    #        else:
-    #            nr_imgs = 16
-    #            standardize = True
-    #        try:
-    #            _save_scimg_plot(src=well_src, nr_imgs=nr_imgs, channel_indices=settings['png_dims'], um_per_pixel=0.1, scale_bar_length_um=10, standardize=standardize, fontsize=12, show_filename=True, channel_names=['red','green','blue'], dpi=300, plot=False)    
-    #        except Exception as e:  # Consider catching a more specific exception if possible
-    #            print(f"Unable to generate figure for folder {well_src}: {e}", flush=True)
-    
-    if settings['save_png']:
-        img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
-        sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
-
-        for i, well_src in enumerate(sc_img_fldrs):
-            if len(os.listdir(well_src)) < 16:
-                nr_imgs = len(os.listdir(well_src))
-                standardize = False
-            else:
-                nr_imgs = 16
-                standardize = True
-            try:
-                all_folders = len(sc_img_fldrs)
-                _save_scimg_plot(src=well_src, nr_imgs=nr_imgs, channel_indices=settings['png_dims'], um_per_pixel=0.1, scale_bar_length_um=10, standardize=standardize, fontsize=12, show_filename=True, channel_names=['red','green','blue'], dpi=300, plot=False, i=i, all_folders=all_folders)
-
-            except Exception as e:
-                print(f"Unable to generate figure for folder {well_src}: {e}", end='\r', flush=True)
-                #traceback.print_exc()
+
+    if settings['representative_images']:
+        if settings['save_png']:
+            img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
+            sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
+
+            for i, well_src in enumerate(sc_img_fldrs):
+                if len(os.listdir(well_src)) < 16:
+                    nr_imgs = len(os.listdir(well_src))
+                    standardize = False
+                else:
+                    nr_imgs = 16
+                    standardize = True
+                try:
+                    all_folders = len(sc_img_fldrs)
+                    _save_scimg_plot(src=well_src, nr_imgs=nr_imgs, channel_indices=settings['png_dims'], um_per_pixel=0.1, scale_bar_length_um=10, standardize=standardize, fontsize=12, show_filename=True, channel_names=['red','green','blue'], dpi=300, plot=False, i=i, all_folders=all_folders)
+
+                except Exception as e:
+                    print(f"Unable to generate figure for folder {well_src}: {e}", end='\r', flush=True)
+                    #traceback.print_exc()
     
         if settings['save_measurements']:
-            if settings['representative_images']:
-                db_path = os.path.join(os.path.dirname(settings['input_folder']), 'measurements', 'measurements.db')
-                channel_indices = settings['png_dims']
-                channel_indices = [min(value, 2) for value in channel_indices]
-                _generate_representative_images(db_path,
-                                            cells=settings['cells'],
-                                            cell_loc=settings['cell_loc'],
-                                            pathogens=settings['pathogens'],
-                                            pathogen_loc=settings['pathogen_loc'],
-                                            treatments=settings['treatments'],
-                                            treatment_loc=settings['treatment_loc'],
-                                            channel_of_interest=settings['channel_of_interest'],
-                                            compartments = settings['compartments'],
-                                            measurement = settings['measurement'],
-                                            nr_imgs=settings['nr_imgs'],
-                                            channel_indices=channel_indices,
-                                            um_per_pixel=settings['um_per_pixel'],
-                                            scale_bar_length_um=10,
-                                            plot=False,
-                                            fontsize=12,
-                                            show_filename=True,
-                                            channel_names=None)
+            db_path = os.path.join(os.path.dirname(settings['input_folder']), 'measurements', 'measurements.db')
+            channel_indices = settings['png_dims']
+            channel_indices = [min(value, 2) for value in channel_indices]
+            _generate_representative_images(db_path,
+                                        cells=settings['cells'],
+                                        cell_loc=settings['cell_loc'],
+                                        pathogens=settings['pathogens'],
+                                        pathogen_loc=settings['pathogen_loc'],
+                                        treatments=settings['treatments'],
+                                        treatment_loc=settings['treatment_loc'],
+                                        channel_of_interest=settings['channel_of_interest'],
+                                        compartments = settings['compartments'],
+                                        measurement = settings['measurement'],
+                                        nr_imgs=settings['nr_imgs'],
+                                        channel_indices=channel_indices,
+                                        um_per_pixel=settings['um_per_pixel'],
+                                        scale_bar_length_um=10,
+                                        plot=False,
+                                        fontsize=12,
+                                        show_filename=True,
+                                        channel_names=None)
 
     if settings['timelapse']:
         if settings['timelapse_objects'] == 'nucleus':
@@ -979,7 +1059,7 @@ def measure_crop(settings, annotation_settings, advanced_settings):
             object_types = ['nucleus','pathogen','cell']
             _timelapse_masks_to_gif(folder_path, mask_channels, object_types)
 
-        if settings['save_png']:
+        #if settings['save_png']:
             img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
             sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
             _scmovie(sc_img_fldrs)

spacr/old_code.py

@@ -133,4 +133,158 @@ def main_thread_update_function(root, q, fig_queue, canvas_widget, progress_labe
     #except Exception as e:
     #    print(f"Error updating GUI figure: {e}")
     finally:
-        root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label))
+        root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label))
+        
+    class MPNN(MessagePassing):
+    def __init__(self, node_in_features, edge_in_features, out_features):
+        super(MPNN, self).__init__(aggr='mean')  # 'mean' aggregation.
+        self.message_mlp = Sequential(
+            Linear(node_in_features + edge_in_features, 128),
+            ReLU(),
+            Linear(128, out_features)
+        )
+        self.update_mlp = Sequential(
+            Linear(out_features, out_features),
+            ReLU(),
+            Linear(out_features, out_features)
+        )
+
+    def forward(self, x, edge_index, edge_attr):
+        # x: Node features [N, node_in_features]
+        # edge_index: Graph connectivity [2, E]
+        # edge_attr: Edge attributes/features [E, edge_in_features]
+        return self.propagate(edge_index, x=x, edge_attr=edge_attr)
+
+    def message(self, x_j, edge_attr):
+        # x_j: Input features of neighbors [E, node_in_features]
+        # edge_attr: Edge attributes [E, edge_in_features]
+        tmp = torch.cat([x_j, edge_attr], dim=-1)  # Concatenate node features with edge attributes
+        return self.message_mlp(tmp)
+
+    def update(self, aggr_out):
+        # aggr_out: Aggregated messages [N, out_features]
+        return self.update_mlp(aggr_out)
+    
+def weighted_mse_loss(output, target, score_threshold=0.8, high_score_weight=10):
+    # Assumes output and target are the predicted and true scores, respectively
+    weights = torch.ones_like(target)
+    high_score_mask = target >= score_threshold
+    weights[high_score_mask] = high_score_weight
+    return ((output - target) ** 2 * weights).mean()
+
+def generate_single_graph(sequencing, scores):
+    # Load and preprocess sequencing data
+    gene_df = pd.read_csv(sequencing)
+    gene_df = gene_df.rename(columns={"prc": "well_id", "grna": "gene_id", "count": "read_count"})
+    total_reads_per_well = gene_df.groupby('well_id')['read_count'].sum().reset_index(name='total_reads')
+    gene_df = gene_df.merge(total_reads_per_well, on='well_id')
+    gene_df['well_read_fraction'] = gene_df['read_count']/gene_df['total_reads']
+
+    # Load and preprocess cell score data
+    cell_df = pd.read_csv(scores)
+    cell_df = cell_df[['prcfo', 'prc', 'pred']].rename(columns={'prcfo': 'cell_id', 'prc': 'well_id', 'pred': 'score'})
+
+    # Initialize mappings
+    gene_id_to_index = {gene: i for i, gene in enumerate(gene_df['gene_id'].unique())}
+    cell_id_to_index = {cell: i + len(gene_id_to_index) for i, cell in enumerate(cell_df['cell_id'].unique())}
+
+    # Initialize edge indices and attributes
+    edge_index = []
+    edge_attr = []
+
+    # Associate each cell with all genes in the same well
+    for well_id, group in gene_df.groupby('well_id'):
+        if well_id in cell_df['well_id'].values:
+            cell_indices = cell_df[cell_df['well_id'] == well_id]['cell_id'].map(cell_id_to_index).values
+            gene_indices = group['gene_id'].map(gene_id_to_index).values
+            fractions = group['well_read_fraction'].values
+            
+            for cell_idx in cell_indices:
+                for gene_idx, fraction in zip(gene_indices, fractions):
+                    edge_index.append([cell_idx, gene_idx])
+                    edge_attr.append([fraction])
+
+    # Convert lists to PyTorch tensors
+    edge_index = torch.tensor(edge_index, dtype=torch.long).t().contiguous()
+    edge_attr = torch.tensor(edge_attr, dtype=torch.float)
+    cell_scores = torch.tensor(cell_df['score'].values, dtype=torch.float)
+
+    # One-hot encoding for genes, and zero features for cells (could be replaced with real features if available)
+    gene_features = torch.eye(len(gene_id_to_index))
+    cell_features = torch.zeros(len(cell_id_to_index), gene_features.size(1))
+
+    # Combine features
+    x = torch.cat([cell_features, gene_features], dim=0)
+
+    # Create the graph data object
+    data = Data(x=x, edge_index=edge_index, edge_attr=edge_attr, y=cell_scores)
+
+    return data, gene_id_to_index, len(gene_id_to_index)
+
+# in _normalize_and_outline
+    outlines = []
+    
+        overlayed_image = rgb_image.copy()
+        for i, mask_dim in enumerate(mask_dims):
+            mask = np.take(image, mask_dim, axis=2)
+            outline = np.zeros_like(mask)
+            # Find the contours of the objects in the mask
+            for j in np.unique(mask)[1:]:
+                contours = find_contours(mask == j, 0.5)
+                for contour in contours:
+                    contour = contour.astype(int)
+                    outline[contour[:, 0], contour[:, 1]] = j
+            # Make the outline thicker
+            outline = dilation(outline, square(outline_thickness))
+            outlines.append(outline)
+            # Overlay the outlines onto the RGB image
+            for j in np.unique(outline)[1:]:
+                overlayed_image[outline == j] = outline_colors[i % len(outline_colors)]
+
+def _extract_filename_metadata(filenames, src, images_by_key, regular_expression, metadata_type='cellvoyager', pick_slice=False, skip_mode='01'):
+    for filename in filenames:
+        match = regular_expression.match(filename)
+        if match:
+            try:
+                try:
+                    plate = match.group('plateID')
+                except:
+                    plate = os.path.basename(src)
+
+                well = match.group('wellID')
+                field = match.group('fieldID')
+                channel = match.group('chanID')
+                mode = None
+
+                if well[0].isdigit():
+                    well = str(_safe_int_convert(well))
+                if field[0].isdigit():
+                    field = str(_safe_int_convert(field))
+                if channel[0].isdigit():
+                    channel = str(_safe_int_convert(channel))
+
+                if metadata_type =='cq1':
+                    orig_wellID = wellID
+                    wellID = _convert_cq1_well_id(wellID)
+                    clear_output(wait=True)
+                    print(f'Converted Well ID: {orig_wellID} to {wellID}', end='\r', flush=True)
+
+                if pick_slice:
+                    try:
+                        mode = match.group('AID')
+                    except IndexError:
+                        sliceid = '00'
+
+                    if mode == skip_mode:
+                        continue      
+                        
+                key = (plate, well, field, channel, mode)
+                with Image.open(os.path.join(src, filename)) as img:
+                    images_by_key[key].append(np.array(img))
+            except IndexError:
+                print(f"Could not extract information from filename {filename} using provided regex")
+        else:
+            print(f"Filename {filename} did not match provided regex")
+            continue
+        
+    return images_by_key