bsplot 0.0.2__py3-none-any.whl

bsplot/graph/nodes.py

@@ -0,0 +1,452 @@
+import matplotlib
+import matplotlib.colors as mcolors
+import matplotlib.pyplot as plt
+import numpy as np
+from typing import Dict, Optional, Union, Tuple, Any
+from pathlib import Path
+
+
+def get_actual_bounds(ax, axis="x"):
+    renderer = ax.figure.canvas.get_renderer()
+    xcoords = []
+    ycoords = []
+
+    for artist in ax.get_children():
+        if not isinstance(artist, matplotlib.text.Text):
+            continue  # Only process text elements
+        elif artist.get_text() == "":
+            continue
+        if hasattr(artist, "get_window_extent"):
+            try:
+                # Get the bounding box in display coordinates
+                bbox = artist.get_window_extent(renderer=renderer)
+                # print(f"Bbox for '{artist.get_text()}': {bbox}")
+
+                # Transform the bounding box corners to data coordinates
+                bbox_data = ax.transData.inverted().transform(
+                    [
+                        [bbox.x0, bbox.y0],  # Bottom-left
+                        [bbox.x1, bbox.y1],  # Top-right
+                    ]
+                )
+                xcoords.extend([bbox_data[0, 0], bbox_data[1, 0]])
+                ycoords.extend([bbox_data[0, 1], bbox_data[1, 1]])
+            except Exception as e:
+                print(f"Error processing '{artist.get_text()}': {e}")
+
+    if axis == "x":
+        return np.min(xcoords), np.max(xcoords)
+    elif axis == "y":
+        return np.min(ycoords), np.max(ycoords)
+
+
+def draw_custom_nodes(
+    G,
+    pos,
+    labels=None,
+    font_size=10,
+    ax=None,
+    node_colors=None,
+    alpha=0.8,
+    facecolor=None,
+    edgecolor=None,
+):
+    """
+    Custom function to draw nodes as text in a network graph.
+
+    Parameters:
+    ----------
+    G : networkx.Graph
+        The graph on which nodes will be drawn.
+    pos : dict
+        A dictionary with nodes as keys and positions as values. Positions should be tuples of (x, y) coordinates.
+    labels : dict, optional
+        A dictionary with node labels. If None, nodes are labeled with node names.
+    font_size : int, optional
+        The font size of the node labels (default is 10).
+    ax : matplotlib.axes.Axes, optional
+        Matplotlib axes object to draw the nodes on. If None, the current axes will be used (default is None).
+    node_colors : dict or str, optional
+        A dictionary specifying the color for each node or a single color for all nodes (default is None).
+
+    Returns:
+    -------
+    list
+        A list of text objects for the node labels.
+    """
+    x = [v[0] for v in pos.values()]
+    y = [v[1] for v in pos.values()]
+
+    if ax is None:
+        ax = plt.gca()
+
+    if min(x) != max(x):
+        ax.set_xlim([min(x), max(x)])
+    if min(y) != max(y):
+        ax.set_ylim([min(y), max(y)])
+
+    if labels is None:
+        labels = {node: node for node in G.nodes()}
+
+    if node_colors is None:
+        node_colors = ["grey" for node in G.nodes()]
+    elif isinstance(node_colors, str):
+        if node_colors.startswith("#"):
+            node_colors = mcolors.to_rgba(node_colors)
+        node_colors = [node_colors for node in G.nodes()]
+    elif isinstance(node_colors, dict):
+        node_colors = [
+            (
+                mcolors.to_rgba(node_colors[node])
+                if isinstance(node_colors[node], str)
+                else node_colors[node]
+            )
+            for node in G.nodes()
+        ]
+
+    texts = {}  # To store the text objects
+    bbox_pad = 0.3  # Padding for the bounding box
+    for i, (node, position) in enumerate(pos.items()):
+        text = labels[node]
+        x, y = position
+        txt_obj = ax.text(
+            x,
+            y,
+            text,
+            bbox=dict(
+                facecolor=node_colors[i] if facecolor is None else facecolor,
+                edgecolor=node_colors[i] if edgecolor is None else edgecolor,
+                alpha=alpha,
+                boxstyle=f"round,pad={bbox_pad}",
+            ),
+            ha="center",
+            va="top",
+            fontsize=font_size,
+        )
+        texts[node] = txt_obj
+    ax.figure.canvas.draw()
+    # Force rendering to ensure bounding boxes are accurate
+    bbox_positions = {
+        node: txt.get_window_extent(
+            renderer=ax.figure.canvas.get_renderer()
+        ).transformed(ax.transData.inverted())
+        for node, txt in texts.items()
+    }
+
+    xmin, xmax = get_actual_bounds(ax, axis="x")
+    ymin, ymax = get_actual_bounds(ax, axis="y")
+    ax.set_xlim([xmin - bbox_pad, xmax + bbox_pad])
+    ax.set_ylim([ymin - bbox_pad, ymax + bbox_pad])
+
+    return texts, bbox_positions
+
+    # return texts
+
+
+def draw_nodes_with_icons(
+    G,
+    pos,
+    labels: Optional[Dict[str, str]] = None,
+    icons: Optional[Dict[str, str]] = None,
+    font_size: int = 10,
+    ax=None,
+    node_colors: Optional[Union[Dict, str, list]] = None,
+    alpha: float = 0.8,
+    facecolor: Optional[str] = None,
+    edgecolor: Optional[str] = None,
+    icon_size: float = 0.15,
+    icon_position: str = "above",
+    local_icons_dir: Optional[Union[str, Path]] = None,
+) -> Tuple[Dict, Dict, Dict]:
+    """
+    Draw nodes with bioicons in a network graph.
+    
+    This function extends draw_custom_nodes to support icons from
+    bioicons.com or local image files.
+    
+    Parameters
+    ----------
+    G : networkx.Graph
+        The graph on which nodes will be drawn.
+    pos : dict
+        A dictionary with nodes as keys and positions as values.
+    labels : dict, optional
+        Node labels. If None, nodes are labeled with node names.
+    icons : dict, optional
+        Dictionary mapping node names to icon IDs or image paths.
+        Example: {"node1": "neuron", "node2": "/path/to/icon.png"}
+    font_size : int
+        Font size for node labels.
+    ax : matplotlib.axes.Axes, optional
+        Axes to draw on. If None, uses current axes.
+    node_colors : dict, str, or list, optional
+        Colors for each node.
+    alpha : float
+        Transparency of node boxes.
+    facecolor : str, optional
+        Background color for all nodes.
+    edgecolor : str, optional
+        Border color for all nodes.
+    icon_size : float
+        Size of icons relative to the plot.
+    icon_position : str
+        Where to place icons: "above", "below", "left", "right", or "center".
+    local_icons_dir : str or Path, optional
+        Directory containing local icon files.
+        
+    Returns
+    -------
+    texts : dict
+        Dictionary of text objects for each node.
+    bbox_positions : dict
+        Dictionary of bounding box positions for each node.
+    icon_annotations : dict
+        Dictionary of icon AnnotationBbox objects for each node.
+        
+    Examples
+    --------
+    >>> import networkx as nx
+    >>> import matplotlib.pyplot as plt
+    >>> from bsplot.graph.nodes import draw_nodes_with_icons
+    >>> 
+    >>> G = nx.Graph()
+    >>> G.add_nodes_from(["A", "B", "C"])
+    >>> G.add_edges_from([("A", "B"), ("B", "C")])
+    >>> pos = {"A": (0, 0), "B": (1, 0), "C": (2, 0)}
+    >>> icons = {"A": "neuron", "B": "brain", "C": "synapse"}
+    >>> 
+    >>> fig, ax = plt.subplots()
+    >>> draw_nodes_with_icons(G, pos, icons=icons, ax=ax)
+    >>> plt.show()
+    """
+    from ..bioicons import BioIcons
+
+    x_coords = [v[0] for v in pos.values()]
+    y_coords = [v[1] for v in pos.values()]
+
+    if ax is None:
+        ax = plt.gca()
+
+    # Set axis limits
+    x_margin = (max(x_coords) - min(x_coords)) * 0.2 if max(x_coords) != min(x_coords) else 1
+    y_margin = (max(y_coords) - min(y_coords)) * 0.2 if max(y_coords) != min(y_coords) else 1
+    ax.set_xlim([min(x_coords) - x_margin, max(x_coords) + x_margin])
+    ax.set_ylim([min(y_coords) - y_margin, max(y_coords) + y_margin])
+
+    if labels is None:
+        labels = {node: node for node in G.nodes()}
+
+    if icons is None:
+        icons = {}
+
+    # Process node colors
+    if node_colors is None:
+        node_colors_list = ["grey" for _ in G.nodes()]
+    elif isinstance(node_colors, str):
+        if node_colors.startswith("#"):
+            node_colors = mcolors.to_rgba(node_colors)
+        node_colors_list = [node_colors for _ in G.nodes()]
+    elif isinstance(node_colors, dict):
+        node_colors_list = [
+            (
+                mcolors.to_rgba(node_colors[node])
+                if isinstance(node_colors[node], str)
+                else node_colors[node]
+            )
+            for node in G.nodes()
+        ]
+    else:
+        node_colors_list = list(node_colors)
+
+    # Initialize bioicons interface
+    bio_icons = BioIcons(
+        local_icons_dir=local_icons_dir,
+    )
+
+    texts = {}
+    icon_annotations = {}
+    bbox_pad = 0.3
+
+    # Calculate offset based on icon position
+    def get_icon_offset(position: str, size: float) -> Tuple[float, float]:
+        offsets = {
+            "above": (0, size * 2),
+            "below": (0, -size * 2),
+            "left": (-size * 2, 0),
+            "right": (size * 2, 0),
+            "center": (0, 0),
+        }
+        return offsets.get(position, (0, size * 2))
+
+    for i, (node, position) in enumerate(pos.items()):
+        text = labels.get(node, str(node))
+        x, y = position
+
+        # Draw the text label with box
+        txt_obj = ax.text(
+            x,
+            y,
+            text,
+            bbox=dict(
+                facecolor=node_colors_list[i] if facecolor is None else facecolor,
+                edgecolor=node_colors_list[i] if edgecolor is None else edgecolor,
+                alpha=alpha,
+                boxstyle=f"round,pad={bbox_pad}",
+            ),
+            ha="center",
+            va="center",
+            fontsize=font_size,
+        )
+        texts[node] = txt_obj
+
+        # Draw icon if specified for this node
+        if node in icons:
+            icon_id = icons[node]
+            dx, dy = get_icon_offset(icon_position, icon_size)
+
+            ab = bio_icons.plot(
+                icon_id,
+                ax=ax,
+                x=x + dx,
+                y=y + dy,
+                size=icon_size,
+            )
+            icon_annotations[node] = ab
+
+    ax.figure.canvas.draw()
+
+    # Get bounding boxes
+    bbox_positions = {}
+    try:
+        renderer = ax.figure.canvas.get_renderer()
+        bbox_positions = {
+            node: txt.get_window_extent(renderer=renderer).transformed(
+                ax.transData.inverted()
+            )
+            for node, txt in texts.items()
+        }
+    except Exception:
+        # Fallback if renderer is not available
+        pass
+
+    # Adjust limits to fit everything
+    try:
+        xmin, xmax = get_actual_bounds(ax, axis="x")
+        ymin, ymax = get_actual_bounds(ax, axis="y")
+        if xmin is not None and xmax is not None:
+            ax.set_xlim([xmin - bbox_pad - icon_size, xmax + bbox_pad + icon_size])
+        if ymin is not None and ymax is not None:
+            ax.set_ylim([ymin - bbox_pad - icon_size, ymax + bbox_pad + icon_size])
+    except Exception:
+        pass
+
+    return texts, bbox_positions, icon_annotations
+
+
+def draw_icon_nodes(
+    G,
+    pos,
+    icons: Dict[str, str],
+    labels: Optional[Dict[str, str]] = None,
+    font_size: int = 10,
+    ax=None,
+    icon_size: float = 0.2,
+    show_labels: bool = True,
+    label_offset: float = 0.15,
+    local_icons_dir: Optional[Union[str, Path]] = None,
+) -> Tuple[Dict, Dict]:
+    """
+    Draw network nodes using only bioicons (no text boxes).
+    
+    This creates a cleaner visualization where nodes are represented
+    purely by icons with optional labels below.
+    
+    Parameters
+    ----------
+    G : networkx.Graph
+        The graph.
+    pos : dict
+        Node positions.
+    icons : dict
+        Dictionary mapping node names to icon IDs.
+    labels : dict, optional
+        Node labels. If None, uses node names.
+    font_size : int
+        Font size for labels.
+    ax : Axes, optional
+        Matplotlib axes.
+    icon_size : float
+        Size of icons.
+    show_labels : bool
+        Whether to show text labels below icons.
+    label_offset : float
+        Vertical offset for labels.
+    local_icons_dir : str or Path, optional
+        Local icons directory.
+        
+    Returns
+    -------
+    icon_annotations : dict
+        Dictionary of icon AnnotationBbox objects.
+    texts : dict
+        Dictionary of text objects (empty if show_labels=False).
+        
+    Examples
+    --------
+    >>> import networkx as nx
+    >>> G = nx.path_graph(3)
+    >>> pos = nx.spring_layout(G)
+    >>> icons = {0: "neuron", 1: "synapse", 2: "brain"}
+    >>> draw_icon_nodes(G, pos, icons)
+    """
+    from ..bioicons import BioIcons
+
+    if ax is None:
+        ax = plt.gca()
+
+    if labels is None:
+        labels = {node: str(node) for node in G.nodes()}
+
+    # Initialize icons interface
+    bio_icons = BioIcons(
+        local_icons_dir=local_icons_dir,
+    )
+
+    icon_annotations = {}
+    texts = {}
+
+    for node, position in pos.items():
+        x, y = position
+
+        # Draw icon
+        icon_id = icons.get(node, str(node))
+        ab = bio_icons.plot(
+            icon_id,
+            ax=ax,
+            x=x,
+            y=y,
+            size=icon_size,
+        )
+        icon_annotations[node] = ab
+
+        # Draw label if enabled
+        if show_labels:
+            txt = ax.text(
+                x,
+                y - label_offset,
+                labels.get(node, str(node)),
+                ha="center",
+                va="top",
+                fontsize=font_size,
+                color="#333333",
+            )
+            texts[node] = txt
+
+    # Set axis limits
+    x_coords = [v[0] for v in pos.values()]
+    y_coords = [v[1] for v in pos.values()]
+    margin = icon_size + label_offset + 0.1
+    ax.set_xlim([min(x_coords) - margin, max(x_coords) + margin])
+    ax.set_ylim([min(y_coords) - margin, max(y_coords) + margin])
+
+    return icon_annotations, texts

