risk-network 0.0.8b15__py3-none-any.whl → 0.0.8b17__py3-none-any.whl

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/graph.py

@@ -4,12 +4,11 @@ risk/network/graph
 """
 
 from collections import defaultdict
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any, Dict, List
 
 import networkx as nx
 import numpy as np
 import pandas as pd
-import matplotlib
 
 
 class NetworkGraph:
@@ -107,139 +106,6 @@ class NetworkGraph:
 
         return domain_id_to_label_map
 
-    def get_domain_colors(
-        self,
-        cmap: str = "gist_rainbow",
-        color: Union[str, None] = None,
-        min_scale: float = 0.8,
-        max_scale: float = 1.0,
-        scale_factor: float = 1.0,
-        random_seed: int = 888,
-    ) -> np.ndarray:
-        """Generate composite colors for domains based on enrichment or specified colors.
-
-        Args:
-            cmap (str, optional): Name of the colormap to use for generating domain colors. Defaults to "gist_rainbow".
-            color (str or None, optional): A specific color to use for all generated colors. 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.
-                Controls the brightest colors. Defaults to 1.0.
-            scale_factor (float, optional): Exponent for adjusting the color scaling based on enrichment scores.
-                A higher value increases contrast by dimming lower scores more. Defaults to 1.0.
-            random_seed (int, optional): Seed for random number generation to ensure reproducibility of color assignments.
-                Defaults to 888.
-
-        Returns:
-            np.ndarray: Array of RGBA colors generated for each domain, based on enrichment or the specified color.
-        """
-        # Get colors for each domain
-        domain_colors = self._get_domain_colors(cmap=cmap, color=color, random_seed=random_seed)
-        # Generate composite colors for nodes
-        node_colors = self._get_composite_node_colors(domain_colors)
-        # Transform colors to ensure proper alpha values and intensity
-        transformed_colors = _transform_colors(
-            node_colors,
-            self.node_enrichment_sums,
-            min_scale=min_scale,
-            max_scale=max_scale,
-            scale_factor=scale_factor,
-        )
-
-        return transformed_colors
-
-    def _get_domain_colors(
-        self,
-        cmap: str = "gist_rainbow",
-        color: Union[str, None] = None,
-        random_seed: int = 888,
-    ) -> Dict[str, Any]:
-        """Get colors for each domain.
-
-        Args:
-            cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
-            color (str or None, optional): A specific color to use for all generated colors. Defaults to None.
-            random_seed (int, optional): Seed for random number generation. Defaults to 888.
-
-        Returns:
-            dict: A dictionary mapping domain keys to their corresponding RGBA colors.
-        """
-        # Get colors for each domain based on node positions
-        domain_colors = _get_colors(
-            self.network,
-            self.domain_id_to_node_ids_map,
-            cmap=cmap,
-            color=color,
-            random_seed=random_seed,
-        )
-        return dict(zip(self.domain_id_to_node_ids_map.keys(), domain_colors))
-
-    def _get_composite_node_colors(self, domain_colors: np.ndarray) -> np.ndarray:
-        """Generate composite colors for nodes based on domain colors and counts.
-
-        Args:
-            domain_colors (np.ndarray): Array of colors corresponding to each domain.
-
-        Returns:
-            np.ndarray: Array of composite colors for each node.
-        """
-        # Determine the number of nodes
-        num_nodes = len(self.node_coordinates)
-        # Initialize composite colors array with shape (number of nodes, 4) for RGBA
-        composite_colors = np.zeros((num_nodes, 4))
-        # Assign colors to nodes based on domain_colors
-        for domain_id, nodes in self.domain_id_to_node_ids_map.items():
-            color = domain_colors[domain_id]
-            for node in nodes:
-                composite_colors[node] = color
-
-        return composite_colors
-
-
-def _transform_colors(
-    colors: np.ndarray,
-    enrichment_sums: np.ndarray,
-    min_scale: float = 0.8,
-    max_scale: float = 1.0,
-    scale_factor: float = 1.0,
-) -> np.ndarray:
-    """Transform colors using power scaling to emphasize high enrichment sums more. Black colors are replaced with
-    very dark grey to avoid issues with color scaling (rgb(0.1, 0.1, 0.1)).
-
-    Args:
-        colors (np.ndarray): An array of RGBA colors.
-        enrichment_sums (np.ndarray): An array of enrichment sums corresponding to the colors.
-        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): Exponent for scaling, where values > 1 increase contrast by dimming small
-            values more. Defaults to 1.0.
-
-    Returns:
-        np.ndarray: The transformed array of RGBA colors with adjusted intensities.
-    """
-    # Ensure that min_scale is less than max_scale
-    if min_scale == max_scale:
-        min_scale = max_scale - 10e-6  # Avoid division by zero
-
-    # Replace black colors (#000000) with very dark grey (#1A1A1A)
-    black_color = np.array([0.0, 0.0, 0.0])  # Pure black RGB
-    dark_grey = np.array([0.1, 0.1, 0.1])  # Very dark grey RGB (#1A1A1A)
-    # Check where colors are black (very close to [0, 0, 0]) and replace with dark grey
-    is_black = np.all(colors[:, :3] == black_color, axis=1)
-    colors[is_black, :3] = dark_grey
-
-    # Normalize the enrichment sums to the range [0, 1]
-    normalized_sums = enrichment_sums / np.max(enrichment_sums)
-    # Apply power scaling to dim lower values and emphasize higher values
-    scaled_sums = normalized_sums**scale_factor
-    # Linearly scale the normalized sums to the range [min_scale, max_scale]
-    scaled_sums = min_scale + (max_scale - min_scale) * scaled_sums
-    # Adjust RGB values based on scaled sums
-    for i in range(3):  # Only adjust RGB values
-        colors[:, i] = scaled_sums * colors[:, i]
-
-    return colors
-
 
 def _unfold_sphere_to_plane(G: nx.Graph) -> nx.Graph:
     """Convert 3D coordinates to 2D by unfolding a sphere to a plane.
@@ -291,103 +157,3 @@ def _extract_node_coordinates(G: nx.Graph) -> np.ndarray:
     }
     node_coordinates = np.vstack(list(node_positions.values()))
     return node_coordinates
-
-
-def _get_colors(
-    network,
-    domain_id_to_node_ids_map,
-    cmap: str = "gist_rainbow",
-    color: Union[str, None] = None,
-    random_seed: int = 888,
-) -> List[Tuple]:
-    """Generate a list of RGBA colors based on domain centroids, ensuring that domains
-    close in space get maximally separated colors, while keeping some randomness.
-
-    Args:
-        network (NetworkX graph): The graph representing the network.
-        domain_id_to_node_ids_map (dict): Mapping from domain IDs to lists of node IDs.
-        cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
-        color (str or None, optional): A specific color to use for all generated colors.
-        random_seed (int): Seed for random number generation. Defaults to 888.
-
-    Returns:
-        List[Tuple]: List of RGBA colors.
-    """
-    # Set random seed for reproducibility
-    np.random.seed(random_seed)
-    # Determine the number of colors to generate based on the number of domains
-    num_colors_to_generate = len(domain_id_to_node_ids_map)
-    if color:
-        # Generate all colors as the same specified color
-        rgba = matplotlib.colors.to_rgba(color)
-        return [rgba] * num_colors_to_generate
-
-    # Load colormap
-    colormap = matplotlib.colormaps.get_cmap(cmap)
-    # Step 1: Calculate centroids for each domain
-    centroids = _calculate_centroids(network, domain_id_to_node_ids_map)
-    # Step 2: Calculate pairwise distances between centroids
-    centroid_array = np.array(centroids)
-    dist_matrix = np.linalg.norm(centroid_array[:, None] - centroid_array, axis=-1)
-    # Step 3: Assign distant colors to close centroids
-    color_positions = _assign_distant_colors(dist_matrix, num_colors_to_generate)
-    # Step 4: Randomly shift the entire color palette while maintaining relative distances
-    global_shift = np.random.uniform(-0.1, 0.1)  # Small global shift to change the overall palette
-    color_positions = (color_positions + global_shift) % 1  # Wrap around to keep within [0, 1]
-    # Step 5: Ensure that all positions remain between 0 and 1
-    color_positions = np.clip(color_positions, 0, 1)
-
-    # Step 6: Generate RGBA colors based on positions
-    return [colormap(pos) for pos in color_positions]
-
-
-def _calculate_centroids(network, domain_id_to_node_ids_map):
-    """Calculate the centroid for each domain based on node x and y coordinates in the network.
-
-    Args:
-        network (NetworkX graph): The graph representing the network.
-        domain_id_to_node_ids_map (dict): Mapping from domain IDs to lists of node IDs.
-
-    Returns:
-        List[Tuple[float, float]]: List of centroids (x, y) for each domain.
-    """
-    centroids = []
-    for domain_id, node_ids in domain_id_to_node_ids_map.items():
-        # Extract x and y coordinates from the network nodes
-        node_positions = np.array(
-            [[network.nodes[node_id]["x"], network.nodes[node_id]["y"]] for node_id in node_ids]
-        )
-        # Compute the centroid as the mean of the x and y coordinates
-        centroid = np.mean(node_positions, axis=0)
-        centroids.append(tuple(centroid))
-
-    return centroids
-
-
-def _assign_distant_colors(dist_matrix, num_colors_to_generate):
-    """Assign colors to centroids that are close in space, ensuring stark color differences.
-
-    Args:
-        dist_matrix (ndarray): Matrix of pairwise centroid distances.
-        num_colors_to_generate (int): Number of colors to generate.
-
-    Returns:
-        np.array: Array of color positions in the range [0, 1].
-    """
-    color_positions = np.zeros(num_colors_to_generate)
-    # Step 1: Sort indices by centroid proximity (based on sum of distances to others)
-    proximity_order = sorted(
-        range(num_colors_to_generate), key=lambda idx: np.sum(dist_matrix[idx])
-    )
-    # Step 2: Assign colors starting with the most distant points in proximity order
-    for i, idx in enumerate(proximity_order):
-        color_positions[idx] = i / num_colors_to_generate
-
-    # Step 3: Adjust colors so that centroids close to one another are maximally distant on the color spectrum
-    half_spectrum = int(num_colors_to_generate / 2)
-    for i in range(half_spectrum):
-        # Split the spectrum so that close centroids are assigned distant colors
-        color_positions[proximity_order[i]] = (i * 2) / num_colors_to_generate
-        color_positions[proximity_order[-(i + 1)]] = ((i * 2) + 1) / num_colors_to_generate
-
-    return color_positions

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/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/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/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/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():

risk/network/plot/utils/color.py

@@ -0,0 +1,353 @@
+"""
+risk/network/plot/utils/plot
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from typing import Any, Dict, List, Tuple, Union
+
+import matplotlib
+import matplotlib.colors as mcolors
+import numpy as np
+
+from risk.network.graph import NetworkGraph
+from risk.network.plot.utils.layout import calculate_centroids
+
+
+def get_annotated_domain_colors(
+    graph: NetworkGraph,
+    cmap: str = "gist_rainbow",
+    color: Union[str, list, tuple, np.ndarray, None] = None,
+    min_scale: float = 0.8,
+    max_scale: float = 1.0,
+    scale_factor: float = 1.0,
+    random_seed: int = 888,
+) -> np.ndarray:
+    """Get colors for the domains based on node annotations, or use a specified color.
+
+    Args:
+        graph (NetworkGraph): The network data and attributes to be visualized.
+        cmap (str, optional): Colormap to use for generating domain colors. Defaults to "gist_rainbow".
+        color (str, list, tuple, np.ndarray, or None, optional): Color to use for the domains. 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 when generating domain colors. Defaults to 0.8.
+        max_scale (float, optional): Maximum scale for color intensity when generating domain colors. Defaults to 1.0.
+        scale_factor (float, optional): Factor for adjusting the contrast in the colors generated based on enrichment. Higher values
+            increase the contrast. Defaults to 1.0.
+        random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
+
+    Returns:
+        np.ndarray: Array of RGBA colors for each domain.
+    """
+    # Generate domain colors based on the enrichment data
+    node_colors = get_domain_colors(
+        graph=graph,
+        cmap=cmap,
+        color=color,
+        min_scale=min_scale,
+        max_scale=max_scale,
+        scale_factor=scale_factor,
+        random_seed=random_seed,
+    )
+    annotated_colors = []
+    for _, node_ids in graph.domain_id_to_node_ids_map.items():
+        if len(node_ids) > 1:
+            # For multi-node domains, choose the brightest color based on RGB sum
+            domain_colors = np.array([node_colors[node] for node in node_ids])
+            brightest_color = domain_colors[
+                np.argmax(domain_colors[:, :3].sum(axis=1))  # Sum the RGB values
+            ]
+            annotated_colors.append(brightest_color)
+        else:
+            # Single-node domains default to white (RGBA)
+            default_color = np.array([1.0, 1.0, 1.0, 1.0])
+            annotated_colors.append(default_color)
+
+    return np.array(annotated_colors)
+
+
+def get_domain_colors(
+    graph: NetworkGraph,
+    cmap: str = "gist_rainbow",
+    color: Union[str, list, tuple, np.ndarray, None] = None,
+    min_scale: float = 0.8,
+    max_scale: float = 1.0,
+    scale_factor: float = 1.0,
+    random_seed: int = 888,
+) -> np.ndarray:
+    """Generate composite colors for domains based on enrichment or specified colors.
+
+    Args:
+        graph (NetworkGraph): The network data and attributes to be visualized.
+        cmap (str, optional): Name of the colormap to use for generating domain colors. Defaults to "gist_rainbow".
+        color (str, list, tuple, np.ndarray, or None, optional): A specific color or array of colors to use for all domains.
+            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. Controls the brightest colors.
+            Defaults to 1.0.
+        scale_factor (float, optional): Exponent for adjusting the color scaling based on enrichment scores. Higher values increase
+            contrast by dimming lower scores more. Defaults to 1.0.
+        random_seed (int, optional): Seed for random number generation to ensure reproducibility of color assignments. Defaults to 888.
+
+    Returns:
+        np.ndarray: Array of RGBA colors generated for each domain, based on enrichment or the specified color.
+    """
+    # Get colors for each domain
+    domain_colors = _get_domain_colors(graph=graph, cmap=cmap, color=color, random_seed=random_seed)
+    # Generate composite colors for nodes
+    node_colors = _get_composite_node_colors(graph=graph, domain_colors=domain_colors)
+    # Transform colors to ensure proper alpha values and intensity
+    transformed_colors = _transform_colors(
+        node_colors,
+        graph.node_enrichment_sums,
+        min_scale=min_scale,
+        max_scale=max_scale,
+        scale_factor=scale_factor,
+    )
+    return transformed_colors
+
+
+def _get_domain_colors(
+    graph: NetworkGraph,
+    cmap: str = "gist_rainbow",
+    color: Union[str, list, tuple, np.ndarray, None] = None,
+    random_seed: int = 888,
+) -> Dict[str, Any]:
+    """Get colors for each domain.
+
+    Args:
+        graph (NetworkGraph): The network data and attributes to be visualized.
+        cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
+        color (str, list, tuple, np.ndarray, or None, optional): A specific color or array of colors to use for the domains.
+            If None, the colormap will be used. Defaults to None.
+        random_seed (int, optional): Seed for random number generation. Defaults to 888.
+
+    Returns:
+        dict: A dictionary mapping domain keys to their corresponding RGBA colors.
+    """
+    # Get colors for each domain based on node positions
+    domain_colors = _get_colors(
+        graph.network,
+        graph.domain_id_to_node_ids_map,
+        cmap=cmap,
+        color=color,
+        random_seed=random_seed,
+    )
+    return dict(zip(graph.domain_id_to_node_ids_map.keys(), domain_colors))
+
+
+def _get_composite_node_colors(graph: NetworkGraph, domain_colors: np.ndarray) -> np.ndarray:
+    """Generate composite colors for nodes based on domain colors and counts.
+
+    Args:
+        graph (NetworkGraph): The network data and attributes to be visualized.
+        domain_colors (np.ndarray): Array of colors corresponding to each domain.
+
+    Returns:
+        np.ndarray: Array of composite colors for each node.
+    """
+    # Determine the number of nodes
+    num_nodes = len(graph.node_coordinates)
+    # Initialize composite colors array with shape (number of nodes, 4) for RGBA
+    composite_colors = np.zeros((num_nodes, 4))
+    # Assign colors to nodes based on domain_colors
+    for domain_id, nodes in graph.domain_id_to_node_ids_map.items():
+        color = domain_colors[domain_id]
+        for node in nodes:
+            composite_colors[node] = color
+
+    return composite_colors
+
+
+def _get_colors(
+    network,
+    domain_id_to_node_ids_map,
+    cmap: str = "gist_rainbow",
+    color: Union[str, list, tuple, np.ndarray, None] = None,
+    random_seed: int = 888,
+) -> List[Tuple]:
+    """Generate a list of RGBA colors based on domain centroids, ensuring that domains
+    close in space get maximally separated colors, while keeping some randomness.
+
+    Args:
+        network (NetworkX graph): The graph representing the network.
+        domain_id_to_node_ids_map (dict): Mapping from domain IDs to lists of node IDs.
+        cmap (str, optional): The name of the colormap to use. Defaults to "gist_rainbow".
+        color (str, list, tuple, np.ndarray, or None, optional): A specific color or array of colors to use for the domains.
+            If None, the colormap will be used. Defaults to None.
+        random_seed (int, optional): Seed for random number generation. Defaults to 888.
+
+    Returns:
+        List[Tuple]: List of RGBA colors.
+    """
+    # Set random seed for reproducibility
+    np.random.seed(random_seed)
+    # Determine the number of colors to generate based on the number of domains
+    num_colors_to_generate = len(domain_id_to_node_ids_map)
+    if color:
+        # Generate all colors as the same specified color
+        rgba = to_rgba(color, num_repeats=num_colors_to_generate)
+        return rgba
+
+    # Load colormap
+    colormap = matplotlib.colormaps.get_cmap(cmap)
+    # Step 1: Calculate centroids for each domain
+    centroids = calculate_centroids(network, domain_id_to_node_ids_map)
+    # Step 2: Calculate pairwise distances between centroids
+    centroid_array = np.array(centroids)
+    dist_matrix = np.linalg.norm(centroid_array[:, None] - centroid_array, axis=-1)
+    # Step 3: Assign distant colors to close centroids
+    color_positions = _assign_distant_colors(dist_matrix, num_colors_to_generate)
+    # Step 4: Randomly shift the entire color palette while maintaining relative distances
+    global_shift = np.random.uniform(-0.1, 0.1)  # Small global shift to change the overall palette
+    color_positions = (color_positions + global_shift) % 1  # Wrap around to keep within [0, 1]
+    # Step 5: Ensure that all positions remain between 0 and 1
+    color_positions = np.clip(color_positions, 0, 1)
+
+    # Step 6: Generate RGBA colors based on positions
+    return [colormap(pos) for pos in color_positions]
+
+
+def _assign_distant_colors(dist_matrix, num_colors_to_generate):
+    """Assign colors to centroids that are close in space, ensuring stark color differences.
+
+    Args:
+        dist_matrix (ndarray): Matrix of pairwise centroid distances.
+        num_colors_to_generate (int): Number of colors to generate.
+
+    Returns:
+        np.array: Array of color positions in the range [0, 1].
+    """
+    color_positions = np.zeros(num_colors_to_generate)
+    # Step 1: Sort indices by centroid proximity (based on sum of distances to others)
+    proximity_order = sorted(
+        range(num_colors_to_generate), key=lambda idx: np.sum(dist_matrix[idx])
+    )
+    # Step 2: Assign colors starting with the most distant points in proximity order
+    for i, idx in enumerate(proximity_order):
+        color_positions[idx] = i / num_colors_to_generate
+
+    # Step 3: Adjust colors so that centroids close to one another are maximally distant on the color spectrum
+    half_spectrum = int(num_colors_to_generate / 2)
+    for i in range(half_spectrum):
+        # Split the spectrum so that close centroids are assigned distant colors
+        color_positions[proximity_order[i]] = (i * 2) / num_colors_to_generate
+        color_positions[proximity_order[-(i + 1)]] = ((i * 2) + 1) / num_colors_to_generate
+
+    return color_positions
+
+
+def _transform_colors(
+    colors: np.ndarray,
+    enrichment_sums: np.ndarray,
+    min_scale: float = 0.8,
+    max_scale: float = 1.0,
+    scale_factor: float = 1.0,
+) -> np.ndarray:
+    """Transform colors using power scaling to emphasize high enrichment sums more. Black colors are replaced with
+    very dark grey to avoid issues with color scaling (rgb(0.1, 0.1, 0.1)).
+
+    Args:
+        colors (np.ndarray): An array of RGBA colors.
+        enrichment_sums (np.ndarray): An array of enrichment sums corresponding to the colors.
+        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): Exponent for scaling, where values > 1 increase contrast by dimming small
+            values more. Defaults to 1.0.
+
+    Returns:
+        np.ndarray: The transformed array of RGBA colors with adjusted intensities.
+    """
+    # Ensure that min_scale is less than max_scale
+    if min_scale == max_scale:
+        min_scale = max_scale - 10e-6  # Avoid division by zero
+
+    # Replace black colors (#000000) with very dark grey (#1A1A1A)
+    black_color = np.array([0.0, 0.0, 0.0])  # Pure black RGB
+    dark_grey = np.array([0.1, 0.1, 0.1])  # Very dark grey RGB (#1A1A1A)
+    # Check where colors are black (very close to [0, 0, 0]) and replace with dark grey
+    is_black = np.all(colors[:, :3] == black_color, axis=1)
+    colors[is_black, :3] = dark_grey
+
+    # Normalize the enrichment sums to the range [0, 1]
+    normalized_sums = enrichment_sums / np.max(enrichment_sums)
+    # Apply power scaling to dim lower values and emphasize higher values
+    scaled_sums = normalized_sums**scale_factor
+    # Linearly scale the normalized sums to the range [min_scale, max_scale]
+    scaled_sums = min_scale + (max_scale - min_scale) * scaled_sums
+    # Adjust RGB values based on scaled sums
+    for i in range(3):  # Only adjust RGB values
+        colors[:, i] = scaled_sums * colors[:, i]
+
+    return colors
+
+
+def to_rgba(
+    color: Union[str, list, tuple, np.ndarray],
+    alpha: Union[float, None] = None,
+    num_repeats: Union[int, None] = None,
+) -> np.ndarray:
+    """Convert color(s) to RGBA format, applying alpha and repeating as needed.
+
+    Args:
+        color (str, list, tuple, np.ndarray): The color(s) to convert. Can be a string (e.g., 'red'), a list or tuple of RGB/RGBA values,
+            or an `np.ndarray` of colors.
+        alpha (float, None, optional): Alpha value (transparency) to apply. If provided, it overrides any existing alpha values found
+            in color.
+        num_repeats (int, None, optional): If provided, the color(s) will be repeated this many times. Defaults to None.
+
+    Returns:
+        np.ndarray: Array of RGBA colors repeated `num_repeats` times, if applicable.
+    """
+
+    def convert_to_rgba(c: Union[str, List, Tuple, np.ndarray]) -> np.ndarray:
+        """Convert a single color to RGBA format, handling strings, hex, and RGB/RGBA lists."""
+        # Note: if no alpha is provided, the default alpha value is 1.0 by mcolors.to_rgba
+        if isinstance(c, str):
+            # Convert color names or hex values (e.g., 'red', '#FF5733') to RGBA
+            rgba = np.array(mcolors.to_rgba(c))
+        elif isinstance(c, (list, tuple, np.ndarray)) and len(c) in [3, 4]:
+            # Convert RGB (3) or RGBA (4) values to RGBA format
+            rgba = np.array(mcolors.to_rgba(c))
+        else:
+            raise ValueError(
+                f"Invalid color format: {c}. Must be a valid string or RGB/RGBA sequence."
+            )
+
+        if alpha is not None:  # Override alpha if provided
+            rgba[3] = alpha
+        return rgba
+
+    # If color is a 2D array of RGBA values, convert it to a list of lists
+    if isinstance(color, np.ndarray) and color.ndim == 2 and color.shape[1] == 4:
+        color = [list(c) for c in color]
+
+    # Handle a single color (string or RGB/RGBA list/tuple)
+    if (
+        isinstance(color, str)
+        or isinstance(color, (list, tuple, np.ndarray))
+        and not any(isinstance(c, (str, list, tuple, np.ndarray)) for c in color)
+    ):
+        rgba_color = convert_to_rgba(color)
+        if num_repeats:
+            return np.tile(
+                rgba_color, (num_repeats, 1)
+            )  # Repeat the color if num_repeats is provided
+        return np.array([rgba_color])  # Return a single color wrapped in a numpy array
+
+    # Handle a list/array of colors
+    elif isinstance(color, (list, tuple, np.ndarray)):
+        rgba_colors = np.array(
+            [convert_to_rgba(c) for c in color]
+        )  # Convert each color in the list to RGBA
+        # Handle repetition if num_repeats is provided
+        if num_repeats:
+            repeated_colors = np.array(
+                [rgba_colors[i % len(rgba_colors)] for i in range(num_repeats)]
+            )
+            return repeated_colors
+
+        return rgba_colors
+
+    else:
+        raise ValueError("Color must be a valid RGB/RGBA or array of RGB/RGBA colors.")

risk/network/plot/utils/layout.py

@@ -0,0 +1,53 @@
+"""
+risk/network/plot/utils/layout
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+from typing import Tuple
+
+import numpy as np
+
+
+def calculate_bounding_box(
+    node_coordinates: np.ndarray, radius_margin: float = 1.05
+) -> Tuple[np.ndarray, float]:
+    """Calculate the bounding box of the network based on node coordinates.
+
+    Args:
+        node_coordinates (np.ndarray): Array of node coordinates (x, y).
+        radius_margin (float, optional): Margin factor to apply to the bounding box radius. Defaults to 1.05.
+
+    Returns:
+        tuple: Center of the bounding box and the radius (adjusted by the radius margin).
+    """
+    # Find minimum and maximum x, y coordinates
+    x_min, y_min = np.min(node_coordinates, axis=0)
+    x_max, y_max = np.max(node_coordinates, axis=0)
+    # Calculate the center of the bounding box
+    center = np.array([(x_min + x_max) / 2, (y_min + y_max) / 2])
+    # Calculate the radius of the bounding box, adjusted by the margin
+    radius = max(x_max - x_min, y_max - y_min) / 2 * radius_margin
+    return center, radius
+
+
+def calculate_centroids(network, domain_id_to_node_ids_map):
+    """Calculate the centroid for each domain based on node x and y coordinates in the network.
+
+    Args:
+        network (NetworkX graph): The graph representing the network.
+        domain_id_to_node_ids_map (dict): Mapping from domain IDs to lists of node IDs.
+
+    Returns:
+        List[Tuple[float, float]]: List of centroids (x, y) for each domain.
+    """
+    centroids = []
+    for domain_id, node_ids in domain_id_to_node_ids_map.items():
+        # Extract x and y coordinates from the network nodes
+        node_positions = np.array(
+            [[network.nodes[node_id]["x"], network.nodes[node_id]["y"]] for node_id in node_ids]
+        )
+        # Compute the centroid as the mean of the x and y coordinates
+        centroid = np.mean(node_positions, axis=0)
+        centroids.append(tuple(centroid))
+
+    return centroids

