risk-network 0.0.8b27__py3-none-any.whl → 0.0.9__py3-none-any.whl

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

@@ -1,9 +1,9 @@
 """
-risk/network/plot/contour
-~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/contour
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
-from typing import List, Tuple, Union
+from typing import Any, Dict, List, Tuple, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -12,18 +12,18 @@ from scipy.ndimage import label
 from scipy.stats import gaussian_kde
 
 from risk.log import params, logger
-from risk.network.graph import NetworkGraph
-from risk.network.plot.utils.color import get_annotated_domain_colors, to_rgba
+from risk.network.graph.graph import Graph
+from risk.network.plotter.utils.colors import get_annotated_domain_colors, to_rgba
 
 
 class Contour:
     """Class to generate Kernel Density Estimate (KDE) contours for nodes in a network graph."""
 
-    def __init__(self, graph: NetworkGraph, ax: plt.Axes) -> None:
-        """Initialize the Contour with a NetworkGraph and axis for plotting.
+    def __init__(self, graph: Graph, ax: plt.Axes) -> None:
+        """Initialize the Contour with a Graph and axis for plotting.
 
         Args:
-            graph (NetworkGraph): The NetworkGraph object containing the network data.
+            graph (Graph): The Graph object containing the network data.
             ax (plt.Axes): The axis to plot the contours on.
         """
         self.graph = graph
@@ -63,6 +63,8 @@ class Contour:
             contour_color=(
                 "custom" if isinstance(color, np.ndarray) else color
             ),  # np.ndarray usually indicates custom colors
+            contour_linestyle=linestyle,
+            contour_linewidth=linewidth,
             contour_alpha=alpha,
             contour_fill_alpha=fill_alpha,
         )
@@ -82,7 +84,7 @@ class Contour:
                     self.ax,
                     node_coordinates,
                     node_ids,
-                    color=color[idx],
+                    color=color_rgba[idx],
                     levels=levels,
                     bandwidth=bandwidth,
                     grid_size=grid_size,
@@ -195,7 +197,7 @@ class Contour:
         # Extract the positions of the specified nodes
         points = np.array([pos[n] for n in nodes])
         if len(points) <= 1:
-            return None  # Not enough points to form a contour
+            return  # Not enough points to form a contour
 
         # Check if the KDE forms a single connected component
         connected = False
@@ -219,12 +221,12 @@ class Contour:
             except Exception as e:
                 # Catch any other exceptions and log them
                 logger.error(f"Unexpected error when drawing KDE contour: {e}")
-                return None
+                return
 
         # 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
+            return
 
         # Define contour levels based on the density
         min_density, max_density = z.min(), z.max()
@@ -232,15 +234,15 @@ class Contour:
             logger.warning(
                 "Contour levels could not be created due to lack of variation in density."
             )
-            return None
+            return
 
         # 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
+            return
 
-        # Set the contour color and linestyle
+        # Set the contour color, fill, and linestyle
         contour_colors = [color for _ in range(levels - 1)]
         # Plot the filled contours using fill_alpha for transparency
         if fill_alpha and fill_alpha > 0:
@@ -256,21 +258,19 @@ class Contour:
                 alpha=fill_alpha,
             )
 
-        # Plot the contour lines with the specified RGBA alpha for transparency
-        c = ax.contour(
+        # Plot the base contour line with the specified RGBA alpha for transparency
+        base_contour_color = [color]
+        base_contour_level = [contour_levels[0]]
+        ax.contour(
             x,
             y,
             z,
-            levels=contour_levels,
-            colors=contour_colors,
+            levels=base_contour_level,
+            colors=base_contour_color,
             linestyles=linestyle,
             linewidths=linewidth,
         )
 
-        # 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)
-
     def get_annotated_contour_colors(
         self,
         cmap: str = "gist_rainbow",
@@ -280,6 +280,7 @@ class Contour:
         min_scale: float = 0.8,
         max_scale: float = 1.0,
         scale_factor: float = 1.0,
+        ids_to_colors: Union[Dict[int, Any], None] = None,
         random_seed: int = 888,
     ) -> np.ndarray:
         """Get colors for the contours based on node annotations or a specified colormap.
@@ -294,8 +295,9 @@ class Contour:
                 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 color scaling based on enrichment scores.
+            scale_factor (float, optional): Exponent for adjusting color scaling based on significance scores.
                 A higher value increases contrast by dimming lower scores more. 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 to ensure reproducibility. Defaults to 888.
 
         Returns:
@@ -310,6 +312,7 @@ class Contour:
             min_scale=min_scale,
             max_scale=max_scale,
             scale_factor=scale_factor,
+            ids_to_colors=ids_to_colors,
             random_seed=random_seed,
         )
 

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

@@ -1,6 +1,6 @@
 """
-risk/network/plot/labels
-~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/labels
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import copy
@@ -11,9 +11,9 @@ import numpy as np
 import pandas as pd
 
 from risk.log import params
-from risk.network.graph import NetworkGraph
-from risk.network.plot.utils.color import get_annotated_domain_colors, to_rgba
-from risk.network.plot.utils.layout import calculate_bounding_box
+from risk.network.graph.graph import Graph
+from risk.network.plotter.utils.colors import get_annotated_domain_colors, to_rgba
+from risk.network.plotter.utils.layout import calculate_bounding_box
 
 TERM_DELIMITER = "::::"  # String used to separate multiple domain terms when constructing composite domain labels
 
@@ -21,11 +21,11 @@ TERM_DELIMITER = "::::"  # String used to separate multiple domain terms when co
 class Labels:
     """Class to handle the annotation of network graphs with labels for different domains."""
 
-    def __init__(self, graph: NetworkGraph, ax: plt.Axes):
+    def __init__(self, graph: Graph, ax: plt.Axes):
         """Initialize the Labeler object with a network graph and matplotlib axes.
 
         Args:
-            graph (NetworkGraph): NetworkGraph object containing the network data.
+            graph (Graph): Graph object containing the network data.
             ax (plt.Axes): Matplotlib axes object to plot the labels on.
         """
         self.graph = graph
@@ -54,7 +54,7 @@ class Labels:
         words_to_omit: Union[List, None] = None,
         overlay_ids: bool = False,
         ids_to_keep: Union[List, Tuple, np.ndarray, None] = None,
-        ids_to_replace: Union[Dict, None] = None,
+        ids_to_labels: Union[Dict[int, str], None] = None,
     ) -> None:
         """Annotate the network graph with labels for different domains, positioned around the network for clarity.
 
@@ -62,7 +62,7 @@ class Labels:
             scale (float, optional): Scale factor for positioning labels around the perimeter. Defaults to 1.05.
             offset (float, optional): Offset distance for labels from the perimeter. Defaults to 0.10.
             font (str, optional): Font name for the labels. Defaults to "Arial".
-            fontcase (Union[str, Dict[str, str], None]): Defines how to transform the case of words.
+            fontcase (str, Dict[str, str], or None, optional): Defines how to transform the case of words.
                 - If a string (e.g., 'upper', 'lower', 'title'), applies the transformation to all words.
                 - If a dictionary, maps specific cases ('lower', 'upper', 'title') to transformations (e.g., 'lower'='upper').
                 - If None, no transformation is applied.
@@ -87,7 +87,7 @@ class Labels:
             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.
-            ids_to_replace (Dict, optional): A dictionary mapping domain IDs to custom labels (strings). The labels should be
+            ids_to_labels (Dict[int, str], optional): A dictionary mapping domain IDs to custom labels (strings). The labels should be
                 space-separated words. If provided, the custom labels will replace the default domain terms. To discover domain IDs, you
                 can set `overlay_ids=True`. Defaults to None.
 
@@ -119,7 +119,7 @@ class Labels:
             label_words_to_omit=words_to_omit,
             label_overlay_ids=overlay_ids,
             label_ids_to_keep=ids_to_keep,
-            label_ids_to_replace=ids_to_replace,
+            label_ids_to_labels=ids_to_labels,
         )
 
         # Convert ids_to_keep to a tuple if it is not None
@@ -152,7 +152,7 @@ class Labels:
             self._process_ids_to_keep(
                 domain_id_to_centroid_map=domain_id_to_centroid_map,
                 ids_to_keep=ids_to_keep,
-                ids_to_replace=ids_to_replace,
+                ids_to_labels=ids_to_labels,
                 words_to_omit=words_to_omit,
                 max_labels=max_labels,
                 min_label_lines=min_label_lines,
@@ -173,7 +173,7 @@ class Labels:
             self._process_remaining_domains(
                 domain_id_to_centroid_map=domain_id_to_centroid_map,
                 ids_to_keep=ids_to_keep,
-                ids_to_replace=ids_to_replace,
+                ids_to_labels=ids_to_labels,
                 words_to_omit=words_to_omit,
                 remaining_labels=remaining_labels,
                 min_chars_per_line=min_chars_per_line,
@@ -218,13 +218,14 @@ class Labels:
                 fontsize=fontsize,
                 fontname=font,
                 color=fontcolor_rgba[idx],
-                arrowprops=dict(
-                    arrowstyle=arrow_style,
-                    color=arrow_color_rgba[idx],
-                    linewidth=arrow_linewidth,
-                    shrinkA=arrow_base_shrink,
-                    shrinkB=arrow_tip_shrink,
-                ),
+                arrowprops={
+                    "arrowstyle": arrow_style,
+                    "linewidth": arrow_linewidth,
+                    "color": arrow_color_rgba[idx],
+                    "alpha": arrow_alpha,
+                    "shrinkA": arrow_base_shrink,
+                    "shrinkB": arrow_tip_shrink,
+                },
             )
 
         # Overlay domain ID at the centroid regardless of max_labels if requested
@@ -334,13 +335,14 @@ class Labels:
                 fontsize=fontsize,
                 fontname=font,
                 color=fontcolor_rgba[idx],
-                arrowprops=dict(
-                    arrowstyle=arrow_style,
-                    color=arrow_color_rgba[idx],
-                    linewidth=arrow_linewidth,
-                    shrinkA=arrow_base_shrink,
-                    shrinkB=arrow_tip_shrink,
-                ),
+                arrowprops={
+                    "arrowstyle": arrow_style,
+                    "linewidth": arrow_linewidth,
+                    "color": arrow_color_rgba[idx],
+                    "alpha": arrow_alpha,
+                    "shrinkA": arrow_base_shrink,
+                    "shrinkB": arrow_tip_shrink,
+                },
             )
 
     def _calculate_domain_centroid(self, nodes: List) -> tuple:
@@ -368,7 +370,7 @@ class Labels:
         self,
         domain_id_to_centroid_map: Dict[str, np.ndarray],
         ids_to_keep: Union[List[str], Tuple[str], np.ndarray],
-        ids_to_replace: Union[Dict[str, str], None],
+        ids_to_labels: Union[Dict[int, str], None],
         words_to_omit: Union[List[str], None],
         max_labels: Union[int, None],
         min_label_lines: int,
@@ -384,7 +386,7 @@ class Labels:
         Args:
             domain_id_to_centroid_map (Dict[str, np.ndarray]): Mapping of domain IDs to their centroids.
             ids_to_keep (List, Tuple, or np.ndarray, optional): IDs of domains that must be labeled.
-            ids_to_replace (Dict[str, str], optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
+            ids_to_labels (Dict[int, str], None, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
             words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
             max_labels (int, optional): Maximum number of labels allowed.
             min_label_lines (int): Minimum number of lines in a label.
@@ -419,7 +421,7 @@ class Labels:
                     domain=domain,
                     domain_centroid=domain_centroid,
                     domain_id_to_centroid_map=domain_id_to_centroid_map,
-                    ids_to_replace=ids_to_replace,
+                    ids_to_labels=ids_to_labels,
                     words_to_omit=words_to_omit,
                     min_label_lines=min_label_lines,
                     max_label_lines=max_label_lines,
@@ -434,7 +436,7 @@ class Labels:
         self,
         domain_id_to_centroid_map: Dict[str, np.ndarray],
         ids_to_keep: Union[List[str], Tuple[str], np.ndarray],
-        ids_to_replace: Union[Dict[str, str], None],
+        ids_to_labels: Union[Dict[int, str], None],
         words_to_omit: Union[List[str], None],
         remaining_labels: int,
         min_label_lines: int,
@@ -450,7 +452,7 @@ class Labels:
         Args:
             domain_id_to_centroid_map (Dict[str, np.ndarray]): Mapping of domain IDs to their centroids.
             ids_to_keep (List, Tuple, or np.ndarray, optional): IDs of domains that must be labeled.
-            ids_to_replace (Dict[str, str], optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
+            ids_to_labels (Dict[int, str], None, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
             words_to_omit (List, optional): List of words to omit from the labels. Defaults to None.
             remaining_labels (int): The remaining number of labels that can be generated.
             min_label_lines (int): Minimum number of lines in a label.
@@ -515,7 +517,7 @@ class Labels:
                 domain=domain,
                 domain_centroid=domain_centroid,
                 domain_id_to_centroid_map=domain_id_to_centroid_map,
-                ids_to_replace=ids_to_replace,
+                ids_to_labels=ids_to_labels,
                 words_to_omit=words_to_omit,
                 min_label_lines=min_label_lines,
                 max_label_lines=max_label_lines,
@@ -536,7 +538,7 @@ class Labels:
         domain: str,
         domain_centroid: np.ndarray,
         domain_id_to_centroid_map: Dict[str, np.ndarray],
-        ids_to_replace: Union[Dict[str, str], None],
+        ids_to_labels: Union[Dict[int, str], None],
         words_to_omit: Union[List[str], None],
         min_label_lines: int,
         max_label_lines: int,
@@ -552,7 +554,7 @@ class Labels:
             domain (str): Domain ID to process.
             domain_centroid (np.ndarray): Centroid position of the domain.
             domain_id_to_centroid_map (Dict[str, np.ndarray]): Mapping of domain IDs to their centroids.
-            ids_to_replace (Dict[str, str], None, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
+            ids_to_labels (Dict[int, str], None, optional): A dictionary mapping domain IDs to custom labels. Defaults to None.
             words_to_omit (List[str], None, optional): List of words to omit from the labels. Defaults to None.
             min_label_lines (int): Minimum number of lines required in a label.
             max_label_lines (int): Maximum number of lines allowed in a label.
@@ -564,39 +566,39 @@ class Labels:
 
         Returns:
             bool: True if the domain is valid and added to the filtered dictionaries, False otherwise.
-
-        Note:
-            The `filtered_domain_centroids`, `filtered_domain_terms`, and `valid_indices` are modified in-place.
         """
