phylustrator 0.2.16__tar.gz → 0.3.0__tar.gz

{phylustrator-0.2.16/src/phylustrator.egg-info → phylustrator-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phylustrator
-Version: 0.2.16
+Version: 0.3.0
 Summary: A composable plotter for evolutionary figures: phylogenetic trees, genomes, synteny and alignments
 Author-email: "Adrian A. Davin" <aaredav@gmail.com>
 License: MIT
@@ -75,6 +75,8 @@ That is the whole idea: `plot(tree)` starts a figure and each `+ layer` adds one
 - **Layers** — `color_branches`, `color_history`, `tip_labels`, `node_labels`, `tip_track`,
   `branch_events`, `colorbar`, `legend`, `time_axis`, `time_marker`, `scale_bar`, `note`,
   `highlight_clade`.
+- **Panels** — `node_points`, placed under a rectangular tree with `ph.below(tree, panel)`. The panel
+  shares the tree's time axis, so a value measured at a node sits directly under that node.
 
 ## Genomes
 

{phylustrator-0.2.16 → phylustrator-0.3.0}/README.md

@@ -36,6 +36,8 @@ That is the whole idea: `plot(tree)` starts a figure and each `+ layer` adds one
 - **Layers** — `color_branches`, `color_history`, `tip_labels`, `node_labels`, `tip_track`,
   `branch_events`, `colorbar`, `legend`, `time_axis`, `time_marker`, `scale_bar`, `note`,
   `highlight_clade`.
+- **Panels** — `node_points`, placed under a rectangular tree with `ph.below(tree, panel)`. The panel
+  shares the tree's time axis, so a value measured at a node sits directly under that node.
 
 ## Genomes
 

{phylustrator-0.2.16 → phylustrator-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "phylustrator"
-version = "0.2.16"
+version = "0.3.0"
 description = "A composable plotter for evolutionary figures: phylogenetic trees, genomes, synteny and alignments"
 readme = "README.md"
 requires-python = ">=3.10"

{phylustrator-0.2.16 → phylustrator-0.3.0}/src/phylustrator/__init__.py

@@ -12,8 +12,9 @@ Two domains, one grammar (``plot(x) + layer + …``), one shared drawing backend
     G = ph.zombi.read_genomes("run")
     (ph.genomes.plot(G["n12"], layout="circular") + ph.genomes.genes(by="family")).save("ring.png")
 
-    # bridge: a matrix beside a tree
+    # bridge: a matrix beside a tree, or a per-node value below it on the same time axis
     ph.beside(ph.trees.plot(tree) + ph.trees.tip_labels(), ph.genomes.heatmap(ph.zombi.read_profiles("run")))
+    ph.below(ph.trees.plot(tree), ph.trees.node_points({"C": 1.5, "R": -0.5}))
 
 ``ph.zombi`` is the only ZOMBI2-format-aware module; ``trees`` / ``genomes`` are general.
 """
@@ -24,7 +25,7 @@ from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as _pkg_version
 
 from . import genomes, trees, zombi
-from .compose import Composite, beside
+from .compose import Composite, below, beside
 from .style import Style
 
 try:  # single source of truth is pyproject.toml; read it from the installed metadata
@@ -32,4 +33,4 @@ try:  # single source of truth is pyproject.toml; read it from the installed met
 except PackageNotFoundError:  # a source tree that hasn't been installed
     __version__ = "0.0.0+unknown"
 
-__all__ = ["trees", "genomes", "zombi", "beside", "Composite", "Style", "__version__"]
+__all__ = ["trees", "genomes", "zombi", "beside", "below", "Composite", "Style", "__version__"]

phylustrator-0.3.0/src/phylustrator/compose.py

@@ -0,0 +1,121 @@
+"""Composition — put a panel beside a Phylustrator tree, rows lined up with the tips, or below it,
+lined up with the time axis.
+
+``beside(tree, panel)`` takes a **Phylustrator** figure (the phylogeny — Phylustrator draws it, we do
+not redraw it) and a panel (``heatmap`` / ``alignment``). It asks the tree for its tip pixel positions
+(``Figure.geometry``), renders the tree into the left column, and draws the panel to the right with
+each row at its tip's ``y`` — so a genome's row sits exactly on its leaf.
+
+``below(tree, panel)`` is its x-axis twin: the panel (``trees.node_points``) sits under the tree and
+places each value at its node's pixel ``x``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+from .render import Canvas
+from .style import Style
+from .trees.layers.guides import draw_time_axis
+
+
+class Composite:
+    """The rendered composite; save like any figure."""
+
+    def __init__(self, canvas: Canvas) -> None:
+        self._canvas = canvas
+
+    def as_svg(self) -> str:
+        return self._canvas.as_svg()
+
+    def save(self, path):
+        return self._canvas.save(path)
+
+
+def beside(tree, panel, *, width: float = 1100.0, height: float | None = None,
+           tree_fraction: float = 0.4, gap: float = 18.0, pad: float = 34.0,
+           footer: float = 0.0, background: str = "white") -> Composite:
+    """Render Phylustrator ``tree`` on the left and ``panel`` on the right, rows aligned to the tips.
+
+    ``tree_fraction`` is the share of the width given to the tree column (the rest, minus ``gap`` and
+    ``pad``, holds the panel). ``footer`` reserves blank height below the rows (for a panel's colour
+    key). Rows are matched to tips by label and drawn in the tree's tip order. Needs ``cairosvg``."""
+    try:
+        import cairosvg
+    except ImportError as exc:                       # pragma: no cover
+        raise RuntimeError("genustrator.beside needs cairosvg (pip install genustrator[export]) "
+                           "to place the tree into the composite") from exc
+
+    n_tips = len(tree.tree.leaves)
+    # per-tip row height eases from ~44px (few tips) down to ~24px (many), so 25-40 rows stay sane
+    row_px = max(24.0, 46.0 - 0.55 * n_tips)
+    H = height if height is not None else max(260.0, 70.0 + row_px * n_tips) + footer
+    tree_w = round(width * tree_fraction)
+    tree_h = H - footer                              # tips fill the area above the footer
+
+    sized = tree.with_size(tree_w, tree_h)
+    geom = sized.geometry()
+    png = cairosvg.svg2png(bytestring=sized.as_svg().encode(),
+                           output_width=int(tree_w * 2), output_height=int(tree_h * 2))
+
+    canvas = Canvas(Style(width=width, height=H, margin=0, background=background), (0.0, 1.0), (0.0, 1.0))
+    canvas.embed_png(png, 0, 0, tree_w, tree_h)
+
+    # A panel that wants **every** tip row says so, and gets them all — including tips it has no
+    # value for. `Bars` does: its axis sits under the last row it is handed, and filtering the rows
+    # down to the ones it has values for put that axis under the last *valued* tip instead of under
+    # the tree, so a tree with extinct tips below the last bar drew its two axes at different heights.
+    wanted = set(panel.rows)
+    rows = [(t.name, t.y) for t in geom.tips
+            if getattr(panel, "all_rows", False) or t.name in wanted]
+    if rows:
+        panel.draw(canvas, tree_w + gap, width - pad, rows, canvas.style)
+    return Composite(canvas)
+
+
+def below(tree, panel, *, panel_height: float = 200.0, gap: float = 18.0, axis: str | None = "Time",
+          ticks: int = 5) -> Composite:
+    """Render Phylustrator ``tree`` with ``panel`` underneath, both on the tree's x axis.
+
+    The x-axis twin of :func:`beside`: a value at a node sits directly under that node (see
+    :func:`~phylustrator.trees.node_points`). The tree keeps its own style — width, height, margins —
+    and every node lands on the pixel it has in the tree alone. The page grows by ``gap`` plus
+    ``panel_height``, and the panel spans the tree's left and right pixel edges.
+
+    ``axis`` labels a time axis under the panel; ``None`` draws none. Leave ``time_axis`` off the
+    tree itself: anything a tree layer puts in its bottom margin (``time_axis``, ``scale_bar``, a
+    bottom-left ``colorbar``) lands in the panel. The panel's y axis sits in the tree's left margin,
+    so widen ``margin_left`` in the tree's ``Style`` for long tick labels or a y label.
+
+    Rectangular trees only, since that is the layout where x is time. The composite is drawn as
+    vectors on one canvas, so it needs no cairosvg (unlike :func:`beside`)."""
+    if tree.layout != "rectangular":
+        raise ValueError(f"below() needs a rectangular tree, where x is time; got layout={tree.layout!r}")
+    if not hasattr(panel, "draw_below"):
+        raise TypeError(f"below() takes a panel lined up with the tree's x axis, such as trees.node_points; "
+                        f"{type(panel).__name__} is not one (a row panel goes in beside())")
+    style = tree.style
+    ts, ls = style.font_size * 0.85, style.font_size
+    plot_bottom = style.height - style.margin_at("bottom")      # where the lowest tip sits in the tree alone
+    top = plot_bottom + gap
+    bottom = top + panel_height
+    # Under the panel: the tree's bottom margin, or more when the axis needs it. The axis label is
+    # centred 14 + ts + ls + 4 below the panel, so a 40px margin cut the label in half.
+    if axis is None:
+        axis_room = 0.0
+    elif axis:
+        axis_room = 14 + ts + ls + 4 + ls / 2 + 6
+    else:                                                       # ticks, no label
+        axis_room = 14 + ts + 3 + ts / 2 + 6
+    height = bottom + max(style.margin_at("bottom"), axis_room)
+    # The same tree on a taller page, with all the extra height given to its bottom margin: the
+    # nodes keep their pixels, and the panel is drawn into that margin on the same canvas.
+    sized = tree.with_style(replace(style, height=height, margin_bottom=height - plot_bottom))
+    geom = sized.geometry()
+    canvas = sized._build()
+    panel.draw_below(canvas, geom, top, bottom, style)
+    if axis is not None:
+        # +14 below the panel, the offset trees.time_axis leaves below a tree
+        draw_time_axis(canvas, geom.px, geom.xlim[1], bottom + 14, axis, ticks=ticks,
+                       tick_size=ts, label_size=ls)
+    return Composite(canvas)

{phylustrator-0.2.16 → phylustrator-0.3.0}/src/phylustrator/genomes/figure.py

@@ -173,14 +173,13 @@ class GridFigure(Figure):
     def _build(self) -> Canvas:
         from ..color import colormap, to_hex
 
-        m = self.style.margin
         canvas = Canvas(self.style, (0.0, 1.0), (0.0, 1.0))
         nrow, ncol = len(self.matrix.rows), len(self.matrix.cols)
         if not nrow or not ncol:
             return canvas
-        x0, y0 = m, m
-        w = self.style.width - 2 * m
-        h = self.style.height - 2 * m
+        x0, y0 = self.style.margin_at("left"), self.style.margin_at("top")
+        w = self.style.width - x0 - self.style.margin_at("right")
+        h = self.style.height - y0 - self.style.margin_at("bottom")
         cw, ch = w / ncol, h / nrow
 
         sample = colormap(self.cmap)

{phylustrator-0.2.16 → phylustrator-0.3.0}/src/phylustrator/genomes/layers/guides.py

@@ -25,9 +25,8 @@ def position_axis(label: str = "position", *, ticks: int = 6):
 
 def _linear(canvas, layout, style, label, ticks) -> None:
     _, height = canvas.size
-    m = style.margin
     x0, x1 = layout.xlim
-    y = height - m * 0.62
+    y = height - style.margin_at("bottom") * 0.62
     canvas.raw_line(canvas.px(x0), y, canvas.px(x1), y, "#333333", 1.2)
     small = style.font_size * 0.85
     for i in range(ticks):

{phylustrator-0.2.16 → phylustrator-0.3.0}/src/phylustrator/render.py

@@ -10,6 +10,7 @@ through cairosvg, falling back to ``.svg`` (with a note) when it is absent.
 from __future__ import annotations
 
 import math
+from collections.abc import Collection
 from pathlib import Path
 
 import drawsvg as draw
@@ -25,22 +26,29 @@ class Canvas:
                  *, equal_aspect: bool = False) -> None:
         self.style = style
         self.scale = None  # set by a colouring layer; read by colorbar()/legend()
+        # node names whose branch is dashed; set by the tree figure, read by a colouring layer
+        self.dashed: Collection[str] | None = None
         self._d = draw.Drawing(style.width, style.height, origin=(0, 0))
         if style.background:
             self._d.append(draw.Rectangle(0, 0, style.width, style.height, fill=style.background))
         self._x0, self._x1 = xlim
         self._y0, self._y1 = ylim
-        self._m = style.margin
-        self._top = style.margin + getattr(style, "headroom", 0.0)
+        self._left = style.margin_at("left")
+        self._right = style.margin_at("right")
+        self._bottom = style.margin_at("bottom")
+        self._top = style.margin_at("top") + getattr(style, "headroom", 0.0)
         # equal_aspect keeps circles round (radial/unrooted): one scale for x and y, centred.
         self._equal = None
         if equal_aspect:
             xspan = (self._x1 - self._x0) or 1.0
             yspan = (self._y1 - self._y0) or 1.0
-            s = min((style.width - 2 * self._m) / xspan,
-                    (style.height - self._m - self._top) / yspan)
-            self._equal = (s, style.width / 2 - s * (self._x0 + self._x1) / 2,
-                           style.height / 2 - s * (self._y0 + self._y1) / 2)
+            s = min((style.width - self._left - self._right) / xspan,
+                    (style.height - self._bottom - self._top) / yspan)
+            # centred between the margins; headroom shrinks the scale but does not shift the centre
+            cx = (self._left + style.width - self._right) / 2
+            cy = (style.margin_at("top") + style.height - self._bottom) / 2
+            self._equal = (s, cx - s * (self._x0 + self._x1) / 2,
+                           cy - s * (self._y0 + self._y1) / 2)
 
     # --- data-space (transformed through the layout extent) ---------------
 
@@ -49,14 +57,14 @@ class Canvas:
             s, ox, _ = self._equal
             return ox + s * x
         span = (self._x1 - self._x0) or 1.0
-        return self._m + (x - self._x0) / span * (self.style.width - 2 * self._m)
+        return self._left + (x - self._x0) / span * (self.style.width - self._left - self._right)
 
     def py(self, y: float) -> float:
         if self._equal:
             s, _, oy = self._equal
             return oy + s * y
         span = (self._y1 - self._y0) or 1.0
-        return self._top + (y - self._y0) / span * (self.style.height - self._m - self._top)
+        return self._top + (y - self._y0) / span * (self.style.height - self._bottom - self._top)
 
     def line(self, x1, y1, x2, y2, color: str, width: float, *, dash: bool = False) -> None:
         extra = {"stroke_dasharray": "5,4"} if dash else {}
@@ -179,7 +187,8 @@ class Canvas:
         self._d.append(draw.Image(x, y, w, h, data=data, embed=True, mime_type="image/png"))
 
     def raw_marker(self, cx, cy, shape: str, color: str, size: float, *,
-                   stroke: str = "#ffffff", stroke_width: float = 0.8) -> None:
+                   stroke: str = "#ffffff", stroke_width: float = 0.8,
+                   angle: float = 0.0) -> None:
         """A small glyph at pixel ``(cx, cy)``: ``circle`` / ``square`` / ``triangle`` /
         ``triangle_right`` (points along the time axis, for a state transition) / ``diamond``
         (filled), ``ring`` (open), or ``cross`` (an ✕, for a loss).
@@ -204,6 +213,12 @@ class Canvas:
                                       (cx - r * 0.85, cy + r)],
                    "diamond": [(cx, cy - r), (cx + r, cy), (cx, cy + r),
                                (cx - r, cy)]}[shape]
+            if angle:
+                # rotate the glyph around its centre, so "along the time axis" can follow a
+                # radial branch's direction rather than always pointing right
+                ca, sa = math.cos(angle), math.sin(angle)
+                pts = [(cx + (x - cx) * ca - (y - cy) * sa,
+                        cy + (x - cx) * sa + (y - cy) * ca) for x, y in pts]
             self._d.append(draw.Lines(*[c for p in pts for c in p], fill=color,
                                       stroke=stroke, stroke_width=stroke_width, close=True))
         elif shape == "ring":

{phylustrator-0.2.16 → phylustrator-0.3.0}/src/phylustrator/style.py

@@ -14,6 +14,13 @@ class Style:
     width: float = 800.0
     height: float = 600.0
     margin: float = 50.0
+    #: one side's margin, when it should differ from ``margin``; ``None`` takes ``margin``. A
+    #: composite reserves room on one side — a y axis on the left, a panel underneath — without
+    #: moving the other three. Read a side through :meth:`margin_at`, never the field itself.
+    margin_left: float | None = None
+    margin_right: float | None = None
+    margin_top: float | None = None
+    margin_bottom: float | None = None
     #: extra space above the plot, on top of ``margin``. A colorbar or legend is drawn inside
     #: the plotting area, so on a tree whose first branch reaches the top corner the two share
     #: a row; this pushes the tree down instead of moving the key somewhere worse.
@@ -34,3 +41,14 @@ class Style:
     font_size: float = 12.0
     label_color: str = "#222222"
     background: str | None = "white"
+
+    def margin_at(self, side: str) -> float:
+        """The margin on ``side`` (``"left"`` / ``"right"`` / ``"top"`` / ``"bottom"``): that side's
+        own value if set, else ``margin``.
+
+        Resolved on every read, not once in ``__post_init__``: ``replace(style, margin=10)`` copies
+        the side fields as they are, so a side filled in from the old ``margin`` would keep it."""
+        if side not in ("left", "right", "top", "bottom"):
+            raise ValueError(f"side must be 'left', 'right', 'top' or 'bottom', got {side!r}")
+        own = getattr(self, f"margin_{side}")
+        return self.margin if own is None else own

{phylustrator-0.2.16 → phylustrator-0.3.0}/src/phylustrator/trees/__init__.py

@@ -7,7 +7,7 @@
 
 from __future__ import annotations
 
-from .figure import Figure, Geometry, TipPos, plot
+from .figure import Figure, Geometry, NodePos, TipPos, plot
 from .io import dumps, loads, read, write
 from .layers import (
                      branch_events,
@@ -27,13 +27,15 @@ from .layers import (
                      tip_labels,
                      tip_track,
 )
+from .panels import NodePoints, node_points
 from .tree import Node, Tree
 
 __all__ = [
     "Node", "Tree", "read", "loads", "write", "dumps",
-    "plot", "Figure", "Geometry", "TipPos",
+    "plot", "Figure", "Geometry", "NodePos", "TipPos",
     "color_branches", "color_history", "color_lanes", "tip_labels", "node_labels", "tip_track", "ring",
     "rubberband",
     "branch_events", "colorbar", "legend", "note", "time_axis", "time_marker", "scale_bar",
     "highlight_clade",
+    "node_points", "NodePoints",
 ]

{phylustrator-0.2.16 → phylustrator-0.3.0}/src/phylustrator/trees/figure.py

@@ -12,7 +12,7 @@ contract, so new decorations never touch the figure.
 
 from __future__ import annotations
 
-from dataclasses import dataclass, replace
+from dataclasses import dataclass, field, replace
 from typing import Callable
 
 from ..render import Canvas
@@ -35,15 +35,39 @@ class TipPos:
     y: float
 
 
+@dataclass
+class NodePos:
+    """Where any node — a tip or an internal node — lands on the rendered page, in pixels."""
+
+    name: str
+    x: float
+    y: float
+    is_leaf: bool
+
+
 @dataclass
 class Geometry:
     """The rendered figure's pixel geometry — enough to align something else (a heatmap, an
     alignment) to the tree's tips without redrawing the tree. ``tips`` are in top-to-bottom order;
-    ``tip_x`` is the pixel x where the tips end (where a companion panel can begin)."""
+    ``tip_x`` is the pixel x where the tips end (where a companion panel can begin).
+
+    The x axis too: ``nodes`` holds every node, internal ones included, in preorder, and :meth:`px`
+    turns a layout x (a time, under the rectangular layout) into a pixel x. ``xlim`` is the layout's
+    x range and ``x_pixels`` its two ends on the page — where a panel under the tree starts and stops
+    (see :func:`~phylustrator.compose.below`)."""
 
     size: tuple[float, float]
     tips: list[TipPos]
     tip_x: float
+    nodes: list[NodePos] = field(default_factory=list)
+    xlim: tuple[float, float] = (0.0, 1.0)
+    x_pixels: tuple[float, float] = (0.0, 1.0)
+
+    def px(self, x: float) -> float:
+        """The pixel x of layout x ``x``. The canvas maps x linearly in every layout, so two points
+        fix it."""
+        (x0, x1), (p0, p1) = self.xlim, self.x_pixels
+        return p0 + (x - x0) / ((x1 - x0) or 1.0) * (p1 - p0)
 
 
 class Figure:
@@ -73,20 +97,26 @@ class Figure:
     def with_size(self, width: float, height: float) -> "Figure":
         """A copy of this figure rendered at a given pixel size (same tree, layers, style otherwise).
         Used to fit the tree into a column beside a companion panel."""
-        return Figure(self.tree, layout=self.layout, stem=self.stem,
-                      style=replace(self.style, width=width, height=height),
+        return self.with_style(replace(self.style, width=width, height=height))
+
+    def with_style(self, style: Style) -> "Figure":
+        """A copy of this figure drawn with ``style`` (same tree, layers and options otherwise)."""
+        return Figure(self.tree, layout=self.layout, stem=self.stem, style=style,
                       dashed=self.dashed, skeleton=self.skeleton, layers=self.layers)
 
     def geometry(self) -> Geometry:
-        """The pixel positions of the tips for this figure's current style — so a companion panel can
-        line its rows up with the tree without redrawing it."""
+        """The pixel positions of the tips and of every node for this figure's current style, and
+        the x-to-pixel mapping — so a companion panel can line up with the tree without redrawing it."""
         layout = _LAYOUTS[self.layout](self.tree, stem=self.stem)
         canvas = Canvas(self.style, layout.xlim, layout.ylim,
                         equal_aspect=(self.layout != "rectangular"))
         tips = [TipPos(leaf.name or "", canvas.px(layout.x(leaf)), canvas.py(layout.y(leaf)))
                 for leaf in self.tree.leaves]
         tip_x = max((t.x for t in tips), default=canvas.size[0])
-        return Geometry(canvas.size, tips, tip_x)
+        nodes = [NodePos(node.name or "", canvas.px(layout.x(node)), canvas.py(layout.y(node)), node.is_leaf)
+                 for node in self.tree.walk()]
+        x_pixels = (canvas.px(layout.xlim[0]), canvas.px(layout.xlim[1]))
+        return Geometry(canvas.size, tips, tip_x, nodes, layout.xlim, x_pixels)
 
     def _build(self) -> Canvas:
         layout = _LAYOUTS[self.layout](self.tree, stem=self.stem)

{phylustrator-0.2.16 → phylustrator-0.3.0}/src/phylustrator/trees/layers/coloring.py

@@ -60,7 +60,7 @@ def color_history(history, *, palette: dict | None = None, cmap: str = "viridis"
     ``(state, duration)`` running from the branch's start to its end. Use this (not
     :func:`color_branches`) for a value that changes *along* a branch: the branch is a mosaic, not
     one colour. ``dashed`` is an optional set of node names to draw dashed (e.g. extinct lineages).
-    Rectangular layout only. ``history``: ``{node name: [(state, dur), …]}``.
+    Rectangular and radial layouts. ``history``: ``{node name: [(state, dur), …]}``.
 
     Dispatches on the states the same way :func:`color_branches` dispatches on its values:
     **labels** get a categorical palette (and record it, so ``legend`` can draw), **numbers** get a
@@ -74,13 +74,16 @@ def color_history(history, *, palette: dict | None = None, cmap: str = "viridis"
     colors, scale = map_values({s: s for s in states}, cmap=cmap, palette=palette, limits=limits)
 
     def layer(canvas, tree, layout, style):
-        if layout.kind != "rectangular":
-            raise ValueError("color_history needs the rectangular layout (segments run along x)")
+        if layout.kind not in ("rectangular", "radial"):
+            raise ValueError("color_history supports the rectangular and radial layouts")
         marks = _dashed_or_figure(dashed, canvas)
         w = width or style.branch_width
         if scale is not None:
             canvas.scale = scale
         base = default or style.branch_color
+        if layout.kind == "radial":
+            _history_radial(canvas, tree, layout, history, colors, base, w, marks)
+            return
         for node in tree.walk():
             y = layout.y(node)
             x_end = layout.x(node)
@@ -108,6 +111,47 @@ def color_history(history, *, palette: dict | None = None, cmap: str = "viridis"
     return layer
 
 
+def _history_radial(canvas, tree, layout, history, colors, base, w, marks) -> None:
+    """The radial half of :func:`color_history`: each branch is a mosaic running OUT along the
+    node's angle, from the parent's radius to the node's, and the speciation connector is an arc
+    at the node's radius in the branch's end state — mirrors ``skeleton._radial``."""
+    import math
+
+    from ..skeleton import _arc
+
+    ang = layout.angle
+
+    def radius(node):
+        return math.hypot(layout.x(node), layout.y(node))
+
+    for node in tree.walk():
+        a = ang[node]
+        r_end = radius(node)
+        r_start = max(0.0, r_end - layout.root_branch) if node.is_root else radius(node.parent)
+        d = node.name in marks
+        ca, sa = math.cos(a), math.sin(a)
+        segs = history.get(node.name)
+        end_state = None
+        if segs:
+            total = sum(dur for _, dur in segs) or 1.0
+            span = r_end - r_start
+            rr = r_start
+            for state, dur in segs:
+                r1 = rr + span * dur / total
+                if r1 != rr:      # two changes at the same instant leave a zero-length segment
+                    canvas.line(rr * ca, rr * sa, r1 * ca, r1 * sa,
+                                colors.get(state, base), w, dash=d)
+                rr = r1
+            end_state = segs[-1][0]
+        else:
+            canvas.line(r_start * ca, r_start * sa, r_end * ca, r_end * sa, base, w, dash=d)
+        if not node.is_leaf and r_end > 1e-9:     # angular connectors in the node's end state
+            cc = colors.get(end_state, base)
+            for c in node.children:
+                _arc(canvas, r_end, min(a, ang[c]), max(a, ang[c]), cc, w,
+                     dash=(c.name in marks))
+
+
 def color_lanes(lanes, *, width=None, gap: float = 1.0, connectors: bool = True,
                 joint: str | None = None, default: str | None = None, dashed=None):
     """Paint each branch as several **parallel lanes** — one per trait — so more than one discrete

{phylustrator-0.2.16 → phylustrator-0.3.0}/src/phylustrator/trees/layers/events.py

@@ -45,7 +45,24 @@ def branch_events(events, *, styles: dict | None = None, size: float = 5.5,
     styles = {**DEFAULT_EVENT_STYLES, **(styles or {})}
 
     def layer(canvas, tree, layout, style):
+        import math
+
         by_name = {n.name: n for n in tree.walk() if n.name}
+        radial = layout.kind == "radial"
+        # events carry distance on the stem-inclusive scale (the rectangular default); the radial
+        # layout drops the stem (its radius starts at the crown), so shift by the stem's length
+        stem_off = float(tree.root.length or 0.0) if radial else 0.0
+
+        def rad(node):
+            return math.hypot(layout.x(node), layout.y(node))
+
+        def place(node, t):
+            """An event at distance ``t`` on ``node``'s branch, in layout coordinates."""
+            if not radial:
+                return t, layout.y(node)
+            a = layout.angle[node]                       # the distance is the radius
+            return t * math.cos(a), t * math.sin(a)
+
         used: dict[str, tuple] = {}
         for raw in events:
             ev = _unpack(raw)
@@ -56,17 +73,40 @@ def branch_events(events, *, styles: dict | None = None, size: float = 5.5,
                     continue
                 # scale the arrow with `size` (as the point glyphs do) so the head reads as an arrow,
                 # not a tick, on a large figure
-                canvas.arrow(ev["x"], layout.y(donor), ev["x"], layout.y(recip), color,
+                dx, dy = place(donor, ev["x"] - stem_off)
+                rx, ry = place(recip, ev["x"] - stem_off)
+                canvas.arrow(dx, dy, rx, ry, color,
                              width=max(1.8, size * 0.42), head=max(9.0, size * 2.4))
             else:
                 node = by_name.get(ev.get("node"))
                 if node is None:
                     continue
-                x = ev["x"]
+                x = ev["x"] - stem_off        # onto the layout's own distance scale
                 if clamp and node.parent is not None:
-                    lo, hi = sorted((layout.x(node.parent), layout.x(node)))
+                    if radial:
+                        lo, hi = sorted((rad(node.parent), rad(node)))
+                    else:
+                        lo, hi = sorted((layout.x(node.parent), layout.x(node)))
                     x = min(max(x, lo), hi)
-                canvas.marker(x, layout.y(node), glyph, color, size)
+                mx, my = place(node, x)
+                if radial:
+                    # the glyph's "forward" must follow the branch: rotate by the branch
+                    # direction in PIXEL space (py may flip y, so measure it there)
+                    ax, ay = place(node, max(x - 1e-6, 0.0))
+                    px, py = canvas.px(mx), canvas.py(my)
+                    ang = math.atan2(py - canvas.py(ay), px - canvas.px(ax))
+                    if glyph == "triangle_right":
+                        # tip AT the event's instant, body trailing over the state it leaves:
+                        # centred, the glyph swallows a short old-state segment and reads as a
+                        # switch inside its own destination colour
+                        px -= size * math.cos(ang)
+                        py -= size * math.sin(ang)
+                    # an ink outline, not white: the tip sits against a branch of its own
+                    # colour, and without a silhouette the flared base reads as the point
+                    canvas.raw_marker(px, py, glyph, color, size, angle=ang,
+                                      stroke="#1a1a1a", stroke_width=1.1)
+                else:
+                    canvas.marker(mx, my, glyph, color, size)
             used[ev["kind"]] = (glyph, color)
         if legend and used:
             _draw_legend(canvas, style, used, legend_title, size, legend_loc, legend_size)
@@ -76,15 +116,14 @@ def branch_events(events, *, styles: dict | None = None, size: float = 5.5,
 
 def _draw_legend(canvas, style, used, title, marker, loc, fsize) -> None:
     width, height = canvas.size
-    m = style.margin
     fs = fsize if fsize is not None else style.font_size
     ms = marker * (fs / style.font_size)                            # glyphs scale with the legend text
     row_h = fs * 1.7
     labels = ([title] if title else []) + list(used)
     box_w = ms * 2 + 14 + max(len(s) for s in labels) * fs * 0.62
     n_rows = len(used) + (1 if title else 0)
-    x = (m + ms + 6) if "left" in loc else (width - m - box_w)
-    y = (m * 0.6 + fs) if "top" in loc else (height - m - row_h * n_rows)
+    x = (style.margin_at("left") + ms + 6) if "left" in loc else (width - style.margin_at("right") - box_w)
+    y = (style.margin_at("top") * 0.6 + fs) if "top" in loc else (height - style.margin_at("bottom") - row_h * n_rows)
     if title:
         canvas.raw_text(x, y, title, anchor="start", weight="bold", size=fs)
         y += fs * 1.8