spacr 0.0.17__py3-none-any.whl → 0.0.20__py3-none-any.whl

spacr/old_code.py

@@ -51,7 +51,7 @@ def resize_figure_to_canvas(fig, canvas):
         
     return fig
     
-    def process_fig_queue_v1():
+def process_fig_queue_v1():
     global canvas
     while not fig_queue.empty():
         try:
@@ -102,3 +102,189 @@ def run_mask_gui(q):
         preprocess_generate_masks_wrapper(settings['src'], settings=settings, advanced_settings={})
     except Exception as e:
         q.put(f"Error during processing: {e}\n")
+
+@log_function_call   
+def main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label):
+    try:
+        while not q.empty():
+            message = q.get_nowait()
+            if message.startswith("Progress"):
+                progress_label.config(text=message)
+            elif message.startswith("Processing"):
+                progress_label.config(text=message)
+            elif message == "" or message == "\r":
+                pass
+            elif message.startswith("/"):
+                pass
+            elif message.startswith("\\"):
+                pass
+            elif message.startswith(""):
+                pass
+            else:
+                print(message)
+    except Exception as e:
+        print(f"Error updating GUI canvas: {e}")
+    #try:    
+    #    while not fig_queue.empty():
+    #        fig = fig_queue.get_nowait()
+    #        #if hasattr(canvas_widget, 'figure'):
+    #        #clear_canvas(canvas_widget)
+    #        canvas_widget.figure = fig
+    #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))
+        
+    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

spacr/plot.py

@@ -220,10 +220,11 @@ def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mas
         if not filter_min_max is None:
             min_max = filter_min_max[i]
         else:
-            min_max = [0, 100000]
+            min_max = [0, 100000000]
 
         mask = np.take(stack, mask_dim, axis=2)
         props = measure.regionprops_table(mask, properties=['label', 'area'])
+        #props = measure.regionprops_table(mask, intensity_image=intensity_image, properties=['label', 'area', 'mean_intensity'])
         avg_size_before = np.mean(props['area'])
         total_count_before = len(props['label'])
 
@@ -264,7 +265,55 @@ def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mas
 
     return stack
 
-def _normalize_and_outline(image, remove_background, backgrounds, normalize, normalization_percentiles, overlay, overlay_chans, mask_dims, outline_colors, outline_thickness):
+def plot_arrays(src, figuresize=50, cmap='inferno', nr=1, normalize=True, q1=1, q2=99):
+    """
+    Plot randomly selected arrays from a given directory.
+
+    Parameters:
+    - src (str): The directory path containing the arrays.
+    - figuresize (int): The size of the figure (default: 50).
+    - cmap (str): The colormap to use for displaying the arrays (default: 'inferno').
+    - nr (int): The number of arrays to plot (default: 1).
+    - normalize (bool): Whether to normalize the arrays (default: True).
+    - q1 (int): The lower percentile for normalization (default: 1).
+    - q2 (int): The upper percentile for normalization (default: 99).
+
+    Returns:
+    None
+    """
+    from .utils import normalize_to_dtype
+    
+    mask_cmap = random_cmap()
+    paths = []
+    for file in os.listdir(src):
+        if file.endswith('.npy'):
+            path = os.path.join(src, file)
+            paths.append(path)
+    paths = random.sample(paths, nr)
+    for path in paths:
+        print(f'Image path:{path}')
+        img = np.load(path)
+        if normalize:
+            img = normalize_to_dtype(array=img, q1=q1, q2=q2)
+        dim = img.shape
+        if len(img.shape)>2:
+            array_nr = img.shape[2]
+            fig, axs = plt.subplots(1, array_nr,figsize=(figuresize,figuresize))
+            for channel in range(array_nr):
+                i = np.take(img, [channel], axis=2)
+                axs[channel].imshow(i, cmap=plt.get_cmap(cmap)) #_imshow
+                axs[channel].set_title('Channel '+str(channel),size=24)
+                axs[channel].axis('off')
+        else:
+            fig, ax = plt.subplots(1, 1,figsize=(figuresize,figuresize))
+            ax.imshow(img, cmap=plt.get_cmap(cmap)) #_imshow
+            ax.set_title('Channel 0',size=24)
+            ax.axis('off')
+        fig.tight_layout()
+        plt.show()
+    return
+
+def _normalize_and_outline(image, remove_background, normalize, normalization_percentiles, overlay, overlay_chans, mask_dims, outline_colors, outline_thickness):
     """
     Normalize and outline an image.
 
@@ -283,43 +332,34 @@ def _normalize_and_outline(image, remove_background, backgrounds, normalize, nor
     Returns:
         tuple: A tuple containing the overlayed image, the original image, and a list of outlines.
     """
