#! /usr/bin/env python # -*- coding: utf-8 -*- # # graph_tool -- a general graph manipulation python module # # Copyright (C) 2006-2025 Tiago de Paula Peixoto # # This program is free software; you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation; either version 3 of the License, or (at your option) any # later version. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see . import os import warnings import numpy from collections.abc import Iterable from .. topology import shortest_distance, is_bipartite from .. import _check_prop_scalar, perfect_prop_hash try: import cairo except ImportError: msg = "Error importing cairo. Graph drawing will not work." warnings.warn(msg, RuntimeWarning) raise default_cm = None try: import matplotlib.artist import matplotlib.backends.backend_cairo import matplotlib.cm import matplotlib.colors from matplotlib.cbook import flatten default_clrs = list(matplotlib.cm.tab20.colors) + \ list(matplotlib.cm.tab20b.colors) default_cm = matplotlib.cm.colors.ListedColormap(default_clrs) default_cm_bin = matplotlib.cm.colors.ListedColormap([[1, 1, 1, 1], [0, 0, 0, 1]]) has_draw_inline = 'inline' in matplotlib.get_backend() color_converter = matplotlib.colors.ColorConverter() except ImportError: msg = "Error importing matplotlib module. Graph drawing will not work." warnings.warn(msg, RuntimeWarning) raise try: import IPython.display except ImportError: pass import numpy as np import gzip import bz2 import zipfile import copy import io from collections import defaultdict from scipy.stats import rankdata from .. import Graph, GraphView, PropertyMap, ungroup_vector_property,\ group_vector_property, _prop, _check_prop_vector, map_property_values from .. generation import label_parallel_edges, label_self_loops from .. dl_import import dl_import dl_import("from . import libgraph_tool_draw") try: from .libgraph_tool_draw import vertex_attrs, edge_attrs, vertex_shape,\ edge_marker except ImportError: msg = "Error importing cairo-based drawing library. " + \ "Was graph-tool compiled with cairomm support?" warnings.warn(msg, RuntimeWarning) from .. draw import sfdp_layout, random_layout, _avg_edge_distance, \ radial_tree_layout, prop_to_size from .. generation import graph_merge from .. topology import shortest_path _vdefaults = { "shape": "circle", "color": (0.6, 0.6, 0.6, 0.8), "fill_color": (0.6470588235294118, 0.058823529411764705, 0.08235294117647059, 0.8), "size": 5, "aspect": 1., "rotation": 0., "anchor": 1, "pen_width": 0.8, "halo": 0, "halo_color": [0., 0., 1., 0.5], "halo_size": 1.5, "text": "", "text_color": [0., 0., 0., 1.], "text_position": -1., "text_rotation": 0., "text_offset": [0., 0.], "text_out_width": .1, "text_out_color": [0., 0., 0., 0.], "font_family": "serif", "font_slant": cairo.FONT_SLANT_NORMAL, "font_weight": cairo.FONT_WEIGHT_NORMAL, "font_size": 12., "surface": None, "pie_fractions": [0.75, 0.25], "pie_colors": [default_cm(x) for x in range(10)] } _edefaults = { "color": (0.1796875, 0.203125, 0.2109375, 0.8), "pen_width": 1, "start_marker": "none", "mid_marker": "none", "end_marker": "none", "marker_size": 4., "mid_marker_pos": .5, "control_points": [], "gradient": [], "dash_style": [], "text": "", "text_color": (0., 0., 0., 1.), "text_distance": 5, "text_parallel": True, "text_out_width": .1, "text_out_color": [0., 0., 0., 0.], "font_family": "serif", "font_slant": cairo.FONT_SLANT_NORMAL, "font_weight": cairo.FONT_WEIGHT_NORMAL, "font_size": 12., "sloppy": False, "seamless": False } _vtypes = { "shape": "int", "color": "vector", "fill_color": "vector", "size": "double", "aspect": "double", "rotation": "double", "anchor": "double", "pen_width": "double", "halo": "bool", "halo_color": "vector", "halo_size": "double", "text": "string", "text_color": "vector", "text_position": "double", "text_rotation": "double", "text_offset": "vector", "text_out_width": "double", "text_out_color": "vector", "font_family": "string", "font_slant": "int", "font_weight": "int", "font_size": "double", "surface": "object", "pie_fractions": "vector", "pie_colors": "vector" } _etypes = { "color": "vector", "pen_width": "double", "start_marker": "int", "mid_marker": "int", "end_marker": "int", "marker_size": "double", "mid_marker_pos": "double", "control_points": "vector", "gradient": "vector", "dash_style": "vector", "text": "string", "text_color": "vector", "text_distance": "double", "text_parallel": "bool", "text_out_width": "double", "text_out_color": "vector", "font_family": "string", "font_slant": "int", "font_weight": "int", "font_size": "double", "sloppy": "bool", "seamless": "bool" } for k in list(_vtypes.keys()): _vtypes[getattr(vertex_attrs, k)] = _vtypes[k] for k in list(_etypes.keys()): _etypes[getattr(edge_attrs, k)] = _etypes[k] def shape_from_prop(shape, enum): if isinstance(shape, PropertyMap): g = shape.get_graph() if shape.key_type() == "v": prop = g.new_vertex_property("int") descs = g.vertices() else: descs = g.edges() prop = g.new_edge_property("int") if shape.value_type() == "string": def conv(x): return int(getattr(enum, x)) map_property_values(shape, prop, conv) else: rg = (min(enum.values.keys()), max(enum.values.keys())) g.copy_property(shape, prop) if prop.fa.min() < rg[0]: prop.fa += rg[0] prop.fa -= rg[0] prop.fa %= rg[1] - rg[0] + 1 prop.fa += rg[0] return prop if isinstance(shape, str): return int(getattr(enum, shape)) else: return shape raise ValueError("Invalid value for attribute %s: %s" % (repr(enum), repr(shape))) def open_file(name, mode="r"): name = os.path.expanduser(name) base, ext = os.path.splitext(name) if ext == ".gz": out = gzip.GzipFile(name, mode) name = base elif ext == ".bz2": out = bz2.BZ2File(name, mode) name = base elif ext == ".zip": out = zipfile.ZipFile(name, mode) name = base else: out = open(name, mode) fmt = os.path.splitext(name)[1].replace(".", "") return out, fmt def get_file_fmt(name): name = os.path.expanduser(name) base, ext = os.path.splitext(name) if ext == ".gz": name = base elif ext == ".bz2": name = base elif ext == ".zip": name = base fmt = os.path.splitext(name)[1].replace(".", "") return fmt def surface_from_prop(surface): if isinstance(surface, PropertyMap): if surface.key_type() == "v": prop = surface.get_graph().new_vertex_property("object") descs = surface.get_graph().vertices() else: descs = surface.get_graph().edges() prop = surface.get_graph().new_edge_property("object") surface_map = {} for v in descs: if surface.value_type() == "string": if surface[v] not in surface_map: sfc = gen_surface(surface[v]) surface_map[surface[v]] = sfc prop[v] = surface_map[surface[v]] elif surface.value_type() == "python::object": if isinstance(surface[v], cairo.Surface): prop[v] = surface[v] elif surface[v] is not None: raise ValueError("Invalid value type for surface property: " + str(type(surface[v]))) else: raise ValueError("Invalid value type for surface property: " + surface.value_type()) return prop if isinstance(surface, str): return gen_surface(surface) elif isinstance(surface, cairo.Surface) or surface is None: return surface raise ValueError("Invalid value for attribute surface: " + repr(surface)) def centered_rotation(g, pos, text_pos=True): x, y = ungroup_vector_property(pos, [0, 1]) cm = (x.fa.mean(), y.fa.mean()) dx = x.fa - cm[0] dy = y.fa - cm[1] angle = g.new_vertex_property("double") angle.fa = numpy.arctan2(dy, dx) pi = numpy.pi angle.fa += 2 * pi angle.fa %= 2 * pi if text_pos: idx = (angle.a > pi / 2 ) * (angle.a < 3 * pi / 2) tpos = g.new_vertex_property("double") angle.a[idx] += pi tpos.a[idx] = pi return angle, tpos return angle def choose_cm(prop, cm): is_bin = False if prop.value_type() in ["double", "long double"]: is_seq = True else: ph = perfect_prop_hash([prop])[0] if ph.fa.max() >= default_cm.N: is_seq = True else: is_seq = False if ph.fa.max() == 1: is_bin = True if cm is not None: return cm, is_seq if prop.key_type() == "e": if is_bin: cm = matplotlib.cm.RdGy is_seq = True elif not is_seq: cm = default_cm else: cm = matplotlib.cm.binary else: if is_bin: cm = default_cm_bin elif not is_seq: cm = default_cm else: cm = matplotlib.cm.magma return cm, is_seq def _convert(attr, val, cmap, vnorm, pmap_default=False, g=None, k=None): try: cmap, alpha = cmap except TypeError: alpha = None if attr == vertex_attrs.shape: new_val = shape_from_prop(val, vertex_shape) if pmap_default and not isinstance(val, PropertyMap): new_val = g.new_vertex_property("int", new_val) return new_val elif attr == vertex_attrs.surface: new_val = surface_from_prop(val) if pmap_default and not isinstance(val, PropertyMap): new_val = g.new_vertex_property("python::object", new_val) return new_val elif attr in [edge_attrs.start_marker, edge_attrs.mid_marker, edge_attrs.end_marker]: new_val = shape_from_prop(val, edge_marker) if pmap_default and not isinstance(val, PropertyMap): new_val = g.new_edge_property("int", new_val) return new_val elif attr in [vertex_attrs.pie_colors]: if isinstance(val, PropertyMap): if val.value_type() in ["vector", "vector"]: return val if val.value_type() in ["vector", "vector", "vector", "vector"]: g = val.get_graph() new_val = g.new_vertex_property("vector") rg = [numpy.inf, -numpy.inf] for v in g.vertices(): for x in val[v]: rg[0] = min(x, rg[0]) rg[1] = max(x, rg[1]) if rg[0] == rg[1]: rg[1] = 1 if cmap is None: cmap = default_cm map_property_values(val, new_val, lambda y: flatten([cmap((x - rg[0]) / (rg[1] - rg[0]), alpha=alpha) for x in y])) return new_val if val.value_type() == "vector": g = val.get_graph() new_val = g.new_vertex_property("vector") map_property_values(val, new_val, lambda y: flatten([color_converter.to_rgba(x) for x in y])) return new_val if val.value_type() == "python::object": try: g = val.get_graph() new_val = g.new_vertex_property("vector") def conv(y): try: new_val[v] = [float(x) for x in flatten(y)] except ValueError: new_val[v] = flatten([color_converter.to_rgba(x) for x in y]) map_property_values(val, new_val, conv) return new_val except ValueError: pass else: try: new_val = [float(x) for x in flatten(val)] except ValueError: try: new_val = flatten(color_converter.to_rgba(x) for x in val) new_val = list(new_val) except ValueError: pass if pmap_default: val_a = numpy.zeros((g.num_vertices(), len(new_val))) for i in range(len(new_val)): val_a[:, i] = new_val[i] return g.new_vertex_property("vector", val_a) else: return new_val elif attr in [vertex_attrs.color, vertex_attrs.fill_color, vertex_attrs.text_color, vertex_attrs.text_out_color, vertex_attrs.halo_color, edge_attrs.color, edge_attrs.text_color, edge_attrs.text_out_color]: if isinstance(val, list): new_val = val elif isinstance(val, (tuple, np.ndarray)): new_val = list(val) elif isinstance(val, str): new_val = list(color_converter.to_rgba(val)) elif isinstance(val, PropertyMap): if val.value_type() in ["vector", "vector"]: new_val = val elif val.value_type() in ["int16_t", "int32_t", "int64_t", "double", "long double", "unsigned long", "unsigned int", "bool"]: cmap, is_seq = choose_cm(val, cmap) g = val.get_graph() if val.value_type() in ["int16_t", "int32_t", "int64_t", "unsigned long", "unsigned int"]: if not is_seq and vnorm is None: nval = val.copy() nval.fa = rankdata(val.fa, method='dense') - 1 else: nval = val else: nval = val try: vrange = [nval.fa.min(), nval.fa.max()] except (AttributeError, ValueError): #vertex index vrange = [int(g.vertex(0, use_index=False)), int(g.vertex(g.num_vertices() - 1, use_index=False))] if vnorm is None: if not is_seq: cnorm = lambda x : x % cmap.N else: cnorm = matplotlib.colors.Normalize(vmin=vrange[0], vmax=vrange[1]) else: cnorm = vnorm cnorm(vrange) # for auto-scale, if needed g = val.get_graph() if val.key_type() == "v": prop = g.new_vertex_property("vector") else: prop = g.new_edge_property("vector") map_property_values(nval, prop, lambda x: cmap(cnorm(x), alpha=alpha)) new_val = prop elif val.value_type() == "string": g = val.get_graph() if val.key_type() == "v": prop = g.new_vertex_property("vector") else: prop = g.new_edge_property("vector") map_property_values(val, prop, lambda x: color_converter.to_rgba(x)) new_val = prop else: raise ValueError("Invalid value for attribute %s: %s" % (repr(attr), repr(val))) if pmap_default and not isinstance(val, PropertyMap): if attr in [vertex_attrs.color, vertex_attrs.fill_color, vertex_attrs.text_color, vertex_attrs.halo_color]: val_a = numpy.zeros((g.num_vertices(),len(new_val))) for i in range(len(new_val)): val_a[:, i] = new_val[i] return g.new_vertex_property("vector", val_a) else: val_a = numpy.zeros((g.num_edges(), len(new_val))) for i in range(len(new_val)): val_a[:,i] = new_val[i] return g.new_edge_property("vector", val_a) else: return new_val if pmap_default and not isinstance(val, PropertyMap): if k == "v": new_val = g.new_vertex_property(_vtypes[attr], val=val) else: new_val = g.new_edge_property(_etypes[attr], val=val) return new_val return val def _attrs(attrs, d, g, cmap, vnorm): nattrs = {} defaults = {} for k, v in attrs.items(): try: if d == "v": attr = getattr(vertex_attrs, k) else: attr = getattr(edge_attrs, k) except AttributeError: warnings.warn("Unknown attribute: " + str(k), UserWarning) continue if isinstance(v, PropertyMap): nattrs[int(attr)] = _prop(d, g, _convert(attr, v, cmap, vnorm)) else: defaults[int(attr)] = _convert(attr, v, cmap, vnorm) return nattrs, defaults def _convert_props(props, d, g, cmap, vnorm, pmap_default=False): nprops = {} for k, v in props.items(): try: if d == "v": attr = getattr(vertex_attrs, k) else: attr = getattr(edge_attrs, k) nprops[k] = _convert(attr, v, cmap, vnorm, pmap_default=pmap_default, g=g, k=d) except AttributeError: kind = "vertex" if d == k else "edge" warnings.warn(f"Unknown {kind} attribute: " + str(k), UserWarning) continue return nprops def get_attr(attr, d, attrs, defaults): if attr in attrs: p = attrs[attr] else: p = defaults[attr] if isinstance(p, PropertyMap): return p[d] else: return p def position_parallel_edges(g, pos, loop_angle=float("nan"), parallel_distance=1): lp = label_parallel_edges(GraphView(g, directed=False)) ll = label_self_loops(g) if isinstance(loop_angle, PropertyMap): angle = loop_angle else: angle = g.new_vertex_property("double", float(loop_angle)) g = GraphView(g, directed=True) if ((len(lp.fa) == 0 or lp.fa.max() == 0) and (len(ll.fa) == 0 or ll.fa.max() == 0)): return [] else: spline = g.new_edge_property("vector") libgraph_tool_draw.put_parallel_splines(g._Graph__graph, _prop("v", g, pos), _prop("e", g, lp), _prop("e", g, spline), _prop("v", g, angle), parallel_distance) return spline def parse_props(prefix, args): props = {} others = {} for k, v in list(args.items()): if v is None: continue if k.startswith(prefix + "_"): props[k.replace(prefix + "_", "")] = v else: others[k] = v return props, others def cairo_draw(g, pos, cr, vprops=None, eprops=None, vorder=None, eorder=None, nodesfirst=False, vcmap=None, vcnorm=None, ecmap=None, ecnorm=None, loop_angle=numpy.nan, parallel_distance=None, res=0, max_render_time=-1, **kwargs): r"""Draw a graph to a :mod:`cairo` context. Parameters ---------- g : :class:`~graph_tool.Graph` Graph to be drawn. pos : :class:`~graph_tool.VertexPropertyMap` Vector-valued vertex property map containing the x and y coordinates of the vertices. cr : :class:`~cairo.Context` A :class:`~cairo.Context` instance. vprops : dict (optional, default: ``None``) Dictionary with the vertex properties. Individual properties may also be given via the ``vertex_`` parameters, where ```` is the name of the property. eprops : dict (optional, default: ``None``) Dictionary with the edge properties. Individual properties may also be given via the ``edge_`` parameters, where ```` is the name of the property. vorder : :class:`~graph_tool.VertexPropertyMap` (optional, default: ``None``) If provided, defines the relative order in which the vertices are drawn. eorder : :class:`~graph_tool.EdgePropertyMap` (optional, default: ``None``) If provided, defines the relative order in which the edges are drawn. nodesfirst : bool (optional, default: ``False``) If ``True``, the vertices are drawn first, otherwise the edges are. vcmap : :class:`matplotlib.colors.Colormap` or tuple (optional, default: ``None``) Vertex color map. Optionally, this may be a (:class:`matplotlib.colors.Colormap`, alpha) tuple. vcnorm : :class:`matplotlib.colors.Normalize` (optional, default: ``None``) An object which, when called, normalizes vertex property values into the :math:`[0.0, 1.0]` interval, before passing to the ``vcmap`` colormap. ecmap : :class:`matplotlib.colors.Colormap` or tuple (optional, default: ``None``) Edge color map. Optionally, this may be a (:class:`matplotlib.colors.Colormap`, alpha) tuple. ecnorm : :class:`matplotlib.colors.Normalize` (optional, default: ``None``) An object which, when called, normalizes edge property values into the :math:`[0.0, 1.0]` interval, before passing to the ``ecmap`` colormap. loop_angle : float or :class:`~graph_tool.EdgePropertyMap` (optional, default: ``numpy.nan``) Angle used to draw self-loops. If ``nan`` is given, they will be placed radially from the center of the layout. parallel_distance : float (optional, default: ``None``) Distance used between parallel edges. If not provided, it will be determined automatically. bg_color : str or sequence (optional, default: ``None``) Background color. The default is transparent. res : float (optional, default: ``0.``): If shape sizes fall below this value, simplified drawing is used. max_render_time : int (optional, default: ``-1``): If nonnegative, this function will return an iterator that will perform part of the drawing at each step, so that each iteration takes at most ``max_render_time`` milliseconds. vertex_* : :class:`~graph_tool.VertexPropertyMap` or arbitrary types (optional, default: ``None``) Parameters following the pattern ``vertex_`` specify the vertex property with name ````, as an alternative to the ``vprops`` parameter. edge_* : :class:`~graph_tool.EdgePropertyMap` or arbitrary types (optional, default: ``None``) Parameters following the pattern ``edge_`` specify the edge property with name ````, as an alternative to the ``eprops`` parameter. Returns ------- iterator : If ``max_render_time`` is nonnegative, this will be an iterator that will perform part of the drawing at each step, so that each iteration takes at most ``max_render_time`` milliseconds. """ if vorder is not None: _check_prop_scalar(vorder, name="vorder") vprops = {} if vprops is None else copy.copy(vprops) eprops = {} if eprops is None else copy.copy(eprops) props, kwargs = parse_props("vertex", kwargs) vprops.update(props) props, kwargs = parse_props("edge", kwargs) eprops.update(props) for k in kwargs: warnings.warn("Unknown parameter: " + k, UserWarning) cr.save() if "control_points" not in eprops: if parallel_distance is None: parallel_distance = vprops.get("size", _vdefaults["size"]) if isinstance(parallel_distance, PropertyMap): parallel_distance = parallel_distance.fa.mean() parallel_distance /= 1.5 M = cr.get_matrix() scale = transform_scale(M, 1,) parallel_distance /= scale eprops["control_points"] = position_parallel_edges(g, pos, loop_angle, parallel_distance) if g.is_directed() and "end_marker" not in eprops: eprops["end_marker"] = "arrow" if vprops.get("text_position", None) == "centered": angle, tpos = centered_rotation(g, pos, text_pos=True) vprops["text_position"] = tpos vprops["text_rotation"] = angle toffset = vprops.get("text_offset", None) if toffset is not None: if not isinstance(toffset, PropertyMap): toffset = g.new_vp("vector", val=toffset) xo, yo = ungroup_vector_property(toffset, [0, 1]) xo.a[tpos.a == numpy.pi] *= -1 toffset = group_vector_property([xo, yo]) vprops["text_offset"] = toffset vattrs, vdefaults = _attrs(vprops, "v", g, vcmap, vcnorm) eattrs, edefaults = _attrs(eprops, "e", g, ecmap, ecnorm) vdefs = _attrs(_vdefaults, "v", g, vcmap, vcnorm)[1] vdefs.update(vdefaults) edefs = _attrs(_edefaults, "e", g, ecmap, ecnorm)[1] edefs.update(edefaults) if "control_points" not in eprops: if parallel_distance is None: parallel_distance = _defaults eprops["control_points"] = position_parallel_edges(g, pos, loop_angle, parallel_distance) generator = libgraph_tool_draw.cairo_draw(g._Graph__graph, _prop("v", g, pos), _prop("v", g, vorder), _prop("e", g, eorder), nodesfirst, vattrs, eattrs, vdefs, edefs, res, max_render_time, cr) if max_render_time >= 0: def gen(): for count in generator: yield count cr.restore() return gen() else: for count in generator: pass cr.restore() def color_contrast(color): c = np.asarray(color) y = c[0] * .299 + c[1] * .587 + c[2] * .114 if y < .5: c[:3] = 1 else: c[:3] = 0 return c def auto_colors(g, bg, pos, back): if not isinstance(bg, PropertyMap): if isinstance(bg, str): bg = color_converter.to_rgba(bg) bg = g.new_vertex_property("vector", val=bg) if not isinstance(pos, PropertyMap): if pos == "centered": pos = 0 pos = g.new_vertex_property("double", pos) bg_a = bg.get_2d_array(range(4)) bgc_pos = numpy.zeros((g.num_vertices(), 5)) for i in range(4): bgc_pos[:, i] = bg_a[i, :] bgc_pos[:, 4] = pos.fa bgc_pos = g.new_vertex_property("vector", bgc_pos) def conv(x): bgc = x[:4] p = x[4] if p < 0: return color_contrast(bgc) else: return color_contrast(back) c = g.new_vertex_property("vector") map_property_values(bgc_pos, c, conv) return c def graph_draw(g, pos=None, vprops=None, eprops=None, vorder=None, eorder=None, nodesfirst=False, output_size=(600, 600), fit_view=True, fit_view_ink=None, adjust_aspect=True, ink_scale=1, inline=has_draw_inline, inline_scale=2, mplfig=None, yflip=True, output=None, fmt="auto", bg_color=None, antialias=None, **kwargs): r"""Draw a graph to screen or to a file using :mod:`cairo`. Parameters ---------- g : :class:`~graph_tool.Graph` Graph to be drawn. pos : :class:`~graph_tool.VertexPropertyMap` (optional, default: ``None``) Vector-valued vertex property map containing the x and y coordinates of the vertices. If not given, it will be computed using :func:`sfdp_layout`. vprops : dict (optional, default: ``None``) Dictionary with the vertex properties. Individual properties may also be given via the ``vertex_`` parameters, where ```` is the name of the property. eprops : dict (optional, default: ``None``) Dictionary with the edge properties. Individual properties may also be given via the ``edge_`` parameters, where ```` is the name of the property. vorder : :class:`~graph_tool.VertexPropertyMap` (optional, default: ``None``) If provided, defines the relative order in which the vertices are drawn. eorder : :class:`~graph_tool.EdgePropertyMap` (optional, default: ``None``) If provided, defines the relative order in which the edges are drawn. nodesfirst : bool (optional, default: ``False``) If ``True``, the vertices are drawn first, otherwise the edges are. output_size : tuple of scalars (optional, default: ``(600,600)``) Size of the drawing canvas. The units will depend on the output format (pixels for the screen, points for PDF, etc). fit_view : bool, float or tuple (optional, default: ``True``) If ``True``, the layout will be scaled to fit the entire clip region. If a float value is given, it will be interpreted as ``True``, and in addition the viewport will be scaled out by that factor. If a tuple value is given, it should have four values ``(x, y, w, h)`` that specify the view in user coordinates. fit_view_ink : bool (optional, default: ``None``) If ``True``, and ``fit_view == True`` the drawing will be performed once to figure out the bounding box, before the actual drawing is made. Otherwise, only the vertex positions will be used for this purpose. If the value is ``None``, then it will be assumed ``True`` for networks of size 10,000 nodes or less, otherwise it will be assumed ``False``. adjust_aspect : bool (optional, default: ``True``) If ``True``, and ``fit_view == True`` the output size will be decreased in the width or height to remove empty spaces. ink_scale : float (optional, default: ``1.``) Scale all sizes and widths by this factor. inline : bool (optional, default: ``False``) If ``True`` and an `IPython notebook `_ is being used, an inline version of the drawing will be returned. inline_scale : float (optional, default: ``2.``): Resolution scaling factor for inline images. mplfig : :mod:`matplotlib` container object (optional, default: ``None``) The ``mplfig`` object needs to have an ``add_artist()`` function. This can for example be a :class:`matplotlib.figure.Figure` or :class:`matplotlib.axes.Axes`. Only the cairo backend is supported; use ``switch_backend('cairo')``. If this option is used, a :class:`~graph_tool.draw.GraphArtist` object is returned. yflip : bool (optional, default: ``True``) If ``mplfig is not None``, and ``fit_view != False``, then the y direction of the axis will be flipped, reproducing the same output as when ``mplfig is None``. output : string or file object (optional, default: ``None``) Output file name (or object). If not given, the graph will be displayed via :func:`interactive_window`. fmt : string (default: ``"auto"``) Output file format. Possible values are ``"auto"``, ``"ps"``, ``"pdf"``, ``"svg"``, and ``"png"``. If the value is ``"auto"``, the format is guessed from the ``output`` parameter. bg_color : str or sequence (optional, default: ``None``) Background color. The default is transparent. antialias : :class:`cairo.Antialias` (optional, default: ``None``) If supplied, this will set the antialising mode of the cairo context. vertex_* : :class:`~graph_tool.VertexPropertyMap` or arbitrary types (optional, default: ``None``) Parameters following the pattern ``vertex_`` specify the vertex property with name ````, as an alternative to the ``vprops`` parameter. edge_* : :class:`~graph_tool.EdgePropertyMap` or arbitrary types (optional, default: ``None``) Parameters following the pattern ``edge_`` specify the edge property with name ````, as an alternative to the ``eprops`` parameter. **kwargs Any extra parameters are passed to :func:`~graph_tool.draw.interactive_window`, :class:`~graph_tool.draw.GraphWindow`, :class:`~graph_tool.draw.GraphWidget` and :func:`~graph_tool.draw.cairo_draw`. Returns ------- pos : :class:`~graph_tool.VertexPropertyMap` Vector vertex property map with the x and y coordinates of the vertices. selected : :class:`~graph_tool.VertexPropertyMap` (optional, only if ``output is None``) Boolean-valued vertex property map marking the vertices which were selected interactively. Notes ----- .. rubric:: List of vertex properties .. table:: +----------------+---------------------------------------------------+------------------------+----------------------------------+ | Name | Description | Accepted types | Default Value | +================+===================================================+========================+==================================+ | shape | The vertex shape. Can be one of the following | ``str`` or ``int`` | ``"circle"`` | | | strings: "circle", "triangle", "square", | | | | | "pentagon", "hexagon", "heptagon", "octagon" | | | | | "double_circle", "double_triangle", | | | | | "double_square", "double_pentagon", | | | | | "double_hexagon", "double_heptagon", | | | | | "double_octagon", "pie", "none". | | | | | Optionally, this might take a numeric value | | | | | corresponding to position in the list above. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | color | Color used to stroke the lines of the vertex. | ``str`` or list of | ``[0., 0., 0., 1]`` | | | | ``floats`` | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | fill_color | Color used to fill the interior of the vertex. | ``str`` or list of | ``[0.640625, 0, 0, 0.9]`` | | | | ``floats`` | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | size | The size of the vertex, in the default units of | ``float`` or ``int`` | ``5`` | | | the output format (normally either pixels or | | | | | points). | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | aspect | The aspect ratio of the vertex. | ``float`` or ``int`` | ``1.0`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | rotation | Angle (in radians) to rotate the vertex. | ``float`` | ``0.`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | anchor | Specifies how the edges anchor to the vertices. | ``int`` | ``1`` | | | If `0`, the anchor is at the center of the vertex,| | | | | otherwise it is at the border. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | pen_width | Width of the lines used to draw the vertex, in | ``float`` or ``int`` | ``0.8`` | | | the default units of the output format (normally | | | | | either pixels or points). | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | halo | Whether to draw a circular halo around the | ``bool`` | ``False`` | | | vertex. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | halo_color | Color used to draw the halo. | ``str`` or list of | ``[0., 0., 1., 0.5]`` | | | | ``floats`` | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | halo_size | Relative size of the halo. | ``float`` | ``1.5`` | | | | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text | Text to draw together with the vertex. | ``str`` | ``""`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_color | Color used to draw the text. If the value is | ``str`` or list of | ``"auto"`` | | | ``"auto"``, it will be computed based on | ``floats`` | | | | fill_color to maximize contrast. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_position | Position of the text relative to the vertex. | ``float`` or ``int`` | ``-1`` | | | If the passed value is positive, it will | or ``"centered"`` | | | | correspond to an angle in radians, which will | | | | | determine where the text will be placed outside | | | | | the vertex. If the value is negative, the text | | | | | will be placed inside the vertex. If the value is | | | | | ``-1``, the vertex size will be automatically | | | | | increased to accommodate the text. The special | | | | | value ``"centered"`` positions the texts rotated | | | | | radially around the center of mass. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_offset | Text position offset. | list of ``float`` | ``[0.0, 0.0]`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_rotation | Angle of rotation (in radians) for the text. | ``float`` | ``0.0`` | | | The center of rotation is the position of the | | | | | vertex. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_out_color | Color used to draw the text outline. | ``str`` or list of | ``[0,0,0,0]`` | | | | ``floats`` | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_out_width | Width of the text outline. | ``float`` | ``1.`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | font_family | Font family used to draw the text. | ``str`` | ``"serif"`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | font_slant | Font slant used to draw the text. | ``cairo.FONT_SLANT_*`` | :data:`cairo.FONT_SLANT_NORMAL` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | font_weight | Font weight used to draw the text. | ``cairo.FONT_WEIGHT_*``| :data:`cairo.FONT_WEIGHT_NORMAL` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | font_size | Font size used to draw the text. | ``float`` or ``int`` | ``12`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | surface | The cairo surface used to draw the vertex. If | :class:`cairo.Surface` | ``None`` | | | the value passed is a string, it is interpreted | or ``str`` | | | | as an image file name to be loaded. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | pie_fractions | Fractions of the pie sections for the vertices if | list of ``int`` or | ``[0.75, 0.25]`` | | | ``shape=="pie"``. | ``float`` | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | pie_colors | Colors used in the pie sections if | list of strings or | ``('b','g','r','c','m','y','k')``| | | ``shape=="pie"``. | ``float``. | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ .. rubric:: List of edge properties .. table:: +----------------+---------------------------------------------------+------------------------+----------------------------------+ | Name | Description | Accepted types | Default Value | +================+===================================================+========================+==================================+ | color | Color used to stroke the edge lines. | ``str`` or list of | ``[0.179, 0.203, 0.210, 0.8]`` | | | | floats | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | pen_width | Width of the line used to draw the edge, in | ``float`` or ``int`` | ``1.0`` | | | the default units of the output format (normally | | | | | either pixels or points). | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | start_marker, | Edge markers. Can be one of "none", "arrow", | ``str`` or ``int`` | ``none`` | | mid_marker, | "circle", "square", "diamond", or "bar". | | | | end_marker | Optionally, this might take a numeric value | | | | | corresponding to position in the list above. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | mid_marker_pos | Relative position of the middle marker. | ``float`` | ``0.5`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | marker_size | Size of edge markers, in units appropriate to the | ``float`` or ``int`` | ``4`` | | | output format (normally either pixels or points). | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | control_points | Control points of a Bézier spline used to draw | sequence of ``floats`` | ``[]`` | | | the edge. Each spline segment requires 6 values | | | | | corresponding to the (x,y) coordinates of the two | | | | | intermediary control points and the final point. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | gradient | Stop points of a linear gradient used to stroke | sequence of ``floats`` | ``[]`` | | | the edge. Each group of 5 elements is interpreted | | | | | as ``[o, r, g, b, a]`` where ``o`` is the offset | | | | | in the range [0, 1] and the remaining values | | | | | specify the colors. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | dash_style | Dash pattern is specified by an array of positive | sequence of ``floats`` | ``[]`` | | | values. Each value provides the length of | | | | | alternate "on" and "off" portions of the stroke. | | | | | The last value specifies an offset into the | | | | | pattern at which the stroke begins. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text | Text to draw next to the edges. | ``str`` | ``""`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_color | Color used to draw the text. | ``str`` or list of | ``[0., 0., 0., 1.]`` | | | | ``floats`` | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_distance | Distance from the edge and its text. | ``float`` or ``int`` | ``4`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_parallel | If ``True`` the text will be drawn parallel to | ``bool`` | ``True`` | | | the edges. | | | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | text_out_color | Color used to draw the text outline. | ``str`` or list of | ``[0,0,0,0]`` | | | | ``floats`` | | +--------------- +---------------------------------------------------+------------------------+----------------------------------+ | text_out_width | Width of the text outline. | ``float`` | ``1.`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | font_family | Font family used to draw the text. | ``str`` | ``"serif"`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | font_slant | Font slant used to draw the text. | ``cairo.FONT_SLANT_*`` | :data:`cairo.FONT_SLANT_NORMAL` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | font_weight | Font weight used to draw the text. | ``cairo.FONT_WEIGHT_*``| :data:`cairo.FONT_WEIGHT_NORMAL` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ | font_size | Font size used to draw the text. | ``float`` or ``int`` | ``12`` | +----------------+---------------------------------------------------+------------------------+----------------------------------+ Examples -------- .. testcode:: :hide: np.random.seed(42) gt.seed_rng(42) from numpy import sqrt >>> g = gt.price_network(1500) >>> deg = g.degree_property_map("in") >>> deg.a = 4 * (sqrt(deg.a) * 0.5 + 0.4) >>> ebet = gt.betweenness(g)[1] >>> ebet.a /= ebet.a.max() / 10. >>> eorder = ebet.copy() >>> eorder.a *= -1 >>> pos = gt.sfdp_layout(g) >>> control = g.new_edge_property("vector") >>> for e in g.edges(): ... d = sqrt(sum((pos[e.source()].a - pos[e.target()].a) ** 2)) / 5 ... control[e] = [0.3, d, 0.7, d] >>> gt.graph_draw(g, pos=pos, vertex_size=deg, vertex_fill_color=deg, vorder=deg, ... edge_color=ebet, eorder=eorder, edge_pen_width=ebet, ... edge_control_points=control, # some curvy edges ... output="graph-draw.pdf") <...> .. testcleanup:: conv_png("graph-draw.pdf") .. figure:: graph-draw.png :align: center :width: 80% SFDP force-directed layout of a Price network with 1500 nodes. The vertex size and color indicate the degree, and the edge color and width the edge betweenness centrality. """ vprops = vprops.copy() if vprops is not None else {} eprops = eprops.copy() if eprops is not None else {} props, kwargs = parse_props("vertex", kwargs) props = _convert_props(props, "v", g, kwargs.get("vcmap", None), kwargs.get("vcnorm", None)) vprops.update(props) props, kwargs = parse_props("edge", kwargs) props = _convert_props(props, "e", g, kwargs.get("ecmap", None), kwargs.get("ecnorm", None)) eprops.update(props) if pos is None: if (g.num_vertices() > 2 and output is None and not inline and kwargs.get("update_layout", True) and mplfig is None): L = np.sqrt(g.num_vertices()) pos = random_layout(g, [L, L]) if g.num_vertices() > 1000: if "multilevel" not in kwargs: kwargs["multilevel"] = True if "layout_K" not in kwargs: kwargs["layout_K"] = _avg_edge_distance(g, pos) / 10 else: pos = sfdp_layout(g) else: pos = g.own_property(pos) _check_prop_vector(pos, name="pos", floating=True) if output is None and not inline and mplfig is None: if "layout_K" not in kwargs: kwargs["layout_K"] = _avg_edge_distance(g, pos) if "update_layout" not in kwargs: kwargs["update_layout"] = False if "pen_width" in eprops and "marker_size" not in eprops: pw = eprops["pen_width"] if isinstance(pw, PropertyMap): pw = pw.copy("double") pw.fa *= 2.75 eprops["marker_size"] = pw else: eprops["marker_size"] = pw * 2.75 if "text" in eprops and "text_distance" not in eprops and "pen_width" in eprops: pw = eprops["pen_width"] if isinstance(pw, PropertyMap): pw = pw.copy("double") pw.fa *= 2 eprops["text_distance"] = pw else: eprops["text_distance"] = pw * 2 if "text" in vprops and ("text_color" not in vprops or vprops["text_color"] == "auto"): vcmap = kwargs.get("vcmap", None) bg = _convert(vertex_attrs.fill_color, vprops.get("fill_color", _vdefaults["fill_color"]), vcmap, kwargs.get("vcnorm", None)) vprops["text_color"] = auto_colors(g, bg, vprops.get("text_position", _vdefaults["text_position"]), bg_color if bg_color is not None else [1., 1., 1., 1.]) if mplfig is not None: ax = None if isinstance(mplfig, matplotlib.figure.Figure): ax = mplfig.gca() elif isinstance(mplfig, matplotlib.axes.Axes): ax = mplfig else: ax = mplfig x, y = ungroup_vector_property(pos, [0, 1]) l, r = x.a.min(), x.a.max() b, t = y.a.min(), y.a.max() adjust_default_sizes(g, (r - l, t - b), vprops, eprops, min_pen_width=0) if ink_scale != 1: scale_ink(ink_scale, vprops, eprops, min_pen_width=0) artist = GraphArtist(g, pos, ax, vprops, eprops, vorder=vorder, eorder=eorder, nodesfirst=nodesfirst, **kwargs) ax.add_artist(artist) return artist output_file = output if inline and output is None: if fmt == "auto": if output is None: fmt = "png" else: fmt = get_file_fmt(output) output = io.BytesIO() if output is None: if ink_scale != 1: scale_ink(ink_scale, vprops, eprops) return interactive_window(g, pos, vprops, eprops, vorder, eorder, nodesfirst, geometry=output_size, fit_view=fit_view, bg_color=bg_color, **kwargs) else: adjust_default_sizes(g, output_size, vprops, eprops) if ink_scale != 1: scale_ink(ink_scale, vprops, eprops) if inline and fmt != "svg": output_size = [int(x * inline_scale) for x in output_size] scale_ink(inline_scale, vprops, eprops) if fit_view != False: try: x, y, w, h = fit_view zoom = min(output_size[0] / w, output_size[1] / h) except TypeError: pad = fit_view if fit_view is not True else 0.9 output_size = list(output_size) if fit_view_ink is None: fit_view_ink = g.num_vertices() <= 1000 if fit_view_ink: x, y, zoom = fit_to_view_ink(g, pos, output_size, vprops, eprops, adjust_aspect, pad=pad) else: x, y, zoom = fit_to_view(get_bb(g, pos), output_size, adjust_aspect=adjust_aspect, pad=pad) else: x, y, zoom = 0, 0, 1 if isinstance(output, str): out, auto_fmt = open_file(output, mode="wb") else: out = output if fmt == "auto": raise ValueError("File format must be specified.") if fmt == "auto": fmt = auto_fmt if fmt == "pdf": srf = cairo.PDFSurface(out, output_size[0], output_size[1]) elif fmt == "ps": srf = cairo.PSSurface(out, output_size[0], output_size[1]) elif fmt == "eps": srf = cairo.PSSurface(out, output_size[0], output_size[1]) srf.set_eps(True) elif fmt == "svg": srf = cairo.SVGSurface(out, output_size[0], output_size[1]) srf.restrict_to_version(cairo.SVG_VERSION_1_2) elif fmt == "png": srf = cairo.ImageSurface(cairo.FORMAT_ARGB32, output_size[0], output_size[1]) else: raise ValueError("Invalid format type: " + fmt) cr = cairo.Context(srf) if antialias is not None: cr.set_antialias(antialias) cr.scale(zoom, zoom) cr.translate(-x, -y) if bg_color is not None: if isinstance(bg_color, str): bg_color = matplotlib.colors.to_rgba(bg_color) cr.set_source_rgba(bg_color[0], bg_color[1], bg_color[2], bg_color[3]) cr.paint() cairo_draw(g, pos, cr, vprops, eprops, vorder, eorder, nodesfirst, **kwargs) srf.flush() if fmt == "png": srf.write_to_png(out) elif fmt == "svg": srf.finish() del cr if inline and output_file is None: img = None if fmt == "png": img = IPython.display.Image(data=out.getvalue(), width=int(output_size[0]/inline_scale), height=int(output_size[1]/inline_scale)) elif fmt == "svg": img = IPython.display.SVG(data=out.getvalue()) elif img is None: inl_out = io.BytesIO() inl_srf = cairo.ImageSurface(cairo.FORMAT_ARGB32, output_size[0], output_size[1]) inl_cr = cairo.Context(inl_srf) inl_cr.set_source_surface(srf, 0, 0) inl_cr.paint() inl_srf.write_to_png(inl_out) del inl_srf img = IPython.display.Image(data=inl_out.getvalue(), width=int(output_size[0]/inline_scale), height=int(output_size[1]/inline_scale)) srf.finish() IPython.display.display(img) del srf return pos def adjust_default_sizes(g, geometry, vprops, eprops, force=False, min_pen_width=0.05): if "size" not in vprops or force: A = geometry[0] * geometry[1] N = max(g.num_vertices(), 1) vprops["size"] = np.sqrt(A / N) / 3.5 if "pen_width" not in vprops or force: size = vprops["size"] if isinstance(vprops["size"], PropertyMap): size = vprops["size"].fa.mean() vprops["pen_width"] = max(size / 10, min_pen_width) if "pen_width" not in eprops or force: eprops["pen_width"] = max(size / 10, min_pen_width) if "marker_size" not in eprops or force: eprops["marker_size"] = size * 0.8 if "font_size" not in vprops or force: size = vprops["size"] if isinstance(vprops["size"], PropertyMap): size = vprops["size"].fa.mean() vprops["font_size"] = size * .6 if "font_size" not in eprops or force: size = vprops["size"] if isinstance(vprops["size"], PropertyMap): size = vprops["size"].fa.mean() eprops["font_size"] = size * .6 def scale_ink(scale, vprops, eprops, copy=True, min_pen_width=0.05): vink_props = ["size", "pen_width", "font_size", "text_out_width"] eink_props = ["marker_size", "pen_width", "font_size", "text_distance", "text_out_width"] for ink_props, props, defaults in zip([vink_props, eink_props], [vprops, eprops], [_vdefaults, _edefaults]): for p in ink_props: if p not in props: props[p] = defaults[p] if isinstance(props[p], PropertyMap): if copy: props[p] = props[p].copy() props[p].fa *= scale if p == "pen_width": x = props[p].fa x[x w: output_size[0] = int(round(float(output_size[1] * w / h))) else: output_size[1] = int(round(float(output_size[0] * h / w))) zoom = max(w / output_size[0], h / output_size[1]) if zoom == 0: zoom = 1 else: zoom = 1 / zoom x -= (output_size[0] / zoom - w) / 2 y -= (output_size[1] / zoom - h) / 2 zoom *= pad x -= (1-pad) / 2 * output_size[0] / zoom y -= (1-pad) / 2 * output_size[1] / zoom return x, y, zoom def fit_to_view_ink(g, pos, output_size, vprops, eprops, adjust_aspect=False, pad=0.9): x, y, zoom = fit_to_view(get_bb(g, pos), output_size, pad=pad) srf = cairo.RecordingSurface(cairo.Content.COLOR_ALPHA, cairo.Rectangle(-output_size[0] * 5, -output_size[1] * 5, output_size[0] * 10, output_size[1] * 10)) cr = cairo.Context(srf) cr.scale(zoom, zoom) cr.translate(-x, -y) # work around cairo bug with small line widths def min_lw(lw): if isinstance(lw, PropertyMap): lw = lw.copy() x = lw.fa x[x < 0.05] = 0.1 lw.fa = x else: lw = max(lw, 0.1) return lw vprops = dict(vprops, pen_width=min_lw(vprops.get("pen_width", 0.))) eprops = dict(eprops, pen_width=min_lw(eprops.get("pen_width", 0.))) cairo_draw(g, pos, cr, vprops, eprops) bb = list(srf.ink_extents()) bb[0], bb[1] = cr.device_to_user(bb[0], bb[1]) bb[2], bb[3] = cr.device_to_user_distance(bb[2], bb[3]) x, y, zoom = fit_to_view(bb, output_size, adjust_aspect=adjust_aspect, pad=pad) return x, y, zoom def transform_scale(M, scale): p = M.transform_distance(scale / np.sqrt(2), scale / np.sqrt(2)) return np.sqrt(p[0] ** 2 + p[1] ** 2) def get_hierarchy_control_points(g, t, tpos, beta=0.8, cts=None, is_tree=True, max_depth=None): r"""Return the Bézier spline control points for the edges in ``g``, given the hierarchical structure encoded in graph `t`. Parameters ---------- g : :class:`~graph_tool.Graph` Graph to be drawn. t : :class:`~graph_tool.Graph` Directed graph containing the hierarchy of ``g``. It must be a directed tree with a single root. The direction of the edges point from the root to the leaves, and the vertices in ``t`` with index in the range :math:`[0, N-1]`, with :math:`N` being the number of vertices in ``g``, must correspond to the respective vertex in ``g``. tpos : :class:`~graph_tool.VertexPropertyMap` Vector-valued vertex property map containing the x and y coordinates of the vertices in graph ``t``. beta : ``float`` (optional, default: ``0.8`` or :class:`~graph_tool.EdgePropertyMap`) Edge bundling strength. For ``beta == 0`` the edges are straight lines, and for ``beta == 1`` they strictly follow the hierarchy. This can be optionally an edge property map, which specified a different bundling strength for each edge. cts : :class:`~graph_tool.EdgePropertyMap` (optional, default: ``None``) Edge property map of type ``vector`` where the control points will be stored. is_tree : ``bool`` (optional, default: ``True``) If ``True``, ``t`` must be a directed tree, otherwise it can be any connected graph. max_depth : ``int`` (optional, default: ``None``) If supplied, only the first ``max_depth`` bottom levels of the hierarchy will be used. Returns ------- cts : :class:`~graph_tool.EdgePropertyMap` Vector-valued edge property map containing the Bézier spline control points for the edges in ``g``. Notes ----- This is an implementation of the edge-bundling algorithm described in [holten-hierarchical-2006]_. Examples -------- .. testsetup:: nested_cts gt.seed_rng(42) np.random.seed(42) .. doctest:: nested_cts >>> g = gt.collection.data["netscience"] >>> g = gt.GraphView(g, vfilt=gt.label_largest_component(g)) >>> state = gt.minimize_nested_blockmodel_dl(g) >>> t = gt.get_hierarchy_tree(state)[0] >>> tpos = pos = gt.radial_tree_layout(t, t.vertex(t.num_vertices() - 1, use_index=False), weighted=True) >>> cts = gt.get_hierarchy_control_points(g, t, tpos) >>> pos = g.own_property(tpos) >>> b = state.levels[0].b >>> shape = b.copy() >>> shape.a %= 14 >>> gt.graph_draw(g, pos=pos, vertex_fill_color=b, vertex_shape=shape, edge_control_points=cts, ... edge_color=[0, 0, 0, 0.3], vertex_anchor=0, output="netscience_nested_mdl.pdf") <...> .. testcleanup:: nested_cts conv_png("netscience_nested_mdl.pdf") .. figure:: netscience_nested_mdl.png :align: center :width: 80% Block partition of a co-authorship network, which minimizes the description length of the network according to the nested (degree-corrected) stochastic blockmodel. References ---------- .. [holten-hierarchical-2006] Holten, D. "Hierarchical Edge Bundles: Visualization of Adjacency Relations in Hierarchical Data.", IEEE Transactions on Visualization and Computer Graphics 12, no. 5, 741–748 (2006). :doi:`10.1109/TVCG.2006.147` """ if cts is None: cts = g.new_edge_property("vector") if cts.value_type() != "vector": raise ValueError("cts property map must be of type 'vector' not '%s' " % cts.value_type()) u = GraphView(g, directed=True) tu = GraphView(t, directed=True) if not isinstance(beta, PropertyMap): beta = u.new_edge_property("double", beta) else: beta = beta.copy("double") if max_depth is None: max_depth = t.num_vertices() tu = GraphView(tu, skip_vfilt=True) tpos = tu.own_property(tpos) libgraph_tool_draw.get_cts(u._Graph__graph, tu._Graph__graph, _prop("v", tu, tpos), _prop("e", u, beta), _prop("e", u, cts), is_tree, max_depth) return cts # # The functions and classes below depend on GTK # ============================================= # try: import gi try: gi.require_version('Gtk', '3.0') except ValueError: raise ImportError from gi.repository import Gtk, Gdk, GdkPixbuf from gi.repository import GObject as gobject from .gtk_draw import * except (ImportError, RuntimeError) as e: msg = "Error importing Gtk module: %s; GTK+ drawing will not work." % str(e) warnings.warn(msg, RuntimeWarning) def gen_surface(name): fobj, fmt = open_file(name) if fmt in ["png", "PNG"]: sfc = cairo.ImageSurface.create_from_png(fobj) return sfc else: pixbuf = GdkPixbuf.Pixbuf.new_from_file(name) surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, pixbuf.get_width(), pixbuf.get_height()) cr = cairo.Context(surface) Gdk.cairo_set_source_pixbuf(cr, pixbuf, 0, 0) cr.paint() return surface # # matplotlib # ========== # class GraphArtist(matplotlib.artist.Artist): def __init__(self, g, pos, ax, vprops=None, eprops=None, raster=False, **kwargs): """:class:`matplotlib.artist.Artist` specialization that draws :class:`~graph_tool.Graph` instances in a :mod:`matplotlib` figure. .. warning:: Vector drawing is available only on cairo-based backends. For other backends, rasterization will be used. Parameters ---------- g : :class:`~graph_tool.Graph` Graph to be drawn. pos : :class:`~graph_tool.VertexPropertyMap` Vector-valued vertex property map containing the x and y coordinates of the vertices. ax : :class:`matplotlib.axes.Axes` A :class:`matplotlib.axes.Axes` instance where the graph will be drawn.. vprops : dict (optional, default: ``None``) Dictionary with the vertex properties. eprops : dict (optional, default: ``None``) Dictionary with the edge properties. **kwargs : dict (optional, default: ``None``) Remaining options to pass to :class:`~graph_tool.draw.cairo_draw`. """ matplotlib.artist.Artist.__init__(self) self.g = g self.pos = pos self.ax = ax self.vprops = vprops if vprops is not None else {} self.eprops = eprops if eprops is not None else {} self.raster = raster self.kwargs = kwargs.copy() self.set_zorder(1) self.ax.update_datalim(self.get_extents()) self.ax.autoscale() def set_raster(self, raster=True): """If ``raster == True``, then the graph will be rasterized even if a cairo-based backend is being used.""" self.raster = raster def fit_view(self, scale=1, margin=.1, yflip=False, keep_aspect=True, set_axis_aspect=False): """Set axis limits to fit the graph, optionally scaling it via the ``scale`` parameter, and adding a relative margin given by ``margin``. If ``yflip is True``, the y axis is flipped upside down. If ``keep_aspect is True``, the aspect ratio is preserved via the data limits. Otherwise, if ``set_axis_aspect is True``, the aspect of the axis will be changed to match the data aspect. """ x, y = ungroup_vector_property(self.pos, [0, 1]) l, r = x.fa.min(), x.fa.max() b, t = y.fa.min(), y.fa.max() w = r - l h = t - b if keep_aspect: ll, ur = (self.ax.get_position() * self.ax.get_figure().get_size_inches()) dw, dh = ur - ll a = dh / dw ar = h / w if ar > a: nw = h / a l -= (nw - w) / 2 r += (nw - w) / 2 w = nw else: nh = w * a b -= (nh - h) / 2 t += (nh - h) / 2 h = nh elif set_axis_aspect: self.ax.set_aspect(h / w) w *= scale h *= scale self.ax.set_xlim(l - w * margin, r + w * margin) if yflip: self.ax.set_ylim(t + h * margin, b - h * margin) else: self.ax.set_ylim(b - h * margin, t + h * margin) def draw_to_cairo(self, ctx, transform, mag=1): """Draw to a cairo context.""" ctx.save() pos = self.pos.copy() eprops = dict(self.eprops) vprops = dict(self.vprops) # clip region l, r = self.ax.get_xlim() b, t = self.ax.get_ylim() l, b = transform((l, b)) r, t = transform((r, t)) ctx.new_path() ctx.rectangle(min(l, r), min(b, t), abs(r-l), abs(t-b)) ctx.clip() d = (self.ax.transData.transform((1, 1)) - self.ax.transData.transform((0, 0))) scale_ink(np.mean(np.abs(d)) * mag, vprops, eprops, min_pen_width=0) pos = pos.t(transform) # transform edge control points, if present cp = eprops.get("control_points", None) if isinstance(cp, PropertyMap): ctx.save() cp = cp.copy() for e in self.g.edges(): s = self.pos[e.source()].a t = self.pos[e.target()].a a = np.arctan2(t[1] - s[1], t[0] - s[0]) l = np.sqrt((t[1] - s[1]) ** 2 + (t[0] - s[0]) ** 2) c = cp[e] for i in range(len(c) // 2): x = c.a[i*2:(i+1)*2] ctx.identity_matrix() ctx.translate(s[0], s[1]) ctx.rotate(a) ctx.scale(l, 1) x = ctx.user_to_device(x[0], x[1]) x = transform(x) c.a[i*2:(i+1)*2] = x s = pos[e.source()].a t = pos[e.target()].a a = np.arctan2(t[1] - s[1], t[0] - s[0]) l = np.sqrt((t[1] - s[1]) ** 2 + (t[0] - s[0]) ** 2) for i in range(len(c) // 2): x = c.a[i*2:(i+1)*2] ctx.identity_matrix() ctx.scale(1/l, 1) ctx.rotate(-a) ctx.translate(-s[0], -s[1]) x = ctx.user_to_device(x[0], x[1]) c.a[i*2:(i+1)*2] = x ctx.restore() eprops["control_points"] = cp cairo_draw(self.g, pos, ctx, vprops, eprops, **self.kwargs) ctx.restore() def draw(self, renderer): width, height = renderer.get_canvas_width_height() if (isinstance(renderer, matplotlib.backends.backend_cairo.RendererCairo) and not self.raster): ctx = renderer.gc.ctx if not isinstance(ctx, cairo.Context): ctx = _UNSAFE_cairocffi_context_to_pycairo(ctx) # Cairo coordinates are flipped in the y direction def transform(x): x = self.ax.transData.transform(x) return (x[0], height - x[1]) self.draw_to_cairo(ctx, transform) else: l, r = self.ax.get_xlim() b, t = self.ax.get_ylim() l, b = self.ax.transData.transform((l, b)) r, t = self.ax.transData.transform((r, t)) mag = renderer.get_image_magnification() width, height = int(abs(r-l) * mag), int(abs(t-b) * mag) img = cairo.ImageSurface(cairo.Format.ARGB32, width, height) ctx = cairo.Context(img) def transform(x): x = self.ax.transData.transform(x) x = ((x[0] - l) * width / (r - l), (x[1] - b) * height / (t - b)) return (x[0], height - x[1]) self.draw_to_cairo(ctx, transform, mag) img.flush() buf = img.get_data() im = np.ndarray(shape=(height, width, 4), dtype=np.uint8, buffer=buf) im[:, :, [0, 2]] = im[:, :, [2, 0]] # fix endianess (swap R and B) im = im[::-1, :, :] # flip y direction gc = renderer.new_gc() renderer.draw_image(gc, l, b, im) def get_extents(self): """Return a :class:`matplotlib.transforms.Bbox` with the node position limits.""" x, y = ungroup_vector_property(self.pos, [0, 1]) return matplotlib.transforms.Bbox([[x.fa.min(), y.fa.min()], [x.fa.max(), y.fa.max()]]) # # Drawing hierarchies # =================== # def draw_hierarchy(state, pos=None, layout="radial", beta=0.8, node_weight=None, vprops=None, eprops=None, hvprops=None, heprops=None, subsample_edges=None, rel_order="degree", deg_size=True, vsize_scale=1, hsize_scale=1, hshortcuts=0, hide=0, bip_aspect=1., empty_branches=False, **kwargs): r"""Draw a nested block model state in a circular hierarchy layout with edge bundling. Parameters ---------- state : :class:`~graph_tool.inference.NestedBlockState` Nested block state to be drawn. pos : :class:`~graph_tool.VertexPropertyMap` (optional, default: ``None``) If supplied, this specifies a vertex property map with the positions of the vertices in the layout. layout : ``str`` or :class:`~graph_tool.VertexPropertyMap` (optional, default: ``"radial"``) If ``layout == "radial"`` :func:`~graph_tool.draw.radial_tree_layout` will be used. If ``layout == "sfdp"``, the hierarchy tree will be positioned using :func:`~graph_tool.draw.sfdp_layout`. If ``layout == "bipartite"`` a bipartite layout will be used. If instead a :class:`~graph_tool.VertexPropertyMap` is provided, it must correspond to the position of the hierarchy tree. beta : ``float`` (optional, default: ``.8``) Edge bundling strength. node_weight : :class:`~graph_tool.VertexPropertyMap` (optional, default: ``None``) If provided, this specifies a vertex property map with the relative angular section that each vertex occupies. This value is ignored if ``layout != "radial"``. vprops : dict (optional, default: ``None``) Dictionary with the vertex properties. Individual properties may also be given via the ``vertex_`` parameters, where ```` is the name of the property. See :func:`~graph_tool.draw.graph_draw` for details. eprops : dict (optional, default: ``None``) Dictionary with the edge properties. Individual properties may also be given via the ``edge_`` parameters, where ```` is the name of the property. See :func:`~graph_tool.draw.graph_draw` for details. hvprops : dict (optional, default: ``None``) Dictionary with the vertex properties for the *hierarchy tree*. Individual properties may also be given via the ``hvertex_`` parameters, where ```` is the name of the property. See :func:`~graph_tool.draw.graph_draw` for details. heprops : dict (optional, default: ``None``) Dictionary with the edge properties for the *hierarchy tree*. Individual properties may also be given via the ``hedge_`` parameters, where ```` is the name of the property. See :func:`~graph_tool.draw.graph_draw` for details. subsample_edges : ``int`` or list of :class:`~graph_tool.Edge` instances (optional, default: ``None``) If provided, only this number of random edges will be drawn. If the value is a list, it should include the edges that are to be drawn. rel_order : ``str`` or ``None`` or :class:`~graph_tool.VertexPropertyMap` (optional, default: ``"degree"``) If ``degree``, the vertices will be ordered according to degree inside each group, and the relative ordering of the hierarchy branches. If instead a :class:`~graph_tool.VertexPropertyMap` is provided, its value will be used for the relative ordering. deg_size : ``bool`` (optional, default: ``True``) If ``True``, the (total) node degrees will be used for the default vertex sizes.. vsize_scale : ``float`` (optional, default: ``1.``) Multiplicative factor for the default vertex sizes. hsize_scale : ``float`` (optional, default: ``1.``) Multiplicative factor for the default sizes of the hierarchy nodes. hshortcuts : ``int`` (optional, default: ``0``) Include shortcuts to the number of upper layers in the hierarchy determined by this parameter. hide : ``int`` (optional, default: ``0``) Hide upper levels of the hierarchy. bip_aspect : ``float`` (optional, default: ``1.``) If ``layout == "bipartite"``, this will define the aspect ratio of layout. empty_branches : ``bool`` (optional, default: ``False``) If ``empty_branches == False``, dangling branches at the upper layers will be pruned. vertex_* : :class:`~graph_tool.VertexPropertyMap` or arbitrary types (optional, default: ``None``) Parameters following the pattern ``vertex_`` specify the vertex property with name ````, as an alternative to the ``vprops`` parameter. See :func:`~graph_tool.draw.graph_draw` for details. edge_* : :class:`~graph_tool.EdgePropertyMap` or arbitrary types (optional, default: ``None``) Parameters following the pattern ``edge_`` specify the edge property with name ````, as an alternative to the ``eprops`` parameter. See :func:`~graph_tool.draw.graph_draw` for details. hvertex_* : :class:`~graph_tool.VertexPropertyMap` or arbitrary types (optional, default: ``None``) Parameters following the pattern ``hvertex_`` specify the vertex property with name ````, as an alternative to the ``hvprops`` parameter. See :func:`~graph_tool.draw.graph_draw` for details. hedge_* : :class:`~graph_tool.EdgePropertyMap` or arbitrary types (optional, default: ``None``) Parameters following the pattern ``hedge_`` specify the edge property with name ````, as an alternative to the ``heprops`` parameter. See :func:`~graph_tool.draw.graph_draw` for details. **kwargs : All remaining keyword arguments will be passed to the :func:`~graph_tool.draw.graph_draw` function. Returns ------- pos : :class:`~graph_tool.VertexPropertyMap` This is a vertex property map with the positions of the vertices in the layout. t : :class:`~graph_tool.Graph` This is a the hierarchy tree used in the layout. tpos : :class:`~graph_tool.VertexPropertyMap` This is a vertex property map with the positions of the hierarchy tree in the layout. Examples -------- .. testsetup:: draw_hierarchy gt.seed_rng(42) np.random.seed(42) .. doctest:: draw_hierarchy >>> g = gt.collection.data["celegansneural"] >>> state = gt.minimize_nested_blockmodel_dl(g) >>> gt.draw_hierarchy(state, output="celegansneural_nested_mdl.pdf") (...) .. testcleanup:: draw_hierarchy conv_png("celegansneural_nested_mdl.pdf") .. figure:: celegansneural_nested_mdl.png :align: center :width: 80% Hierarchical block partition of the C. elegans neural network, which minimizes the description length of the network according to the nested (degree-corrected) stochastic blockmodel. References ---------- .. [holten-hierarchical-2006] Holten, D. "Hierarchical Edge Bundles: Visualization of Adjacency Relations in Hierarchical Data.", IEEE Transactions on Visualization and Computer Graphics 12, no. 5, 741–748 (2006). :doi:`10.1109/TVCG.2006.147` """ g = state.g overlap = state.levels[0].overlap if overlap: ostate = state.levels[0] bv, bcin, bcout, bc = ostate.get_overlap_blocks() be = ostate.get_edge_blocks() orig_state = state state = state.copy() b = ostate.get_majority_blocks() state.levels[0] = BlockState(g, b=b) else: b = state.levels[0].b if subsample_edges is not None: emask = g.new_edge_property("bool", False) if isinstance(subsample_edges, int): eidx = g.edge_index.copy("int").fa.copy() numpy.random.shuffle(eidx) emask = g.new_edge_property("bool") emask.a[eidx[:subsample_edges]] = True else: for e in subsample_edges: emask[e] = True g = GraphView(g, efilt=emask) t, tb, tvorder = get_hierarchy_tree(state, empty_branches=empty_branches) if layout == "radial": if rel_order == "degree": rel_order = g.degree_property_map("total") vorder = t.own_property(rel_order.copy()) if pos is not None: x, y = ungroup_vector_property(pos, [0, 1]) x.fa -= x.fa.mean() y.fa -= y.fa.mean() angle = g.new_vertex_property("double") angle.fa = (numpy.arctan2(y.fa, x.fa) + 2 * numpy.pi) % (2 * numpy.pi) vorder = t.own_property(angle) if node_weight is not None: node_weight = t.own_property(node_weight.copy()) node_weight.a[node_weight.a == 0] = 1 tpos = radial_tree_layout(t, root=t.vertex(t.num_vertices() - 1, use_index=False), node_weight=node_weight, rel_order=vorder, rel_order_leaf=True) elif layout == "bipartite": tpos = get_bip_hierachy_pos(state, aspect=bip_aspect, node_weight=node_weight) tpos = t.own_property(tpos) elif layout == "sfdp": if pos is None: tpos = sfdp_layout(t) else: x, y = ungroup_vector_property(pos, [0, 1]) x.fa -= x.fa.mean() y.fa -= y.fa.mean() K = numpy.sqrt(x.fa.std() + y.fa.std()) / 10 tpos = t.new_vertex_property("vector") for v in t.vertices(): if int(v) < g.num_vertices(True): tpos[v] = [x[v], y[v]] else: tpos[v] = [0, 0] pin = t.new_vertex_property("bool") pin.a[:g.num_vertices(True)] = True tpos = sfdp_layout(t, K=K, pos=tpos, pin=pin, multilevel=False) else: tpos = t.own_property(layout) hvvisible = t.new_vertex_property("bool", True) if hide is None: L = len([s for s in state.levels if s.get_nonempty_B() > 0]) hide = len(state.levels) - L if hide > 0: root = t.vertex(t.num_vertices(True) - 1) dist = shortest_distance(t, source=root) hvvisible.fa = dist.fa >= hide pos = g.own_property(tpos.copy()) cts = get_hierarchy_control_points(g, t, tpos, beta, max_depth=len(state.levels) - hshortcuts) vprops_orig = vprops eprops_orig = eprops hvprops_orig = vprops heprops_orig = eprops kwargs_orig = kwargs vprops = vprops.copy() if vprops is not None else {} eprops = eprops.copy() if eprops is not None else {} props, kwargs = parse_props("vertex", kwargs) vprops.update(props) vprops.setdefault("fill_color", b) vprops.setdefault("color", b) vprops.setdefault("shape", _vdefaults["shape"] if not overlap else "pie") output_size = kwargs.get("output_size", (600, 600)) if kwargs.get("mplfig", None) is not None: x, y = ungroup_vector_property(pos, [0, 1]) w = x.a.max() - x.a.min() h = y.a.max() - y.a.min() output_size = (w, h) s = numpy.mean(output_size) / (4 * numpy.sqrt(g.num_vertices())) vprops.setdefault("size", prop_to_size(g.degree_property_map("total"), s/5, s)) adjust_default_sizes(g, output_size, vprops, eprops) if vprops.get("text_position", None) == "centered": angle, text_pos = centered_rotation(g, pos, text_pos=True) vprops["text_position"] = text_pos vprops["text_rotation"] = angle toffset = vprops.get("text_offset", None) if toffset is not None: if not isinstance(toffset, PropertyMap): toffset = g.new_vp("vector", val=toffset) xo, yo = ungroup_vector_property(toffset, [0, 1]) xo.a[text_pos.a == numpy.pi] *= -1 toffset = group_vector_property([xo, yo]) vprops["text_offset"] = toffset self_loops = label_self_loops(g, mark_only=True) if self_loops.fa.max() > 0: parallel_distance = vprops.get("size", _vdefaults["size"]) if isinstance(parallel_distance, PropertyMap): parallel_distance = parallel_distance.fa.mean() cts_p = position_parallel_edges(g, pos, numpy.nan, parallel_distance) gu = GraphView(g, efilt=self_loops) for e in gu.edges(): cts[e] = cts_p[e] vprops = _convert_props(vprops, "v", g, kwargs.get("vcmap", None), kwargs.get("vcnorm", None), pmap_default=True) props, kwargs = parse_props("edge", kwargs) eprops.update(props) eprops.setdefault("control_points", cts) eprops.setdefault("pen_width", _edefaults["pen_width"]) eprops.setdefault("color", list(_edefaults["color"][:-1]) + [.6]) eprops.setdefault("end_marker", "arrow" if g.is_directed() else "none") eprops = _convert_props(eprops, "e", g, kwargs.get("ecmap", None), kwargs.get("ecnorm", None), pmap_default=True) hvprops = hvprops.copy() if hvprops is not None else {} heprops = heprops.copy() if heprops is not None else {} props, kwargs = parse_props("hvertex", kwargs) hvprops.update(props) blue = list(color_converter.to_rgba("#729fcf")) blue[-1] = .6 hvprops.setdefault("fill_color", blue) hvprops.setdefault("color", [1, 1, 1, 0]) hvprops.setdefault("shape", "square") hvprops.setdefault("size", s) if hvprops.get("text_position", None) == "centered": angle, text_pos = centered_rotation(t, tpos, text_pos=True) hvprops["text_position"] = text_pos hvprops["text_rotation"] = angle toffset = hvprops.get("text_offset", None) if toffset is not None: if not isinstance(toffset, PropertyMap): toffset = t.new_vp("vector", val=toffset) xo, yo = ungroup_vector_property(toffset, [0, 1]) xo.a[text_pos.a == numpy.pi] *= -1 toffset = group_vector_property([xo, yo]) hvprops["text_offset"] = toffset hvprops = _convert_props(hvprops, "v", t, kwargs.get("vcmap", None), kwargs.get("vcnorm", None), pmap_default=True) props, kwargs = parse_props("hedge", kwargs) heprops.update(props) heprops.setdefault("color", blue) heprops.setdefault("end_marker", "arrow") heprops.setdefault("marker_size", s * .8) heprops.setdefault("pen_width", s / 10) heprops = _convert_props(heprops, "e", t, kwargs.get("ecmap", None), kwargs.get("ecnorm", None), pmap_default=True) vcmap = kwargs.get("vcmap", None) ecmap = kwargs.get("ecmap", vcmap) B = state.levels[0].get_B() if overlap and "pie_fractions" not in vprops: vprops["pie_fractions"] = bc.copy("vector") if "pie_colors" not in vprops: vertex_pie_colors = g.new_vertex_property("vector") nodes = defaultdict(list) def conv(k): clrs = [vcmap(r / (B - 1) if B > 1 else 0) for r in k] return [item for l in clrs for item in l] map_property_values(bv, vertex_pie_colors, conv) vprops["pie_colors"] = vertex_pie_colors gradient = eprops.get("gradient", None) if gradient is None: gradient = g.new_edge_property("double") gradient = group_vector_property([gradient]) ecolor = eprops.get("ecolor", _edefaults["color"]) eprops["gradient"] = gradient if overlap: for e in g.edges(): # ******** SLOW ******* r, s = be[e] if not g.is_directed() and e.source() > e.target(): r, s = s, r gradient[e] = [0] + list(vcmap(r / (B - 1))) + \ [1] + list(vcmap(s / (B - 1))) if isinstance(ecolor, PropertyMap): gradient[e][4] = gradient[e][9] = ecolor[e][3] else: gradient[e][4] = gradient[e][9] = ecolor[3] t_orig = t t = GraphView(t, vfilt=lambda v: int(v) >= g.num_vertices(True) and hvvisible[v]) t_vprops = {} t_eprops = {} props = [] for k in set(list(vprops.keys()) + list(hvprops.keys())): t_vprops[k] = (vprops.get(k, None), hvprops.get(k, None)) props.append(t_vprops[k]) for k in set(list(eprops.keys()) + list(heprops.keys())): t_eprops[k] = (eprops.get(k, None), heprops.get(k, None)) props.append(t_eprops[k]) props.append((pos, tpos)) props.append((g.vertex_index, tb)) props.append((b, None)) if "eorder" in kwargs: eorder = kwargs["eorder"] props.append((eorder, t.new_ep(eorder.value_type(), eorder.fa.max() + 1))) u, props = graph_merge(GraphView(g, directed=True), t, props={"set": props}, vmap=None, multiset=True) props = props["set"] for k in set(list(vprops.keys()) + list(hvprops.keys())): t_vprops[k] = props.pop(0) for k in set(list(eprops.keys()) + list(heprops.keys())): t_eprops[k] = props.pop(0) pos = props.pop(0) tb = props.pop(0) b = props.pop(0) if "eorder" in kwargs: eorder = props.pop(0) def update_cts(widget, gg, picked, pos, vprops, eprops): vmask = gg.vertex_index.copy("int") u = GraphView(gg, directed=False, vfilt=vmask.fa < g.num_vertices(True)) cts = eprops["control_points"] get_hierarchy_control_points(u, t_orig, pos, beta, cts=cts, max_depth=len(state.levels) - hshortcuts) def draw_branch(widget, gg, key_id, picked, pos, vprops, eprops): if key_id == ord('b'): if picked is not None and not isinstance(picked, PropertyMap) and int(picked) > g.num_vertices(True): p = shortest_path(t_orig, source=t_orig.vertex(t_orig.num_vertices(True) - 1), target=picked)[0] l = len(state.levels) - max(len(p), 1) bstack = state.get_bstack() bs = [s.vp["b"].a for s in bstack[:l+1]] bs[-1][:] = 0 if not overlap: b = state.project_level(l).b u = GraphView(g, vfilt=b.a == tb[picked]) u.vp["b"] = state.levels[0].b u = Graph(u, prune=True) b = u.vp["b"] bs[0] = b.a else: be = orig_state.project_level(l).get_edge_blocks() emask = g.new_edge_property("bool") for e in g.edges(): rs = be[e] if rs[0] == tb[picked] and rs[1] == tb[picked]: emask[e] = True u = GraphView(g, efilt=emask) d = u.degree_property_map("total") u = GraphView(u, vfilt=d.fa > 0) u.ep["be"] = orig_state.levels[0].get_edge_blocks() u = Graph(u, prune=True) be = u.ep["be"] s = OverlapBlockState(u, b=be) bs[0] = s.b.a.copy() nstate = NestedBlockState(u, bs=bs, base_type=type(state.levels[0]), state_args=state.state_args) kwargs_ = kwargs_orig.copy() if "no_main" in kwargs_: del kwargs_["no_main"] draw_hierarchy(nstate, beta=beta, vprops=vprops_orig, eprops=eprops_orig, hvprops=hvprops_orig, heprops=heprops_orig, subsample_edges=subsample_edges, deg_order=deg_order, empty_branches=False, no_main=True, **kwargs_) if key_id == ord('r'): if layout == "radial": x, y = ungroup_vector_property(pos, [0, 1]) x.fa -= x.fa.mean() y.fa -= y.fa.mean() angle = t_orig.new_vertex_property("double") angle.fa = (numpy.arctan2(y.fa, x.fa) + 2 * numpy.pi) % (2 * numpy.pi) tpos = radial_tree_layout(t_orig, root=t_orig.vertex(t_orig.num_vertices(True) - 1), rel_order=angle) gg.copy_property(gg.own_property(tpos), pos) update_cts(widget, gg, picked, pos, vprops, eprops) if widget.vertex_matrix is not None: widget.vertex_matrix.update() widget.picked = None widget.selected.fa = False widget.fit_to_window() widget.regenerate_surface(reset=True) widget.queue_draw() if ("output" not in kwargs and not kwargs.get("inline", has_draw_inline) and kwargs.get("mplfig", None) is None): kwargs["layout_callback"] = update_cts kwargs["key_press_callback"] = draw_branch if "eorder" in kwargs: kwargs["eorder"] = eorder vorder = kwargs.pop("vorder", None) if vorder is None: vorder = g.degree_property_map("total") tvorder = u.own_property(tvorder) tvorder.fa[:g.num_vertices()] = vorder.fa for k, v in kwargs.items(): if isinstance(v, PropertyMap) and v.get_graph().base is not u.base: kwargs[k] = u.own_property(v.copy()) ret = graph_draw(u, pos, vprops=t_vprops, eprops=t_eprops, vorder=tvorder, **kwargs) if isinstance(ret, PropertyMap): ret = g.own_property(ret) return ret, t_orig, tpos def get_bip_hierachy_pos(state, aspect=1., node_weight=None): if state.levels[0].overlap: g = state.g ostate = state.levels[0] bv, bcin, bcout, bc = ostate.get_overlap_blocks() be = ostate.get_edge_blocks() n_r = zeros(ostate.get_B()) b = g.new_vertex_property("int") for v in g.vertices(): i = bc[v].a.argmax() b[v] = bv[v][i] n_r[b[v]] += 1 orphans = [r for r in range(ostate.get_B()) if n_r[r] == 0] for v in g.vertices(): for r in orphans: b[v] = r orig_state = state state = state.copy() state.levels[0] = BlockState(g, b=b) g = state.g deg = g.degree_property_map("total") t, tb, order = get_hierarchy_tree(state) root = t.vertex(t.num_vertices(True) - 1) if root.out_degree() > 2: clabel = is_bipartite(g, partition=True)[1].copy("int") if state.levels[0].overlap: ostate = OverlapBlockState(g, b=clabel) ostate = orig_state.copy(clabel=clabel) bc = ostate.propagate_clabel(len(state.levels) - 2) else: state = state.copy(clabel=clabel) bc = state.propagate_clabel(len(state.levels) - 2) ps = list(root.out_neighbors()) t.clear_vertex(root) p1 = t.add_vertex() p2 = t.add_vertex() t.add_edge(root, p1) t.add_edge(root, p2) for p in ps: if bc.a[tb[p]] == 0: t.add_edge(p2, p) else: t.add_edge(p1, p) w = t.new_vertex_property("double") for v in t.vertices(): if v.in_degree() == 0: break if v.out_degree() == 0: w[v] = 1 if node_weight is None else node_weight[v] parent, = v.in_neighbors() w[parent] += w[v] pos = t.new_vertex_property("vector") pos[root] = (0., 0.) p1, p2 = root.out_neighbors() if ((w[p1] == w[p2] and p1.out_degree() > p2.out_degree()) or w[p1] > w[p2]): p1, p2 = p2, p1 L = len(state.levels) pos[p1] = (-1 / L * .5 * aspect, 0) pos[p2] = (+1 / L * .5 * aspect, 0) for i, p in enumerate([p1, p2]): roots = [p] while len(roots) > 0: nroots = [] for r in roots: cw = pos[r][1] - w[r] / (2. * w[p]) for v in sorted(r.out_neighbors(), key=lambda a: order[a]): pos[v] = (0, 0) if i == 0: pos[v][0] = pos[r][0] - 1 / L * .5 * aspect else: pos[v][0] = pos[r][0] + 1 / L * .5 * aspect pos[v][1] = cw + w[v] / (2. * w[p]) cw += w[v] / w[p] nroots.append(v) roots = nroots return pos # Handle cairo contexts from cairocffi try: import cairocffi import ctypes pycairo_aux = ctypes.PyDLL(os.path.dirname(os.path.abspath(__file__)) + "/libgt_pycairo_aux.so") pycairo_aux.gt_PycairoContext_FromContext.restype = ctypes.c_void_p pycairo_aux.gt_PycairoContext_FromContext.argtypes = 3 * [ctypes.c_void_p] ctypes.pythonapi.PyList_Append.argtypes = 2 * [ctypes.c_void_p] except ImportError: pass def _UNSAFE_cairocffi_context_to_pycairo(cairocffi_context): # Sanity check. Continuing with another type would probably segfault. if not isinstance(cairocffi_context, cairocffi.Context): raise TypeError('Expected a cairocffi.Context, got %r' % cairocffi_context) # Create a reference for PycairoContext_FromContext to take ownership of. cairocffi.cairo.cairo_reference(cairocffi_context._pointer) # Casting the pointer to uintptr_t (the integer type as wide as a pointer) # gets the context’s integer address. # On CPython id(cairo.Context) gives the address to the Context type, # as expected by PycairoContext_FromContext. address = pycairo_aux.gt_PycairoContext_FromContext( int(cairocffi.ffi.cast('uintptr_t', cairocffi_context._pointer)), id(cairo.Context), None) assert address # This trick uses Python’s C API # to get a reference to a Python object from its address. temp_list = [] assert ctypes.pythonapi.PyList_Append(id(temp_list), address) == 0 return temp_list[0] # Bottom imports to avoid circular dependency issues from .. inference import get_hierarchy_tree, NestedBlockState, BlockState, \ OverlapBlockState