iplotx 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

iplotx/tree.py

@@ -1,6 +1,7 @@
 from typing import (
     Optional,
     Sequence,
+    Any,
 )
 from collections.abc import Hashable
 from collections import defaultdict
@@ -30,6 +31,9 @@ from .edge import (
     EdgeCollection,
     make_stub_patch as make_undirected_edge_patch,
 )
+from .edge.leaf import (
+    LeafEdgeCollection,
+)
 from .label import (
     LabelCollection,
 )
@@ -58,7 +62,6 @@ class TreeArtist(mpl.artist.Artist):
         self,
         tree,
         layout: Optional[str] = "horizontal",
-        orientation: Optional[str] = None,
         directed: bool | str = False,
         vertex_labels: Optional[
             bool | list[str] | dict[Hashable, str] | pd.Series
@@ -67,15 +70,13 @@ class TreeArtist(mpl.artist.Artist):
         leaf_labels: Optional[Sequence | dict[Hashable, str]] | pd.Series = None,
         transform: mpl.transforms.Transform = mpl.transforms.IdentityTransform(),
         offset_transform: Optional[mpl.transforms.Transform] = None,
+        show_support: bool = False,
     ):
         """Initialize the TreeArtist.
 
         Parameters:
             tree: The tree to plot.
             layout: The layout to use for the tree. Can be "horizontal", "vertical", or "radial".
-            orientation: The orientation of the tree layout. Can be "right" or "left" (for
-                horizontal and radial layouts) and "descending" or "ascending" (for vertical
-                layouts).
             directed: Whether the tree is directed. Can be a boolean or a string with the
                 following choices: "parent" or "child".
             vertex_labels: Labels for the vertices. Can be a list, dictionary, or pandas Series.
@@ -88,13 +89,14 @@ class TreeArtist(mpl.artist.Artist):
             transform: The transform to apply to the tree artist. This is usually the identity.
             offset_transform: The offset transform to apply to the tree artist. This is
                 usually `ax.transData`.
+            show_support: Whether to show support values on the nodes. If both show_support and
+                vertex_labels are set, this parameters takes precedence.
         """
 
         self.tree = tree
         self._ipx_internal_data = ingest_tree_data(
             tree,
             layout,
-            orientation=orientation,
             directed=directed,
             layout_style=get_style(".layout", {}),
             vertex_labels=vertex_labels,
@@ -102,6 +104,10 @@ class TreeArtist(mpl.artist.Artist):
             leaf_labels=leaf_labels,
         )
 
+        if show_support:
+            support = self._ipx_internal_data["vertex_df"]["support"]
+            self._ipx_internal_data["vertex_df"]["label"] = support
+
         super().__init__()
 
         # This is usually the identity (which scales poorly with dpi)
@@ -116,10 +122,11 @@ class TreeArtist(mpl.artist.Artist):
         self._add_vertices()
         self._add_edges()
         self._add_leaf_vertices()
+        self._add_leaf_edges()
 
         # NOTE: cascades need to be created after leaf vertices in case
         # they are requested to wrap around them.
-        if "cascade" in self.get_vertices().get_style():
+        if get_style(".cascade") != {}:
             self._add_cascades()
 
     def get_children(self) -> tuple[mpl.artist.Artist]:
@@ -131,6 +138,8 @@ class TreeArtist(mpl.artist.Artist):
         children = [self._vertices, self._edges]
         if hasattr(self, "_leaf_vertices"):
             children.append(self._leaf_vertices)
+        if hasattr(self, "_leaf_edges"):
+            children.append(self._leaf_edges)
         if hasattr(self, "_cascades"):
             children.append(self._cascades)
         return tuple(children)
