risk-network 0.0.8b15__tar.gz → 0.0.8b17__tar.gz

{risk_network-0.0.8b15 → risk_network-0.0.8b17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.8b15
+Version: 0.0.8b17
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>

{risk_network-0.0.8b15 → risk_network-0.0.8b17}/risk/__init__.py

@@ -7,4 +7,4 @@ RISK: RISK Infers Spatial Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.8-beta.15"
+__version__ = "0.0.8-beta.17"

risk_network-0.0.8b17/risk/network/graph.py

@@ -0,0 +1,159 @@
+"""
+risk/network/graph
+~~~~~~~~~~~~~~~~~~
+"""
+
+from collections import defaultdict
+from typing import Any, Dict, List
+
+import networkx as nx
+import numpy as np
+import pandas as pd
+
+
+class NetworkGraph:
+    """A class to represent a network graph and process its nodes and edges.
+
+    The NetworkGraph class provides functionality to handle and manipulate a network graph,
+    including managing domains, annotations, and node enrichment data. It also includes methods
+    for transforming and mapping graph coordinates, as well as generating colors based on node
+    enrichment.
+    """
+
+    def __init__(
+        self,
+        network: nx.Graph,
+        top_annotations: pd.DataFrame,
+        domains: pd.DataFrame,
+        trimmed_domains: pd.DataFrame,
+        node_label_to_node_id_map: Dict[str, Any],
+        node_enrichment_sums: np.ndarray,
+    ):
+        """Initialize the NetworkGraph object.
+
+        Args:
+            network (nx.Graph): The network graph.
+            top_annotations (pd.DataFrame): DataFrame containing annotations data for the network nodes.
+            domains (pd.DataFrame): DataFrame containing domain data for the network nodes.
+            trimmed_domains (pd.DataFrame): DataFrame containing trimmed domain data for the network nodes.
+            node_label_to_node_id_map (dict): A dictionary mapping node labels to their corresponding IDs.
+            node_enrichment_sums (np.ndarray): Array containing the enrichment sums for the nodes.
+        """
+        self.top_annotations = top_annotations
+        self.domain_id_to_node_ids_map = self._create_domain_id_to_node_ids_map(domains)
+        self.domains = domains
+        self.domain_id_to_domain_terms_map = self._create_domain_id_to_domain_terms_map(
+            trimmed_domains
+        )
+        self.node_enrichment_sums = node_enrichment_sums
+        self.node_id_to_node_label_map = {v: k for k, v in node_label_to_node_id_map.items()}
+        self.node_label_to_enrichment_map = dict(
+            zip(node_label_to_node_id_map.keys(), node_enrichment_sums)
+        )
+        self.node_label_to_node_id_map = node_label_to_node_id_map
+        # NOTE: Below this point, instance attributes (i.e., self) will be used!
+        self.domain_id_to_node_labels_map = self._create_domain_id_to_node_labels_map()
+        # Unfold the network's 3D coordinates to 2D and extract node coordinates
+        self.network = _unfold_sphere_to_plane(network)
+        self.node_coordinates = _extract_node_coordinates(self.network)
+
+    def _create_domain_id_to_node_ids_map(self, domains: pd.DataFrame) -> Dict[str, Any]:
+        """Create a mapping from domains to the list of node IDs belonging to each domain.
+
+        Args:
+            domains (pd.DataFrame): DataFrame containing domain information, including the 'primary domain' for each node.
+
+        Returns:
+            dict: A dictionary where keys are domain IDs and values are lists of node IDs belonging to each domain.
+        """
+        cleaned_domains_matrix = domains.reset_index()[["index", "primary domain"]]
+        node_to_domains_map = cleaned_domains_matrix.set_index("index")["primary domain"].to_dict()
+        domain_id_to_node_ids_map = defaultdict(list)
+        for k, v in node_to_domains_map.items():
+            domain_id_to_node_ids_map[v].append(k)
+
+        return domain_id_to_node_ids_map
+
+    def _create_domain_id_to_domain_terms_map(
+        self, trimmed_domains: pd.DataFrame
+    ) -> Dict[str, Any]:
+        """Create a mapping from domain IDs to their corresponding terms.
+
+        Args:
+            trimmed_domains (pd.DataFrame): DataFrame containing domain IDs and their corresponding labels.
+
+        Returns:
+            dict: A dictionary mapping domain IDs to their corresponding terms.
+        """
+        return dict(
+            zip(
+                trimmed_domains.index,
+                trimmed_domains["label"],
+            )
+        )
+
+    def _create_domain_id_to_node_labels_map(self) -> Dict[int, List[str]]:
+        """Create a map from domain IDs to node labels.
+
+        Returns:
+            dict: A dictionary mapping domain IDs to the corresponding node labels.
+        """
+        domain_id_to_label_map = {}
+        for domain_id, node_ids in self.domain_id_to_node_ids_map.items():
+            domain_id_to_label_map[domain_id] = [
+                self.node_id_to_node_label_map[node_id] for node_id in node_ids
+            ]
+
+        return domain_id_to_label_map
+
+
+def _unfold_sphere_to_plane(G: nx.Graph) -> nx.Graph:
+    """Convert 3D coordinates to 2D by unfolding a sphere to a plane.
+
+    Args:
+        G (nx.Graph): A network graph with 3D coordinates. Each node should have 'x', 'y', and 'z' attributes.
+
+    Returns:
+        nx.Graph: The network graph with updated 2D coordinates (only 'x' and 'y').
+    """
+    for node in G.nodes():
+        if "z" in G.nodes[node]:
+            # Extract 3D coordinates
+            x, y, z = G.nodes[node]["x"], G.nodes[node]["y"], G.nodes[node]["z"]
+            # Calculate spherical coordinates theta and phi from Cartesian coordinates
+            r = np.sqrt(x**2 + y**2 + z**2)
+            theta = np.arctan2(y, x)
+            phi = np.arccos(z / r)
+
+            # Convert spherical coordinates to 2D plane coordinates
+            unfolded_x = (theta + np.pi) / (2 * np.pi)  # Shift and normalize theta to [0, 1]
+            unfolded_x = unfolded_x + 0.5 if unfolded_x < 0.5 else unfolded_x - 0.5
+            unfolded_y = (np.pi - phi) / np.pi  # Reflect phi and normalize to [0, 1]
+            # Update network node attributes
+            G.nodes[node]["x"] = unfolded_x
+            G.nodes[node]["y"] = -unfolded_y
+            # Remove the 'z' coordinate as it's no longer needed
+            del G.nodes[node]["z"]
+
+    return G
+
+
+def _extract_node_coordinates(G: nx.Graph) -> np.ndarray:
+    """Extract 2D coordinates of nodes from the graph.
+
+    Args:
+        G (nx.Graph): The network graph with node coordinates.
+
+    Returns:
+        np.ndarray: Array of node coordinates with shape (num_nodes, 2).
+    """
+    # Extract x and y coordinates from graph nodes
+    x_coords = dict(G.nodes.data("x"))
+    y_coords = dict(G.nodes.data("y"))
+    coordinates_dicts = [x_coords, y_coords]
+    # Combine x and y coordinates into a single array
+    node_positions = {
+        node: np.array([coords[node] for coords in coordinates_dicts]) for node in x_coords
+    }
+    node_coordinates = np.vstack(list(node_positions.values()))
+    return node_coordinates

{risk_network-0.0.8b15 → risk_network-0.0.8b17}/risk/network/plot/canvas.py

@@ -10,7 +10,8 @@ import numpy as np
 
 from risk.log import params
 from risk.network.graph import NetworkGraph
-from risk.network.plot.utils import calculate_bounding_box, to_rgba
+from risk.network.plot.utils.color import to_rgba
+from risk.network.plot.utils.layout import calculate_bounding_box
 
 
 class Canvas:
@@ -33,8 +34,8 @@ class Canvas:
         title_fontsize: int = 20,
         subtitle_fontsize: int = 14,
         font: str = "Arial",
-        title_color: str = "black",
-        subtitle_color: str = "gray",
+        title_color: Union[str, list, tuple, np.ndarray] = "black",
+        subtitle_color: Union[str, list, tuple, np.ndarray] = "gray",
         title_y: float = 0.975,
         title_space_offset: float = 0.075,
         subtitle_offset: float = 0.025,
@@ -47,8 +48,10 @@ class Canvas:
             title_fontsize (int, optional): Font size for the title. Defaults to 20.
             subtitle_fontsize (int, optional): Font size for the subtitle. Defaults to 14.
             font (str, optional): Font family used for both title and subtitle. Defaults to "Arial".
-            title_color (str, optional): Color of the title text. Defaults to "black".
-            subtitle_color (str, optional): Color of the subtitle text. Defaults to "gray".
+            title_color (str, list, tuple, or np.ndarray, optional): Color of the title text. Can be a string or an array of colors.
+                Defaults to "black".
+            subtitle_color (str, list, tuple, or np.ndarray, optional): Color of the subtitle text. Can be a string or an array of colors.
+                Defaults to "gray".
             title_y (float, optional): Y-axis position of the title. Defaults to 0.975.
             title_space_offset (float, optional): Fraction of figure height to leave for the space above the plot. Defaults to 0.075.
             subtitle_offset (float, optional): Offset factor to position the subtitle below the title. Defaults to 0.025.
@@ -141,7 +144,9 @@ class Canvas:
         )
 
         # Convert color to RGBA using the to_rgba helper function - use outline_alpha for the perimeter
