iplotx 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

iplotx/cascades.py

@@ -0,0 +1,223 @@
+from typing import (
+    Any,
+    Optional,
+)
+import numpy as np
+import pandas as pd
+
+from .typing import (
+    TreeType,
+)
+from .ingest.typing import (
+    TreeDataProvider,
+)
+import matplotlib as mpl
+
+from .style import (
+    copy_with_deep_values,
+    rotate_style,
+)
+
+
+class CascadeCollection(mpl.collections.PatchCollection):
+    def __init__(
+        self,
+        tree: TreeType,
+        layout: pd.DataFrame,
+        layout_name: str,
+        orientation: str,
+        style: dict[str, Any],
+        provider: TreeDataProvider,
+        transform: mpl.transforms.Transform,
+        maxdepth: Optional[float] = None,
+    ):
+        self._layout_name = layout_name
+        self._orientation = orientation
+        style = copy_with_deep_values(style)
+        zorder = style.get("zorder", 0)
+
+        # NOTE: there is a weird bug in pandas when using generic Hashable-s
+        # with .loc. Seems like doing .T[...] works for individual index
+        # elements only though
+        def get_node_coords(node):
+            return layout.T[node].values
+
+        def get_leaves_coords(leaves):
+            return np.array(
+                [get_node_coords(leaf) for leaf in leaves],
+            )
+
+        if "color" in style:
+            style["facecolor"] = style["edgecolor"] = style.pop("color")
+        extend = style.get("extend", False)
+
+        # These patches need at least a facecolor (usually) or an edgecolor
+        # so it's safe to make a list from these
+        nodes_unordered = set()
+        for prop in ("facecolor", "edgecolor"):
+            if prop in style:
+                nodes_unordered |= set(style[prop].keys())
+
+        # Draw the patches from the closest to the root (earlier drawing)
+        # to the closer to the leaves (later drawing).
+        drawing_order = []
+        for node in provider(tree).preorder():
+            if node in nodes_unordered:
+                drawing_order.append(node)
+
+        if layout_name not in ("horizontal", "vertical", "radial"):
+            raise NotImplementedError(
+                f"Cascading patches not implemented for layout: {layout_name}.",
+            )
+
+        nleaves = sum(1 for leaf in provider(tree).get_leaves())
+        extend_mode = style.get("extend", False)
+        if extend_mode and (extend_mode != "leaf_labels"):
+            if layout_name == "horizontal":
+                if orientation == "right":
+                    maxdepth = layout.values[:, 0].max()
+                else:
+                    maxdepth = layout.values[:, 0].min()
+            elif layout_name == "vertical":
+                if orientation == "descending":
+                    maxdepth = layout.values[:, 1].min()
+                else:
+                    maxdepth = layout.values[:, 1].max()
+            elif layout_name == "radial":
+                # layout values are: r, theta
+                maxdepth = layout.values[:, 0].max()
+        self._maxdepth = maxdepth
+
+        cascading_patches = []
+        for node in drawing_order:
+            stylei = rotate_style(style, key=node)
+            stylei.pop("extend", None)
+            # Default alpha is 0.5 for simple colors
+            if isinstance(stylei.get("facecolor", None), str) and (
+                "alpha" not in stylei
+            ):
+                stylei["alpha"] = 0.5
+
+            provider_node = provider(node)
+            bl = provider_node.get_branch_length_default_to_one(node)
+            node_coords = get_node_coords(node).copy()
+            leaves_coords = get_leaves_coords(provider_node.get_leaves())
+            if len(leaves_coords) == 0:
+                leaves_coords = np.array([node_coords])
+
+            if layout_name in ("horizontal", "vertical"):
+                if layout_name == "horizontal":
+                    ybot = leaves_coords[:, 1].min() - 0.5
+                    ytop = leaves_coords[:, 1].max() + 0.5
+                    if orientation == "right":
+                        xleft = node_coords[0] - bl
+                        xright = maxdepth if extend else leaves_coords[:, 0].max()
+                    else:
+                        xleft = maxdepth if extend else leaves_coords[:, 0].min()
+                        xright = node_coords[0] + bl
+                elif layout_name == "vertical":
+                    xleft = leaves_coords[:, 0].min() - 0.5
+                    xright = leaves_coords[:, 0].max() + 0.5
+                    if orientation == "descending":
+                        ytop = node_coords[1] + bl
+                        ybot = maxdepth if extend else leaves_coords[:, 1].min()
+                    else:
+                        ytop = maxdepth if extend else leaves_coords[:, 1].max()
+                        ybot = node_coords[1] - bl
+
+                patch = mpl.patches.Rectangle(
+                    (xleft, ybot),
+                    xright - xleft,
+                    ytop - ybot,
+                    **stylei,
+                )
+            elif layout_name == "radial":
+                dtheta = 2 * np.pi / nleaves
+                rmin = node_coords[0] - bl
+                rmax = maxdepth if extend else leaves_coords[:, 0].max()
+                thetamin = leaves_coords[:, 1].min() - 0.5 * dtheta
+                thetamax = leaves_coords[:, 1].max() + 0.5 * dtheta
+                thetas = np.linspace(
+                    thetamin, thetamax, max(30, (thetamax - thetamin) // 3)
+                )
+                xs = list(rmin * np.cos(thetas)) + list(rmax * np.cos(thetas[::-1]))
+                ys = list(rmin * np.sin(thetas)) + list(rmax * np.sin(thetas[::-1]))
+                points = list(zip(xs, ys))
+                points.append(points[0])
+                codes = ["MOVETO"] + ["LINETO"] * (len(points) - 2) + ["CLOSEPOLY"]
+
+                if "edgecolor" not in stylei:
+                    stylei["edgecolor"] = "none"
+
+                path = mpl.path.Path(
+                    points,
+                    codes=[getattr(mpl.path.Path, code) for code in codes],
+                )
+                patch = mpl.patches.PathPatch(
+                    path,
+                    **stylei,
+                )
+
+            cascading_patches.append(patch)
+
+        super().__init__(
+            cascading_patches,
+            transform=transform,
+            match_original=True,
+            zorder=zorder,
+        )
+
+    def get_maxdepth(self) -> float:
+        """Get the maxdepth of the cascades.
+
+        Returns: The maximum depth of the cascading patches.
+        """
+        return self._maxdepth
+
+    def set_maxdepth(self, maxdepth: float):
+        """Set the maximum depth of the cascading patches.
+
+        Parameters:
+            maxdepth: The new maximum depth for the cascades.
+
+        NOTE: Calling this function updates the cascade patches
+        without chechking whether the extent style requires it.
+        """
+        self._maxdepth = maxdepth
+        self._update_maxdepth()
+
+    def _update_maxdepth(self):
+        """Update the cascades with a new max depth.
+
+        Note: This function changes the paths without checking whether
+        the extent is set or not.
+        """
+        layout_name = self._layout_name
+        orientation = self._orientation
+
+        # This being a PatchCollection, we have to touch the paths
+        if layout_name == "radial":
+            for path in self.get_paths():
+                # Old radii
+                r2old = np.linalg.norm(path.vertices[-2])
+                path.vertices[(len(path.vertices) - 1) // 2 :] *= (
+                    self.get_maxdepth() / r2old
+                )
+            return
+
+        if (layout_name, orientation) == ("horizontal", "right"):
+            for path in self.get_paths():
+                path.vertices[[1, 2], 0] = self.get_maxdepth()
+        elif (layout_name, orientation) == ("horizontal", "right"):
+            for path in self.get_paths():
+                path.vertices[[0, 3], 0] = self.get_maxdepth()
+        elif (layout_name, orientation) == ("vertical", "descending"):
+            for path in self.get_paths():
+                path.vertices[[1, 2], 1] = self.get_maxdepth()
+        elif (layout_name, orientation) == ("vertical", "ascending"):
+            for path in self.get_paths():
+                path.vertices[[0, 3], 1] = self.get_maxdepth()
+        else:
+            raise ValueError(
+                f"Layout name and orientation not supported: {layout_name}, {orientation}."
+            )

iplotx/edge/__init__.py

@@ -297,6 +297,8 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 ports = None
 
             waypoints = edge_stylei.get("waypoints", "none")
+            if waypoints != "none":
+                ports = edge_stylei.get("ports", (None, None))
 
             # Compute actual edge path
             path, angles = _compute_edge_path(
@@ -311,6 +313,22 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 layout_coordinate_system=self._vertex_collection.get_layout_coordinate_system(),
             )
 
+            offset = edge_stylei.get("offset", 0)
+            if np.isscalar(offset):
+                if offset == 0:
+                    offset = (0, 0)
+                else:
+                    vd_fig = trans(vcoord_data[1]) - trans(vcoord_data[0])
+                    vd_fig /= np.linalg.norm(vd_fig)
+                    vrot = vd_fig @ np.array([[0, -1], [1, 0]])
+                    offset = offset * vrot
+            offset = np.asarray(offset, dtype=float)
+            # Scale by dpi
+            dpi = self.figure.dpi if hasattr(self, "figure") else 72.0
+            offset *= dpi / 72.0
+            if (offset != 0).any():
+                path.vertices[:] = trans_inv(trans(path.vertices) + offset)
+
             # Collect angles for this vertex, to be used for loops plotting below
             if v1 in loop_vertex_dict:
                 loop_vertex_dict[v1]["edge_angles"].append(angles[0])
@@ -338,7 +356,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
                         indices_inv,
                         trans,
                         trans_inv,
-                        offset=self._style.get("offset", 3),
+                        paralleloffset=self._style.get("paralleloffset", 3),
                     )
 
         # 3. Deal with loops at the end