@@ -141,12 +150,24 @@ class TreeArtist(mpl.artist.Artist):
         Parameters:
             fig: the figure to set for this artist and its children.
         """
-        super().set_figure(fig)
-        for child in self.get_children():
-            child.set_figure(fig)
-
         # At the end, if there are cadcades with extent depending on
         # leaf edges, we should update them
+        super().set_figure(fig)
+
+        # The next two are vanilla NetworkArtist
+        self._vertices.set_figure(fig)
+        self._edges.set_figure(fig)
+
+        # For trees, there are a few more elements to coordinate,
+        # including possibly text at the fringes (leaf labels)
+        # which might require a redraw (without rendering) to compute
+        # its actual scren real estate.
+        if hasattr(self, "_leaf_vertices"):
+            self._leaf_vertices.set_figure(fig)
+        if hasattr(self, "_leaf_edges"):
+            self._leaf_edges.set_figure(fig)
+        if hasattr(self, "_cascades"):
+            self._cascades.set_figure(fig)
         self._update_cascades_extent()
 
     def _update_cascades_extent(self) -> None:
@@ -154,7 +175,7 @@ class TreeArtist(mpl.artist.Artist):
         if not hasattr(self, "_cascades"):
             return
 
-        style_cascade = self.get_vertices().get_style()["cascade"]
+        style_cascade = get_style(".cascade")
         extend_to_labels = style_cascade.get("extend", False) == "leaf_labels"
         if not extend_to_labels:
             return
@@ -213,13 +234,16 @@ class TreeArtist(mpl.artist.Artist):
         edge_bbox = self._edges.get_datalim(transData)
         bbox = mpl.transforms.Bbox.union([bbox, edge_bbox])
 
+        if hasattr(self, "_leaf_vertices"):
+            leaf_labels_bbox = self._leaf_vertices.get_datalim(transData)
+            bbox = mpl.transforms.Bbox.union([bbox, leaf_labels_bbox])
+
         if hasattr(self, "_cascades"):
             cascades_bbox = self._cascades.get_datalim(transData)
             bbox = mpl.transforms.Bbox.union([bbox, cascades_bbox])
 
-        if hasattr(self, "_leaf_vertices"):
-            leaf_labels_bbox = self._leaf_vertices.get_datalim(transData)
-            bbox = mpl.transforms.Bbox.union([bbox, leaf_labels_bbox])
+        # NOTE: We do not need to check leaf edges for bbox, because they are
+        # guaranteed within the convex hull of leaf vertices.
 
         bbox = bbox.expanded(sw=(1.0 + pad), sh=(1.0 + pad))
         return bbox
@@ -244,6 +268,12 @@ class TreeArtist(mpl.artist.Artist):
             return self._leaf_vertices
         return None
 
+    def get_leaf_edges(self) -> Optional[LeafEdgeCollection]:
+        """Get LeafEdgeCollection artist if present."""
+        if hasattr(self, "_leaf_edges"):
+            return self._leaf_edges
+        return None
+
     def get_vertex_labels(self) -> LabelCollection:
         """Get list of vertex label artists."""
         return self._vertices.get_labels()
@@ -253,10 +283,17 @@ class TreeArtist(mpl.artist.Artist):
         return self._edges.get_labels()
 
     def get_leaf_labels(self) -> Optional[LabelCollection]:
+        """Get the leaf label artist if present."""
         if hasattr(self, "_leaf_vertices"):
             return self._leaf_vertices.get_labels()
         return None
 
+    def get_leaf_edge_labels(self) -> Optional[LabelCollection]:
+        """Get the leaf edge label artist if present."""
+        if hasattr(self, "_leaf_edges"):
+            return self._leaf_edges.get_labels()
+        return None
+
     def _add_vertices(self) -> None:
         """Add vertices to the tree."""
         self._vertices = VertexCollection(
@@ -271,36 +308,153 @@ class TreeArtist(mpl.artist.Artist):
             offset_transform=self.get_offset_transform(),
         )
 
+    def _add_leaf_edges(self) -> None:
+        """Add edges from the leaf to the max leaf depth."""
+        # If there are no leaves, no leaf labels, or leaves are not deep,
+        # skip leaf edges
+        if not hasattr(self, "_leaf_vertices"):
+            return
+        leaf_style = get_style(".leaf", {})
+        if ("deep" not in leaf_style) and self.get_leaf_labels() is None:
+            return
+        if not leaf_style.get("deep", True):
+            return
+
+        edge_style = get_style(
+            ".leafedge",
+        )
+        default_style = {
+            "linestyle": "--",
+            "linewidth": 1,
+            "edgecolor": "#111",
+        }
+        for key, value in default_style.items():
+            if key not in edge_style:
+                edge_style[key] = value
+
+        labels = None
+        # TODO: implement leaf edge labels
+        # self._get_label_series("leafedge")
+
+        if "cmap" in edge_style:
+            cmap_fun = _build_cmap_fun(
+                edge_style["color"],
+                edge_style["cmap"],
+            )
+        else:
+            cmap_fun = None
+
+        leaf_shallow_layout = self.get_layout("leaf")
+
+        if "cmap" in edge_style:
+            colorarray = []
+        edgepatches = []
+        adjacent_vertex_ids = []
+        for i, vid in enumerate(leaf_shallow_layout.index):
+            edge_stylei = rotate_style(edge_style, index=i, key=vid)
+
+            if cmap_fun is not None:
+                colorarray.append(edge_stylei["color"])
+                edge_stylei["color"] = cmap_fun(edge_stylei["color"])
+
+            # These are not the actual edges drawn, only stubs to establish
+            # the styles which are then fed into the dynamic, optimised
+            # factory (the collection) below
+            patch = make_undirected_edge_patch(
+                **edge_stylei,
+            )
+            edgepatches.append(patch)
+            adjacent_vertex_ids.append(vid)
+
+        if "cmap" in edge_style:
+            vmin = np.min(colorarray)
+            vmax = np.max(colorarray)
+            norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
+            edge_style["norm"] = norm
+
+        self._leaf_edges = LeafEdgeCollection(
+            edgepatches,
+            vertex_leaf_ids=adjacent_vertex_ids,
+            vertex_collection=self._vertices,
+            leaf_collection=self._leaf_vertices,
+            labels=labels,
+            transform=self.get_offset_transform(),
+            style=edge_style,
+            directed=False,
+        )
+        if "cmap" in edge_style:
+            self._leaf_edges.set_array(colorarray)
+
     def _add_leaf_vertices(self) -> None:
         """Add invisible deep vertices as leaf label anchors."""
+        layout_name = self._ipx_internal_data["layout_name"]
+        orientation = self._ipx_internal_data["orientation"]
+        user_leaf_style = get_style(".leaf", {})
+
         leaf_layout = self.get_layout("leaf").copy()
+
         # Set all to max depth
-        depth_idx = int(self._ipx_internal_data["layout_name"] == "vertical")
-        leaf_layout.iloc[:, depth_idx] = leaf_layout.iloc[:, depth_idx].max()
+        if user_leaf_style.get("deep", True):
+            if layout_name == "radial":
+                leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].max()
+            elif layout_name == "horizontal":
+                if orientation == "right":
+                    leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].max()
+                else:
+                    leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].min()
+            elif layout_name == "vertical":
+                if orientation == "descending":
+                    leaf_layout.iloc[:, 1] = leaf_layout.iloc[:, 1].min()
+                else:
+                    leaf_layout.iloc[:, 1] = leaf_layout.iloc[:, 1].max()
+            else:
+                raise ValueError(
+                    f"Layout and orientation not supported: {layout_name}, {orientation}."
+                )
 
         # Set invisible vertices with visible labels
-        layout_name = self._ipx_internal_data["layout_name"]
-        orientation = self._ipx_internal_data["orientation"]
         if layout_name == "radial":
             ha = "auto"
-        elif orientation in ("left", "ascending"):
+            rotation = 0
+        elif orientation == "right":
+            ha = "left"
+            rotation = 0
+        elif orientation == "left":
             ha = "right"
+            rotation = 0
+        elif orientation == "ascending":
+            ha = "left"
+            rotation = 90
         else:
             ha = "left"
+            rotation = -90
 
-        leaf_vertex_style = {
+        default_leaf_style = {
             "size": 0,
             "label": {
-                "verticalalignment": "center",
+                "verticalalignment": "center_baseline",
                 "horizontalalignment": ha,
+                "rotation": rotation,
                 "hmargin": 5,
+                "vmargin": 0,
                 "bbox": {
                     "facecolor": (1, 1, 1, 0),
                 },
             },
         }
-        with context({"vertex": leaf_vertex_style}):
+        with context([{"vertex": default_leaf_style}, {"vertex": user_leaf_style}]):
             leaf_vertex_style = get_style(".vertex")
+            # Left horizontal layout has no rotation of the labels but we need to
+            # reverse hmargin
+            if (
+                layout_name == "horizontal"
+                and orientation == "left"
+                and "label" in leaf_vertex_style
+                and "hmargin" in leaf_vertex_style["label"]
+            ):
+                # Reverse the horizontal margin
+                leaf_vertex_style["label"]["hmargin"] *= -1
+
             self._leaf_vertices = VertexCollection(
                 layout=leaf_layout,
                 layout_coordinate_system=self._ipx_internal_data.get(
@@ -318,7 +472,7 @@ class TreeArtist(mpl.artist.Artist):
         # NOTE: If leaf labels are present and the cascades are requested to wrap around them,
         # we have to compute the max extend of the cascades from the leaf labels.
         maxdepth = None
-        style_cascade = self.get_vertices().get_style()["cascade"]
+        style_cascade = get_style(".cascade")
         extend_to_labels = style_cascade.get("extend", False) == "leaf_labels"
         has_leaf_labels = self.get_leaf_labels() is not None
         if extend_to_labels and not has_leaf_labels:
@@ -342,7 +496,6 @@ class TreeArtist(mpl.artist.Artist):
         layout_name = self.get_layout_name()
         if layout_name == "radial":
             maxdepth = 0
-            # These are the text boxes, they must all be included
             bboxes = self.get_leaf_labels().get_datalims_children(
                 self.get_offset_transform()
             )
@@ -447,7 +600,10 @@ class TreeArtist(mpl.artist.Artist):
             norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
             edge_style["norm"] = norm
 
-        edge_style["waypoints"] = waypoints
+        if get_style(".layout", {}).get("angular", False):
+            edge_style.pop("waypoints", None)
+        else:
+            edge_style["waypoints"] = waypoints
 
         # NOTE: Trees are directed is their "directed" property is True, "child", or "parent"
         self._edges = EdgeCollection(
@@ -470,24 +626,83 @@ class TreeArtist(mpl.artist.Artist):
         """Get the orientation of the tree layout."""
         return self._ipx_internal_data.get("orientation", None)
 
+    def style_subtree(
+        self,
+        nodes: Sequence[Hashable],
+        style: Optional[dict[str, Any] | Sequence[str | dict[str, Any]]] = None,
+    ) -> None:
+        """Style a subtree of the tree.
+
+        Parameters:
+            nodes: Sequence of nodes that span the subtree. All elements below including
+                the most recent common ancestor of these leaves will be styled.
+            style: Style or sequence of styles to apply to the subtree. Each style can
+                be either a string, referring to an internal `iplotx` style, or a dictionary
+                with custom styling elements.
+        """
+        provider = data_providers["tree"][self._ipx_internal_data["tree_library"]]
+
+        # Get last (deepest) common ancestor of the requested nodes
+        root = provider(self.tree).get_lca(nodes)
+
+        # Populate a DataFrame with the array of properties to update
+        vertex_idx = {
+            node: i for i, node in enumerate(self._ipx_internal_data["vertex_df"].index)
+        }
+        edge_idx = {
+            node: i
+            for i, node in enumerate(
+                self._ipx_internal_data["edge_df"]["_ipx_target"].values
+            )
+        }
+        vertex_props = {}
+        edge_props = {}
+        vertex_style = style.get("vertex", {})
+        edge_style = style.get("edge", {})
+        for inode, node in enumerate(provider(root).preorder()):
+            for attr, value in vertex_style.items():
+                if attr not in vertex_props:
+                    vertex_props[attr] = list(getattr(self._vertices, f"get_{attr}")())
+                vertex_props[attr][vertex_idx[node]] = value
+
+            # Ignore branch coming into the root node
+            if inode == 0:
+                continue
+
+            for attr, value in edge_style.items():
+                # Edge color is actually edgecolor
+                if attr == "color":
+                    attr = "edgecolor"
+                if attr not in edge_props:
+                    edge_props[attr] = list(getattr(self._edges, f"get_{attr}")())
+                edge_props[attr][edge_idx[node]] = value
+
+        # Update the properties from the DataFrames
+        for attr in vertex_props:
+            getattr(self._vertices, f"set_{attr}")(vertex_props[attr])
+        for attr in edge_props:
+            getattr(self._edges, f"set_{attr}")(edge_props[attr])
+
     @_stale_wrapper
     def draw(self, renderer) -> None:
         """Draw each of the children, with some buffering mechanism."""
         if not self.get_visible():
             return
 
-        # At the end, if there are cadcades with extent depending on
-        # leaf edges, we should update them
-        self._update_cascades_extent()
-
         # NOTE: looks like we have to manage the zorder ourselves
         # this is kind of funny actually. Btw we need to ensure
         # that cascades are drawn behind (earlier than) vertices
         # and edges at equal zorder because it looks better that way.
         z_suborder = defaultdict(int)
+        if hasattr(self, "_leaf_vertices"):
+            z_suborder[self._leaf_vertices] = -2
+        if hasattr(self, "_leaf_edges"):
+            z_suborder[self._leaf_edges] = -2
         if hasattr(self, "_cascades"):
             z_suborder[self._cascades] = -1
         children = list(self.get_children())
         children.sort(key=lambda x: (x.zorder, z_suborder[x]))
         for art in children:
+            if isinstance(art, CascadeCollection):
+                self._update_cascades_extent()
             art.draw(renderer)

iplotx/utils/matplotlib.py

@@ -74,13 +74,24 @@ def _additional_set_methods(attributes, cls=None):
     return cls
 
 
-# FIXME: this method appears quite inconsistent, would be better to improve.
-# The issue is that to really know the size of a label on screen, we need to
-# render it first. Therefore, we should render the labels, then render the
-# vertices. Leaving for now, since this can be styled manually which covers
-# many use cases.
-def _get_label_width_height(text, hpadding=18, vpadding=12, **kwargs):
-    """Get the bounding box size for a text with certain properties."""
+def _get_label_width_height(text, hpadding=18, vpadding=12, dpi=72.0, **kwargs):
+    """Get the bounding box size for a text with certain properties.
+
+    Parameters:
+        text: The text to measure.
+        hpadding: Horizontal padding to add to the width.
+        vpadding: Vertical padding to add to the height.
+        **kwargs: Additional keyword arguments for text properties. "fontsize" is accepted,
+            as is "size". Many other properties are not used and will raise and exception.
+
+    Returns:
+        A tuple (width, height) representing the size of the text bounding box. Because
+        some text properties such as weight are not taken into account, ths function is not
+        very accurate. Yet, it is often good enough and easier to implement than a careful
+        orchestration of Figure.draw_without_rendering.
+    """
+    if "fontsize" in kwargs:
+        kwargs["size"] = kwargs.pop("fontsize")
     forbidden_props = [
         "horizontalalignment",
         "verticalalignment",
@@ -99,12 +110,18 @@ def _get_label_width_height(text, hpadding=18, vpadding=12, **kwargs):
     width = boundingbox.width
     height = boundingbox.height
 
-    # Scaling with font size appears broken... try to patch it up linearly here, even though we know it don't work well
+    # Scaling with font size appears broken... try to patch it up linearly here, even though we
+    # know it does not work terribly accurately
     width *= kwargs.get("size", 12) / 12.0
     height *= kwargs.get("size", 12) / 12.0
 
     width += hpadding
     height += vpadding
+
+    # Scale by dpi
+    width *= dpi / 72.0
+    height *= dpi / 72.0
+
     return (width, height)
 
 
@@ -139,7 +156,7 @@ def _compute_mid_coord_and_rot(path, trans):
     return coord, rot
 
 
-def _build_cmap_fun(values, cmap):
+def _build_cmap_fun(values, cmap, norm=None):
     """Map colormap on top of numerical values."""
     cmap = mpl.cm._ensure_cmap(cmap)
 
@@ -149,8 +166,9 @@ def _build_cmap_fun(values, cmap):
     if isinstance(values, dict):
         values = np.array(list(values.values()))
 
-    vmin = np.nanmin(values)
-    vmax = np.nanmax(values)
-    norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
+    if norm is None:
+        vmin = np.nanmin(values)
+        vmax = np.nanmax(values)
+        norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
 
     return lambda x: cmap(norm(x))

iplotx/utils/style.py

@@ -1 +1,12 @@
-from copy import copy
+import copy
+
+
+def copy_with_deep_values(style):
+    """Make a deep copy of the style dict but do not create copies of the keys."""
+    newdict = {}
+    for key, value in style.items():
+        if isinstance(value, dict):
+            newdict[key] = copy_with_deep_values(value)
+        else:
+            newdict[key] = copy.copy(value)
+    return newdict

iplotx/version.py

@@ -2,4 +2,4 @@
 iplotx version information module.
 """
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