-        color = to_rgba(color=color, alpha=outline_alpha)
+        color = to_rgba(
+            color=color, alpha=outline_alpha, num_repeats=1
+        )  # num_repeats=1 for a single color
         # Set the fill_alpha to 0 if not provided
         fill_alpha = fill_alpha if fill_alpha is not None else 0.0
         # Extract node coordinates from the network graph
@@ -162,7 +167,9 @@ class Canvas:
         )
         # Set the transparency of the fill if applicable
         if fill_alpha > 0:
-            circle.set_facecolor(to_rgba(color=color, alpha=fill_alpha))
+            circle.set_facecolor(
+                to_rgba(color=color, alpha=fill_alpha, num_repeats=1)
+            )  # num_repeats=1 for a single color
 
         self.ax.add_artist(circle)
 
@@ -209,7 +216,7 @@ class Canvas:
         )
 
         # Convert color to RGBA using outline_alpha for the line (outline)
-        outline_color = to_rgba(color=color)
+        outline_color = to_rgba(color=color, num_repeats=1)  # num_repeats=1 for a single color
         # Extract node coordinates from the network graph
         node_coordinates = self.graph.node_coordinates
         # Scale the node coordinates if needed

{risk_network-0.0.8b15 → risk_network-0.0.8b17}/risk/network/plot/contour.py

@@ -13,7 +13,7 @@ from scipy.stats import gaussian_kde
 
 from risk.log import params, logger
 from risk.network.graph import NetworkGraph
-from risk.network.plot.utils import get_annotated_domain_colors, to_rgba
+from risk.network.plot.utils.color import get_annotated_domain_colors, to_rgba
 
 
 class Contour:
@@ -110,7 +110,7 @@ class Contour:
             bandwidth (float, optional): Bandwidth for KDE. Controls the smoothness of the contour. Defaults to 0.8.
             grid_size (int, optional): Resolution of the grid for KDE. Higher values create finer contours. Defaults to 250.
             color (str, list, tuple, or np.ndarray, optional): Color of the contour. Can be a string (e.g., 'white') or RGBA array.
-                Defaults to "white".
+                Can be a single color or an array of colors. Defaults to "white".
             linestyle (str, optional): Line style for the contour. Defaults to "solid".
             linewidth (float, optional): Line width for the contour. Defaults to 1.5.
             alpha (float, None, optional): Transparency level of the contour lines. If provided, it overrides any existing alpha values
@@ -125,15 +125,16 @@ class Contour:
         if any(isinstance(item, (list, tuple, np.ndarray)) for item in nodes):
             # If it's a list of lists, iterate over sublists
             node_groups = nodes
+            # Convert color to RGBA arrays to match the number of groups
+            color_rgba = to_rgba(color=color, alpha=alpha, num_repeats=len(node_groups))
         else:
             # If it's a flat list of nodes, treat it as a single group
             node_groups = [nodes]
-
-        # Convert color to RGBA using the to_rgba helper function
-        color_rgba = to_rgba(color=color, alpha=alpha)
+            # Wrap the RGBA color in an array to index the first element
+            color_rgba = to_rgba(color=color, alpha=alpha, num_repeats=1)
 
         # Iterate over each group of nodes (either sublists or flat list)