{risk_network-0.0.8b15.dist-info → risk_network-0.0.8b17.dist-info}/METADATA

@@ -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.dist-info → risk_network-0.0.8b17.dist-info}/RECORD

@@ -1,4 +1,4 @@
-risk/__init__.py,sha256=IvvDrNrYMIFlFEmfZ6J1gTBoHqc33MwADdxoLjnyZg4,113
+risk/__init__.py,sha256=pF-sA0CxulV6zIC6axfgeXWkkQGyVZGuoGF_u4RgoQM,113
 risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
 risk/risk.py,sha256=slJXca_a726_D7oXwe765HaKTv3ZrOvhttyrWdCGPkA,21231
 risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
@@ -13,15 +13,16 @@ risk/neighborhoods/domains.py,sha256=D5MUIghbwyKKCAE8PN_HXvsO9NxLTGejQmyEqetD1Bk
 risk/neighborhoods/neighborhoods.py,sha256=M-wL4xB_BUTlSZg90swygO5NdrZ6hFUFqs6jsiZaqHk,18260
 risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
 risk/network/geometry.py,sha256=H1yGVVqgbfpzBzJwEheDLfvGLSA284jGQQTn612L4Vc,6759
-risk/network/graph.py,sha256=WxWh1BZvH9E_kgDb5HrwcQ-30hM8aNHPkBm2l3vzkAw,16973
+risk/network/graph.py,sha256=x5cur1meitkR0YuE5vGxX0s_IFa5wkx8z44f_C1vK7U,6509
 risk/network/io.py,sha256=u0PPcKjp6Xze--7eDOlvalYkjQ9S2sjiC-ac2476PUI,22942
 risk/network/plot/__init__.py,sha256=MfmaXJgAZJgXZ2wrhK8pXwzETlcMaLChhWXKAozniAo,98