-        # Process the domain terms
-        domain_terms = self._process_terms(
-            domain=domain,
-            ids_to_replace=ids_to_replace,
-            words_to_omit=words_to_omit,
-            max_label_lines=max_label_lines,
-            min_chars_per_line=min_chars_per_line,
-            max_chars_per_line=max_chars_per_line,
-        )
-        # If domain_terms is empty, skip further processing
-        if not domain_terms:
-            return False
-
-        # Split the terms by TERM_DELIMITER and count the number of lines
-        num_domain_lines = len(domain_terms.split(TERM_DELIMITER))
-        # Check if the number of lines is greater than or equal to the minimum
-        if num_domain_lines >= min_label_lines:
-            filtered_domain_centroids[domain] = domain_centroid
-            filtered_domain_terms[domain] = domain_terms
-            # Add the index of the domain to the valid indices list
-            valid_indices.append(list(domain_id_to_centroid_map.keys()).index(domain))
-            return True
-
-        return False
+        if ids_to_labels and domain in ids_to_labels:
+            # Directly use custom labels without filtering
+            domain_terms = ids_to_labels[domain]
+        else:
+            # Process the domain terms automatically
+            domain_terms = self._process_terms(
+                domain=domain,
+                words_to_omit=words_to_omit,
+                max_label_lines=max_label_lines,
+                min_chars_per_line=min_chars_per_line,
+                max_chars_per_line=max_chars_per_line,
+            )
+            # If no valid terms are generated, skip further processing
+            if not domain_terms:
+                return False
+
+            # Split the terms by TERM_DELIMITER and count the number of lines
+            num_domain_lines = len(domain_terms.split(TERM_DELIMITER))
+            # Check if the number of lines meets the minimum requirement
+            if num_domain_lines < min_label_lines:
+                return False
+
+        # Store the valid terms and centroids
+        filtered_domain_centroids[domain] = domain_centroid
+        filtered_domain_terms[domain] = domain_terms
+        valid_indices.append(list(domain_id_to_centroid_map.keys()).index(domain))
+
+        return True
 
     def _process_terms(
         self,
         domain: str,
-        ids_to_replace: Union[Dict[str, str], None],
         words_to_omit: Union[List[str], None],
         max_label_lines: int,
         min_chars_per_line: int,
@@ -606,8 +608,7 @@ class Labels:
 
         Args:
             domain (str): The domain being processed.
-            ids_to_replace (Dict[str, str], optional): Dictionary mapping domain IDs to custom labels.
-            words_to_omit (List, optional): List of words to omit from the labels.
+            words_to_omit (List[str], None): List of words to omit from the labels.
             max_label_lines (int): Maximum number of lines in a label.
             min_chars_per_line (int): Minimum number of characters in a line to display.
             max_chars_per_line (int): Maximum number of characters in a line to display.
@@ -615,14 +616,8 @@ class Labels:
         Returns:
             str: Processed terms separated by TERM_DELIMITER, with words combined if necessary to fit within constraints.
         """
-        # Return custom labels if domain is in ids_to_replace
-        if ids_to_replace and domain in ids_to_replace:
-            terms = ids_to_replace[domain].replace(" ", TERM_DELIMITER)
-            return terms
-
-        else:
-            terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
-
+        # Set custom labels from significant terms
+        terms = self.graph.domain_id_to_domain_terms_map[domain].split(" ")
         # Apply words_to_omit and word length constraints
         if words_to_omit:
             terms = [
@@ -645,6 +640,7 @@ class Labels:
         min_scale: float = 0.8,
         max_scale: float = 1.0,
         scale_factor: float = 1.0,
+        ids_to_colors: Union[Dict[int, Any], None] = None,
         random_seed: int = 888,
     ) -> np.ndarray:
         """Get colors for the labels based on node annotations or a specified colormap.
@@ -659,8 +655,9 @@ class Labels:
                 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 color scaling based on enrichment scores.
+            scale_factor (float, optional): Exponent for adjusting color scaling based on significance scores.
                 A higher value increases contrast by dimming lower scores more. 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 to ensure reproducibility. Defaults to 888.
 
         Returns:
@@ -675,6 +672,7 @@ class Labels:
             min_scale=min_scale,
             max_scale=max_scale,
             scale_factor=scale_factor,
+            ids_to_colors=ids_to_colors,
             random_seed=random_seed,
         )
 
