iplotx 1.2.1__py3-none-any.whl → 1.4.0__py3-none-any.whl

iplotx/edge/__init__.py

@@ -370,6 +370,9 @@ class EdgeCollection(mpl.collections.PatchCollection):
             if edge_stylei.get("curved", False):
                 tension = edge_stylei.get("tension", 5)
                 ports = edge_stylei.get("ports", (None, None))
+            elif edge_stylei.get("arc", False):
+                tension = edge_stylei.get("tension", 1)
+                ports = None
             else:
                 tension = 0
                 ports = None
@@ -391,6 +394,8 @@ class EdgeCollection(mpl.collections.PatchCollection):
             if waypoints != "none":
                 ports = edge_stylei.get("ports", (None, None))
 
+            arc = edge_stylei.get("arc", False)
+
             # Compute actual edge path
             path, angles = _compute_edge_path(
                 vcoord_data,
@@ -401,6 +406,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 tension=tension,
                 waypoints=waypoints,
                 ports=ports,
+                arc=arc,
                 layout_coordinate_system=self._vertex_collection.get_layout_coordinate_system(),
                 shrink=shrink,
             )
@@ -712,6 +718,7 @@ def make_stub_patch(**kwargs):
         "split",
         "shrink",
         "depthshade",
+        "arc",
         # DEPRECATED
         "padding",
     ]

iplotx/edge/geometry.py

