iplotx 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

iplotx/utils/matplotlib.py

@@ -1,5 +1,6 @@
 from functools import wraps, partial
 from math import atan2
+import numpy as np
 import matplotlib as mpl
 
 from .geometry import (
@@ -29,6 +30,7 @@ def _forwarder(forwards, cls=None):
 
     def make_forward(name):
         def method(self, *args, **kwargs):
+            """Each decorated method is called on the decorated class and then, nonrecursively, on all children."""
             ret = getattr(cls.mro()[1], name)(self, *args, **kwargs)
             for c in self.get_children():
                 getattr(c, name)(*args, **kwargs)
@@ -46,7 +48,13 @@ def _forwarder(forwards, cls=None):
 
 
 def _additional_set_methods(attributes, cls=None):
-    """Decorator to add specific set methods for children properties."""
+    """Decorator to add specific set methods for children properties.
+
+    This is useful to autogenerate methods a la set_<key>(value), for
+    instance set_alpha(value). It works by delegating to set(alpha=value).
+
+    Overall, this is a minor tweak compared to the previous decorator.
+    """
     if cls is None:
         return partial(_additional_set_methods, attributes)
 
@@ -73,64 +81,76 @@ def _additional_set_methods(attributes, cls=None):
 # 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."""
-    forbidden_props = ["horizontalalignment", "verticalalignment", "ha", "va"]
+    forbidden_props = [
+        "horizontalalignment",
+        "verticalalignment",
+        "ha",
+        "va",
+        "color",
+        "edgecolor",
+        "facecolor",
+    ]
     for prop in forbidden_props:
         if prop in kwargs:
             del kwargs[prop]
 
     path = mpl.textpath.TextPath((0, 0), text, **kwargs)
     boundingbox = path.get_extents()
-    width = boundingbox.width + hpadding
-    height = boundingbox.height + vpadding
+    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
+    width *= kwargs.get("size", 12) / 12.0
+    height *= kwargs.get("size", 12) / 12.0
+
+    width += hpadding
+    height += vpadding
     return (width, height)
 
 
-def _compute_mid_coord(path):
+def _compute_mid_coord_and_rot(path, trans):
     """Compute mid point of an edge, straight or curved."""
     # Distinguish between straight and curved paths
     if path.codes[-1] == mpl.path.Path.LINETO:
-        return path.vertices.mean(axis=0)
+        coord = path.vertices.mean(axis=0)
+        vtr = trans(path.vertices)
+        rot = atan2(
+            vtr[-1, 1] - vtr[0, 1],
+            vtr[-1, 0] - vtr[0, 0],
+        )
 
     # Cubic Bezier
-    if path.codes[-1] == mpl.path.Path.CURVE4:
-        return _evaluate_cubic_bezier(path.vertices, 0.5)
+    elif path.codes[-1] == mpl.path.Path.CURVE4:
+        coord = _evaluate_cubic_bezier(path.vertices, 0.5)
+        # TODO:
+        rot = 0
 
     # Square Bezier
-    if path.codes[-1] == mpl.path.Path.CURVE3:
-        return _evaluate_squared_bezier(path.vertices, 0.5)
-
-    raise ValueError(
-        "Curve type not straight and not squared/cubic Bezier, cannot compute mid point."
-    )
+    elif path.codes[-1] == mpl.path.Path.CURVE3:
+        coord = _evaluate_squared_bezier(path.vertices, 0.5)
+        # TODO:
+        rot = 0
 
+    else:
+        raise ValueError(
+            "Curve type not straight and not squared/cubic Bezier, cannot compute mid point."
+        )
 
-def _compute_group_path_with_vertex_padding(
-    points,
-    transform,
-    vertexpadding=10,
-):
-    """Offset path for a group based on vertex padding.
+    return coord, rot
 
-    At the input, the structure is [v1, v1, v1, v2, v2, v2, ...]
-    """
 
-    # Transform into figure coordinates
-    trans = transform.transform
-    trans_inv = transform.inverted().transform
-    points = trans(points)
+def _build_cmap_fun(values, cmap):
+    """Map colormap on top of numerical values."""
+    cmap = mpl.cm._ensure_cmap(cmap)
 
-    npoints = len(points) // 3
-    vprev = points[-1]
-    mprev = atan2(points[0, 1] - vprev[1], points[0, 0] - vprev[0])
-    for i, vcur in enumerate(points[::3]):
-        vnext = points[(i + 1) * 3]
-        mnext = atan2(vnext[1] - vcur[1], vnext[0] - vcur[0])
+    if np.isscalar(values):
+        values = [values]
 
-        mprev_orth = -1 / mprev
-        points[i * 3] = vcur + vertexpadding * mprev_orth
+    if isinstance(values, dict):
+        values = np.array(list(values.values()))
 
-        vprev = vcur
-        mprev = mnext
+    vmin = np.nanmin(values)
+    vmax = np.nanmax(values)
+    norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
 
-    points = trans_inv(points)
-    return points
+    return lambda x: cmap(norm(x))

iplotx/utils/style.py

@@ -0,0 +1 @@
+from copy import copy

iplotx/version.py

@@ -1 +1,5 @@
-__version__ = "0.1.0"
+"""
+iplotx version information module.
+"""
+
+__version__ = "0.2.0"

iplotx/vertex.py

@@ -1,51 +1,129 @@
+"""
+Module containing code to manipulate vertex visualisations, especially the VertexCollection class.
+"""
+
+from typing import (
+    Optional,
+    Sequence,
+    Any,
+    Never,
+)
+import warnings
 import numpy as np
-from matplotlib.transforms import IdentityTransform
+import pandas as pd
+import matplotlib as mpl
 from matplotlib.collections import PatchCollection
 from matplotlib.patches import (
+    Patch,
     Ellipse,
     Circle,
     RegularPolygon,
     Rectangle,
 )
 
+from .style import (
+    get_style,
+    rotate_style,
+    copy_with_deep_values,
+)
+from .utils.matplotlib import (
+    _get_label_width_height,
+    _build_cmap_fun,
+    _forwarder,
+)
+from .label import LabelCollection
+
 
+@_forwarder(
+    (
+        "set_clip_path",
+        "set_clip_box",
+        "set_snap",
+        "set_sketch_params",
+        "set_animated",
+        "set_picker",
+    )
+)
 class VertexCollection(PatchCollection):
-    """Collection of vertex patches for plotting.
+    """Collection of vertex patches for plotting."""
 
-    This class takes additional keyword arguments compared to PatchCollection:
+    _factor = 1.0
 
-    @param vertex_builder: A list of vertex builders to construct the visual
-        vertices. This is updated if the size of the vertices is changed.
-    @param size_callback: A function to be triggered after vertex sizes are
-        changed. Typically this redraws the edges.
-    """
+    def __init__(
+        self,
+        layout: pd.DataFrame,
+        *args,
+        layout_coordinate_system: str = "cartesian",
+        style: Optional[dict[str, Any]] = None,
+        labels: Optional[Sequence[str]] = None,
+        **kwargs,
+    ):
+        """Initialise the VertexCollection.
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+        Parameters:
+            layout: The vertex layout.
+            layout_coordinate_system: The coordinate system for the layout, usually "cartesian").
+            style: The vertex style (subdictionary "vertex") to apply.
+            labels: The vertex labels, if present.
+        """
 
-    def get_sizes(self):
-        """Same as get_size."""
-        return self.get_size()
+        self._index = layout.index
+        self._style = style
+        self._labels = labels
+
+        # Create patches from structured data
+        patches, offsets, sizes, kwargs2 = self._init_vertex_patches(
+            layout,
+            layout_coordinate_system=layout_coordinate_system,
+        )
+
+        kwargs.update(kwargs2)
+        kwargs["offsets"] = offsets
+        kwargs["match_original"] = True
 
-    def get_size(self):
-        """Get vertex sizes.
+        # Pass to PatchCollection constructor
+        super().__init__(patches, *args, **kwargs)
 
-        If width and height are unequal, get the largest of the two.
+        # Compute _transforms like in _CollectionWithScales for dpi issues
+        self.set_sizes(sizes)
 
-        @return: An array of vertex sizes.
+        if self._labels is not None:
+            self._compute_label_collection()
+
+    def get_children(self) -> tuple[mpl.artist.Artist]:
+        """Get the children artists.
+
+        This can include the labels as a LabelCollection.
         """
-        import numpy as np
+        children = []
+        if hasattr(self, "_label_collection"):
+            children.append(self._label_collection)
+        return tuple(children)
 
-        sizes = []
-        for path in self.get_paths():
-            bbox = path.get_extents()
-            mins, maxs = bbox.min, bbox.max
-            width, height = maxs - mins
-            size = max(width, height)
-            sizes.append(size)
-        return np.array(sizes)
+    def set_figure(self, fig) -> Never:
+        """Set the figure for this artist and all children."""
+        super().set_figure(fig)
+        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+        for child in self.get_children():
+            child.set_figure(fig)
+
+    def get_index(self):
+        """Get the VertexCollection index."""
+        return self._index
+
+    def get_vertex_id(self, index):
+        """Get the id of a single vertex at a positional index."""
+        return self._index[index]
 
-    def set_size(self, sizes):
+    def get_sizes(self):
+        """Get vertex sizes (max of width and height), not scaled by dpi."""
+        return self._sizes
+
+    def get_sizes_dpi(self):
+        """Get vertex sizes (max of width and height), scaled by dpi."""
+        return self._transforms[:, 0, 0]
+
+    def set_sizes(self, sizes, dpi=72.0):
         """Set vertex sizes.
 
         This rescales the current vertex symbol/path linearly, using this
@@ -53,26 +131,109 @@ class VertexCollection(PatchCollection):
 
         @param sizes: A sequence of vertex sizes or a single size.
         """
-        paths = self._paths
-        try:
-            iter(sizes)
-        except TypeError:
-            sizes = [sizes] * len(paths)
-
-        sizes = list(sizes)
-        current_sizes = self.get_sizes()
-        for path, cursize in zip(paths, current_sizes):
-            # Circular use of sizes
-            size = sizes.pop(0)
+        if sizes is None:
+            self._sizes = np.array([])
+            self._transforms = np.empty((0, 3, 3))
+        else:
+            self._sizes = np.asarray(sizes)
+            self._transforms = np.zeros((len(self._sizes), 3, 3))
+            scale = self._sizes * dpi / 72.0 * self._factor
+            self._transforms[:, 0, 0] = scale
+            self._transforms[:, 1, 1] = scale
+            self._transforms[:, 2, 2] = 1.0
+        self.stale = True
+
+    get_size = get_sizes
+    set_size = set_sizes
+
+    def _init_vertex_patches(
+        self, vertex_layout_df, layout_coordinate_system="cartesian"
+    ):
+        style = self._style or {}
+        if "cmap" in style:
+            cmap_fun = _build_cmap_fun(
+                style["facecolor"],
+                style["cmap"],
+            )
+        else:
+            cmap_fun = None
+
+        if style.get("size", 20) == "label":
+            if self._labels is None:
+                warnings.warn(
+                    "No labels found, cannot resize vertices based on labels."
+                )
+                style["size"] = get_style("default.vertex")["size"]
+            else:
+                vertex_labels = self._labels
+
+        if "cmap" in style:
+            colorarray = []
+        patches = []
+        offsets = []
+        sizes = []
+        for i, (vid, row) in enumerate(vertex_layout_df.iterrows()):
+            # Centre of the vertex
+            offset = list(row.values)
+
+            # Transform to cartesian coordinates if needed
+            if layout_coordinate_system == "polar":
+                r, theta = offset
+                offset = [r * np.cos(theta), r * np.sin(theta)]
+
+            offsets.append(offset)
+
+            if style.get("size") == "label":
+                # NOTE: it's ok to overwrite the dict here
+                style["size"] = _get_label_width_height(
+                    str(vertex_labels[vid]), **style.get("label", {})
+                )
+
+            stylei = rotate_style(style, index=i, key=vid)
+            if cmap_fun is not None:
+                colorarray.append(style["facecolor"])
+                stylei["facecolor"] = cmap_fun(stylei["facecolor"])
+
+            # Shape of the vertex (Patch)
+            art, size = make_patch(**stylei)
+            patches.append(art)
             sizes.append(size)
-            # Rescale the path for this vertex
-            path.vertices *= size / cursize
 
-        self.stale = True
+        kwargs = {}
+        if "cmap" in style:
+            vmin = np.min(colorarray)
+            vmax = np.max(colorarray)
+            norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
+            kwargs["cmap"] = style["cmap"]
+            kwargs["norm"] = norm
+
+        return patches, offsets, sizes, kwargs
 
-    def set_sizes(self, sizes):
-        """Same as set_size."""
-        self.set_size(sizes)
+    def _compute_label_collection(self):
+        transform = self.get_offset_transform()
+
+        style = (
+            copy_with_deep_values(self._style.get("label", None))
+            if self._style is not None
+            else {}
+        )
+        forbidden_props = ["hpadding", "vpadding"]
+        for prop in forbidden_props:
+            if prop in style:
+                del style[prop]
+
+        self._label_collection = LabelCollection(
+            self._labels,
+            style=style,
+            offsets=self._offsets,
+            transform=transform,
+        )
+
+    def get_labels(self):
+        if hasattr(self, "_label_collection"):
+            return self._label_collection
+        else:
+            return None
 
     @property
     def stale(self):
@@ -84,29 +245,63 @@ class VertexCollection(PatchCollection):
         if val and hasattr(self, "stale_callback_post"):
             self.stale_callback_post(self)
 
+    @mpl.artist.allow_rasterization
+    def draw(self, renderer):
+        if not self.get_visible():
+            return
+
+        # null graph, no need to draw anything
+        # NOTE: I would expect this to be already a clause in the superclass by oh well
+        if len(self.get_paths()) == 0:
+            return
 
-def make_patch(marker: str, size, **kwargs):
+        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+
+        # NOTE: This draws the vertices first, then the labels.
+        # The correct order would be vertex1->label1->vertex2->label2, etc.
+        # We might fix if we manage to find a way to do it.
+        super().draw(renderer)
+        for child in self.get_children():
+            child.draw(renderer)
+
+
+def make_patch(
+    marker: str, size: float | Sequence[float], **kwargs
+) -> tuple[Patch, float]:
     """Make a patch of the given marker shape and size."""
-    forbidden_props = ["label"]
+    forbidden_props = ["label", "cmap", "norm"]
     for prop in forbidden_props:
         if prop in kwargs:
             kwargs.pop(prop)
 
-    if isinstance(size, (int, float)):
+    if np.isscalar(size):
+        size = float(size)
         size = (size, size)
 
-    if marker in ("o", "circle"):
-        return Circle((0, 0), size[0] / 2, **kwargs)
+    # 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
+
+    art: Patch
+    if marker in ("o", "c", "circle"):
+        art = Circle((0, 0), size[0] / 2, **kwargs)
     elif marker in ("s", "square", "r", "rectangle"):
-        return Rectangle((-size[0] / 2, -size[1] / 2), size[0], size[1], **kwargs)
+        art = Rectangle((-size[0] / 2, -size[1] / 2), size[0], size[1], **kwargs)
     elif marker in ("^", "triangle"):
-        return RegularPolygon((0, 0), numVertices=3, radius=size[0] / 2, **kwargs)
+        art = RegularPolygon((0, 0), numVertices=3, radius=size[0] / 2, **kwargs)
     elif marker in ("d", "diamond"):
-        return make_patch("s", size[0], angle=45, **kwargs)
+        art, _ = make_patch("s", size[0], angle=45, **kwargs)
     elif marker in ("v", "triangle_down"):
-        return RegularPolygon(
+        art = RegularPolygon(
             (0, 0), numVertices=3, radius=size[0] / 2, orientation=np.pi, **kwargs
         )
     elif marker in ("e", "ellipse"):
-        return Ellipse((0, 0), size[0] / 2, size[1] / 2, **kwargs)
-    raise KeyError(f"Unknown marker: {marker}")
+        art = Ellipse((0, 0), size[0] / 2, size[1] / 2, **kwargs)
+    else:
+        raise KeyError(f"Unknown marker: {marker}")
+
+    return (art, size_max)

{iplotx-0.1.0.dist-info → iplotx-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.1.0
+Version: 0.2.0
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx
@@ -14,13 +14,14 @@ Keywords: graph,network,plotting,visualisation
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
 Requires-Dist: matplotlib>=2.0.0
+Requires-Dist: numpy>=2.0.0
 Requires-Dist: pandas>=2.0.0
+Requires-Dist: pylint>=3.3.7
 Provides-Extra: igraph
 Requires-Dist: igraph>=0.11.0; extra == 'igraph'
 Provides-Extra: networkx
@@ -29,17 +30,45 @@ Description-Content-Type: text/markdown
 
 ![Github Actions](https://github.com/fabilab/iplotx/actions/workflows/test.yml/badge.svg)
 ![PyPI - Version](https://img.shields.io/pypi/v/iplotx)
+![RTD](https://readthedocs.org/projects/iplotx/badge/?version=latest)
 
 # iplotx
 Plotting networks from igraph and networkx.
 
-**NOTE**: This is currently pre-alpha quality software. The API and functionality will break constantly, so use at your own risk. That said, if you have things you would like to see improved, please open a GitHub issue.
+**NOTE**: This is currently alpha quality software. The API and functionality will break constantly, so use at your own risk. That said, if you have things you would like to see improved, please open a GitHub issue.
+
+## Installation
+```bash
+pip install iplotx
+```
+
+## Quick Start
+```python
+import networkx as nx
+import matplotlib.pyplot as plt
+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)
+```
+
+![Quick start image](docs/source/_static/graph_basic.png)
+
+## Documentation
+See [readthedocs](https://iplotx.readthedocs.io/en/latest/) for the full documentation.
+
+## Gallery
+See [gallery](https://iplotx.readthedocs.io/en/latest/gallery/index.html).
 
 ## Roadmap
 - Plot networks from igraph and networkx interchangeably, using matplotlib as a backend. ✅
 - Support interactive plotting, e.g. zooming and panning after the plot is created. ✅
-- Support storing the plot to disk thanks to the many matplotlib backends (SVG, PNG, PDF, etc.).
-- Efficient plotting of large graphs using matplotlib's collection functionality. ✅ (partially)
+- Support storing the plot to disk thanks to the many matplotlib backends (SVG, PNG, PDF, etc.). ✅
+- Support flexible yet easy styling. ✅
+- Efficient plotting of large graphs using matplotlib's collection functionality. ✅
+- Support trees from special libraries such as ete3, biopython, etc. This will need a dedicated function and layouting. ✅
 - Support animations, e.g. showing the evolution of a network over time. 🏗️
 - Support uni- and bi-directional communication between graph object and plot object.🏗️
 

iplotx-0.2.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+iplotx/__init__.py,sha256=DIOWUaEo9vgmz8B6hBlurV95BEYmjmUe5BU-jRWrtG4,418
+iplotx/groups.py,sha256=QZ4iounIcoPQfxRIJamGJljpdKTsVJGM0DCfBPJKBm0,6106
+iplotx/label.py,sha256=zS53rzA2j4yjo150CfjqbYfBTFWNG5tt9AkfdNWZlZ0,3884
+iplotx/layout.py,sha256=IDj66gXUvAN8q1uBIhmob-ZOQFWO8GAlW-4gGprN7H0,3963
+iplotx/network.py,sha256=VcrKdq0PzbXfufIAir-nyMgrpfGvvXpdqK5H8kPDf3I,9739
+iplotx/plotting.py,sha256=1C6wenDeUohoYVl_vAcTs2aR-5LcRHFOcNb4ghIbkLI,7152
+iplotx/style.py,sha256=m-sWbC4qjfdPr4fUns_vCPKl035-uJXLy6F4J-egQjM,11058
+iplotx/tree.py,sha256=7o9BUltkl37wy9Gn8RepPoNlcbzZYALC1tZVLDJ0CVo,9372
+iplotx/typing.py,sha256=dfiCkn_7plbQZ1tkBAdK8vCap8r9ZB6Skw2W4RYKVbo,1078
+iplotx/version.py,sha256=yw3yV4Zl2O7TK5Iy1aB2-9BhAM-EcoMbba7u7G2n1TE,66
+iplotx/vertex.py,sha256=h0B5pTDxT2dTd73fN8sXYsJdzanwaI38T12ZYpX_EgI,9505
+iplotx/edge/__init__.py,sha256=1BE4qCIXJwcN6A1AQVY1PFxje9WNYR1PEMk36vTALkk,30285
+iplotx/edge/arrow.py,sha256=dTlXMi1PsQDbpIktjRCGtubMGF72iOg1Gw9vC0FMOYo,11217
+iplotx/edge/ports.py,sha256=UdK3ylEWOyaZkKAKqN-reL0euF6QBWHLTJG7Ts7uhz4,1126
+iplotx/ingest/__init__.py,sha256=75Pml7X65tP8b2G3qaeZUdnDgwP6dclcCEEFl0BYSdo,4707
+iplotx/ingest/heuristics.py,sha256=32AZ8iidM_uooaBKe2EMjNU_nJDbhA_28ADc0dpQy5A,6636
+iplotx/ingest/typing.py,sha256=QEgCpLyfp-0v9czn6OaJ0_nuCo1AXv3lGS3aD6w-Ezw,3134
+iplotx/ingest/providers/network/igraph.py,sha256=_J7lH-jrT0_1oSfwgT_mQMRhxNoFwHo8dyBLCbgqETQ,2766
+iplotx/ingest/providers/network/networkx.py,sha256=u7NegapWZ0gWUj5n1PUVD-zZ92lKUiv6BLNTNIrXlRk,4233
+iplotx/ingest/providers/tree/biopython.py,sha256=7ZVD_WwIaBOSl-at4r_Y4d2qHQq6BcvlV-yDxMVCWnw,3456
+iplotx/ingest/providers/tree/cogent3.py,sha256=5O92zkdA43LWQ7h6r-uG_5X76EPHo-Yx9ODLb0hd_qc,3636
+iplotx/ingest/providers/tree/ete4.py,sha256=sGm2363yLJWsWsrRn2iFx8qRiq57h_5dQWBD41xJmhY,3660
+iplotx/ingest/providers/tree/skbio.py,sha256=iNZhY_TNLpzd55cK2nybjiftUfakeOrDDJ9dMBna_io,3629
+iplotx/utils/geometry.py,sha256=K5ZBYPmz4-KNm64pDh2p0L6PF5-u57SCVaEd2eWeRv0,8956
+iplotx/utils/internal.py,sha256=WWfcZDGK8Ut1y_tOHRGg9wSqY1bwSeLQO7dHM_8Tvwo,107
+iplotx/utils/matplotlib.py,sha256=T37SMwKNSA-dRKgNkVw5H4fGr5NACtxvBPebDJGdhjk,4516
+iplotx/utils/style.py,sha256=fEi14nc37HQqHxZTPeQaTnFFwbSneY1oDCyv2UbWfKk,22
+iplotx-0.2.0.dist-info/METADATA,sha256=5Xey_j3r4NJ78C9f-cMvfyhZc9rPb6E6xwdBXbVjRUI,3055
+iplotx-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iplotx-0.2.0.dist-info/RECORD,,

iplotx/edge/common.py

@@ -1,47 +0,0 @@
-from math import pi
-import numpy as np
-
-
-def _compute_loops_per_angle(nloops, angles):
-    if len(angles) == 0:
-        return [(0, 2 * pi, nloops)]
-
-    angles_sorted_closed = list(sorted(angles))
-    angles_sorted_closed.append(angles_sorted_closed[0] + 2 * pi)
-    deltas = np.diff(angles_sorted_closed)
-
-    # Now we have the deltas and the total number of loops
-    # 1. Assign all loops to the largest wedge
-    idx_dmax = deltas.argmax()
-    if nloops == 1:
-        return [
-            (angles_sorted_closed[idx_dmax], angles_sorted_closed[idx_dmax + 1], nloops)
-        ]
-
-    # 2. Check if any other wedges are larger than this
-    # If not, we are done (this is the algo in igraph)
-    dsplit = deltas[idx_dmax] / nloops
-    if (deltas > dsplit).sum() < 2:
-        return [
-            (angles_sorted_closed[idx_dmax], angles_sorted_closed[idx_dmax + 1], nloops)
-        ]
-
-    # 3. Check how small the second-largest wedge would become
-    idx_dsort = np.argsort(deltas)
-    return [
-        (
-            angles_sorted_closed[idx_dmax],
-            angles_sorted_closed[idx_dmax + 1],
-            nloops - 1,
-        ),
-        (
-            angles_sorted_closed[idx_dsort[-2]],
-            angles_sorted_closed[idx_dsort[-2] + 1],
-            1,
-        ),
-    ]
-
-    ## TODO: we should greedily iterate from this
-    ## TODO: finish this
-    # dsplit_new = dsplit * nloops / (nloops - 1)
-    # dsplit2_new = deltas[idx_dsort[-2]]