@@ -763,10 +761,7 @@ def _calculate_best_label_positions(
         center, radius, offset, num_domains
     )
     # Create a mapping of domains to their initial label positions
-    label_positions = {
-        domain: position
-        for domain, position in zip(filtered_domain_centroids.keys(), equidistant_positions)
-    }
+    label_positions = dict(zip(filtered_domain_centroids.keys(), equidistant_positions))
     # Optimize the label positions to minimize distance to domain centroids
     return _optimize_label_positions(label_positions, filtered_domain_centroids)
 

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

@@ -1,26 +1,29 @@
 """
-risk/network/plot/network
-~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/network
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
-from typing import Any, List, Tuple, Union
+from typing import Any, Dict, List, Tuple, Union
 
 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.graph import Graph
+from risk.network.plotter.utils.colors import get_domain_colors, to_rgba
 
 
 class Network:
-    """Class for plotting nodes and edges in a network graph."""
+    """A class for plotting network graphs with customizable options.
 
-    def __init__(self, graph: NetworkGraph, ax: Any = None) -> None:
-        """Initialize the NetworkPlotter class.
+    The Network class provides methods to plot network graphs with flexible node and edge properties.
+    """
+
+    def __init__(self, graph: Graph, ax: Any = None) -> None:
+        """Initialize the Plotter class.
 
         Args:
-            graph (NetworkGraph): The network data and attributes to be visualized.
+            graph (Graph): The network data and attributes to be visualized.
             ax (Any, optional): Axes object to plot the network graph. Defaults to None.
         """
         self.graph = graph
@@ -203,11 +206,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 +222,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 +244,51 @@ 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