-    from .utils import normalize_to_dtype
-    
-    outlines = []
+    from .utils import normalize_to_dtype, _outline_and_overlay, _gen_rgb_image
+
     if remove_background:
-        for chan_index, channel in enumerate(range(image.shape[-1])):
-            single_channel = image[:, :, channel]  # Extract the specific channel
-            background = backgrounds[chan_index]
-            single_channel[single_channel < background] = 0
-            image[:, :, channel] = single_channel
+        backgrounds = np.percentile(image, 1, axis=(0, 1))
+        backgrounds = backgrounds[:, np.newaxis, np.newaxis]
+        mask = np.zeros_like(image, dtype=bool)
+        for chan_index in range(image.shape[-1]):
+            if chan_index not in mask_dims:
+                mask[:, :, chan_index] = image[:, :, chan_index] < backgrounds[chan_index]
+        image[mask] = 0
+
     if normalize:
         image = normalize_to_dtype(array=image, q1=normalization_percentiles[0], q2=normalization_percentiles[1])
-    rgb_image = np.take(image, overlay_chans, axis=-1)
-    rgb_image = rgb_image.astype(float)
-    rgb_image -= rgb_image.min()
-    rgb_image /= rgb_image.max()
+
+    rgb_image = _gen_rgb_image(image, cahnnels=overlay_chans)
+
     if overlay:
-        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)]
+        overlayed_image, outlines, image = _outline_and_overlay(image, rgb_image, mask_dims, outline_colors, outline_thickness)
+
         return overlayed_image, image, outlines
     else:
+        # Remove mask_dims from image
+        channels_to_keep = [i for i in range(image.shape[-1]) if i not in mask_dims]
+        image = np.take(image, channels_to_keep, axis=-1)
         return [], image, []
 
 def _plot_merged_plot(overlay, image, stack, mask_dims, figuresize, overlayed_image, outlines, cmap, outline_colors, print_object_number):
+    
     """
     Plot the merged plot with overlay, image channels, and masks.
 
@@ -338,6 +378,7 @@ def _plot_merged_plot(overlay, image, stack, mask_dims, figuresize, overlayed_im
     Returns:
         fig (Figure): The generated matplotlib figure.
     """
+    
     if overlay:
         fig, ax = plt.subplots(1, image.shape[-1] + len(mask_dims) + 1, figsize=(4 * figuresize, figuresize))
         ax[0].imshow(overlayed_image) #_imshow
@@ -378,60 +419,12 @@ def _plot_merged_plot(overlay, image, stack, mask_dims, figuresize, overlayed_im
     plt.show()
     return fig
 
-def plot_arrays(src, figuresize=50, cmap='inferno', nr=1, normalize=True, q1=1, q2=99):
-    """
-    Plot randomly selected arrays from a given directory.
-
-    Parameters:
-    - src (str): The directory path containing the arrays.
-    - figuresize (int): The size of the figure (default: 50).
-    - cmap (str): The colormap to use for displaying the arrays (default: 'inferno').
-    - nr (int): The number of arrays to plot (default: 1).
-    - normalize (bool): Whether to normalize the arrays (default: True).
-    - q1 (int): The lower percentile for normalization (default: 1).
-    - q2 (int): The upper percentile for normalization (default: 99).
-
-    Returns:
-    None
-    """
-    from .utils import normalize_to_dtype
-    
-    mask_cmap = random_cmap()
-    paths = []
-    for file in os.listdir(src):
-        if file.endswith('.npy'):
-            path = os.path.join(src, file)
-            paths.append(path)
-    paths = random.sample(paths, nr)
-    for path in paths:
-        print(f'Image path:{path}')
-        img = np.load(path)
-        if normalize:
-            img = normalize_to_dtype(array=img, q1=q1, q2=q2)
-        dim = img.shape
-        if len(img.shape)>2:
-            array_nr = img.shape[2]
-            fig, axs = plt.subplots(1, array_nr,figsize=(figuresize,figuresize))
-            for channel in range(array_nr):
-                i = np.take(img, [channel], axis=2)
-                axs[channel].imshow(i, cmap=plt.get_cmap(cmap)) #_imshow
-                axs[channel].set_title('Channel '+str(channel),size=24)
-                axs[channel].axis('off')
-        else:
-            fig, ax = plt.subplots(1, 1,figsize=(figuresize,figuresize))
-            ax.imshow(img, cmap=plt.get_cmap(cmap)) #_imshow
-            ax.set_title('Channel 0',size=24)
-            ax.axis('off')
-        fig.tight_layout()
-        plt.show()
-    return
-
 def plot_merged(src, settings):
     """
     Plot the merged images after applying various filters and modifications.
 
     Args:
-        src (ndarray): The source images.
+        src (path): Path to folder with images.
         settings (dict): The settings for the plot.
 
     Returns:
@@ -463,15 +456,27 @@ def plot_merged(src, settings):
         if settings['include_multiinfected'] is not True or settings['include_multinucleated'] is not True or settings['filter_min_max'] is not None:
             stack = _filter_objects_in_plot(stack, settings['cell_mask_dim'], settings['nucleus_mask_dim'], settings['pathogen_mask_dim'], mask_dims, settings['filter_min_max'], settings['include_multinucleated'], settings['include_multiinfected'])
 
-        #channels_to_keep = np.ones(stack.shape[-1], dtype=bool)
-        #channels_to_keep[mask_dims] = False
-        #channel_image = stack[:, :, channels_to_keep]
-        
-        overlayed_image, image, outlines = _normalize_and_outline(stack, settings['remove_background'], settings['backgrounds'], settings['normalize'], settings['normalization_percentiles'], settings['overlay'], settings['overlay_chans'], mask_dims, outline_colors, settings['outline_thickness'])
-        
+        overlayed_image, image, outlines = _normalize_and_outline(image=stack, 
+                                                                  remove_background=settings['remove_background'],
+                                                                  normalize=settings['normalize'],
+                                                                  normalization_percentiles=settings['normalization_percentiles'],
+                                                                  overlay=settings['overlay'],
+                                                                  overlay_chans=settings['overlay_chans'],
+                                                                  mask_dims=mask_dims,
+                                                                  outline_colors=outline_colors,
+                                                                  outline_thickness=settings['outline_thickness'])
         if index < settings['nr']:
             index += 1
-            fig = _plot_merged_plot(settings['overlay'], image, stack, mask_dims, settings['figuresize'], overlayed_image, outlines, settings['cmap'], outline_colors, settings['print_object_number'])
+            fig = _plot_merged_plot(overlay=settings['overlay'],
+                                    image=image,
+                                    stack=stack,
+                                    mask_dims=mask_dims,
+                                    figuresize=settings['figuresize'],
+                                    overlayed_image=overlayed_image,
+                                    outlines=outlines,
+                                    cmap=settings['cmap'],
+                                    outline_colors=outline_colors,
+                                    print_object_number=settings['print_object_number'])
         else:
             return fig
 
@@ -702,7 +707,7 @@ def _visualize_and_save_timelapse_stack_with_tracks(masks, tracks_df, save, src,
         interactive (bool, optional): Flag indicating whether to display the timelapse stack interactively. Defaults to False.
     """
     
-    from .timelapse import _save_mask_timelapse_as_gif
+    from .io import _save_mask_timelapse_as_gif
     
     highest_label = max(np.max(mask) for mask in masks)
     # Generate random colors for each label, including the background