bsplot/panels.py

@@ -0,0 +1,110 @@
+import string
+
+
+def get_alphabet(index, uppercase=False):
+    """
+    Get the alphabet letter(s) corresponding to an index (1-based).
+    Extends beyond 'Z' to 'AA', 'AB', etc., if needed.
+
+    Parameters:
+        index (int): The 1-based index (1 = A, 2 = B, ..., 27 = AA).
+        uppercase (bool): If True, returns uppercase letters; otherwise, lowercase.
+
+    Returns:
+        str: The corresponding letter(s).
+    """
+    alphabet = string.ascii_uppercase if uppercase else string.ascii_lowercase
+    result = ""
+    while index > 0:
+        index, remainder = divmod(index - 1, 26)
+        result = alphabet[remainder] + result
+    return result
+
+
+def add_panel_number(
+    ax,
+    label,
+    option="letters",
+    background=False,
+    loc="upper left",
+        coord="axes",
+    x_scale=1,
+    y_scale=1.01,
+    x_shift=0,
+    y_shift=0,
+    **kwargs,
+):
+    """
+        Adds a label to the given axis near the upper-left corner.
+        If option is 'letters' and the label is a number, it converts it to the
+        corresponding alphabetical letter(s).
+
+        Placement coordinates:
+        - coord='axes' (default): positions are specified in axes-fraction coordinates
+            with (0,0) bottom-left and (1,1) top-right. x_shift/y_shift are interpreted
+            as fractions of the axes size (so they are data-independent).
+        - coord='data': positions are specified in data coordinates for backward
+            compatibility. In this mode x_scale/y_scale and x_shift/y_shift behave like
+            before, but are now robust to inverted axes.
+
+    Parameters:
+        ax (matplotlib.axes.Axes): The axis to add the label to.
+        label (int or str): The label to place in the upper left corner.
+        option (str): 'letters' to convert numbers to letters, 'numbers' to use label as-is.
+        background (bool): If True, adds a white rounded box behind the label.
+        loc (str): Currently unused; reserved for future placement options.
+        text_kwargs (dict): Additional keyword args forwarded to ax.text.
+        x_scale (float): Scale factor applied to the left x-limit before placement.
+        y_scale (float): Scale factor applied to the top y-limit before placement.
+        x_shift (float): Fraction of the x-axis span to shift after scaling
+            (+ moves right, - moves left), independent of data range.
+        y_shift (float): Fraction of the y-axis span to shift after scaling
+            (+ moves up, - moves down), independent of data range.
+    """
+    kwargs = {
+        "fontsize": 16,
+        "fontweight": "bold",
+        "va": "bottom",
+        "ha": "center",
+        **kwargs,
+    }
+    if option == "letters" and isinstance(label, int):
+        label = get_alphabet(label)
+
+    if background:
+        kwargs["bbox"] = {
+            "boxstyle": "round,pad=0.1",
+            "facecolor": "white",
+            "edgecolor": "none",
+            "alpha": 0.8,
+        }
+    else:
+        kwargs["bbox"] = None
+
+    if coord == "axes":
+        # Axes-fraction coordinates: robust to inverted/scaled axes
+        ax.text(
+            0.0 + x_shift,
+            1.0 + y_shift,
+            str(label),
+            transform=ax.transAxes,
+            **kwargs,
+        )
+    else:
+        # Data-coordinate placement (legacy). Robust to inverted axes.
+        x0, x1 = ax.get_xlim()
+        y0, y1 = ax.get_ylim()
+        x_left = min(x0, x1)
+        y_top = max(y0, y1)
+
+        x = x_left * x_scale
+        y = y_top * y_scale
+        x += abs(x1 - x0) * x_shift
+        y += abs(y1 - y0) * y_shift
+
+        ax.text(
+            x,
+            y,
+            str(label),
+            **kwargs,
+        )

bsplot/scientific_color_maps/_sync_from_zenodo_download.sh

@@ -0,0 +1 @@
+find "/Users/leonmartin_bih/Downloads/ScientificColourMaps8" -type f -name "*.txt" ! -name "*10*" ! -name "*25*" ! -name "*50*" ! -name "*HEX*" ! -name "*S*"  -exec cp {} "/Users/leonmartin_bih/tools/bsplot/bsplot/scientific_color_maps" \;