@@ -393,6 +393,108 @@ def _compute_edge_path_waypoints(
     return path, angles
 
 
+def _compute_edge_path_arc(
+    tension,
+    vcoord_data,
+    vpath_fig,
+    vsize_fig,
+    trans,
+    trans_inv,
+    ports: Pair[Optional[str]] = (None, None),
+    shrink: float = 0,
+):
+    """Shorten the edge path along an arc.
+
+    Parameters:
+        tension: the tension of the arc. This is defined, for this function, as the tangent
+            of the angle spanning the arc. For instance, for a semicircle, the angle is
+            180 degrees, so the tension is +-1 (depending on the orientation).
+    """
+
+    # Coordinates in figure (default) coords
+    vcoord_fig = trans(vcoord_data)
+
+    dv = vcoord_fig[1] - vcoord_fig[0]
+
+    # Tension is the fraction of the semicircle covered by the
+    # arc. Values are clipped between -1 (left-hand semicircle)
+    # and 1 (right-hand semicircle). 0 means a straight line,
+    # which is a (degenerate) arc too.
+    if tension == 0:
+        vs = [None, None]
+        thetas = [atan2(dv[1], dv[0])]
+        thetas.append(-thetas[0])
+        for i in range(2):
+            vs[i] = (
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i], shrink)
+                + vcoord_fig[i]
+            )
+        auxs = []
+
+    else:
+        edge_straight_length = np.sqrt((dv**2).sum())
+        theta_straight = atan2(dv[1], dv[0])
+        theta_tension = 4 * np.arctan(tension)
+        # print(f"theta_straight: {np.degrees(theta_straight):.2f}")
+        # print(f"theta_tension: {np.degrees(theta_tension):.2f}")
+        # NOTE: positive tension means an arc shooting off to the right of the straight
+        # line, same convensio as for tension elsewhere in the codebase.
+        thetas = [theta_straight - theta_tension / 2, np.pi + theta_straight + theta_tension / 2]
+        # This is guaranteed to be finite because tension == 0 is taken care of above,
+        # and tension = np.inf is not allowed.
+        mid = vcoord_fig.mean(axis=0)
+        # print(f"theta_s: {thetas}")
+        # print(f"mid: {mid}")
+        theta_offset = theta_straight + np.pi / 2
+        if np.abs(tension) <= 1:
+            offset_length = edge_straight_length / 2 / np.tan(theta_tension / 2)
+        else:
+            # print("Large tension arc")
+            offset_length = -edge_straight_length / 2 * np.tan(theta_tension / 2 - np.pi / 2)
+        # print(f"theta_offset: {np.degrees(theta_offset):.2f}")
+        offset = offset_length * np.array([np.cos(theta_offset), np.sin(theta_offset)])
+        # print(f"offset: {offset}")
+        center = mid + offset
+        # print(f"center: {center}")
+
+        # Compute shorter start and end points
+        vs = [None, None]
+        for i in range(2):
+            vs[i] = (
+                _get_shorter_edge_coords(vpath_fig[i], vsize_fig[i], thetas[i], shrink)
+                + vcoord_fig[i]
+            )
+        angle_start = atan2(*(vs[0] - center)[::-1])
+        angle_end = atan2(*(vs[1] - center)[::-1])
+        if (np.abs(tension) > 1) and (np.abs(angle_end - angle_start) < np.pi):
+            if angle_end > angle_start:
+                angle_start += 2 * np.pi
+            else:
+                angle_end += 2 * np.pi
+        # print(f"angle_start: {np.degrees(angle_start):.2f}")
+        # print(f"angle_end: {np.degrees(angle_end):.2f}")
+
+        naux = 30
+        angles = np.linspace(angle_start, angle_end, naux + 2)[1:-1]
+        auxs = center + np.array([np.cos(angles), np.sin(angles)]).T * np.linalg.norm(
+            vs[0] - center
+        )
+
+    path = {
+        "vertices": [vs[0]] + list(auxs) + [vs[1]],
+        "codes": ["MOVETO"] + ["LINETO"] * (len(auxs) + 1),
+    }
+
+    path = mpl.path.Path(
+        path["vertices"],
+        codes=[getattr(mpl.path.Path, x) for x in path["codes"]],
+    )
+
+    # Return to data transform
+    path.vertices = trans_inv(path.vertices)
+    return path, tuple(thetas)
+
+
 def _compute_edge_path_curved(
     tension,
     vcoord_data,
@@ -483,12 +585,15 @@ def _compute_edge_path(
     tension: float = 0,
     waypoints: str | tuple[float, float] | Sequence[tuple[float, float]] | np.ndarray = "none",
     ports: Pair[Optional[str]] = (None, None),
+    arc: bool = False,
     layout_coordinate_system: str = "cartesian",
     **kwargs,
 ):
     """Compute the edge path in a few different ways."""
     if (waypoints != "none") and (tension != 0):
         raise ValueError("Waypoints not supported for curved edges.")
+    if (waypoints != "none") and arc:
+        raise ValueError("Waypoint not supported for arc edges.")
 
     if waypoints != "none":
         return _compute_edge_path_waypoints(
@@ -506,6 +611,14 @@ def _compute_edge_path(
             **kwargs,
         )
 
+    if arc:
+        return _compute_edge_path_arc(
+            tension,
+            *args,
+            ports=ports,
+            **kwargs,
+        )
+
     return _compute_edge_path_curved(
         tension,
         *args,

iplotx/ingest/providers/tree/biopython.py

@@ -21,8 +21,9 @@ class BiopythonDataProvider(TreeDataProvider):
 
     preorder = partialmethod(_traverse, order="preorder")
     postorder = partialmethod(_traverse, order="postorder")
+    levelorder = partialmethod(_traverse, order="level")
 
-    def get_leaves(self) -> Sequence[Any]:
+    def _get_leaves(self) -> Sequence[Any]:
         return self.tree.get_terminals()
 
     @staticmethod

iplotx/ingest/providers/tree/cogent3.py

@@ -16,7 +16,10 @@ class Cogent3DataProvider(TreeDataProvider):
     def postorder(self) -> Sequence[Any]:
         return self.tree.postorder()
 
-    def get_leaves(self) -> Sequence[Any]:
+    def levelorder(self) -> Sequence[Any]:
+        return self.tree.levelorder()
+
+    def _get_leaves(self) -> Sequence[Any]:
         return self.tree.tips()
 
     @staticmethod

iplotx/ingest/providers/tree/dendropy.py

@@ -36,7 +36,16 @@ class DendropyDataProvider(TreeDataProvider):
             return self.tree.postorder_node_iter()
         return self.tree.postorder_iter()
 
-    def get_leaves(self) -> Sequence[Any]:
+    def levelorder(self) -> Any:
+        """Levelorder traversal of the tree.
+
+        NOTE: This will work on both entire Trees and Nodes (which means a subtree including self).
+        """
+        if hasattr(self.tree, "levelorder_node_iter"):
+            return self.tree.levelorder_node_iter()
+        return self.tree.levelorder_iter()
+
+    def _get_leaves(self) -> Sequence[Any]:
         """Get a list of leaves."""
         return self.tree.leaf_nodes()
 

iplotx/ingest/providers/tree/ete4.py

@@ -18,8 +18,9 @@ class Ete4DataProvider(TreeDataProvider):
 
     preorder = partialmethod(_traverse, order="preorder")
     postorder = partialmethod(_traverse, order="postorder")
+    levelorder = partialmethod(_traverse, order="levelorder")
 
-    def get_leaves(self) -> Sequence[Any]:
+    def _get_leaves(self) -> Sequence[Any]:
         return self.tree.leaves()
 
     @staticmethod

iplotx/ingest/providers/tree/simple.py

@@ -64,7 +64,17 @@ class SimpleTreeDataProvider(TreeDataProvider):
 
         yield from _recur(self.tree)
 
-    def get_leaves(self) -> Sequence[Any]:
+    def levelorder(self) -> Iterable[dict[dict | str, Any]]:
+        from collections import deque
+
+        queue = deque([self.get_root()])
+        while queue:
+            node = queue.popleft()
+            for child in self.get_children(node):
+                queue.append(child)
+            yield node
+
+    def _get_leaves(self) -> Sequence[Any]:
         def _recur(node):
             if len(node.children) == 0:
                 yield node

iplotx/ingest/providers/tree/skbio.py

@@ -16,7 +16,10 @@ class SkbioDataProvider(TreeDataProvider):
     def postorder(self) -> Sequence[Any]:
         return self.tree.postorder()
 
-    def get_leaves(self) -> Sequence[Any]:
+    def levelorder(self) -> Sequence[Any]:
+        return self.tree.levelorder()
+
+    def _get_leaves(self) -> Sequence[Any]:
         return self.tree.tips()
 
     @staticmethod

iplotx/ingest/typing.py

@@ -12,6 +12,7 @@ from typing import (
     Any,
     Iterable,
 )
+
 # NOTE: __init__ in Protocols has had a difficult gestation
 # https://github.com/python/cpython/issues/88970
 if sys.version_info < (3, 11):
@@ -156,8 +157,32 @@ class TreeDataProvider(Protocol):
                 return root_attr
         return self.tree.get_root()
 
-    def get_leaves(self) -> Sequence[Any]:
-        """Get the tree leaves/tips in a provider-specific data structure.
+    def get_subtree(self, node: TreeType):
+        """Get the subtree rooted at the given node.
+
+        Parameters:
+            node: The node to get the subtree from.
+        Returns:
+            The subtree rooted at the given node.
+        """
+        return self.__class__(node)
+
+    def get_leaves(self, node: Optional[TreeType] = None) -> Sequence[Any]:
+        """Get the leaves of the entire tree or a subtree.
+
+        Parameters:
+            node: The node to get the leaves from. If None, get from the entire
+                tree.
+        Returns:
+            The leaves or tips of the tree or node-anchored subtree.
+        """
+        if node is None:
+            return self._get_leaves()
+        else:
+            return self.get_subtree(node)._get_leaves()
+
+    def _get_leaves(self) -> Sequence[Any]:
+        """Get the whole tree leaves/tips in a provider-specific data structure.
 
         Returns:
             The leaves or tips of the tree.
@@ -235,8 +260,6 @@ class TreeDataProvider(Protocol):
         NOTE: individual providers may implement more efficient versions of
         this function if desired.
         """
-        provider = self.__class__
-
         # Find leaves of the selected nodes
         leaves = set()
         for node in nodes:
@@ -244,7 +267,7 @@ class TreeDataProvider(Protocol):
             if len(self.get_children(node)) == 0:
                 leaves.add(node)
             else:
-                leaves |= set(provider(node).get_leaves())
+                leaves |= set(self.get_leaves(node))
 
         # Look for nodes with the same set of leaves, starting from the bottom
         # and stopping at the first (i.e. lowest) hit.
@@ -253,7 +276,7 @@ class TreeDataProvider(Protocol):
             if len(self.get_children(node)) == 0:
                 leaves_node = {node}
             else:
-                leaves_node = set(provider(node).get_leaves())
+                leaves_node = set(self.get_leaves(node))
             if leaves <= leaves_node:
                 root = node
                 break
@@ -285,9 +308,26 @@ class TreeDataProvider(Protocol):
                 orientation = "right"
             elif layout == "vertical":
                 orientation = "descending"
-            elif layout == "radial":
+            elif layout in ("radial", "equalangle", "daylight"):
                 orientation = "clockwise"
 
+        # Validate orientation
+        valid = (layout == "horizontal") and (orientation in ("right", "left"))
+        valid |= (layout == "vertical") and (orientation in ("ascending", "descending"))
+        valid |= (layout == "radial") and (
+            orientation in ("clockwise", "counterclockwise", "left", "right")
+        )
+        valid |= (layout == "equalangle") and (
+            orientation in ("clockwise", "counterclockwise", "left", "right")
+        )
+        valid |= (layout == "daylight") and (
+            orientation in ("clockwise", "counterclockwise", "left", "right")
+        )
+        if not valid:
+            raise ValueError(
+                f"Orientation '{orientation}' is not valid for layout '{layout}'.",
+            )
+
         tree_data = {
             "root": self.get_root(),
             "rooted": self.is_rooted(),
@@ -304,8 +344,10 @@ class TreeDataProvider(Protocol):
             root=tree_data["root"],
             preorder_fun=self.preorder,
             postorder_fun=self.postorder,
+            levelorder_fun=self.levelorder,
             children_fun=self.get_children,
             branch_length_fun=self.get_branch_length_default_to_one,
+            leaves_fun=self.get_leaves,
             **layout_style,
         )
         if layout in ("radial",):

iplotx/layout/__init__.py

@@ -0,0 +1,9 @@
+"""
+Layout functions.
+"""
+
+from .tree import compute_tree_layout
+
+__all__ = [
+    "compute_tree_layout",
+]

iplotx/layout/tree/__init__.py

@@ -0,0 +1,72 @@
+"""
+Tree layout algorithms.
+"""
+
+from typing import (
+    Any,
+)
+from collections.abc import (
+    Hashable,
+    Callable,
+)
+
+from .rooted import (
+    _horizontal_tree_layout,
+    _vertical_tree_layout,
+    _radial_tree_layout,
+)
+from .unrooted import (
+    _equalangle_tree_layout,
+    _daylight_tree_layout,
+)
+
+
+def compute_tree_layout(
+    layout: str,
+    orientation: str,
+    root: Any,
+    preorder_fun: Callable,
+    postorder_fun: Callable,
+    levelorder_fun: Callable,
+    children_fun: Callable,
+    branch_length_fun: Callable,
+    leaves_fun: Callable,
+    **kwargs,
+) -> dict[Hashable, list[float]]:
+    """Compute the layout for a tree.
+
+    Parameters:
+        layout: The name of the layout, e.g. "horizontal", "vertical", or "radial".
+        orientation: The orientation of the layout, e.g. "right", "left", "descending",
+            "ascending", "clockwise", "anticlockwise".
+
+    Returns:
+        A layout dictionary with node positions.
+    """
+    kwargs["root"] = root
+    kwargs["preorder_fun"] = preorder_fun
+    kwargs["postorder_fun"] = postorder_fun
+    kwargs["levelorder_fun"] = levelorder_fun
+    kwargs["children_fun"] = children_fun
+    kwargs["orientation"] = orientation
+    kwargs["branch_length_fun"] = branch_length_fun
+    kwargs["leaves_fun"] = leaves_fun
+
+    # Angular or not, the vertex layout is unchanged. Since we do not
+    # currently compute an edge layout here, we can ignore the option.
+    kwargs.pop("angular", None)
+
+    if layout == "radial":
+        layout_dict = _radial_tree_layout(**kwargs)
+    elif layout == "horizontal":
+        layout_dict = _horizontal_tree_layout(**kwargs)
+    elif layout == "vertical":
+        layout_dict = _vertical_tree_layout(**kwargs)
+    elif layout == "equalangle":
+        layout_dict = _equalangle_tree_layout(**kwargs)
+    elif layout == "daylight":
+        layout_dict = _daylight_tree_layout(**kwargs)
+    else:
+        raise ValueError(f"Tree layout not available: {layout}")
+
+    return layout_dict

iplotx/{layout.py → layout/tree/rooted.py}

@@ -1,5 +1,5 @@
 """
-Layout functions, currently limited to trees.
+Rooted tree layout for iplotx library.
 """
 
 from typing import (
@@ -14,55 +14,13 @@ from collections.abc import (
 import numpy as np
 
 
-def compute_tree_layout(
-    layout: str,
-    orientation: str,
-    root: Any,
-    preorder_fun: Callable,
-    postorder_fun: Callable,
-    children_fun: Callable,
-    branch_length_fun: Callable,
-    **kwargs,
-) -> dict[Hashable, list[float]]:
-    """Compute the layout for a tree.
-
-    Parameters:
-        layout: The name of the layout, e.g. "horizontal", "vertical", or "radial".
-        orientation: The orientation of the layout, e.g. "right", "left", "descending",
-            "ascending", "clockwise", "anticlockwise".
-
-    Returns:
-        A layout dictionary with node positions.
-    """
-    kwargs["root"] = root
-    kwargs["preorder_fun"] = preorder_fun
-    kwargs["postorder_fun"] = postorder_fun
-    kwargs["children_fun"] = children_fun
-    kwargs["branch_length_fun"] = branch_length_fun
-    kwargs["orientation"] = orientation
-
-    # Angular or not, the vertex layout is unchanged. Since we do not
-    # currently compute an edge layout here, we can ignore the option.
-    kwargs.pop("angular", None)
-
-    if layout == "radial":
-        layout_dict = _radial_tree_layout(**kwargs)
-    elif layout == "horizontal":
-        layout_dict = _horizontal_tree_layout(**kwargs)
-    elif layout == "vertical":
-        layout_dict = _vertical_tree_layout(**kwargs)
-    else:
-        raise ValueError(f"Tree layout not available: {layout}")
-
-    return layout_dict
-
-
 def _horizontal_tree_layout_right(
     root: Any,
     preorder_fun: Callable,
     postorder_fun: Callable,
     children_fun: Callable,
     branch_length_fun: Callable,
+    **kwargs,
 ) -> dict[Hashable, list[float]]:
     """Build a tree layout horizontally, left to right.
 
@@ -173,7 +131,7 @@ def _radial_tree_layout(
             360, it leaves a small gap at the end to ensure the first and last leaf
             are not overlapping.
     Returns:
-        A dictionary with the radial layout.
+        A dictionary with the layout.
     """
     # Short form
     th = start * np.pi / 180

iplotx/layout/tree/unrooted.py

@@ -0,0 +1,444 @@
+"""
+Unrooted tree layout for iplotx.
+"""
+
+from typing import (
+    Any,
+)
+from collections.abc import (
+    Hashable,
+    Callable,
+)
+import numpy as np
+
+
+def _equalangle_tree_layout(
+    root: Any,
+    preorder_fun: Callable,
+    postorder_fun: Callable,
+    children_fun: Callable,
+    branch_length_fun: Callable,
+    leaves_fun: Callable,
+    orientation: str = "right",
+    start: float = 180,
+    span: float = 360,
+    **kwargs,
+) -> dict[Hashable, list[float]]:
+    """Equal angle unrooted tree layout.
+
+    Parameters:
+        orientation: Whether the layout fans out towards the right (clockwise) or left
+            (anticlockwise).
+        start: The starting angle in degrees, default is -180 (left).
+        span: The angular span in degrees, default is 360 (full circle). When this is
+            360, it leaves a small gap at the end to ensure the first and last leaf
+            are not overlapping.
+    Returns:
+        A dictionary with the layout.
+
+    Reference: "Inferring Phylogenies" by Joseph Felsenstein, ggtree.
+    """
+
+    props = {
+        "layout": {},
+        "nleaves": {},
+        "start": {},
+        "end": {},
+        "angle": {},
+    }
+
+    props["layout"][root] = [0.0, 0.0]
+    props["start"][root] = 0.0
+    props["end"][root] = 360.0
+    props["angle"][root] = 0.0
+
+    # Count the number of leaves in each subtree
+    for node in postorder_fun():
+        props["nleaves"][node] = sum(props["nleaves"][child] for child in children_fun(node)) or 1
+
+    # Set the layout of everyone except the root
+    # NOTE: In ggtree, it says "postorder", but I cannot quite imagine how that would work,
+    # given that in postorder the root is visited last but it's also the only node about
+    # which we know anything at this point.
+    for node in preorder_fun():
+        nleaves = props["nleaves"][node]
+        children = children_fun(node)
+
+        # Get current node props
+        start = props["start"].get(node, 0)
+        end = props["end"].get(node, 0)
+        cur_x, cur_y = props["layout"].get(node, [0.0, 0.0])
+
+        total_angle = end - start
+
+        for child in children:
+            nleaves_child = props["nleaves"][child]
+            alpha = nleaves_child / nleaves * total_angle
+            if orientation in ("left", "counterclockwise"):
+                alpha = -alpha
+            beta = start + alpha / 2
+
+            props["layout"][child] = [
+                cur_x + branch_length_fun(child) * np.cos(np.radians(beta)),
+                cur_y + branch_length_fun(child) * np.sin(np.radians(beta)),
+            ]
+            # props["angle"][child] = -90 - beta * np.sign(beta - 180)
+            props["start"][child] = start
+            props["end"][child] = start + alpha
+            start += alpha
+
+    # FIXME: figure out how to tell the caller about "angle"
+    return props["layout"]
+
+
+def _daylight_tree_layout(
+    root: Any,
+    preorder_fun: Callable,
+    postorder_fun: Callable,
+    levelorder_fun: Callable,
+    children_fun: Callable,
+    branch_length_fun: Callable,
+    leaves_fun: Callable,
+    orientation: str = "right",
+    start: float = 180,
+    span: float = 360,
+    max_iter: int = 5,
+    dampening: float = 0.33,
+    max_correction: float = 10.0,
+    **kwargs,
+) -> dict[Hashable, list[float]]:
+    """Daylight unrooted tree layout.
+
+    Parameters:
+        orientation: Whether the layout fans out towards the right (clockwise) or left
+            (anticlockwise).
+        start: The starting angle in degrees, default is -180 (left).
+        span: The angular span in degrees, default is 360 (full circle). When this is
+            360, it leaves a small gap at the end to ensure the first and last leaf
+            are not overlapping.
+        max_iter: Maximum number of iterations to perform.
+        dampening: Dampening factor for angle adjustments. 1.0 means full adjustment.
+            The number must be strictily positive (usually between 0 excluded and 1
+            included).
+    Returns:
+        A dictionary with the layout.
+
+    Reference: "Inferring Phylogenies" by Joseph Felsenstein, ggtree.
+    """
+
+    delta_angle_min = 9.0
+
+    layout = _equalangle_tree_layout(
+        root,
+        preorder_fun,
+        postorder_fun,
+        children_fun,
+        branch_length_fun,
+        leaves_fun,
+        orientation,
+        start,
+        span,
+        **kwargs,
+    )
+
+    if len(layout) <= 2:
+        return layout
+
+    # Make all arrays for easier manipulation
+    orig_class = next(iter(layout.values())).__class__
+    for key, value in layout.items():
+        layout[key] = np.asarray(value)
+
+    all_leaves = list(leaves_fun(root))
+
+    change_avg = 1.0
+    for it in range(max_iter):
+        change_sum = 0
+        ninternal = 0
+        parents = [None] + list(levelorder_fun())
+        for parent in parents:
+            if parent is None:
+                # If the root has only two children, it's a passthrough node, skip it
+                if len(children_fun(root)) < 3:
+                    continue
+                # Else, include it
+                children = [root]
+            else:
+                children = children_fun(parent)
+
+            for node in children:
+                grandchildren = children_fun(node)
+                # Exclude leaves, since they have no children subtrees
+                # that can be adjusted. Exclude also passthrough nodes with
+                # a single child, because they are rotating rigidly when their
+                # parent does so or tells them to do so.
+                if len(grandchildren) < 2:
+                    continue
+
+                res = _apply_daylight_single_node(
+                    node,
+                    parent,
+                    grandchildren,
+                    all_leaves,
+                    layout,
+                    leaves_fun,
+                    children_fun,
+                    dampening,
+                    max_correction,
+                )
+                change_sum += res
+                ninternal += 1
+
+        change_avg = change_sum / ninternal
+        if change_avg < delta_angle_min:
+            break
+
+    # Make all lists again
+    for key, value in layout.items():
+        layout[key] = orig_class(value)
+
+    return layout
+
+
+def _apply_daylight_single_node(
+    node: Any,
+    parent: Any,
+    children: list[Any],
+    all_leaves: list[Any],
+    layout: dict[Hashable, np.ndarray],
+    leaves_fun: Callable,
+    children_fun: Callable,
+    dampening: float,
+    max_correction: float,
+) -> float:
+    """Apply daylight adjustment to a single internal node.
+
+    Parameters:
+        node: The internal node to adjust.
+    Returns:
+        The total change in angle applied.
+
+    NOTE: The layout is also changed in place.
+
+    # Inspired from:
+    # https://github.com/thomasp85/ggraph/blob/6c4ce81e460c50a16f9cd97e0b3a089f36901316/src/unrooted.cpp#L122
+    """
+
+    import os
+    from builtins import print as _print
+
+    DEBUG_DAYLIGHT = os.getenv("IPLOTX_DEBUG_DAYLIGHT", "0") == "1"
+
+    print = _print if DEBUG_DAYLIGHT else lambda *a, **k: None
+
+    # 1. Find daylight boundary leaves for each subtree. There are always at least two subtrees,
+    # the first child and the parent (this function is not called for leaves, and the root hopefully
+    # has at least two children).
+    p0 = layout[node]
+    bounds = {}
+
+    print("node")
+    print(node)
+    print(float(p0[0]), float(p0[1]))
+
+    # To find the parent side leaves, we take all leaves and skip the ones
+    # downstream of this node
+    leaves_below = leaves_fun(node)
+
+    # Check the parent first if there is one
+    if parent is not None:
+        leaves_parent_subtree = [leaf for leaf in all_leaves if leaf not in leaves_below]
+        vec1 = layout[parent] - p0
+        print("parent side leaves:")
+        print(parent)
+        print(
+            f"  node to parent vector: {vec1[0]:.2f}, {vec1[1]:.2f}, angle: {np.degrees(np.arctan2(vec1[1], vec1[0])):.2f}"
+        )
+        lower_angle, upper_angle = 2 * np.pi, -2 * np.pi
+        for leaf in leaves_parent_subtree:
+            vec2 = layout[leaf] - p0
+            angle = _anticlockwise_angle(vec1, vec2)
+            print("  parent side leaf:")
+            print(leaf)
+            print(
+                f"  node to leaf vector: {vec2[0]:.2f}, {vec2[1]:.2f}, angle: {np.degrees(np.arctan2(vec2[1], vec2[0])):.2f}"
+            )
+            print(f"  angle: {np.degrees(angle):.2f}")
+            if angle < lower_angle:
+                print("lowering lower angle")
+                lower_angle = angle
+                lower = leaf
+            else:
+                print("not lowering lower angle")
+            if angle > upper_angle:
+                print("raising upper angle")
+                upper_angle = angle
+                upper = leaf
+            else:
+                print("not raising upper angle")
+        bounds[parent] = (lower, upper, lower_angle, upper_angle)
+
+    # Repeat the exact same thing for each child rather than the parent
+    print("subtree leaves:")
+    for child in children:
+        vec1 = layout[child] - p0
+        print(
+            f"  node to child vector: {vec1[0]:.2f}, {vec1[1]:.2f}, angle: {np.degrees(np.arctan2(vec1[1], vec1[0])):.2f}"
+        )
+        lower_angle, upper_angle = 2 * np.pi, -2 * np.pi
+
+        for leaf in leaves_fun(child):
+            vec2 = layout[leaf] - p0
+            angle = _anticlockwise_angle(vec1, vec2)
+            print(
+                f"  node to leaf vector: {vec2[0]:.2f}, {vec2[1]:.2f}, angle: {np.degrees(np.arctan2(vec2[1], vec2[0])):.2f}"
+            )
+            print(leaf)
+            print(f"  angle: {np.degrees(angle):.2f}")
+            if angle < lower_angle:
+                print("lowering lower angle")
+                lower_angle = angle
+                lower = leaf
+            else:
+                print("not lowering lower angle")
+            if angle > upper_angle:
+                print("raising upper angle")
+                upper_angle = angle
+                upper = leaf
+            else:
+                print("not raising upper angle")
+        bounds[child] = (lower, upper, lower_angle, upper_angle)
+
+    for subtree, bound in bounds.items():
+        vec1 = layout[bound[0]] - p0
+        vec2 = layout[bound[1]] - p0
+        angle = _anticlockwise_angle(vec1, vec2)
+        print("subtree angles:")
+        print(f"  lower {np.degrees(np.arctan2(vec1[1], vec1[0])):.2f}")
+        print(f"  upper {np.degrees(np.arctan2(vec2[1], vec2[0])):.2f}")
+        print(f"  angle {np.degrees(angle):.2f}")
+
+    # 2. Compute daylight angles
+    # NOTE: Since Python 3.6, python keys are ordered by insertion order.
+    daylight = {}
+    subtrees = list(bounds.keys())
+    subtrees += [subtrees[0]]  # Repeat first subtree
+
+    for i in range(len(subtrees) - 1):
+        subtree = subtrees[i + 1]
+        old_subtree = subtrees[i]
+        lower = bounds[subtree][0]
+        old_upper = bounds[old_subtree][1]
+        vec1 = layout[old_upper] - p0
+        vec2 = layout[lower] - p0
+        angle = _anticlockwise_angle(vec1, vec2)
+        daylight[subtree] = float(angle)
+        print("daylight angle:")
+        print(f"  previous upper {np.degrees(np.arctan2(vec1[1], vec1[0])):.2f}")
+        print(f"  new lower      {np.degrees(np.arctan2(vec2[1], vec2[0])):.2f}")
+        print(f"  angle: {np.degrees(angle):.2f}")
+
+    daylight_avg = sum(daylight.values()) / len(daylight)
+    print(f"daylight average angle: {np.degrees(daylight_avg):.2f}")
+
+    # 3. Compute *excess* daylight and corrections
+    daylight_correction = {}
+    corr_cum = 0.0
+    print("daylight correction:")
+    for subtree, angle in daylight.items():
+        # Correction is negative of the residue
+        corr_cum -= angle - daylight_avg
+        daylight_correction[subtree] = corr_cum
+        print(f"  daylight angle: {np.degrees(angle):.2f}, correction: {np.degrees(corr_cum):.2f}")
+
+    # NOTE: the last daylight correction must be 0, otherwise we are just rotating the entire tree.
+    # In most cases, this will be the parent which cannot rotate anyway (for the same reason).
+    # However, when applied to the root node with 3+ children, the nonrotating one will be the first
+    # child, which is arbitrary but correct: even in this case, we do not want a merry-go-round.
+
+    # 4. Correct (the last one is dumb)
+    daylight_corrections_abs = 0.0
+    for subtree, correction in daylight_correction.items():
+        correction *= dampening
+        correction = np.clip(correction, np.radians(-max_correction), np.radians(max_correction))
+        print(f"Applying correction to subtree {subtree}: {np.degrees(correction):.2f}")
+        _rotate_subtree_anticlockwise(
+            leaf,
+            children_fun,
+            layout,
+            p0,
+            correction,
+            recur=True,
+        )
+        daylight_corrections_abs += abs(correction)
+
+    # __import__("ipdb").set_trace()
+
+    # Caller wants degrees
+    # NOTE: The denominator is -1 because the last correction is always zero anyway, so the
+    # actually possible corrections are #subtrees - 1.
+    return np.degrees(daylight_corrections_abs / (len(daylight_correction) - 1))
+
+
+# see: https://stackoverflow.com/questions/14066933/direct-way-of-computing-the-clockwise-angle-between-two-vectors
+def _anticlockwise_angle(v1, v2):
+    """Compute the anticlockwise angle between two 2D vectors.
+
+    Parameters:
+        v1: First vector.
+        v2: Second vector.
+    Returns:
+        The angle in radians.
+    """
+    dot = v1[0] * v2[0] + v1[1] * v2[1]
+    determinant = v1[0] * v2[1] - v1[1] * v2[0]
+    return np.arctan2(determinant, dot)
+
+
+def _rotate_subtree_anticlockwise(
+    node,
+    children_fun: Callable,
+    layout: dict[Hashable, list[float]],
+    pivot,
+    angle,
+    recur: bool = True,
+):
+    point = np.asarray(layout[node])
+    pivot = np.asarray(pivot)
+    layout[node] = _rotate_anticlockwise(
+        point,
+        pivot,
+        angle,
+    )
+    if not recur:
+        return
+    for child in children_fun(node):
+        _rotate_subtree_anticlockwise(
+            child,
+            children_fun,
+            layout,
+            pivot,
+            angle,
+        )
+
+
+def _rotate_anticlockwise(
+    point,
+    pivot,
+    angle,
+):
+    """Rotate a point around a piviot by angle (in radians).
+
+    Parameters:
+        point: The point to rotate.
+        pivot: The piviot point.
+        angle: The angle in radians.
+    Returns:
+        The rotated point.
+    """
+    point = np.asarray(point)
+    pivot = np.asarray(pivot)
+    cos = np.cos(angle)
+    sin = np.sin(angle)
+    rot = np.array([[cos, -sin], [sin, cos]])
+    return pivot + (point - pivot) @ rot

iplotx/style/leaf_info.py

@@ -41,6 +41,7 @@ nonrotating_leaves = (
     "deep",
     "angular",
     "curved",
+    "arc",
     "capstyle",
     "depthshade",
 )

iplotx/tree/__init__.py

@@ -445,7 +445,7 @@ class TreeArtist(mpl.artist.Artist):
         leaf_layout = self.get_layout("leaf").copy()
 
         # Set all to max depth
-        if user_leaf_style.get("deep", True):
+        if user_leaf_style.get("deep", False):
             if layout_name == "radial":
                 leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].max()
             elif (layout_name, orientation) == ("horizontal", "right"):
@@ -666,7 +666,10 @@ class TreeArtist(mpl.artist.Artist):
             norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
             edge_style["norm"] = norm
 
-        if get_style(".layout", {}).get("angular", False):
+        angular_layout = get_style(".layout", {}).get("angular", False)
+        if self._ipx_internal_data["layout_name"] in ("equalangle", "daylight"):
+            angular_layout = True
+        if angular_layout:
             edge_style.pop("waypoints", None)
         else:
             edge_style["waypoints"] = waypoints

iplotx/version.py

@@ -2,4 +2,4 @@
 iplotx version information module.
 """
 
-__version__ = "1.2.1"
+__version__ = "1.4.0"

{iplotx-1.2.1.dist-info → iplotx-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 1.2.1
+Version: 1.4.0
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx
@@ -36,9 +36,9 @@ Provides-Extra: networkx
 Requires-Dist: networkx>=2.0.0; extra == 'networkx'
 Description-Content-Type: text/markdown
 
-![Github Actions](https://github.com/fabilab/iplotx/actions/workflows/test.yml/badge.svg)
-![PyPI - Version](https://img.shields.io/pypi/v/iplotx)
-![RTD](https://readthedocs.org/projects/iplotx/badge/?version=latest)
+[![Github Actions](https://github.com/fabilab/iplotx/actions/workflows/test.yml/badge.svg)](https://github.com/fabilab/iplotx/actions/workflows/test.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/iplotx)](https://pypi.org/project/iplotx/)
+[![RTD](https://readthedocs.org/projects/iplotx/badge/?version=latest)](https://iplotx.readthedocs.io/en/latest/)
 [![Coverage Status](https://coveralls.io/repos/github/fabilab/iplotx/badge.svg?branch=main)](https://coveralls.io/github/fabilab/iplotx?branch=main)
 ![pylint](assets/pylint.svg)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.16599333.svg)](https://doi.org/10.5281/zenodo.16599333)
@@ -89,6 +89,13 @@ See [readthedocs](https://iplotx.readthedocs.io/en/latest/) for the full documen
 ## Gallery
 See [gallery](https://iplotx.readthedocs.io/en/latest/gallery/index.html).
 
+## Citation
+If you use `iplotx` for publication figures, please cite the [zenodo preprint](https://doi.org/10.5281/zenodo.16599333):
+
+```
+F. Zanini. (2025). Unified network visualisation in Python. Zenodo [PREPRINT]. https://doi.org/10.5281/zenodo.16599333
+```
+
 ## Features
 - Plot networks from multiple libraries including networkx, igraph and graph-tool, using Matplotlib. ✅
 - Plot trees from multiple libraries such as cogent3, ETE4, skbio, biopython, and dendropy. ✅

{iplotx-1.2.1.dist-info → iplotx-1.4.0.dist-info}/RECORD

@@ -1,45 +1,48 @@
 iplotx/__init__.py,sha256=RKlRSSEAv2qECd6rCiovdLDu-4k1eXMGCOCPt0xwpFA,523
 iplotx/artists.py,sha256=2dBDT240zGwKb6tIc_y9pXeyU3LuYeF9wjj2tvi4KJo,730
 iplotx/label.py,sha256=7eS8ByadrhdIFOZz19U4VrS-oXY_ndFYNB-D4RZbFqI,9573
-iplotx/layout.py,sha256=S-iFxHaIOzhBDG2JUzl9_oDBRP5TYY1hXnEOs0h1Rck,5588
 iplotx/plotting.py,sha256=RyAdvaHSpuyJkf8DF3SJBvEXBrPmJEdovUyAlBWQvqU,16228
 iplotx/typing.py,sha256=QLdzV358IiD1CFe88MVp0D77FSx5sSAVUmM_2WPPE8I,1463
-iplotx/version.py,sha256=2CsPuf8-y4qmmHpnn5_1DZwxypX8SRHYrsqTTmN1h5A,66
+iplotx/version.py,sha256=O8IErtvV5ZWlH0H4BksvQyiERBsQVCHqnwNyeNF_Nhk,66
 iplotx/vertex.py,sha256=_yYyvusn4vYvi6RBEW6CHa3vnbv43GnZylnMIaK4bG0,16040
 iplotx/art3d/vertex.py,sha256=Xf8Um30X2doCd8KdNN7332F6BxC4k72Mb_GeRAuzQfQ,2545
 iplotx/art3d/edge/__init__.py,sha256=uw1U_mMXqcZAvea-7JbU1PUKULQD1CMMrbwY02tiWRQ,8529
 iplotx/art3d/edge/arrow.py,sha256=14BFXY9kDOUGPZl2fMD9gRVGyaaN5kyd-l6ikBg6WHU,3601
 iplotx/art3d/edge/geometry.py,sha256=76VUmpPG-4Mls7x_994dMwdDPrWWnjT7nHJsHfwK_hA,2467
-iplotx/edge/__init__.py,sha256=GlY_CmlMVD1DWJeOb5cFQEP_4K1pPneS_fRLqAxNGMk,26573
+iplotx/edge/__init__.py,sha256=jH0qjRzlD7ZbiNziMv-rVOhiHPWtKc4WqBHRRbDQgvg,26795
 iplotx/edge/arrow.py,sha256=ymup2YT_0GVYMtZw_DSKrZqFHG_ysYteEhmoL6T8Mu4,17563
-iplotx/edge/geometry.py,sha256=jkTMvQC5425GjB_fmGLIPJeSDAr_7NZF8zZDLTrSj34,15541
+iplotx/edge/geometry.py,sha256=dczXCLCn5vlFm_SwXXh_gwf0h7irILSCdNIDKTuuqmA,19646
 iplotx/edge/leaf.py,sha256=SyGMv2PIOoH0pey8-aMVaZheK3hNe1Qz_okcyWbc4E4,4268
 iplotx/edge/ports.py,sha256=BpkbiEhX4mPBBAhOv4jcKFG4Y8hxXz5GRtVLCC0jbtI,1235
 iplotx/ingest/__init__.py,sha256=k1Q-7lSdotMR4RkF1x0t19RFsTknohX0L507Dw69WyU,5035
 iplotx/ingest/heuristics.py,sha256=715VqgfKek5LOJnu1vTo7RqPgCl-Bb8Cf6o7_Tt57fA,5797
-iplotx/ingest/typing.py,sha256=nk0UTqTuZoa9YE7F8RlOTqhxPw4OEYFTqrFFRWQs0jI,14488
+iplotx/ingest/typing.py,sha256=VYWlNGwn047J0i10vC_F3Lfnx2CSiX6IeH_NtAgHLQg,16089
 iplotx/ingest/providers/network/graph_tool.py,sha256=iTCf4zHe4Zmdd8Tlz6j7Xfo_FwfsIiK5JkQfH3uq7TM,3028
 iplotx/ingest/providers/network/igraph.py,sha256=WL9Yx2IF5QhUIoKMlozdyq5HWIZ-IJmNoeS8GOhL0KU,2945
 iplotx/ingest/providers/network/networkx.py,sha256=ehCg4npL073HX-eAG-VoP6refLPsMb3lYG51xt_rNjA,4636
 iplotx/ingest/providers/network/simple.py,sha256=e_aHhiHhN9DrMoNrt7tEMPURXGhQ1TYRPzsxDEptUlc,3766
-iplotx/ingest/providers/tree/biopython.py,sha256=4N_54cVyHHPcASJZGr6pHKE2p5R3i8Cm307SLlSLHLA,1480
-iplotx/ingest/providers/tree/cogent3.py,sha256=JmELbDK7LyybiJzFNbmeqZ4ySJoDajvFfJebpNfFKWo,1073
-iplotx/ingest/providers/tree/dendropy.py,sha256=uRMe46PfDPUTeNInUO2Gbp4pVr-WIFIZQvrND2tovsg,1548
-iplotx/ingest/providers/tree/ete4.py,sha256=D7usSq0MOjzrk3EoLi834IlaDGwv7_qG6Qt0ptfKqfI,928
-iplotx/ingest/providers/tree/simple.py,sha256=-T7Kf-G4F4niggy_tNZ8AafDf8fpDdthC-vlkjbEZso,2569
-iplotx/ingest/providers/tree/skbio.py,sha256=O1KUr8tYi28pZ3VVjapgO4Uj-YpMuix3GhOH5je8Lv4,822
+iplotx/ingest/providers/tree/biopython.py,sha256=si-ncMVHrdbwDVspznFbO7ajTaa37gqSfYGKdx9eoQ8,1538
+iplotx/ingest/providers/tree/cogent3.py,sha256=6omk0cDSmb2k2J1BQ9depcSPWcfamSyS0eIlRpLRgoM,1156
+iplotx/ingest/providers/tree/dendropy.py,sha256=MRmPdlrPwqCQWLkKM4vJLN4hpqLY7qGtNrBYs5pLP9E,1891
+iplotx/ingest/providers/tree/ete4.py,sha256=JT0Zv-nzHKTSJ0h4I7SxkwFafww_siDZ06Krvz-BT1U,991
+iplotx/ingest/providers/tree/simple.py,sha256=hin38l9ZAnuDGwZAPctxNhIBrmIkQYIkBMFPt9uALuE,2877
+iplotx/ingest/providers/tree/skbio.py,sha256=T3IbOBut98A2GoGJzo6Tzp108uFa9n485mV4M9J5xFk,905
+iplotx/layout/__init__.py,sha256=7on7I9CcbByz4X4hNJGsCc0GDFr3ul1K2UvTyvcGAWo,107
+iplotx/layout/tree/__init__.py,sha256=hxASc8uXMWbpxnEHnChMzb3VQTTIyU4ww7SQRez1hK0,2000
+iplotx/layout/tree/rooted.py,sha256=j3Y_Yd3YCWJRnhfE1qwEX5xCyUgvOJCX9Qfkc81B5BM,4215
+iplotx/layout/tree/unrooted.py,sha256=7iWLcQLwPsZgJpNlAnVKnEj-XI3twpYZhe4WztU9gEc,14668
 iplotx/network/__init__.py,sha256=cJ6m6s157AOCqg-znUAlsumuZ2jiE9QsVQ3-GCK01wo,13543
 iplotx/network/groups.py,sha256=E_eYVXRHjv1DcyA4RupTkMa-rRFrIKkt9Rxn_Elw9Nc,6796
 iplotx/style/__init__.py,sha256=rf1GutrE8hHUhCoe4FGKYX-aNtHuu_U-kYQnqUxZNrY,10282
-iplotx/style/leaf_info.py,sha256=3xBn7xv9Uy2KAqdhM9S6ew5ZBJrGRTXRL3xXb8atfLw,1018
+iplotx/style/leaf_info.py,sha256=oBiOH-fHt_D2Nic2eYeE5nG5nLIE_0gSDNbLAYe5g2w,1029
 iplotx/style/library.py,sha256=58Y8BlllGLsR4pQM7_PVCP5tH6_4GkchXZvJpqGHlcg,8534
-iplotx/tree/__init__.py,sha256=nV2iWrtpPhpGZnkEJqK8ydimMi7pJtRQ1Eqn5dgqUyA,31043
+iplotx/tree/__init__.py,sha256=sxVrxZcsDIZddBdtI-TxOs37FyeYbHBLYqkLPWs6c8M,31199
 iplotx/tree/cascades.py,sha256=Wwqhy46QGeb4LNGUuz_-bgNWUMz6PFzs_dIxIb1dtqc,8394
 iplotx/tree/scalebar.py,sha256=Yxt_kF8JdTwKGa8Jzqt3qVePPK5ZBG8P0EiONrsh3E8,11863
 iplotx/utils/geometry.py,sha256=6RrC6qaB0-1vIk1LhGA4CfsiMd-9JNniSPyL_l9mshE,9245
 iplotx/utils/internal.py,sha256=WWfcZDGK8Ut1y_tOHRGg9wSqY1bwSeLQO7dHM_8Tvwo,107
 iplotx/utils/matplotlib.py,sha256=p_53Oamof0RI4mtV8HrdDtZbgVqUxeUZ_KDvLZSiBUQ,8604
 iplotx/utils/style.py,sha256=vyNP80nDYVinqm6_9ltCJCtjK35ZcGlHvOskNv3eQBc,4225
-iplotx-1.2.1.dist-info/METADATA,sha256=DVxutHflrg2vXCJfyzmPR83ywc4_5DfGdrViUMvV43E,5001
-iplotx-1.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-iplotx-1.2.1.dist-info/RECORD,,
+iplotx-1.4.0.dist-info/METADATA,sha256=8mg2vInkk2LjL7kMr5jc9MXPsf35iAVBIOfOaWoqIsM,5407
+iplotx-1.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iplotx-1.4.0.dist-info/RECORD,,