risk-network 0.0.8b26__py3-none-any.whl → 0.0.9b26__py3-none-any.whl

risk/network/{plot → plotter}/network.py

@@ -3,18 +3,26 @@ risk/network/plot/network
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
-from typing import Any, List, Tuple, Union
+from typing import Any, Dict, List, Tuple, Union
 
+import matplotlib.pyplot as plt
 import networkx as nx
 import numpy as np
 
 from risk.log import params
-from risk.network.graph import NetworkGraph
-from risk.network.plot.utils.color import get_domain_colors, to_rgba
+from risk.network.graph.network import NetworkGraph
+from risk.network.plotter.canvas import Canvas
+from risk.network.plotter.contour import Contour
+from risk.network.plotter.labels import Labels
+from risk.network.plotter.utils.colors import get_domain_colors, to_rgba
+from risk.network.plotter.utils.layout import calculate_bounding_box
 
 
 class Network:
-    """Class for plotting nodes and edges in a network graph."""
+    """A class for plotting network graphs with customizable options.
+
+    The Network class provides methods to plot network graphs with flexible node and edge properties.
+    """
 
     def __init__(self, graph: NetworkGraph, ax: Any = None) -> None:
         """Initialize the NetworkPlotter class.
@@ -203,11 +211,12 @@ class Network:
         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_alpha: Union[float, None] = 1.0,
+        nonsignificant_color: Union[str, List, Tuple, np.ndarray] = "white",
+        nonsignificant_alpha: Union[float, None] = 1.0,
+        ids_to_colors: Union[Dict[int, Any], None] = None,
         random_seed: int = 888,
     ) -> np.ndarray:
-        """Adjust the colors of nodes in the network graph based on enrichment.
+        """Adjust the colors of nodes in the network graph based on significance.
 
         Args:
             cmap (str, optional): Colormap to use for coloring the nodes. Defaults to "gist_rainbow".
@@ -218,16 +227,17 @@ class Network:
             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`.
+            alpha (float, None, optional): Alpha value for significant 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.
+            nonsignificant_color (str, List, Tuple, or np.ndarray, optional): Color for non-significant 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.
+            nonsignificant_alpha (float, None, optional): Alpha value for non-significant nodes. If provided, it overrides any existing alpha values found
+                in `nonsignificant_color`. Defaults to 1.0.
+            ids_to_colors (Dict[int, Any], None, optional): Mapping of domain IDs to specific colors. Defaults to None.
             random_seed (int, optional): Seed for random number generation. Defaults to 888.
 
         Returns:
-            np.ndarray: Array of RGBA colors adjusted for enrichment status.
+            np.ndarray: Array of RGBA colors adjusted for significance status.
         """
         # Get the initial domain colors for each node, which are returned as RGBA
         network_colors = get_domain_colors(
@@ -239,50 +249,176 @@ class Network:
             min_scale=min_scale,
             max_scale=max_scale,
             scale_factor=scale_factor,
+            ids_to_colors=ids_to_colors,
             random_seed=random_seed,
         )
-        # 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_rgba = to_rgba(
-            color=nonenriched_color, alpha=nonenriched_alpha, num_repeats=1
+        # Apply the alpha value for significant nodes
+        network_colors[:, 3] = alpha  # Apply the alpha value to the significant nodes' A channel
+        # Convert the non-significant color to RGBA using the to_rgba helper function
+        nonsignificant_color_rgba = to_rgba(
+            color=nonsignificant_color, alpha=nonsignificant_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
+        # Adjust node colors: replace any nodes where all three RGB values are equal and less than or equal to 0.1
         # 0.1 is a predefined threshold for the minimum color intensity
         adjusted_network_colors = np.where(
             (
-                np.all(network_colors[:, :3] < 0.1, axis=1)
+                np.all(network_colors[:, :3] <= 0.1, axis=1)
                 & np.all(network_colors[:, :3] == network_colors[:, 0:1], axis=1)
             )[:, None],
             np.tile(
-                np.array(nonenriched_color_rgba), (network_colors.shape[0], 1)
-            ),  # Replace with the full RGBA non-enriched color
+                np.array(nonsignificant_color_rgba), (network_colors.shape[0], 1)
+            ),  # Replace with the full RGBA non-significant color
             network_colors,  # Keep the original colors where no match is found
         )
         return adjusted_network_colors
 
     def get_annotated_node_sizes(
-        self, enriched_size: int = 50, nonenriched_size: int = 25
+        self, significant_size: int = 50, nonsignificant_size: int = 25
     ) -> np.ndarray:
-        """Adjust the sizes of nodes in the network graph based on whether they are enriched or not.
+        """Adjust the sizes of nodes in the network graph based on whether they are significant or not.
 
         Args:
-            enriched_size (int): Size for enriched nodes. Defaults to 50.
-            nonenriched_size (int): Size for non-enriched nodes. Defaults to 25.
+            significant_size (int): Size for significant nodes. Defaults to 50.
+            nonsignificant_size (int): Size for non-significant nodes. Defaults to 25.
 
         Returns:
-            np.ndarray: Array of node sizes, with enriched nodes larger than non-enriched ones.
+            np.ndarray: Array of node sizes, with significant nodes larger than non-significant ones.
         """
-        # Merge all enriched nodes from the domain_id_to_node_ids_map dictionary
-        enriched_nodes = set()
+        # Merge all significant nodes from the domain_id_to_node_ids_map dictionary
+        significant_nodes = set()
         for _, node_ids in self.graph.domain_id_to_node_ids_map.items():
-            enriched_nodes.update(node_ids)
+            significant_nodes.update(node_ids)
 
-        # Initialize all node sizes to the non-enriched size
-        node_sizes = np.full(len(self.graph.network.nodes), nonenriched_size)
-        # Set the size for enriched nodes
-        for node in enriched_nodes:
+        # Initialize all node sizes to the non-significant size
+        node_sizes = np.full(len(self.graph.network.nodes), nonsignificant_size)
+        # Set the size for significant nodes
+        for node in significant_nodes:
             if node in self.graph.network.nodes:
-                node_sizes[node] = enriched_size
+                node_sizes[node] = significant_size
 
         return node_sizes
+
+
+class NetworkPlotter(Canvas, Network, Contour, Labels):
+    """A class for visualizing network graphs with customizable options.
+
+    The NetworkPlotter class uses a NetworkGraph object and provides methods to plot the network with
+    flexible node and edge properties. It also supports plotting labels, contours, drawing the network's
+    perimeter, and adjusting background colors.
+    """
+
+    def __init__(
+        self,
+        graph: NetworkGraph,
+        figsize: Tuple = (10, 10),
+        background_color: Union[str, List, Tuple, np.ndarray] = "white",
+        background_alpha: Union[float, None] = 1.0,
+        pad: float = 0.3,
+    ) -> None:
+        """Initialize the NetworkPlotter with a NetworkGraph object and plotting parameters.
+
+        Args:
+            graph (NetworkGraph): The network data and attributes to be visualized.
+            figsize (Tuple, optional): Size of the figure in inches (width, height). Defaults to (10, 10).
+            background_color (str, List, Tuple, np.ndarray, optional): Background color of the plot. Defaults to "white".
+            background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides
+                any existing alpha values found in background_color. Defaults to 1.0.
+            pad (float, optional): Padding value to adjust the axis limits. Defaults to 0.3.
+        """
+        self.graph = graph
+        # Initialize the plot with the specified parameters
+        self.ax = self._initialize_plot(
+            graph=graph,
+            figsize=figsize,
+            background_color=background_color,
+            background_alpha=background_alpha,
+            pad=pad,
+        )
+        super().__init__(graph=graph, ax=self.ax)
+
+    def _initialize_plot(
+        self,
+        graph: NetworkGraph,
+        figsize: Tuple,
+        background_color: Union[str, List, Tuple, np.ndarray],
+        background_alpha: Union[float, None],
+        pad: float,
+    ) -> plt.Axes:
+        """Set up the plot with figure size and background color.
+
+        Args:
+            graph (NetworkGraph): The network data and attributes to be visualized.
+            figsize (Tuple): Size of the figure in inches (width, height).
+            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:
+            plt.Axes: The axis object for the plot.
+        """
+        # Log the plotter settings
+        params.log_plotter(
+            figsize=figsize,
+            background_color=background_color,
+            background_alpha=background_alpha,
+            pad=pad,
+        )
+
+        # Extract node coordinates from the network graph
+        node_coordinates = graph.node_coordinates
+        # Calculate the center and radius of the bounding box around the network
+        center, radius = calculate_bounding_box(node_coordinates)
+
+        # Create a new figure and axis for plotting
+        fig, ax = plt.subplots(figsize=figsize)
+        fig.tight_layout()  # Adjust subplot parameters to give specified padding
+        # Set axis limits based on the calculated bounding box and radius
+        ax.set_xlim([center[0] - radius - pad, center[0] + radius + pad])
+        ax.set_ylim([center[1] - radius - pad, center[1] + radius + pad])
+        ax.set_aspect("equal")  # Ensure the aspect ratio is equal
+
+        # 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, 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():
+            spine.set_visible(False)
+
+        # Hide axis ticks and labels
+        ax.set_xticks([])
+        ax.set_yticks([])
+        ax.patch.set_visible(False)  # Hide the axis background
+
+        return ax
+
+    @staticmethod
+    def savefig(*args, pad_inches: float = 0.5, dpi: int = 100, **kwargs) -> None:
+        """Save the current plot to a file with additional export options.
+
+        Args:
+            *args: Positional arguments passed to `plt.savefig`.
+            pad_inches (float, optional): Padding around the figure when saving. Defaults to 0.5.
+            dpi (int, optional): Dots per inch (DPI) for the exported image. Defaults to 300.
+            **kwargs: Keyword arguments passed to `plt.savefig`, such as filename and format.
+        """
+        # Ensure user-provided kwargs take precedence
+        kwargs.setdefault("dpi", dpi)
+        kwargs.setdefault("pad_inches", pad_inches)
+        # Ensure the plot is saved with tight bounding box if not specified
+        kwargs.setdefault("bbox_inches", "tight")
+        # Call plt.savefig with combined arguments
+        plt.savefig(*args, **kwargs)
+
+    @staticmethod
+    def show(*args, **kwargs) -> None:
+        """Display the current plot.
+
+        Args:
+            *args: Positional arguments passed to `plt.show`.
+            **kwargs: Keyword arguments passed to `plt.show`.
+        """
+        plt.show(*args, **kwargs)