iplotx 1.3.0__tar.gz → 1.4.0__tar.gz

{iplotx-1.3.0 → iplotx-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 1.3.0
+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

{iplotx-1.3.0 → iplotx-1.4.0}/docs/source/api/complete_style_specification.md

@@ -102,9 +102,14 @@
 
         "curved": bool,  # Whether the edge is curved (True) or straight (False)
 
-        # Tension for curved edges (0.0 for straight, higher values position the
-        # Bezier control points further away from the nodes, creating more wiggly lines)
+        # Tension for curved edges and arcs.
+        # For Bezier (curved) edges, 0.0 means straight, higher values position the
+        # Bezier control points further away from the nodes, creating more wiggly lines.
         # Negative values bend the curve on the other side of the straight line.
+        # For arc edges, 0.0 means straight, higher values draw larger arcs. 1.0
+        # means a semicircle, and numbers above 5 create very large arcs, almost full
+        # circles. The exact definition of tension for arcs is the tangent of a
+        # quarter of the angle spanned by the arc.
         "tension": float,
 
         # Tension for self-loops (higher values create more bigger loops).
@@ -281,7 +286,7 @@
         # 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],
+        "start": float | tuple[float            margins=0.2,
         "span": float,
     },
     ############################################################################

{iplotx-1.3.0 → iplotx-1.4.0}/docs/source/sg_execution_times.rst

@@ -6,7 +6,7 @@
 
 Computation times
 =================
-**00:00.514** total execution time for 78 files **from all galleries**:
+**00:00.117** total execution time for 79 files **from all galleries**:
 
 .. container::
 
@@ -32,8 +32,8 @@ Computation times
    * - Example
      - Time
      - Mem (MB)
-   * - :ref:`sphx_glr_gallery_tree_plot_equalangle.py` (``../../gallery/tree/plot_equalangle.py``)
-     - 00:00.514
+   * - :ref:`sphx_glr_gallery_basic_plot_arcs.py` (``../../gallery/basic/plot_arcs.py``)
+     - 00:00.117
      - 0.0
    * - :ref:`sphx_glr_gallery_basic_plot_3d.py` (``../../gallery/basic/plot_3d.py``)
      - 00:00.000
@@ -227,6 +227,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_tree_plot_elements_tree.py` (``../../gallery/tree/plot_elements_tree.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_equalangle.py` (``../../gallery/tree/plot_equalangle.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_tree_plot_ete4.py` (``../../gallery/tree/plot_ete4.py``)
      - 00:00.000
      - 0.0

iplotx-1.4.0/gallery/basic/plot_arcs.py

@@ -0,0 +1,42 @@
+"""
+Arcs
+====
+
+This example showcases the ability of `iplotx` to curve edges into arcs, using tension to define the angular span of the arc.
+"""
+
+import igraph as ig
+import matplotlib.pyplot as plt
+import iplotx as ipx
+
+
+g = ig.Graph.Full(4)
+layout = [[0, 0], [1, 0], [2, 0], [3, 0]]
+
+fig, ax = plt.subplots()
+ipx.plot(
+    g,
+    layout=layout,
+    ax=ax,
+    edge_arc=True,
+    edge_tension=-1,
+)
+
+# %%
+# ..tip::
+#   Specifically, tension is defined as the tangent of the quarter of the angle spanned by the arc. A tension of 0 gives
+#   a straight line, a tension of 1 gives a semicircle, and higher tensions give increasingly larger arcs. A tension of
+#   infinity would give you a straight line away from the target vertex, but is not accepted by the library. Negative
+#   tensions result in arcs curving in the opposite direction.
+
+fig, axs = plt.subplots(2, 2, figsize=(8, 8))
+for tension, ax in zip([0.5, 2.5, -0.5, -2.5], axs.ravel()):
+    ipx.plot(
+        g,
+        layout=layout,
+        ax=ax,
+        edge_arc=True,
+        edge_tension=tension,
+        margins=0.15,
+        title=f"Edge tension = {tension:.2f}",
+    )

{iplotx-1.3.0 → iplotx-1.4.0}/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-1.3.0 → iplotx-1.4.0}/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-1.3.0 → iplotx-1.4.0}/iplotx/layout/tree/unrooted.py

@@ -74,13 +74,15 @@ def _equalangle_tree_layout(
         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["angle"][child] = -90 - beta * np.sign(beta - 180)
             props["start"][child] = start
             props["end"][child] = start + alpha
             start += alpha
@@ -101,7 +103,8 @@ def _daylight_tree_layout(
     start: float = 180,
     span: float = 360,
     max_iter: int = 5,
-    dampening: float = 0.3,
+    dampening: float = 0.33,
+    max_correction: float = 10.0,
     **kwargs,
 ) -> dict[Hashable, list[float]]:
     """Daylight unrooted tree layout.
@@ -154,16 +157,34 @@ def _daylight_tree_layout(
         ninternal = 0
         parents = [None] + list(levelorder_fun())
         for parent in parents:
-            children = children_fun(parent) if parent is not None else [root]
+            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
@@ -182,11 +203,13 @@ def _daylight_tree_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.
 
@@ -208,9 +231,9 @@ def _apply_daylight_single_node(
 
     print = _print if DEBUG_DAYLIGHT else lambda *a, **k: None
 
-    children = children_fun(node)
-
-    # 1. Find boundary leaves for each child and for the parent
+    # 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 = {}
 
@@ -224,99 +247,137 @@ def _apply_daylight_single_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}")
+        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 all_leaves:
-            # Skip subtree leaves
-            if leaf in leaves_below:
-                continue
+        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}")
-            print(f"  angle: {angle:.2f}")
+            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}")
+        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}")
+            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: {angle:.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[child] = (lower, upper, lower_angle, upper_angle)
 
-    print("final boundary leaves:")
-    print(bounds)
+    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 = {}
-    daylight_sum = 0.0
-    # TODO: Mayvbe optimise this by avoiding creating all these lists
-    prev_leaves = [bound[1] for bound in bounds.values()]
-    leaves = [bound[0] for bound in bounds.values()]
-    leaves = leaves[1:] + [leaves[0]]  # cycle left
-    subtrees = children + ([parent] if parent is not None else [])
-    for subtree, prev_leaf, leaf in zip(subtrees, prev_leaves, leaves):
-        vec1 = layout[prev_leaf] - p0
-        vec2 = layout[leaf] - p0
+    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_sum += angle
-        if leaf != parent:
-            # daylight[leaf] = float(angle)
-            daylight[subtree] = float(angle)
-
-    print("daylight")
-    print(daylight)
-    print(f"daylight sum: {daylight_sum:.2f}")
-
-    # 3. Compute *excess* daylight, and correct it
-    # NOTE: There seems to be this notion that you rotate a node by the accumulated daylight
-    # correction (to fill the space on the left) plus its own correction (to fill the space on the right).
-    # It reads funny and this is within a BFS iteration anyway so it's probably ok, but it's
-    # curious.
-    # NOTE: The average adjustment is divided by children + 1 (the parent) bc this is unrooted.
-    daylight_avg = daylight_sum / (len(children) + 1)
-    daylight_cum_corr = 0.0
-    daylight_changes = 0
-    for leaf in daylight:
-        daylight_cum_corr += daylight_avg - daylight[leaf]
-        _rotate_subtree_around_point(
+        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,
-            dampening * daylight_cum_corr,
+            correction,
             recur=True,
         )
-        daylight_changes += abs(dampening * daylight_cum_corr)
+        daylight_corrections_abs += abs(correction)
+
+    # __import__("ipdb").set_trace()
 
     # Caller wants degrees
-    return np.degrees(daylight_changes / len(leaves))
+    # 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
@@ -334,7 +395,7 @@ def _anticlockwise_angle(v1, v2):
     return np.arctan2(determinant, dot)
 
 
-def _rotate_subtree_around_point(
+def _rotate_subtree_anticlockwise(
     node,
     children_fun: Callable,
     layout: dict[Hashable, list[float]],
@@ -344,7 +405,7 @@ def _rotate_subtree_around_point(
 ):
     point = np.asarray(layout[node])
     pivot = np.asarray(pivot)
-    layout[node] = _rotate_around_point(
+    layout[node] = _rotate_anticlockwise(
         point,
         pivot,
         angle,
@@ -352,7 +413,7 @@ def _rotate_subtree_around_point(
     if not recur:
         return
     for child in children_fun(node):
-        _rotate_subtree_around_point(
+        _rotate_subtree_anticlockwise(
             child,
             children_fun,
             layout,
@@ -361,7 +422,7 @@ def _rotate_subtree_around_point(
         )
 
 
-def _rotate_around_point(
+def _rotate_anticlockwise(
     point,
     pivot,
     angle,
@@ -379,5 +440,5 @@ def _rotate_around_point(
     pivot = np.asarray(pivot)
     cos = np.cos(angle)
     sin = np.sin(angle)
-    rot = np.array([[cos, sin], [-sin, cos]])
+    rot = np.array([[cos, -sin], [sin, cos]])
     return pivot + (point - pivot) @ rot

{iplotx-1.3.0 → iplotx-1.4.0}/iplotx/style/leaf_info.py

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

{iplotx-1.3.0 → iplotx-1.4.0}/iplotx/version.py

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

{iplotx-1.3.0 → iplotx-1.4.0}/tests/test_igraph.py

@@ -204,6 +204,35 @@ class GraphTestRunner(unittest.TestCase):
         ipx.graph(g, ax=ax)
         ax.set_aspect(1.0)
 
+    @image_comparison(baseline_images=["arcs"])
+    def test_arcs(self):
+        g = ig.Graph.Full(4)
+        layout = [[0, 0], [1, 0], [2, 0], [3, 0]]
+
+        fig, ax = plt.subplots()
+        ipx.plot(
+            g,
+            layout=layout,
+            ax=ax,
+            edge_arc=True,
+            edge_tension=-1,
+        )
+
+    @image_comparison(baseline_images=["large_arcs"])
+    def test_large_arcs(self):
+        g = ig.Graph.Full(4)
+        layout = [[0, 0], [1, 0], [2, 0], [3, 0]]
+
+        fig, ax = plt.subplots()
+        ipx.plot(
+            g,
+            layout=layout,
+            ax=ax,
+            edge_arc=True,
+            edge_tension=-3,
+            margins=0.2,
+        )
+
 
 class ClusteringTestRunner(unittest.TestCase):
     @property