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

iplotx/label.py

@@ -7,6 +7,7 @@ from typing import (
     Sequence,
 )
 import numpy as np
+import pandas as pd
 import matplotlib as mpl
 
 from .style import (
@@ -39,7 +40,7 @@ class LabelCollection(mpl.artist.Artist):
 
     def __init__(
         self,
-        labels: Sequence[str],
+        labels: pd.Series,
         style: Optional[dict[str, dict]] = None,
         offsets: Optional[np.ndarray] = None,
         transform: mpl.transforms.Transform = mpl.transforms.IdentityTransform(),
@@ -97,6 +98,11 @@ class LabelCollection(mpl.artist.Artist):
             vmargin = stylei.pop("vmargin", 0.0)
             margins.append((hmargin, vmargin))
 
+            # Initially, ignore autoalignment since we do not know the
+            # rotations
+            if stylei.get("horizontalalignment") == "auto":
+                stylei["horizontalalignment"] = "center"
+
             art = mpl.text.Text(
                 self._offsets[i][0],
                 self._offsets[i][1],
@@ -107,15 +113,20 @@ class LabelCollection(mpl.artist.Artist):
             arts.append(art)
         self._labelartists = arts
         self._margins = np.array(margins)
+        self._rotations = np.zeros(len(self._labels))
 
     def _update_offsets(self, dpi: float = 72.0) -> None:
         """Update offsets including margins."""
-        offsets = self._adjust_offsets_for_margins(self._offsets, dpi=dpi)
-        self.set_offsets(offsets)
+        self.set_offsets(self._offsets, dpi=dpi)
 
-    def get_offsets(self) -> np.ndarray:
+    def get_offsets(self, with_margins: bool = False) -> np.ndarray:
         """Get the positions (offsets) of the labels."""
-        return self._offsets
+        if not with_margins:
+            return self._offsets
+        else:
+            return np.array(
+                [art.get_position() for art in self._labelartists],
+            )
 
     def _adjust_offsets_for_margins(self, offsets, dpi=72.0):
         margins = self._get_margins_with_dpi(dpi=dpi)
@@ -123,31 +134,67 @@ class LabelCollection(mpl.artist.Artist):
             transform = self.get_transform()
             trans = transform.transform
             trans_inv = transform.inverted().transform
-            offsets = trans_inv(trans(offsets) + margins)
+            rotations = self.get_rotations()
+            vrot = [np.cos(rotations), np.sin(rotations)]
+
+            margins_rot = np.empty_like(margins)
+            margins_rot[:, 0] = margins[:, 0] * vrot[0] - margins[:, 1] * vrot[1]
+            margins_rot[:, 1] = margins[:, 0] * vrot[1] + margins[:, 1] * vrot[0]
+            offsets = trans_inv(trans(offsets) + margins_rot)
         return offsets
 
-    def set_offsets(self, offsets) -> None:
+    def set_offsets(self, offsets, dpi: float = 72.0) -> None:
         """Set positions (offsets) of the labels.
 
         Parameters:
             offsets: A sequence of offsets for each label, specifying the position of the label.
         """
         self._offsets = np.asarray(offsets)
-        for art, offset in zip(self._labelartists, self._offsets):
+        offsets_with_margins = self._adjust_offsets_for_margins(offsets, dpi=dpi)
+        for art, offset in zip(self._labelartists, offsets_with_margins):
             art.set_position((offset[0], offset[1]))
 
+    def get_rotations(self) -> np.ndarray:
+        """Get the rotations of the labels in radians."""
+        return self._rotations
+
     def set_rotations(self, rotations: Sequence[float]) -> None:
         """Set the rotations of the labels.
 
         Parameters:
             rotations: A sequence of rotations in radians for each label.
         """
+        self._rotations = np.asarray(rotations)
+        ha = self._style.get("horizontalalignment", "center")
         for art, rotation in zip(self._labelartists, rotations):
             rot_deg = 180.0 / np.pi * rotation
             # Force the font size to be upwards
+            if ha == "auto":
+                if -90 <= rot_deg < 90:
+                    art.set_horizontalalignment("left")
+                else:
+                    art.set_horizontalalignment("right")
             rot_deg = ((rot_deg + 90) % 180) - 90
             art.set_rotation(rot_deg)
 
+    def get_datalim(self, transData=None) -> mpl.transforms.Bbox:
+        """Get the data limits of the labels."""
+        bboxes = self.get_datalims_children(transData=transData)
+        bbox = mpl.transforms.Bbox.union(bboxes)
+        return bbox
+
+    def get_datalims_children(self, transData=None) -> Sequence[mpl.transforms.Bbox]:
+        """Get the data limits of the children of this artist."""
+        if transData is None:
+            transData = self.get_transform()
+        trans_inv = transData.inverted().transform_bbox
+        bboxes = []
+        for art in self._labelartists:
+            bbox_fig = art.get_bbox_patch().get_extents()
+            bbox_data = trans_inv(bbox_fig)
+            bboxes.append(bbox_data)
+        return bboxes
+
     @_stale_wrapper
     def draw(self, renderer) -> None:
         """Draw each of the children, with some buffering mechanism."""

iplotx/layout.py

@@ -2,35 +2,48 @@
 Layout functions, currently limited to trees.
 """
 
-from collections.abc import Hashable
+from typing import Any
+from collections.abc import (
+    Hashable,
+    Callable,
+)
 
 import numpy as np
 
 
 def compute_tree_layout(
-    tree,
     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:
-        tree: The tree to compute the layout for.
-        layout: The name of the layout, e.g. "horizontal" or "radial".
-        orientation: The orientation of the layout, e.g. "right", "left", "descending", or
-            "ascending".
+        layout: The name of the layout, e.g. "horizontal", "vertial", 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
 
     if layout == "radial":
-        layout_dict = _circular_tree_layout(tree, orientation=orientation, **kwargs)
+        layout_dict = _radial_tree_layout(**kwargs)
     elif layout == "horizontal":
-        layout_dict = _horizontal_tree_layout(tree, orientation=orientation, **kwargs)
+        layout_dict = _horizontal_tree_layout(**kwargs)
     elif layout == "vertical":
-        layout_dict = _vertical_tree_layout(tree, orientation=orientation, **kwargs)
+        layout_dict = _vertical_tree_layout(**kwargs)
     else:
         raise ValueError(f"Tree layout not available: {layout}")
 
@@ -38,12 +51,11 @@ def compute_tree_layout(
 
 
 def _horizontal_tree_layout_right(
-    tree,
-    root_fun: callable,
-    preorder_fun: callable,
-    postorder_fun: callable,
-    children_fun: callable,
-    branch_length_fun: callable,
+    root: Any,
+    preorder_fun: Callable,
+    postorder_fun: Callable,
+    children_fun: Callable,
+    branch_length_fun: Callable,
 ) -> dict[Hashable, list[float]]:
     """Build a tree layout horizontally, left to right.
 
@@ -58,7 +70,7 @@ def _horizontal_tree_layout_right(
 
     # Set the y values for vertices
     i = 0
-    for node in postorder_fun(tree):
+    for node in postorder_fun():
         children = children_fun(node)
         if len(children) == 0:
             layout[node] = [None, i]
@@ -70,8 +82,8 @@ def _horizontal_tree_layout_right(
             ]
 
     # Set the x values for vertices
-    layout[root_fun(tree)][0] = 0
-    for node in preorder_fun(tree):
+    layout[root][0] = 0
+    for node in preorder_fun():
         for child in children_fun(node):
             bl = branch_length_fun(child)
             if bl is None:
@@ -82,7 +94,6 @@ def _horizontal_tree_layout_right(
 
 
 def _horizontal_tree_layout(
-    tree,
     orientation="right",
     **kwargs,
 ) -> dict[Hashable, list[float]]:
@@ -90,7 +101,7 @@ def _horizontal_tree_layout(
     if orientation not in ("right", "left"):
         raise ValueError("Orientation must be 'right' or 'left'.")
 
-    layout = _horizontal_tree_layout_right(tree, **kwargs)
+    layout = _horizontal_tree_layout_right(**kwargs)
 
     if orientation == "left":
         for key in layout:
@@ -99,13 +110,12 @@ def _horizontal_tree_layout(
 
 
 def _vertical_tree_layout(
-    tree,
     orientation="descending",
     **kwargs,
 ) -> dict[Hashable, list[float]]:
     """Vertical tree layout."""
-    sign = 1 if orientation == "descending" else -1
-    layout = _horizontal_tree_layout(tree, **kwargs)
+    sign = -1 if orientation == "descending" else 1
+    layout = _horizontal_tree_layout(**kwargs)
     for key, value in layout.items():
         # Invert x and y
         layout[key] = value[::-1]
@@ -114,24 +124,35 @@ def _vertical_tree_layout(
     return layout
 
 
-def _circular_tree_layout(
-    tree,
-    orientation="right",
-    starting_angle=0,
-    angular_span=360,
+def _radial_tree_layout(
+    orientation: str = "right",
+    start: float = 180,
+    span: float = 360,
     **kwargs,
-) -> dict[Hashable, list[float]]:
-    """Circular tree layout."""
+) -> dict[Hashable, tuple[float, float]]:
+    """Radial 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 radial layout.
+    """
     # Short form
-    th = starting_angle * np.pi / 180
-    th_span = angular_span * np.pi / 180
-    sign = 1 if orientation == "right" else -1
+    th = start * np.pi / 180
+    th_span = span * np.pi / 180
+    pad = int(span == 360)
+    sign = -1 if orientation in ("right", "clockwise") else 1
 
-    layout = _horizontal_tree_layout_right(tree, **kwargs)
+    layout = _horizontal_tree_layout_right(**kwargs)
     ymax = max(point[1] for point in layout.values())
     for key, (x, y) in layout.items():
         r = x
-        theta = sign * th_span * y / (ymax + 1) + th
+        theta = sign * th_span * y / (ymax + pad) + th
         # We export r and theta to ensure theta does not
         # modulo 2pi if we take the tan and then arctan later.
         layout[key] = (r, theta)

iplotx/plotting.py

@@ -123,9 +123,10 @@ def network(
 def tree(
     tree: Optional[TreeType] = None,
     layout: str | LayoutType = "horizontal",
-    orientation: str = "right",
+    orientation: Optional[str] = None,
     directed: bool | str = False,
     vertex_labels: Optional[list | dict | pd.Series] = None,
+    leaf_labels: Optional[list | dict | pd.Series] = None,
     ax: Optional[mpl.axes.Axes] = None,
     style: str | dict | Sequence[str | dict] = "tree",
     title: Optional[str] = None,
@@ -138,8 +139,9 @@ def tree(
     Parameters:
         tree: The tree to plot. Can be a BioPython.Phylo.Tree object.
         layout: The layout to use for plotting.
-        orientation: The orientation of the horizontal layout. Can be "right" or "left". Defaults to
-            "right".
+        orientation: The orientation of the layout. Can be "right" or "left". Defaults to
+            "right" for horizontal layout, "descending" or "ascending" for vertical layout,
+            and "clockwise" or "anticlockwise" for radial layout.
         directed: If False, donot draw arrows. If True or "child", draw arrows from parent to child
             node. If "parent", draw arrows the other way around.
 
@@ -160,6 +162,7 @@ def tree(
             transform=mpl.transforms.IdentityTransform(),
             offset_transform=ax.transData,
             vertex_labels=vertex_labels,
+            leaf_labels=leaf_labels,
         )
         ax.add_artist(artist)
 

iplotx/style.py

@@ -23,6 +23,8 @@ style_leaves = (
     "tension",
     "looptension",
     "loopmaxangle",
+    "paralleloffset",
+    "offset",
     "rotate",
     "marker",
     "waypoints",
@@ -34,15 +36,17 @@ style_leaves = (
     "hmargin",
     "vmargin",
     "ports",
+    "extend",
 )
 
 # These properties are not allowed to be rotated (global throughout the graph).
 # This might change in the future as the API improves.
 nonrotating_leaves = (
-    "offset",
+    "paralleloffset",
     "looptension",
     "loopmaxangle",
     "vertexpadding",
+    "extend",
 )
 
 
@@ -64,7 +68,7 @@ default = {
         "linestyle": "-",
         "color": "black",
         "curved": False,
-        "offset": 3,
+        "paralleloffset": 3,
         "tension": 1,
         "looptension": 4,
         "loopmaxangle": 60,
@@ -111,6 +115,7 @@ hollow["vertex"]["edgecolor"] = "black"
 hollow["vertex"]["linewidth"] = 1.5
 hollow["vertex"]["marker"] = "r"
 hollow["vertex"]["size"] = "label"
+hollow["vertex"]["label"]["color"] = "black"
 
 tree = copy_with_deep_values(default)
 tree["vertex"]["size"] = 0
@@ -123,8 +128,8 @@ tree["vertex"]["label"]["bbox"] = {
 }
 tree["vertex"]["label"]["color"] = "black"
 tree["vertex"]["label"]["size"] = 12
-tree["vertex"]["label"]["horizontalalignment"] = "left"
-tree["vertex"]["label"]["hmargin"] = 5
+tree["vertex"]["label"]["verticalalignment"] = "center"
+tree["vertex"]["label"]["hmargin"] = 10
 
 
 styles = {
@@ -145,13 +150,17 @@ def get_stylename():
     return str(stylename)
 
 
-def get_style(name: str = "") -> dict[str, Any]:
+def get_style(name: str = "", *args) -> dict[str, Any]:
     """Get a *deep copy* of the chosen style.
 
     Parameters:
         name: The name of the style to get. If empty, the current style is returned.
             Substyles can be obtained by using a dot notation, e.g. "default.vertex".
             If "name" starts with a dot, it means a substyle of the current style.
+        *args: A single argument is accepted. If present, this value (usually a
+            dictionary) is returned if the queried style is not found. For example,
+            get_style(".nonexistent") raises an Exception but
+            get_style("nonexistent", {}) does not, returning an empty dict instead.
     Returns:
         The requected style or substyle.
 
@@ -160,6 +169,9 @@ def get_style(name: str = "") -> dict[str, Any]:
         useful for hashables that change hash upon copying, such as Biopython's
         tree nodes.
     """
+    if len(args) > 1:
+        raise ValueError("get_style() accepts at most one additional argument.")
+
     namelist = name.split(".")
     style = styles
     for i, namei in enumerate(namelist):
@@ -173,6 +185,8 @@ def get_style(name: str = "") -> dict[str, Any]:
             # which will not fail unless the uder tries to enter it
             elif namei not in style_leaves:
                 style = {}
+            elif len(args) > 0:
+                return args[0]
             else:
                 raise KeyError(f"Style not found: {name}")