-        for sublist in node_groups:
+        for idx, sublist in enumerate(node_groups):
             # Filter to get node IDs and their coordinates for each sublist
             node_ids = [
                 self.graph.node_label_to_node_id_map.get(node)
@@ -151,7 +152,7 @@ class Contour:
                 self.ax,
                 node_coordinates,
                 node_ids,
-                color=color_rgba,
+                color=color_rgba[idx],
                 levels=levels,
                 bandwidth=bandwidth,
                 grid_size=grid_size,
@@ -273,7 +274,7 @@ class Contour:
     def get_annotated_contour_colors(
         self,
         cmap: str = "gist_rainbow",
-        color: Union[str, None] = None,
+        color: Union[str, list, tuple, np.ndarray, None] = None,
         min_scale: float = 0.8,
         max_scale: float = 1.0,
         scale_factor: float = 1.0,
@@ -283,7 +284,8 @@ class Contour:
 
         Args:
             cmap (str, optional): Name of the colormap to use for generating contour colors. Defaults to "gist_rainbow".
-            color (str or None, optional): Color to use for the contours. If None, the colormap will be used. Defaults to None.
+            color (str, list, tuple, np.ndarray, or None, optional): Color to use for the contours. Can be a single color or an array of colors.
+                If None, the colormap will be used. Defaults to None.
             min_scale (float, optional): Minimum intensity scale for the colors generated by the colormap.
                 Controls the dimmest colors. Defaults to 0.8.
             max_scale (float, optional): Maximum intensity scale for the colors generated by the colormap.

{risk_network-0.0.8b15 → risk_network-0.0.8b17}/risk/network/plot/labels.py

@@ -11,7 +11,8 @@ import pandas as pd
 
 from risk.log import params
 from risk.network.graph import NetworkGraph
-from risk.network.plot.utils import calculate_bounding_box, get_annotated_domain_colors, to_rgba
+from risk.network.plot.utils.color import get_annotated_domain_colors, to_rgba
+from risk.network.plot.utils.layout import calculate_bounding_box
 
 TERM_DELIMITER = "::::"  # String used to separate multiple domain terms when constructing composite domain labels
 
@@ -284,13 +285,19 @@ class Labels:
         if any(isinstance(item, (list, tuple, np.ndarray)) for item in nodes):
             # If it's a list of lists, iterate over sublists
             node_groups = nodes
+            # Convert fontcolor and arrow_color to RGBA arrays to match the number of groups
+            fontcolor_rgba = to_rgba(color=fontcolor, alpha=fontalpha, num_repeats=len(node_groups))
+            arrow_color_rgba = to_rgba(
+                color=arrow_color, alpha=arrow_alpha, num_repeats=len(node_groups)
+            )
         else:
             # If it's a flat list of nodes, treat it as a single group
             node_groups = [nodes]
-
-        # Convert fontcolor and arrow_color to RGBA
-        fontcolor_rgba = to_rgba(color=fontcolor, alpha=fontalpha)
-        arrow_color_rgba = to_rgba(color=arrow_color, alpha=arrow_alpha)
+            # Wrap the RGBA fontcolor and arrow_color in an array to index the first element
+            fontcolor_rgba = np.array(to_rgba(color=fontcolor, alpha=fontalpha, num_repeats=1))
+            arrow_color_rgba = np.array(
+                to_rgba(color=arrow_color, alpha=arrow_alpha, num_repeats=1)
+            )
 
         # Calculate the bounding box around the network
         center, radius = calculate_bounding_box(self.graph.node_coordinates, radius_margin=scale)
@@ -302,7 +309,7 @@ class Labels:
         )
 
         # Iterate over each group of nodes (either sublists or flat list)
-        for sublist in node_groups:
+        for idx, sublist in enumerate(node_groups):
             # Map node labels to IDs
             node_ids = [
                 self.graph.node_label_to_node_id_map.get(node)
@@ -326,10 +333,10 @@ class Labels:
                 va="center",
                 fontsize=fontsize,
                 fontname=font,
-                color=fontcolor_rgba,
+                color=fontcolor_rgba[idx],
                 arrowprops=dict(
                     arrowstyle=arrow_style,
-                    color=arrow_color_rgba,
+                    color=arrow_color_rgba[idx],
                     linewidth=arrow_linewidth,
                     shrinkA=arrow_base_shrink,
                     shrinkB=arrow_tip_shrink,
@@ -630,7 +637,7 @@ class Labels:
     def get_annotated_label_colors(
         self,
         cmap: str = "gist_rainbow",
-        color: Union[str, None] = None,
+        color: Union[str, list, tuple, np.ndarray, None] = None,
         min_scale: float = 0.8,
         max_scale: float = 1.0,
         scale_factor: float = 1.0,
@@ -640,7 +647,8 @@ class Labels:
 
         Args:
             cmap (str, optional): Name of the colormap to use for generating label colors. Defaults to "gist_rainbow".
-            color (str or None, optional): Color to use for the labels. If None, the colormap will be used. Defaults to None.
+            color (str, list, tuple, np.ndarray, or None, optional): Color to use for the labels. Can be a single color or an array
+                of colors. If None, the colormap will be used. Defaults to None.
             min_scale (float, optional): Minimum intensity scale for the colors generated by the colormap.
                 Controls the dimmest colors. Defaults to 0.8.
             max_scale (float, optional): Maximum intensity scale for the colors generated by the colormap.

{risk_network-0.0.8b15 → risk_network-0.0.8b17}/risk/network/plot/network.py

@@ -10,7 +10,7 @@ import numpy as np
 
 from risk.log import params
 from risk.network.graph import NetworkGraph
-from risk.network.plot.utils import to_rgba
+from risk.network.plot.utils.color import get_domain_colors, to_rgba
 
 
 class Network:
@@ -47,8 +47,10 @@ class Network:
             edge_width (float, optional): Width of the edges. Defaults to 1.0.
             node_color (str, list, tuple, or np.ndarray, optional): Color of the nodes. Can be a single color or an array of colors.
                 Defaults to "white".
-            node_edgecolor (str, list, tuple, or np.ndarray, optional): Color of the node edges. Defaults to "black".
-            edge_color (str, list, tuple, or np.ndarray, optional): Color of the edges. Defaults to "black".
+            node_edgecolor (str, list, tuple, or np.ndarray, optional): Color of the node edges. Can be a single color or an array of colors.
+                Defaults to "black".
+            edge_color (str, list, tuple, or np.ndarray, optional): Color of the edges. Can be a single color or an array of colors.
+                Defaults to "black".
             node_alpha (float, None, optional): Alpha value (transparency) for the nodes. If provided, it overrides any existing alpha
                 values found in node_color. Defaults to 1.0. Annotated node_color alphas will override this value.
             edge_alpha (float, None, optional): Alpha value (transparency) for the edges. If provided, it overrides any existing alpha
@@ -194,12 +196,12 @@ class Network:
     def get_annotated_node_colors(
         self,
         cmap: str = "gist_rainbow",
-        color: Union[str, None] = None,
+        color: Union[str, list, tuple, np.ndarray, None] = None,
         min_scale: float = 0.8,
         max_scale: float = 1.0,
         scale_factor: float = 1.0,
         alpha: Union[float, None] = 1.0,
-        nonenriched_color: Union[str, List, Tuple, np.ndarray] = "white",
+        nonenriched_color: Union[str, list, tuple, np.ndarray] = "white",
         nonenriched_alpha: Union[float, None] = 1.0,
         random_seed: int = 888,
     ) -> np.ndarray:
@@ -207,22 +209,25 @@ class Network:
 
         Args:
             cmap (str, optional): Colormap to use for coloring the nodes. Defaults to "gist_rainbow".
-            color (str or None, optional): Color to use for the nodes. If None, the colormap will be used. Defaults to None.
+            color (str, list, tuple, np.ndarray, or None, optional): Color to use for the nodes. Can be a single color or an array of colors.
+                If None, the colormap will be used. Defaults to None.
             min_scale (float, optional): Minimum scale for color intensity. Defaults to 0.8.
             max_scale (float, optional): Maximum scale for color intensity. Defaults to 1.0.
             scale_factor (float, optional): Factor for adjusting the color scaling intensity. Defaults to 1.0.
-            alpha (float, None, optional): Alpha value for enriched nodes. If provided, it overrides any existing alpha values
-                found in color. Defaults to 1.0.
-            nonenriched_color (str, list, tuple, or np.ndarray, optional): Color for non-enriched nodes. Defaults to "white".
-            nonenriched_alpha (float, None, optional): Alpha value for non-enriched nodes. If provided, it overrides any existing
-                alpha values found in nonenriched_color. Defaults to 1.0.
+            alpha (float, None, optional): Alpha value for enriched nodes. If provided, it overrides any existing alpha values found in `color`.
+                Defaults to 1.0.
+            nonenriched_color (str, list, tuple, or np.ndarray, optional): Color for non-enriched nodes. Can be a single color or an array of colors.
+                Defaults to "white".
+            nonenriched_alpha (float, None, optional): Alpha value for non-enriched nodes. If provided, it overrides any existing alpha values found
+                in `nonenriched_color`. Defaults to 1.0.
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
         Returns:
             np.ndarray: Array of RGBA colors adjusted for enrichment status.
         """
         # Get the initial domain colors for each node, which are returned as RGBA
-        network_colors = self.graph.get_domain_colors(
+        network_colors = get_domain_colors(
+            graph=self.graph,
             cmap=cmap,
             color=color,
             min_scale=min_scale,
@@ -233,7 +238,9 @@ class Network:
         # Apply the alpha value for enriched nodes
         network_colors[:, 3] = alpha  # Apply the alpha value to the enriched nodes' A channel
         # Convert the non-enriched color to RGBA using the to_rgba helper function
-        nonenriched_color = to_rgba(color=nonenriched_color, alpha=nonenriched_alpha)
+        nonenriched_color = to_rgba(
+            color=nonenriched_color, alpha=nonenriched_alpha, num_repeats=1
+        )  # num_repeats=1 for a single color
         # Adjust node colors: replace any nodes where all three RGB values are equal and less than 0.1
         # 0.1 is a predefined threshold for the minimum color intensity
         adjusted_network_colors = np.where(

{risk_network-0.0.8b15 → risk_network-0.0.8b17}/risk/network/plot/plotter.py

@@ -14,7 +14,8 @@ from risk.network.plot.canvas import Canvas
 from risk.network.plot.contour import Contour
 from risk.network.plot.labels import Labels
 from risk.network.plot.network import Network
-from risk.network.plot.utils import calculate_bounding_box, to_rgba
+from risk.network.plot.utils.color import to_rgba
+from risk.network.plot.utils.layout import calculate_bounding_box
 
 
 class NetworkPlotter(Canvas, Network, Contour, Labels):
@@ -58,7 +59,7 @@ class NetworkPlotter(Canvas, Network, Contour, Labels):
         self,
         graph: NetworkGraph,
         figsize: Tuple,
-        background_color: Union[str, List, Tuple, np.ndarray],
+        background_color: Union[str, list, tuple, np.ndarray],
         background_alpha: Union[float, None],
         pad: float,
     ) -> plt.Axes:
@@ -67,9 +68,9 @@ class NetworkPlotter(Canvas, Network, Contour, Labels):
         Args:
             graph (NetworkGraph): The network data and attributes to be visualized.
             figsize (tuple): Size of the figure in inches (width, height).
-            background_color (str): Background color of the plot.
-            background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides any
-            existing alpha values found in background_color.
+            background_color (str, list, tuple, or np.ndarray): Background color of the plot. Can be a single color or an array of colors.
+            background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides any existing
+                alpha values found in `background_color`.
             pad (float, optional): Padding value to adjust the axis limits.
 
         Returns:
@@ -98,7 +99,9 @@ class NetworkPlotter(Canvas, Network, Contour, Labels):
 
         # Set the background color of the plot
         # Convert color to RGBA using the to_rgba helper function
-        fig.patch.set_facecolor(to_rgba(color=background_color, alpha=background_alpha))
+        fig.patch.set_facecolor(
+            to_rgba(color=background_color, alpha=background_alpha, num_repeats=1)
+        )  # num_repeats=1 for single color
         ax.invert_yaxis()  # Invert the y-axis to match typical image coordinates
         # Remove axis spines for a cleaner look
         for spine in ax.spines.values():