iplotx/vertex.py

@@ -14,6 +14,7 @@ import matplotlib as mpl
 from matplotlib.collections import PatchCollection
 from matplotlib.patches import (
     Patch,
+    Polygon,
     Ellipse,
     Circle,
     RegularPolygon,
@@ -355,7 +356,7 @@ def make_patch(
     **kwargs,
 ) -> tuple[Patch, float]:
     """Make a patch of the given marker shape and size."""
-    forbidden_props = ["label", "cmap", "norm", "cascade"]
+    forbidden_props = ["label", "cmap", "norm", "cascade", "deep"]
     for prop in forbidden_props:
         if prop in kwargs:
             kwargs.pop(prop)
@@ -363,12 +364,12 @@ def make_patch(
     if np.isscalar(size):
         size = float(size)
         size = (size, size)
+    size = np.asarray(size, dtype=float)
 
     # Size of vertices is determined in self._transforms, which scales with dpi, rather than here,
     # so normalise by the average dimension (btw x and y) to keep the ratio of the marker.
     # If you check in get_sizes, you will see that rescaling also happens with the max of width
     # and height.
-    size = np.asarray(size, dtype=float)
     size_max = size.max()
     if size_max > 0:
         size /= size_max
@@ -379,15 +380,69 @@ def make_patch(
     elif marker in ("s", "square", "r", "rectangle"):
         art = Rectangle((-size[0] / 2, -size[1] / 2), size[0], size[1], **kwargs)
     elif marker in ("^", "triangle"):
-        art = RegularPolygon((0, 0), numVertices=3, radius=size[0] / 2, **kwargs)
-    elif marker in ("d", "diamond"):
-        art, _ = make_patch("s", size[0], angle=45, **kwargs)
+        art = RegularPolygon(
+            (0, 0), numVertices=3, radius=size[0] / np.sqrt(2), **kwargs
+        )
     elif marker in ("v", "triangle_down"):
         art = RegularPolygon(
-            (0, 0), numVertices=3, radius=size[0] / 2, orientation=np.pi, **kwargs
+            (0, 0),
+            numVertices=3,
+            radius=size[0] / np.sqrt(2),
+            orientation=np.pi,
+            **kwargs,
+        )
+    elif marker in ("<", "triangle_left"):
+        art = RegularPolygon(
+            (0, 0),
+            numVertices=3,
+            radius=size[0] / np.sqrt(2),
+            orientation=np.pi / 2,
+            **kwargs,
+        )
+    elif marker in (">", "triangle_right"):
+        art = RegularPolygon(
+            (0, 0),
+            numVertices=3,
+            radius=size[0] / np.sqrt(2),
+            orientation=-np.pi / 2,
+            **kwargs,
+        )
+    elif marker in ("d", "diamond"):
+        art = RegularPolygon(
+            (0, 0), numVertices=4, radius=size[0] / np.sqrt(2), **kwargs
+        )
+    elif marker in ("p", "pentagon"):
+        art = RegularPolygon(
+            (0, 0), numVertices=5, radius=size[0] / np.sqrt(2), **kwargs
+        )
+    elif marker in ("h", "hexagon"):
+        art = RegularPolygon(
+            (0, 0), numVertices=6, radius=size[0] / np.sqrt(2), **kwargs
+        )
+    elif marker in ("8", "octagon"):
+        art = RegularPolygon(
+            (0, 0), numVertices=8, radius=size[0] / np.sqrt(2), **kwargs
         )
     elif marker in ("e", "ellipse"):
-        art = Ellipse((0, 0), size[0] / 2, size[1] / 2, **kwargs)
+        art = Ellipse((0, 0), size[0], size[1], **kwargs)
+    elif marker in ("*", "star"):
+        size *= np.sqrt(2)
+        art = Polygon(
+            [
+                (0, size[1] / 2),
+                (size[0] / 7, size[1] / 7),
+                (size[0] / 2, size[1] / 7),
+                (size[0] / 4, -size[1] / 8),
+                (size[0] / 3, -size[1] / 2),
+                (0, -0.27 * size[1]),
+                (-size[0] / 3, -size[1] / 2),
+                (-size[0] / 4, -size[1] / 8),
+                (-size[0] / 2, size[1] / 7),
+                (-size[0] / 7, size[1] / 7),
+                (0, size[1] / 2),
+            ][::-1],
+            **kwargs,
+        )
     else:
         raise KeyError(f"Unknown marker: {marker}")
 

{iplotx-0.3.0.dist-info → iplotx-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.3.0
+Version: 0.4.0
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx