iplotx 1.0.1__tar.gz → 1.2.0__tar.gz

{iplotx-1.0.1 → iplotx-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 1.0.1
+Version: 1.2.0
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx
@@ -78,8 +78,7 @@ import iplotx as ipx
 
 g = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
 layout = nx.layout.circular_layout(g)
-fig, ax = plt.subplots(figsize=(3, 3))
-ipx.plot(g, ax=ax, layout=layout)
+ipx.plot(g, layout)
 ```
 
 ![Quick start image](/docs/source/_static/graph_basic.png)

{iplotx-1.0.1 → iplotx-1.2.0}/README.md

@@ -40,8 +40,7 @@ import iplotx as ipx
 
 g = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
 layout = nx.layout.circular_layout(g)
-fig, ax = plt.subplots(figsize=(3, 3))
-ipx.plot(g, ax=ax, layout=layout)
+ipx.plot(g, layout)
 ```
 
 ![Quick start image](/docs/source/_static/graph_basic.png)

{iplotx-1.0.1 → iplotx-1.2.0}/docs/source/api/complete_style_specification.md

@@ -274,8 +274,15 @@
         # - "radial" layout: "clockwise" or "counterclockwise"
         "orientation": str,
         "angular": bool,  # Whether to use an angular or waypoint-based layout
-        "start": float,  # Starting angle for radial layouts (in degrees)
-        "span": float,  # Angle span for radial layouts (in degrees)
+        # The following two parameters are used differently depending on the layout.
+        # For radial layouts:
+        #   start: Starting angle (in degrees, one float)
+        #   span: Angle span (in degrees)
+        # For horizontal and vertical layouts:
+        #   start: Starting position in data units (tuple of two floats)
+        #   span: Breadth in data units (float)
+        "start": float | tuple[float, float],
+        "span": float,
     },
     ############################################################################
 }

{iplotx-1.0.1 → iplotx-1.2.0}/docs/source/sg_execution_times.rst

@@ -6,7 +6,7 @@
 
 Computation times
 =================
-**00:00.497** total execution time for 76 files **from all galleries**:
+**00:00.565** total execution time for 77 files **from all galleries**:
 
 .. container::
 
@@ -32,8 +32,8 @@ Computation times
    * - Example
      - Time
      - Mem (MB)
-   * - :ref:`sphx_glr_gallery_tree_plot_scalebar.py` (``../../gallery/tree/plot_scalebar.py``)
-     - 00:00.497
+   * - :ref:`sphx_glr_gallery_tree_plot_double_tree.py` (``../../gallery/tree/plot_double_tree.py``)
+     - 00:00.565
      - 0.0
    * - :ref:`sphx_glr_gallery_basic_plot_3d.py` (``../../gallery/basic/plot_3d.py``)
      - 00:00.000