-risk/network/plot/canvas.py,sha256=LXHndwanWIBShChoPag8zgGHF2P9MFWYdEnLKc2eeb0,10295
-risk/network/plot/contour.py,sha256=YPG8Uz0VlJ4skLdGaTH_FmQN6A_ArK8XSTNo1LzkSws,14276
-risk/network/plot/labels.py,sha256=MQqM6iJJW91JI_dHzaFRbkrjK0yxJc5WBhTc_ea7Unk,43371
-risk/network/plot/network.py,sha256=t5eMh7mBJOh_Wa19aK8g_1zpL7maiXZAYw-TEFHxAVM,12819
-risk/network/plot/plotter.py,sha256=rQV4Db6Ud86FJm11uaBvgSuzpmGsrZxnsRnUKjg6w84,5572
-risk/network/plot/utils.py,sha256=jZgI8EysSjviQmdYAceZk2MwJXcdeFAkYp-odZNqV0k,6316
+risk/network/plot/canvas.py,sha256=JnjPQaryRb_J6LP36BT2-rlsbJO3T4tTBornL8Oqqbs,10778
+risk/network/plot/contour.py,sha256=8uwJ7K-Z6VMyr_uQ5VUyoQSqDHA7zDvR_nYAmLn60-I,14647
+risk/network/plot/labels.py,sha256=Gt2HIbYsC5QZNZa_Mk29hijDVv0_V0pXEl1IILaNKkY,44016
+risk/network/plot/network.py,sha256=9blVFeCp5x5XoGhPwOOdADegXC4gC72c2vrM2u4QPe0,13235
+risk/network/plot/plotter.py,sha256=lN-_GDXRk9V3IFu8q7QmPjJGBZiP0QYwSvU6dVVDV2E,5770
+risk/network/plot/utils/color.py,sha256=4W4EoQ_Fs4tmbngdczXnFkkAjvyYP5EV_P2Vu-TCCwY,15573
+risk/network/plot/utils/layout.py,sha256=znssSqe2VZzzSz47hLZtTuXwMTpHR9b8lkQPL0BX7OA,1950
 risk/stats/__init__.py,sha256=WcgoETQ-hS0LQqKRsAMIPtP15xZ-4eul6VUBuUx4Wzc,220
 risk/stats/hypergeom.py,sha256=o6Qnj31gCAKxr2uQirXrbv7XvdDJGEq69MFW-ubx_hA,2272
 risk/stats/poisson.py,sha256=8x9hB4DCukq4gNIlIKO-c_jYG1-BTwTX53oLauFyfj8,1793
@@ -29,8 +30,8 @@ risk/stats/stats.py,sha256=kvShov-94W6ffgDUTb522vB9hDJQSyTsYif_UIaFfSM,7059
 risk/stats/permutation/__init__.py,sha256=neJp7FENC-zg_CGOXqv-iIvz1r5XUKI9Ruxhmq7kDOI,105
 risk/stats/permutation/permutation.py,sha256=D84Rcpt6iTQniK0PfQGcw9bLcHbMt9p-ARcurUnIXZQ,10095
 risk/stats/permutation/test_functions.py,sha256=lftOude6hee0pyR80HlBD32522JkDoN5hrKQ9VEbuoY,2345
-risk_network-0.0.8b15.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.8b15.dist-info/METADATA,sha256=4hN4nT8j1a52ghqyJQ0mhjaVuhw2mt3EgKMAjpYTagY,47498
-risk_network-0.0.8b15.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-risk_network-0.0.8b15.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.8b15.dist-info/RECORD,,
+risk_network-0.0.8b17.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.8b17.dist-info/METADATA,sha256=HmkNnAzSs7IdEGzYirOsrzy0euWVd0Ezn4OztCtXhnE,47498
+risk_network-0.0.8b17.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+risk_network-0.0.8b17.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.8b17.dist-info/RECORD,,

risk/network/plot/utils.py

@@ -1,153 +0,0 @@
-"""
-risk/network/plot/utils
-~~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-from typing import List, Tuple, Union
-
-import matplotlib.colors as mcolors
-import numpy as np
-
-from risk.network.graph import NetworkGraph
-
-
-def get_annotated_domain_colors(
-    graph: NetworkGraph,
-    cmap: str = "gist_rainbow",
-    color: Union[str, None] = None,
-    min_scale: float = 0.8,
-    max_scale: float = 1.0,
-    scale_factor: float = 1.0,
-    random_seed: int = 888,
-) -> np.ndarray:
-    """Get colors for the domains based on node annotations, or use a specified color.
-
-    Args:
-        graph (NetworkGraph): The network data and attributes to be visualized.
-        cmap (str, optional): Colormap to use for generating domain colors. Defaults to "gist_rainbow".
-        color (str or None, optional): Color to use for the domains. If None, the colormap will be used. Defaults to None.
-        min_scale (float, optional): Minimum scale for color intensity when generating domain colors.
-            Defaults to 0.8.
-        max_scale (float, optional): Maximum scale for color intensity when generating domain colors.
-            Defaults to 1.0.
-        scale_factor (float, optional): Factor for adjusting the contrast in the colors generated based on
-            enrichment. Higher values increase the contrast. Defaults to 1.0.
-        random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
-
-    Returns:
-        np.ndarray: Array of RGBA colors for each domain.
-    """
-    # Generate domain colors based on the enrichment data
-    node_colors = graph.get_domain_colors(
-        cmap=cmap,
-        color=color,
-        min_scale=min_scale,
-        max_scale=max_scale,
-        scale_factor=scale_factor,
-        random_seed=random_seed,
-    )
-    annotated_colors = []
-    for _, node_ids in graph.domain_id_to_node_ids_map.items():
-        if len(node_ids) > 1:
-            # For multi-node domains, choose the brightest color based on RGB sum
-            domain_colors = np.array([node_colors[node] for node in node_ids])
-            brightest_color = domain_colors[
-                np.argmax(domain_colors[:, :3].sum(axis=1))  # Sum the RGB values
-            ]
-            annotated_colors.append(brightest_color)
-        else:
-            # Single-node domains default to white (RGBA)
-            default_color = np.array([1.0, 1.0, 1.0, 1.0])
-            annotated_colors.append(default_color)
-
-    return np.array(annotated_colors)
-
-
-def calculate_bounding_box(
-    node_coordinates: np.ndarray, radius_margin: float = 1.05
-) -> Tuple[np.ndarray, float]:
-    """Calculate the bounding box of the network based on node coordinates.
-
-    Args:
-        node_coordinates (np.ndarray): Array of node coordinates (x, y).
-        radius_margin (float, optional): Margin factor to apply to the bounding box radius. Defaults to 1.05.
-
-    Returns:
-        tuple: Center of the bounding box and the radius (adjusted by the radius margin).
-    """
-    # Find minimum and maximum x, y coordinates
-    x_min, y_min = np.min(node_coordinates, axis=0)
-    x_max, y_max = np.max(node_coordinates, axis=0)
-    # Calculate the center of the bounding box
-    center = np.array([(x_min + x_max) / 2, (y_min + y_max) / 2])
-    # Calculate the radius of the bounding box, adjusted by the margin
-    radius = max(x_max - x_min, y_max - y_min) / 2 * radius_margin
-    return center, radius
-
-
-def to_rgba(
-    color: Union[str, List, Tuple, np.ndarray],
-    alpha: Union[float, None] = None,
-    num_repeats: Union[int, None] = None,
-) -> np.ndarray:
-    """Convert color(s) to RGBA format, applying alpha and repeating as needed.
-
-    Args:
-        color (Union[str, list, tuple, np.ndarray]): The color(s) to convert. Can be a string, list, tuple, or np.ndarray.
-        alpha (float, None, optional): Alpha value (transparency) to apply. If provided, it overrides any existing alpha values
-            found in color.
-        num_repeats (int, None, optional): If provided, the color(s) will be repeated this many times. Defaults to None.
-
-    Returns:
-        np.ndarray: Array of RGBA colors repeated `num_repeats` times, if applicable.
-    """
-
-    def convert_to_rgba(c: Union[str, List, Tuple, np.ndarray]) -> np.ndarray:
-        """Convert a single color to RGBA format, handling strings, hex, and RGB/RGBA lists."""
-        # Note: if no alpha is provided, the default alpha value is 1.0 by mcolors.to_rgba
-        if isinstance(c, str):
-            # Convert color names or hex values (e.g., 'red', '#FF5733') to RGBA
-            rgba = np.array(mcolors.to_rgba(c))
-        elif isinstance(c, (list, tuple, np.ndarray)) and len(c) in [3, 4]:
-            # Convert RGB (3) or RGBA (4) values to RGBA format
-            rgba = np.array(mcolors.to_rgba(c))
-        else:
-            raise ValueError(
-                f"Invalid color format: {c}. Must be a valid string or RGB/RGBA sequence."
-            )
-
-        if alpha is not None:  # Override alpha if provided
-            rgba[3] = alpha
-        return rgba
-
-    # If color is a 2D array of RGBA values, convert it to a list of lists
-    if isinstance(color, np.ndarray) and color.ndim == 2 and color.shape[1] == 4:
-        color = [list(c) for c in color]
-
-    # Handle a single color (string or RGB/RGBA list/tuple)
-    if isinstance(color, (str, list, tuple)) and not any(
-        isinstance(c, (list, tuple, np.ndarray)) for c in color
-    ):
-        rgba_color = convert_to_rgba(color)
-        if num_repeats:
-            return np.tile(
-                rgba_color, (num_repeats, 1)
-            )  # Repeat the color if num_repeats is provided
-        return np.array([rgba_color])  # Return a single color wrapped in a numpy array
-
-    # Handle a list/array of colors
-    elif isinstance(color, (list, tuple, np.ndarray)):
-        rgba_colors = np.array(
-            [convert_to_rgba(c) for c in color]
-        )  # Convert each color in the list to RGBA
-        # Handle repetition if num_repeats is provided
-        if num_repeats:
-            repeated_colors = np.array(
-                [rgba_colors[i % len(rgba_colors)] for i in range(num_repeats)]
-            )
-            return repeated_colors
-
-        return rgba_colors
-
-    else:
-        raise ValueError("Color must be a valid RGB/RGBA or array of RGB/RGBA colors.")