risk-network 0.0.6b9__py3-none-any.whl → 0.0.7__py3-none-any.whl

risk/network/graph.py

@@ -3,7 +3,6 @@ risk/network/graph
 ~~~~~~~~~~~~~~~~~~
 """
 
-import random
 from collections import defaultdict
 from typing import Any, Dict, List, Tuple, Union
 
@@ -55,10 +54,9 @@ class NetworkGraph:
         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()
-        # self.network and self.node_coordinates are properly declared in _initialize_network
-        self.network = None
-        self.node_coordinates = None
-        self._initialize_network(network)
+        # 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.
@@ -109,19 +107,6 @@ class NetworkGraph:
 
         return domain_id_to_label_map
 
-    def _initialize_network(self, G: nx.Graph) -> None:
-        """Initialize the network by unfolding it and extracting node coordinates.
-
-        Args:
-            G (nx.Graph): The input network graph with 3D node coordinates.
-        """
-        # Unfold the network's 3D coordinates to 2D
-        G_2d = _unfold_sphere_to_plane(G)
-        # Assign the unfolded graph to self.network
-        self.network = G_2d
-        # Extract 2D coordinates of nodes
-        self.node_coordinates = _extract_node_coordinates(G_2d)
-
     def get_domain_colors(
         self,
         cmap: str = "gist_rainbow",
@@ -200,14 +185,15 @@ class NetworkGraph:
         Returns:
             dict: A dictionary mapping domain keys to their corresponding RGBA colors.
         """
-        # Exclude non-numeric domain columns
-        numeric_domains = [
-            col for col in self.domains.columns if isinstance(col, (int, np.integer))
-        ]
-        domains = np.sort(numeric_domains)
+        # Get colors for each domain based on node positions
         domain_colors = _get_colors(
-            num_colors_to_generate=len(domains), cmap=cmap, color=color, random_seed=random_seed
+            self.network,
+            self.domain_id_to_node_ids_map,
+            cmap=cmap,
+            color=color,
+            random_seed=random_seed,
         )
+        self.network, self.domain_id_to_node_ids_map
         return dict(zip(self.domain_id_to_node_ids_map.keys(), domain_colors))
 
 
@@ -300,35 +286,100 @@ def _extract_node_coordinates(G: nx.Graph) -> np.ndarray:
 
 
 def _get_colors(
-    num_colors_to_generate: int = 10,
+    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 from a specified colormap or use a direct color string.
+    """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:
-        num_colors_to_generate (int): The number of colors to generate. Defaults to 10.
+        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.
-            Defaults to None.
 
     Returns:
-        list of tuple: List of RGBA colors.
+        List[Tuple]: List of RGBA colors.
     """
     # Set random seed for reproducibility
-    random.seed(random_seed)
+    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:
-        # If a direct color is provided, generate a list with that color
+        # Generate all colors as the same specified color
         rgba = matplotlib.colors.to_rgba(color)
-        rgbas = [rgba] * num_colors_to_generate
-    else:
-        colormap = matplotlib.colormaps.get_cmap(cmap)
-        # Generate evenly distributed color positions
-        color_positions = np.linspace(0, 1, num_colors_to_generate)
-        random.shuffle(color_positions)  # Shuffle the positions to randomize colors
-        # Generate colors based on shuffled positions
-        rgbas = [colormap(pos) for pos in color_positions]
-
-    return rgbas
+        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/io.py

@@ -16,7 +16,7 @@ import networkx as nx
 import pandas as pd
 
 from risk.network.geometry import assign_edge_lengths
-from risk.log import params, print_header
+from risk.log import params, logger, log_header
 
 
 class NetworkIO:
@@ -57,9 +57,8 @@ class NetworkIO:
             weight_label=weight_label,
         )
 