@@ -609,6 +627,7 @@ def make_stub_patch(**kwargs):
         "looptension",
         "loopmaxangle",
         "offset",
+        "paralleloffset",
         "cmap",
     ]
     for prop in forbidden_props:

iplotx/edge/geometry.py

@@ -108,7 +108,7 @@ def _fix_parallel_edges_straight(
     indices_inv,
     trans,
     trans_inv,
-    offset=3,
+    paralleloffset=3,
 ):
     """Offset parallel edges along the same path."""
     ntot = len(indices) + len(indices_inv)
@@ -124,7 +124,7 @@ def _fix_parallel_edges_straight(
     for i, idx in enumerate(indices + indices_inv):
         # Offset the path
         paths[idx].vertices = trans_inv(
-            trans(paths[idx].vertices) + fracs * offset * (i - ntot / 2)
+            trans(paths[idx].vertices) + fracs * paralleloffset * (i - ntot / 2)
         )
 
 
@@ -210,6 +210,7 @@ def _compute_edge_path_waypoints(
     trans_inv,
     layout_coordinate_system: str = "cartesian",
     points_per_curve: int = 30,
+    ports: Pair[Optional[str]] = (None, None),
     **kwargs,
 ):
 
@@ -225,22 +226,76 @@ def _compute_edge_path_waypoints(
             waypoint = np.array([vcoord_fig[1][0], vcoord_fig[0][1]])
 
         # Angles of the straight lines
-        theta0 = atan2(*((waypoint - vcoord_fig[0])[::-1]))
-        theta1 = atan2(*((waypoint - vcoord_fig[1])[::-1]))
-
-        # Shorten at starting vertex
-        vs = (
-            _get_shorter_edge_coords(vpath_fig[0], vsize_fig[0], theta0) + vcoord_fig[0]
-        )
+        thetas = [None, None]
+        vshorts = [None, None]
+        for i in range(2):
+            if ports[i] is None:
+                thetas[i] = atan2(*((waypoint - vcoord_fig[i])[::-1]))
+            else:
+                thetas[i] = atan2(*(_get_port_unit_vector(ports[i], trans_inv)[::-1]))
+
+            # Shorten at vertex border
+            vshorts[i] = (
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i])
+                + vcoord_fig[i]
+            )
 
-        # Shorten at end vertex
-        ve = (
-            _get_shorter_edge_coords(vpath_fig[1], vsize_fig[1], theta1) + vcoord_fig[1]
-        )
+        # Shorten waypoints to keep the angles right
+        if waypoints == "x0y1":
+            waypoint[0] = vshorts[0][0]
+            waypoint[1] = vshorts[1][1]
+        else:
+            waypoint[1] = vshorts[0][1]
+            waypoint[0] = vshorts[1][0]
 
-        points = [vs, waypoint, ve]
+        points = [vshorts[0], waypoint, vshorts[1]]
         codes = ["MOVETO", "LINETO", "LINETO"]
-        angles = (theta0, theta1)
+        angles = tuple(thetas)
+    elif waypoints in ("xmidy0,xmidy1", "x0ymid,x1ymid"):
+        # S-shaped orthogonal line
+        assert layout_coordinate_system == "cartesian"
+
+        # Coordinates in figure (default) coords
+        vcoord_fig = trans(vcoord_data)
+
+        if waypoints == "xmidy0,xmidy1":
+            xmid = 0.5 * (vcoord_fig[0][0] + vcoord_fig[1][0])
+            waypoint_array = np.array(
+                [
+                    [xmid, vcoord_fig[0][1]],
+                    [xmid, vcoord_fig[1][1]],
+                ]
+            )
+        else:
+            ymid = 0.5 * (vcoord_fig[0][1] + vcoord_fig[1][1])
+            waypoint_array = np.array(
+                [
+                    [vcoord_fig[0][0], ymid],
+                    [vcoord_fig[1][0], ymid],
+                ]
+            )
+
+        # Angles of the straight lines
+        thetas = []
+        vshorts = []
+        for i in range(2):
+            if ports[i] is None:
+                theta = atan2(*((waypoint_array[i] - vcoord_fig[i])[::-1]))
+            else:
+                theta = atan2(*(_get_port_unit_vector(ports[i], trans_inv)[::-1]))
+
+            # Shorten at vertex border
+            vshort = (
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], theta)
+                + vcoord_fig[i]
+            )
+            thetas.append(theta)
+            vshorts.append(vshort)
+
+        points = [vshorts[0], waypoint_array[0], waypoint_array[1], vshorts[1]]
+        codes = ["MOVETO", "LINETO", "LINETO", "LINETO"]
+        angles = tuple(thetas)
+
     elif waypoints == "r0a1":
         assert layout_coordinate_system == "polar"
 
@@ -283,7 +338,7 @@ def _compute_edge_path_curved(
     vsize_fig,
     trans,
     trans_inv,
-    ports=(None, None),
+    ports: Pair[Optional[str]] = (None, None),
 ):
     """Shorten the edge path along a cubic Bezier between the vertex centres.
 
@@ -378,6 +433,7 @@ def _compute_edge_path(
             waypoints,
             *args,
             layout_coordinate_system=layout_coordinate_system,
+            ports=ports,
             **kwargs,
         )
 

iplotx/ingest/__init__.py

@@ -45,7 +45,7 @@ for kind in data_providers:
             if key == provider_protocols[kind].__name__:
                 continue
             if key.endswith("DataProvider"):
-                data_providers[kind][module_name] = val()
+                data_providers[kind][module_name] = val
                 break
     del providers_path
 
@@ -95,7 +95,7 @@ def ingest_network_data(
             f"Currently installed supported libraries: {sup}."
         )
 
-    result = provider(
+    result = provider()(
         network=network,
         layout=layout,
         vertex_labels=vertex_labels,
@@ -108,10 +108,12 @@ def ingest_network_data(
 def ingest_tree_data(
     tree: TreeType,
     layout: Optional[str] = "horizontal",
-    orientation: Optional[str] = "right",
+    orientation: Optional[str] = None,
     directed: bool | str = False,
+    layout_style: Optional[dict[str, str | int | float]] = None,
     vertex_labels: Optional[Sequence[str] | dict[Hashable, str] | pd.Series] = None,
-    edge_labels: Optional[Sequence[str] | dict[str,]] = None,
+    edge_labels: Optional[Sequence[str] | dict[Hashable, str]] = None,
+    leaf_labels: Optional[Sequence[str] | dict[Hashable, str] | pd.Series] = None,
 ) -> TreeData:
     """Create internal data for the tree."""
     _update_data_providers("tree")
@@ -129,13 +131,19 @@ def ingest_tree_data(
 
     result = provider(
         tree=tree,
+    )(
         layout=layout,
         orientation=orientation,
         directed=directed,
+        layout_style=layout_style,
         vertex_labels=vertex_labels,
         edge_labels=edge_labels,
+        leaf_labels=leaf_labels,
     )
     result["tree_library"] = tl
+
+    # TODO: cascading thing here
+
     return result
 
 

iplotx/ingest/heuristics.py

@@ -15,7 +15,6 @@ from ..layout import compute_tree_layout
 from ..typing import (
     GraphType,
     GroupingType,
-    TreeType,
     LayoutType,
 )
 
@@ -91,7 +90,6 @@ def normalise_layout(layout, network=None):
 
 def normalise_tree_layout(
     layout: str | Any,
-    tree: Optional[TreeType] = None,
     **kwargs,
 ) -> pd.DataFrame:
     """Normalise tree layout from a variety of inputs.
@@ -108,7 +106,7 @@ def normalise_tree_layout(
         the layout internally. This might change in the future.
     """
     if isinstance(layout, str):
-        layout = compute_tree_layout(tree, layout, **kwargs)
+        layout = compute_tree_layout(layout, **kwargs)
     else:
         raise NotImplementedError(
             "Only internally computed tree layout currently accepted."

iplotx/ingest/providers/network/igraph.py

@@ -83,14 +83,16 @@ class IGraphDataProvider(NetworkDataProvider):
         }
         return network_data
 
-    def check_dependencies(self) -> bool:
+    @staticmethod
+    def check_dependencies() -> bool:
         try:
             import igraph
         except ImportError:
             return False
         return True
 
-    def graph_type(self):
+    @staticmethod
+    def graph_type():
         import igraph as ig
 
         return ig.Graph

iplotx/ingest/providers/network/networkx.py

@@ -120,14 +120,16 @@ class NetworkXDataProvider(NetworkDataProvider):
         }
         return network_data
 
-    def check_dependencies(self) -> bool:
+    @staticmethod
+    def check_dependencies() -> bool:
         try:
             import networkx
         except ImportError:
             return False
         return True
 
-    def graph_type(self):
+    @staticmethod
+    def graph_type():
         from networkx import Graph
 
         return Graph

iplotx/ingest/providers/tree/biopython.py

@@ -1,105 +1,47 @@
 from typing import (
+    Any,
     Optional,
     Sequence,
 )
-from collections.abc import Hashable
-from operator import attrgetter
-import numpy as np
-import pandas as pd
+from functools import partialmethod
 
-from ....typing import (
-    TreeType,
-    LayoutType,
-)
 from ...typing import (
     TreeDataProvider,
-    TreeData,
-)
-from ...heuristics import (
-    normalise_tree_layout,
 )
 
 
 class BiopythonDataProvider(TreeDataProvider):
-    def __call__(
-        self,
-        tree: TreeType,
-        layout: str | LayoutType,
-        orientation: str = "horizontal",
-        directed: bool | str = False,
-        vertex_labels: Optional[
-            Sequence[str] | dict[Hashable, str] | pd.Series | bool
-        ] = None,
-        edge_labels: Optional[Sequence[str] | dict] = None,
-    ) -> TreeData:
-        """Create tree data object for iplotx from BioPython.Phylo.Tree classes."""
+    def is_rooted(self) -> bool:
+        return self.tree.rooted
 
-        tree_data = {
-            "root": tree.root,
-            "leaves": tree.get_terminals(),
-            "rooted": tree.rooted,
-            "directed": directed,
-            "ndim": 2,
-            "layout_name": layout,
-        }
+    def _traverse(self, order: str) -> Any:
+        """Traverse the tree."""
+        return self.tree.find_clades(order=order)
 
-        # Add vertex_df including layout
-        tree_data["vertex_df"] = normalise_tree_layout(
-            layout,
-            tree=tree,
-            orientation=orientation,
-            root_fun=attrgetter("root"),
-            preorder_fun=lambda tree: tree.find_clades(order="preorder"),
-            postorder_fun=lambda tree: tree.find_clades(order="postorder"),
-            children_fun=attrgetter("clades"),
-            branch_length_fun=attrgetter("branch_length"),
-        )
-        if layout in ("radial",):
-            tree_data["layout_coordinate_system"] = "polar"
-        else:
-            tree_data["layout_coordinate_system"] = "cartesian"
+    preorder = partialmethod(_traverse, order="preorder")
+    postorder = partialmethod(_traverse, order="postorder")
 
-        # Add edge_df
-        edge_data = {"_ipx_source": [], "_ipx_target": []}
-        for node in tree.find_clades(order="preorder"):
-            for child in node.clades:
-                if directed == "parent":
-                    edge_data["_ipx_source"].append(child)
-                    edge_data["_ipx_target"].append(node)
-                else:
-                    edge_data["_ipx_source"].append(node)
-                    edge_data["_ipx_target"].append(child)
-        edge_df = pd.DataFrame(edge_data)
-        tree_data["edge_df"] = edge_df
+    def get_leaves(self) -> Sequence[Any]:
+        return self.tree.get_terminals()
 
-        # Add vertex labels
-        if vertex_labels is None:
-            vertex_labels = False
-        if np.isscalar(vertex_labels) and vertex_labels:
-            tree_data["vertex_df"]["label"] = [
-                x.name for x in tree_data["vertices"].index
-            ]
-        elif not np.isscalar(vertex_labels):
-            # If a dict-like object is passed, it can be incomplete (e.g. only the leaves):
-            # we fill the rest with empty strings which are not going to show up in the plot.
-            if isinstance(vertex_labels, pd.Series):
-                vertex_labels = dict(vertex_labels)
-            if isinstance(vertex_labels, dict):
-                for vertex in tree_data["vertex_df"].index:
-                    if vertex not in vertex_labels:
-                        vertex_labels[vertex] = ""
-            tree_data["vertex_df"]["label"] = pd.Series(vertex_labels)
+    @staticmethod
+    def get_children(node: Any) -> Sequence[Any]:
+        return node.clades
 
-        return tree_data
+    @staticmethod
+    def get_branch_length(node: Any) -> Optional[float]:
+        return node.branch_length
 
-    def check_dependencies(self) -> bool:
+    @staticmethod
+    def check_dependencies() -> bool:
         try:
             from Bio import Phylo
         except ImportError:
             return False
         return True
 
-    def tree_type(self):
+    @staticmethod
+    def tree_type():
         from Bio import Phylo
 
         return Phylo.BaseTree.Tree