@@ -233,6 +233,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_tree_plot_leafedges_and_cascades.py` (``../../gallery/tree/plot_leafedges_and_cascades.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_scalebar.py` (``../../gallery/tree/plot_scalebar.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_tree_plot_skbio_tree.py` (``../../gallery/tree/plot_skbio_tree.py``)
      - 00:00.000
      - 0.0

iplotx-1.2.0/gallery/tree/plot_double_tree.py

@@ -0,0 +1,91 @@
+"""
+Double tree
+===========
+
+This example shows how to use `iplotx` to plot two trees facing each other, which is typical in coevolutionary studies.
+"""
+
+from ete4 import Tree
+from matplotlib import pyplot as plt
+import iplotx as ipx
+
+tree1 = Tree(
+    "((),((),(((),()),((),()))));",
+)
+
+
+tree2 = Tree(
+    "((),((),(),((),())),());",
+)
+
+fig, ax = plt.subplots(figsize=(9, 4))
+
+# Plot first tree on the left
+ipx.plotting.tree(
+    tree1,
+    ax=ax,
+    aspect=1,
+    edge_color="tomato",
+    leaf_deep=True,
+)
+
+# Plot second tree on the right, facing left
+ipx.plotting.tree(
+    tree2,
+    ax=ax,
+    aspect=1,
+    edge_color="steelblue",
+    layout="horizontal",
+    layout_orientation="left",
+    layout_start=(11, 0),
+    leaf_deep=True,
+)
+
+# Add lines connecting corresponding leaves
+matches = [
+    (0, 0),
+    (1, 4),
+    (2, 5),
+    (3, 2),
+    (4, 1),
+    (5, 5),
+]
+for y1, y2 in matches:
+    ax.plot(
+        [5.2, 6.8], [y1, y2], color="gray", linewidth=2,
+    )
+
+# %%
+# ``iplotx`` has a dedicated function for double trees, which virtually the same result with less code:
+
+fig, ax = plt.subplots(figsize=(9, 4))
+ipx.doubletree(
+    tree1,
+    tree2,
+    ax=ax,
+    kwargs_left=dict(
+        leaf_deep=True,
+        edge_color="tomato",
+    ),
+    kwargs_right=dict(
+        leaf_deep=True,
+        edge_color="steelblue",
+    ),
+    gap=2,
+    aspect=1,
+)
+
+# Add lines connecting corresponding leaves
+# NOTE: The layout is horizontally centered now
+matches = [
+    (0, 0),
+    (1, 4),
+    (2, 5),
+    (3, 2),
+    (4, 1),
+    (5, 5),
+]
+for y1, y2 in matches:
+    ax.plot(
+        [-0.3, 1.3], [y1, y2], color="gray", linewidth=2,
+    )

{iplotx-1.0.1 → iplotx-1.2.0}/iplotx/__init__.py

@@ -11,6 +11,7 @@ from .plotting import (
     network,
     graph,
     tree,
+    doubletree,
     plot,
 )
 import iplotx.artists as artists
@@ -20,6 +21,7 @@ import iplotx.style as style
 __all__ = [
     "network",
     "tree",
+    "doubletree",
     "plot",
     "graph",
     "artists",

{iplotx-1.0.1 → iplotx-1.2.0}/iplotx/edge/__init__.py

@@ -274,6 +274,12 @@ class EdgeCollection(mpl.collections.PatchCollection):
         """Return mappable for colorbar."""
         return self
 
+    def shift(self, x: float, y: float) -> None:
+        """Shift the cascade by a certain amount."""
+        for path in self._paths:
+            path.vertices[:, 0] += x
+            path.vertices[:, 1] += y
+
     def _get_adjacent_vertices_info(self):
         index = self._vertex_collection.get_index()
         index = pd.Series(

{iplotx-1.0.1 → iplotx-1.2.0}/iplotx/layout.py

@@ -2,7 +2,10 @@
 Layout functions, currently limited to trees.
 """
 
-from typing import Any
+from typing import (
+    Any,
+    Optional,
+)
 from collections.abc import (
     Hashable,
     Callable,
@@ -99,6 +102,8 @@ def _horizontal_tree_layout_right(
 
 def _horizontal_tree_layout(
     orientation="right",
+    start: tuple[float, float] = (0, 0),
+    span: Optional[float] = None,
     **kwargs,
 ) -> dict[Hashable, list[float]]:
     """Horizontal tree layout."""
@@ -110,11 +115,24 @@ def _horizontal_tree_layout(
     if orientation == "left":
         for key in layout:
             layout[key][0] *= -1
+
+    if span is not None:
+        cur_span = len(layout) - 1
+        for key in layout:
+            layout[key][1] = float(layout[key][1]) * span / cur_span
+
+    if start != (0, 0):
+        for key in layout:
+            layout[key][0] += start[0]
+            layout[key][1] += start[1]
+
     return layout
 
 
 def _vertical_tree_layout(
     orientation="descending",
+    start: tuple[float, float] = (0, 0),
+    span: Optional[float] = None,
     **kwargs,
 ) -> dict[Hashable, list[float]]:
     """Vertical tree layout."""
@@ -125,6 +143,17 @@ def _vertical_tree_layout(
         layout[key] = value[::-1]
         # Orient vertically
         layout[key][1] *= sign
+
+    if span is not None:
+        cur_span = len(layout) - 1
+        for key in layout:
+            layout[key][0] = float(layout[key][0]) * span / cur_span
+
+    if start != (0, 0):
+        for key in layout:
+            layout[key][0] += start[0]
+            layout[key][1] += start[1]
+
     return layout
 
 

{iplotx-1.0.1 → iplotx-1.2.0}/iplotx/plotting.py

@@ -1,4 +1,8 @@
-from typing import Optional, Sequence
+from typing import (
+    Optional,
+    Sequence,
+    Any,
+)
 from contextlib import nullcontext
 import numpy as np
 import pandas as pd
@@ -269,8 +273,86 @@ def tree(
     return artist
 
 
+def doubletree(
+    tree_left: Optional[TreeType] = None,
+    tree_right: Optional[TreeType] = None,
+    kwargs_left: Optional[dict[Any]] = None,
+    kwargs_right: Optional[dict[Any]] = None,
+    gap: float = 0,
+    ax: Optional[mpl.axes.Axes] = None,
+    title: Optional[str] = None,
+    aspect: Optional[str | float] = None,
+    margins: float | tuple[float, float] = 0,
+    strip_axes: bool = True,
+    figsize: Optional[tuple[float, float]] = None,
+) -> tuple[TreeArtist, TreeArtist]:
+    """Visualize two trees facing each other.
+
+    Parameters:
+        tree_left: The tree to plot on the left side.
+        tree_right: The tree to plot on the right side.
+        kwargs_left: Additional keyword arguments passed to the left tree plotting function.
+        kwargs_right: Additional keyword arguments passed to the right tree plotting function.
+        ax: The axis to plot on. If None, a new figure and axis will be created. Defaults to
+            None.
+        title: If not None, set the axes title to this value.
+        aspect: If not None, set the aspect ratio of the axis to this value. The most common
+            value is 1.0, which proportionates x- and y-axes.
+        margins: How much margin to leave around the plot. A higher value (e.g. 0.1) can be
+            used as a quick fix when some vertex shapes reach beyond the plot edge. This is
+            a fraction of the data limits, so 0.1 means 10% of the data limits will be left
+            as margin.
+        strip_axes: If True, remove axis spines and ticks.
+        figsize: If ax is None, a new matplotlib Figure is created. This argument specifies
+            the (width, height) dimension of the figure in inches. If ax is not None, this
+            argument is ignored. If None, the default matplotlib figure size is used.
+    Returns:
+        A tuple with the left and right TreeArtist objects.
+    """
+    artist1 = tree(
+        tree_left,
+        layout="horizontal",
+        layout_orientation="right",
+        ax=ax,
+        strip_axes=False,
+        figsize=figsize,
+        **kwargs_left or {},
+    )
+
+    ax = artist1.axes
+
+    if kwargs_right is None:
+        kwargs_right = {}
+
+    had_layout_start = "layout_start" in kwargs_right
+
+    artist2 = tree(
+        tree_right,
+        layout="horizontal",
+        layout_orientation="left",
+        ax=ax,
+        title=title,
+        aspect=aspect,
+        strip_axes=False,
+        margins=margins,
+        **kwargs_right,
+    )
+
+    if not had_layout_start:
+        x2min = artist2.get_layout().values[:, 0].min()
+        x1max = artist1.get_layout().values[:, 0].max()
+        xshift = x1max - x2min + gap
+
+        artist2.shift(0.5 * xshift, 0)
+        artist1.shift(-0.5 * xshift, 0)
+
+    _postprocess_axes(ax, [artist1, artist2], strip=strip_axes, ignore_previous=True)
+
+    return (artist1, artist2)
+
+
 # INTERNAL ROUTINES
-def _postprocess_axes(ax, artists, strip=True, had_data=None):
+def _postprocess_axes(ax, artists, strip=True, had_data=None, ignore_previous=False):
     """Postprocess axis after plotting."""
 
     if strip:
@@ -309,7 +391,11 @@ def _postprocess_axes(ax, artists, strip=True, had_data=None):
         for art in artists:
             bboxes.append(art.get_datalim(ax.transData))
         bbox = mpl.transforms.Bbox.union(bboxes)
-        ax.update_datalim(bbox)
+
+        if not ignore_previous:
+            ax.update_datalim(bbox)
+        else:
+            ax.dataLim.update_from_data_xy(bbox.corners(), ignore=True)
 
         # Autoscale for x/y axis limits
         ax.autoscale_view()

{iplotx-1.0.1 → iplotx-1.2.0}/iplotx/tree/__init__.py

@@ -219,6 +219,31 @@ class TreeArtist(mpl.artist.Artist):
         else:
             raise ValueError(f"Unknown layout kind: {kind}. Use 'vertex' or 'edge'.")
 
+    def shift(self, x: float, y: float) -> None:
+        """Shift layout coordinates for all tree elements.
+
+        Paramerers:
+            x: The shift in x direction.
+            y: The shift in y direction.
+        """
+        layout_columns = [f"_ipx_layout_{i}" for i in range(self._ipx_internal_data["ndim"])]
+        self._ipx_internal_data["vertex_df"][layout_columns[0]] += x
+        self._ipx_internal_data["vertex_df"][layout_columns[1]] += y
+
+        self.get_vertices()._layout.values[:, 0] += x
+        self.get_vertices()._layout.values[:, 1] += y
+        self.get_vertices()._update_offsets_from_layout()
+
+        self.get_edges().shift(x, y)
+
+        if hasattr(self, "_leaf_vertices"):
+            self.get_leaf_vertices()._layout.values[:, 0] += x
+            self.get_leaf_vertices()._layout.values[:, 1] += y
+            self.get_leaf_vertices()._update_offsets_from_layout()
+
+        if hasattr(self, "_cascades"):
+            self._cascades.shift(x, y)
+
     def get_datalim(self, transData, pad=0.15):
         """Get limits on x/y axes based on the graph layout data.
 

{iplotx-1.0.1 → iplotx-1.2.0}/iplotx/tree/cascades.py

@@ -158,6 +158,12 @@ class CascadeCollection(mpl.collections.PatchCollection):
             zorder=zorder,
         )
 
+    def shift(self, x: float, y: float) -> None:
+        """Shift the cascade by a certain amount."""
+        for path in self._paths:
+            path.vertices[:, 0] += x
+            path.vertices[:, 1] += y
+
     def get_maxdepth(self) -> float:
         """Get the maxdepth of the cascades.
 

{iplotx-1.0.1 → iplotx-1.2.0}/iplotx/version.py

@@ -2,4 +2,4 @@
 iplotx version information module.
 """
 
-__version__ = "1.0.1"
+__version__ = "1.2.0"

iplotx-1.2.0/tests/test_doubletree.py

@@ -0,0 +1,66 @@
+import pytest
+import matplotlib as mpl
+
+mpl.use("agg")
+import iplotx as ipx
+from utils import image_comparison
+
+
+@pytest.fixture
+def tree():
+    tree = {
+        "children": [
+            {
+                "children": [
+                    {},
+                    {},
+                ],
+            },
+            {
+                "children": [
+                    {
+                        "children": [
+                            {"branch_length": 1.5},
+                            {},
+                        ],
+                    },
+                    {
+                        "children": [
+                            {},
+                            {},
+                        ],
+                    },
+                ],
+            },
+        ],
+    }
+    tree = ipx.ingest.providers.tree.simple.SimpleTree.from_dict(tree)
+    return tree
+
+
+@image_comparison(baseline_images=["tree_nogap"], remove_text=True)
+def test_nogap(tree):
+    ipx.doubletree(
+        tree,
+        tree,
+        kwargs_right=dict(
+            edge_color="steelblue",
+        ),
+        gap=0,
+    )
+
+
+@image_comparison(baseline_images=["tree_gap"], remove_text=True)
+def test_gap(tree):
+    ipx.doubletree(
+        tree,
+        tree,
+        kwargs_left=dict(
+            leaf_deep=True,
+        ),
+        kwargs_right=dict(
+            edge_color="steelblue",
+            leaf_deep=True,
+        ),
+        gap=1.0,
+    )