-    @classmethod
+    @staticmethod
     def load_gpickle_network(
-        cls,
         filepath: str,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
@@ -80,7 +79,7 @@ class NetworkIO:
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -109,9 +108,8 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(G)
 
-    @classmethod
+    @staticmethod
     def load_networkx_network(
-        cls,
         network: nx.Graph,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
@@ -132,7 +130,7 @@ class NetworkIO:
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -158,9 +156,8 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(network)
 
-    @classmethod
+    @staticmethod
     def load_cytoscape_network(
-        cls,
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
@@ -187,7 +184,7 @@ class NetworkIO:
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -312,9 +309,8 @@ class NetworkIO:
             if os.path.exists(tmp_dir):
                 shutil.rmtree(tmp_dir)
 
-    @classmethod
+    @staticmethod
     def load_cytoscape_json_network(
-        cls,
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
@@ -339,7 +335,7 @@ class NetworkIO:
         Returns:
             NetworkX graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -455,10 +451,10 @@ class NetworkIO:
         # Log the number of nodes and edges before and after cleaning
         num_final_nodes = G.number_of_nodes()
         num_final_edges = G.number_of_edges()
-        print(f"Initial node count: {num_initial_nodes}")
-        print(f"Final node count: {num_final_nodes}")
-        print(f"Initial edge count: {num_initial_edges}")
-        print(f"Final edge count: {num_final_edges}")
+        logger.debug(f"Initial node count: {num_initial_nodes}")
+        logger.debug(f"Final node count: {num_final_nodes}")
+        logger.debug(f"Initial edge count: {num_initial_edges}")
+        logger.debug(f"Final edge count: {num_final_edges}")
 
     def _assign_edge_weights(self, G: nx.Graph) -> None:
         """Assign weights to the edges in the graph.
@@ -476,7 +472,7 @@ class NetworkIO:
             )  # Default to 1.0 if 'weight' not present
 
         if self.include_edge_weight and missing_weights:
-            print(f"Total edges missing weights: {missing_weights}")
+            logger.debug(f"Total edges missing weights: {missing_weights}")
 
     def _validate_nodes(self, G: nx.Graph) -> None:
         """Validate the graph structure and attributes.
@@ -514,14 +510,14 @@ class NetworkIO:
             filetype (str): The type of the file being loaded (e.g., 'CSV', 'JSON').
             filepath (str, optional): The path to the file being loaded. Defaults to "".
         """
-        print_header("Loading network")
-        print(f"Filetype: {filetype}")
+        log_header("Loading network")
+        logger.debug(f"Filetype: {filetype}")
         if filepath:
-            print(f"Filepath: {filepath}")
-        print(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
+            logger.debug(f"Filepath: {filepath}")
+        logger.debug(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
         if self.include_edge_weight:
-            print(f"Weight label: {self.weight_label}")
-        print(f"Minimum edges per node: {self.min_edges_per_node}")
-        print(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
+            logger.debug(f"Weight label: {self.weight_label}")
+        logger.debug(f"Minimum edges per node: {self.min_edges_per_node}")
+        logger.debug(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
         if self.compute_sphere:
-            print(f"Surface depth: {self.surface_depth}")
+            logger.debug(f"Surface depth: {self.surface_depth}")

risk/network/plot.py

@@ -9,10 +9,12 @@ import matplotlib.colors as mcolors
 import matplotlib.pyplot as plt
 import networkx as nx
 import numpy as np
+import pandas as pd
+from scipy import linalg
 from scipy.ndimage import label
 from scipy.stats import gaussian_kde
 
-from risk.log import params
+from risk.log import params, logger
 from risk.network.graph import NetworkGraph
 
 
@@ -85,6 +87,83 @@ class NetworkPlotter:
 
         return ax
 
+    def plot_title(
+        self,
+        title: Union[str, None] = None,
+        subtitle: Union[str, None] = None,
+        title_fontsize: int = 20,
+        subtitle_fontsize: int = 14,
+        font: str = "Arial",
+        title_color: str = "black",
+        subtitle_color: str = "gray",
+        title_y: float = 0.975,
+        title_space_offset: float = 0.075,
+        subtitle_offset: float = 0.025,
+    ) -> None:
+        """Plot title and subtitle on the network graph with customizable parameters.
+
+        Args:
+            title (str, optional): Title of the plot. Defaults to None.
+            subtitle (str, optional): Subtitle of the plot. Defaults to None.
+            title_fontsize (int, optional): Font size for the title. Defaults to 16.
+            subtitle_fontsize (int, optional): Font size for the subtitle. Defaults to 12.
+            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_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.
+        """
+        # Log the title and subtitle parameters
+        params.log_plotter(
+            title=title,
+            subtitle=subtitle,
+            title_fontsize=title_fontsize,
+            subtitle_fontsize=subtitle_fontsize,
+            title_subtitle_font=font,
+            title_color=title_color,
+            subtitle_color=subtitle_color,
+            subtitle_offset=subtitle_offset,
+            title_y=title_y,
+            title_space_offset=title_space_offset,
+        )
+
+        # Get the current figure and axis dimensions
+        fig = self.ax.figure
+        # Use a tight layout to ensure that title and subtitle do not overlap with the original plot
+        fig.tight_layout(
+            rect=[0, 0, 1, 1 - title_space_offset]
+        )  # Leave space above the plot for title
+
+        # Plot title if provided
+        if title:
+            # Set the title using figure's suptitle to ensure centering
+            self.ax.figure.suptitle(
+                title,
+                fontsize=title_fontsize,
+                color=title_color,
+                fontname=font,
+                x=0.5,  # Center the title horizontally
+                ha="center",
+                va="top",
+                y=title_y,
+            )
+
+        # Plot subtitle if provided
+        if subtitle:
+            # Calculate the subtitle's y position based on title's position and subtitle_offset
+            subtitle_y_position = title_y - subtitle_offset
+            self.ax.figure.text(
+                0.5,  # Ensure horizontal centering for subtitle
+                subtitle_y_position,
+                subtitle,
+                ha="center",
+                va="top",
+                fontname=font,
+                fontsize=subtitle_fontsize,
+                color=subtitle_color,
+            )
+
     def plot_circle_perimeter(
         self,
         scale: float = 1.0,
@@ -509,26 +588,52 @@ class NetworkPlotter:
         # Extract the positions of the specified nodes
         points = np.array([pos[n] for n in nodes])
         if len(points) <= 1:
-            return  # Not enough points to form a contour
+            return None  # Not enough points to form a contour
 
+        # Check if the KDE forms a single connected component
         connected = False
+        z = None  # Initialize z to None to avoid UnboundLocalError
         while not connected and bandwidth <= 100.0:
-            # Perform KDE on the points with the given bandwidth
-            kde = gaussian_kde(points.T, bw_method=bandwidth)
-            xmin, ymin = points.min(axis=0) - bandwidth
-            xmax, ymax = points.max(axis=0) + bandwidth
-            x, y = np.mgrid[
-                xmin : xmax : complex(0, grid_size), ymin : ymax : complex(0, grid_size)
-            ]
-            z = kde(np.vstack([x.ravel(), y.ravel()])).reshape(x.shape)
-            # Check if the KDE forms a single connected component
-            connected = _is_connected(z)
-            if not connected:
-                bandwidth += 0.05  # Increase bandwidth slightly and retry
+            try:
+                # Perform KDE on the points with the given bandwidth
+                kde = gaussian_kde(points.T, bw_method=bandwidth)
+                xmin, ymin = points.min(axis=0) - bandwidth
+                xmax, ymax = points.max(axis=0) + bandwidth
+                x, y = np.mgrid[
+                    xmin : xmax : complex(0, grid_size), ymin : ymax : complex(0, grid_size)
+                ]
+                z = kde(np.vstack([x.ravel(), y.ravel()])).reshape(x.shape)
+                # Check if the KDE forms a single connected component
+                connected = _is_connected(z)
+                if not connected:
+                    bandwidth += 0.05  # Increase bandwidth slightly and retry
+            except linalg.LinAlgError:
+                bandwidth += 0.05  # Increase bandwidth and retry
+            except Exception as e:
+                # Catch any other exceptions and log them
+                logger.error(f"Unexpected error when drawing KDE contour: {e}")
+                return None
+
+        # If z is still None, the KDE computation failed
+        if z is None:
+            logger.error("Failed to compute KDE. Skipping contour plot for these nodes.")
+            return None
 
         # Define contour levels based on the density
         min_density, max_density = z.min(), z.max()
+        if min_density == max_density:
+            logger.warning(
+                "Contour levels could not be created due to lack of variation in density."
+            )
+            return None
+
+        # Create contour levels based on the density values
         contour_levels = np.linspace(min_density, max_density, levels)[1:]
+        if len(contour_levels) < 2 or not np.all(np.diff(contour_levels) > 0):
+            logger.error("Contour levels must be strictly increasing. Skipping contour plot.")
+            return None
+
+        # Set the contour color and linestyle
         contour_colors = [color for _ in range(levels - 1)]
         # Plot the filled contours using fill_alpha for transparency
         if fill_alpha > 0:
@@ -553,6 +658,7 @@ class NetworkPlotter:
             linewidths=linewidth,
             alpha=alpha,
         )
+
         # Set linewidth for the contour lines to 0 for levels other than the base level
         for i in range(1, len(contour_levels)):
             c.collections[i].set_linewidth(0)
@@ -601,7 +707,7 @@ class NetworkPlotter:
             min_words (int, optional): Minimum number of words required to display a label. Defaults to 1.
             max_word_length (int, optional): Maximum number of characters in a word to display. Defaults to 20.
             min_word_length (int, optional): Minimum number of characters in a word to display. Defaults to 1.
-            words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
+            words_to_omit (list, optional): List of words to omit from the labels. Defaults to None.
             overlay_ids (bool, optional): Whether to overlay domain IDs in the center of the centroids. Defaults to False.
             ids_to_keep (list, tuple, np.ndarray, or None, optional): IDs of domains that must be labeled. To discover domain IDs,
                 you can set `overlay_ids=True`. Defaults to None.
@@ -710,6 +816,9 @@ class NetworkPlotter:
         # Process remaining domains to fill in additional labels, if there are slots left
         if remaining_labels and remaining_labels > 0:
             for idx, (domain, centroid) in enumerate(domain_centroids.items()):
+                # Check if the domain is NaN and continue if true
+                if pd.isna(domain) or (isinstance(domain, float) and np.isnan(domain)):
+                    continue  # Skip NaN domains
                 if ids_to_keep and domain in ids_to_keep:
                     continue  # Skip domains already handled by ids_to_keep
 
@@ -1086,14 +1195,16 @@ class NetworkPlotter:
         return np.array(annotated_colors)
 
     @staticmethod
-    def savefig(*args, **kwargs) -> None:
-        """Save the current plot to a file.
+    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.
         """
-        plt.savefig(*args, bbox_inches="tight", **kwargs)
+        plt.savefig(*args, bbox_inches="tight", pad_inches=pad_inches, dpi=dpi, **kwargs)
 
     @staticmethod
     def show(*args, **kwargs) -> None:
@@ -1123,7 +1234,9 @@ def _to_rgba(
     """
     # Handle single color case (string, RGB, or RGBA)
     if isinstance(color, str) or (
-        isinstance(color, (list, tuple, np.ndarray)) and len(color) in [3, 4]
+        isinstance(color, (list, tuple, np.ndarray))
+        and len(color) in [3, 4]
+        and not any(isinstance(c, (list, tuple, np.ndarray)) for c in color)
     ):
         rgba_color = np.array(mcolors.to_rgba(color))
         # Only set alpha if the input is an RGB color or a string (not RGBA)