Source code for toyplot.html

# Copyright 2014, Sandia Corporation. Under the terms of Contract
# DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain
# rights in this software.

"""Functions to render the canonical HTML representation of a Toyplot figure."""

# pylint: disable=function-redefined


import base64
import collections
import copy
import functools
import itertools
import json
import logging
import string
import uuid
import xml.etree.ElementTree as xml

from multipledispatch import dispatch
import numpy

import toyplot.bitmap
import toyplot.coordinates
import toyplot.canvas
import toyplot.color
import toyplot.font
import toyplot.mark
import toyplot.marker
import toyplot.text

log = logging.getLogger(__name__)


_namespace = dict()

#: Decorator for registering custom rendering code.
#:
#: This is only of use when creating your own custom Toyplot marks.  It is
#: not intended for end-users.
#:
#: Example
#: -------
#: To register your own rendering function::
#:
#:     @toyplot.html.dispatch(toyplot.coordinates.Cartesian, MyCustomMark, toyplot.html.RenderContext)
#:     def _render(axes, mark, context):
#:         # Rendering implementation here
dispatch = functools.partial(dispatch, namespace=_namespace)


class _CustomJSONEncoder(json.JSONEncoder):
    # pylint: disable=method-hidden
    def default(self, o): # pragma: no cover
        if isinstance(o, numpy.generic):
            return numpy.asscalar(o)
        if isinstance(o, xml.Element):
            return xml.tostring(o, encoding="unicode", method="html")
        return json.JSONEncoder.default(self, o)


[docs]class RenderContext(object): """Stores context data during rendering. This is only of use for Toyplot developers and library developers who are implementing rendering code. It is not intended for end-users. """ def __init__(self, scenegraph, root): self._animation = {} self._id_cache = {} self._javascript_modules = {} self._javascript_calls = [] self._parent = None self._rendered = set() self._root = root self._scenegraph = scenegraph
[docs] def already_rendered(self, o): """Track whether an object has already been rendered. Used to prevent objects that can be shared, such as :class:`toyplot.coordinates.Axis`, from generating duplicate markup in the output HTML. Parameters ---------- o: any Python object, required Returns ------- rendered: bool If the given object hasn't already been rendered, records it as rendered and returns `False`. Subsequent calls with the given object will always return `True`. Examples -------- The following checks to see if `mark` has already been rendered:: if not context.already_rendered(mark): # Render the mark """ if o in self._rendered: return True self._rendered.add(o) return False
[docs] def get_id(self, o): """Return a globally unique identifier for an object. The generated identifier is cached, so multiple lookups on the same object will return consistent results. Parameters ---------- o: any Python object, required. Returns ------- id: str Globally unique identifier that can be used in HTML markup as an identifier that can be targeted from Javascript code. """ python_id = id(o) if python_id not in self._id_cache: self._id_cache[python_id] = "t" + uuid.uuid4().hex return self._id_cache[python_id]
[docs] def copy(self, parent): """Copy the current :class:`toyplot.html.RenderContext`. Creates a copy of the current render context that can be used to render children of the currently-rendered object. Parameters ---------- parent: any Python object, required. Returns ------- context: :class:`toyplot.html.RenderContext` The `parent` attribute will be set to the supplied parent object. """ result = copy.copy(self) result._parent = parent return result
[docs] def define(self, name, dependencies=None, factory=None, value=None): """Define a Javascript module that can be embedded in the output markup. The module will only be embedded in the output if it is listed as a dependency of another module, or code specified using :meth:`require`. You must specify either `factory` or `value`. Parameters ---------- name: string, required Module name. Any string is valid, but alphanumerics separated with slashes are recommended. Multiple calls to `define` with the same name argument will be silently ignored. dependencies: sequence of strings, optional Names of modules that are dependencies of this module. factory: string, optional Javascript code that will construct the module, which must be a function that takes the modules listed in `dependencies`, in-order, as arguments, and returns the initialized module. value: Python object, optional Arbitrary value for this module, which must be compatible with :func:`json.dumps`. """ if name in self._javascript_modules: return if dependencies is None: dependencies = [] if factory is None and value is None: raise ValueError("You must specify either factory or value.") #pragma: no cover if factory is not None and value is not None: raise ValueError("You must specify either factory or value.") #pragma: no cover if value is not None and dependencies: raise ValueError("Dependencies can only be specified when defining a factory, not a value.") #pragma: no cover self._javascript_modules[name] = (dependencies, factory, value)
[docs] def require(self, dependencies=None, arguments=None, code=None): """Embed Javascript code and its dependencies into the output markup. The given code will be unconditionally embedded in the output markup, along with any modules listed as dependencies (plus their dependencies, and-so-on). Parameters ---------- dependencies: sequence of strings, optional Names of modules that are required by this code. arguments: sequence of Python objects, optional Additional arguments to be passed to the Javascript code, which must be compatible with :func:`json.dumps`. code: string, required Javascript code to be embedded, which must be a function that accepts the modules listed in `requirements` in-order, followed by the values listed in `arguments` in-order, as arguments. """ if dependencies is None: dependencies = [] if arguments is None: arguments = [] if code is None: raise ValueError("You must specify a Javascript function using the code argument.") #pragma: no cover self._javascript_calls.append((dependencies, arguments, code))
@property def animation(self): return self._animation @property def parent(self): """Current DOM node. Typical rendering code will append HTML content to this node.""" return self._parent @property def root(self): """Top-level DOM node.""" return self._root @property def scenegraph(self): return self._scenegraph
[docs]def apply_changes(html, changes): for change, states in changes.items(): if change == "set-mark-style": for state in states: mark = html.find(".//*[@id='%s']" % state["mark"]) style = toyplot.style.combine(dict([declaration.split(":") for declaration in mark.get("style").split(";") if declaration != ""]), state["style"]) mark.set("style", _css_style(style)) elif change == "set-datum-style": for state in states: mark_xml = html.find(".//*[@id='%s']" % state["mark"]) series_xml = mark_xml.findall("*[@class='toyplot-Series']")[state["series"]] datum_xml = series_xml.findall("*[@class='toyplot-Datum']")[state["datum"]] style = toyplot.style.combine(dict([declaration.split( ":") for declaration in datum_xml.get("style").split(";") if declaration != ""]), state["style"]) datum_xml.set("style", _css_style(style)) elif change == "set-datum-text": for state in states: mark_xml = html.find(".//*[@id='%s']" % state["mark"]) series_xml = mark_xml.findall("*[@class='toyplot-Series']")[state["series"]] datum_xml = series_xml.findall("*[@class='toyplot-Datum']")[state["datum"]] # Remove old markup from the datum. while len(datum_xml): del datum_xml[0] # Copy new markup to the datum. for child in state["layout"]: datum_xml.append(child)
[docs]def render(canvas, fobj=None, animation=False, style=None): """Convert a canvas to its HTML DOM representation. Generates HTML markup with an embedded SVG representation of the canvas, plus JavaScript code for interactivity. If the canvas contains animation, the markup will include an HTML user interface to control playback. Parameters ---------- canvas: :class:`toyplot.canvas.Canvas` The canvas to be rendered. fobj: file-like object or string, optional The file to write. Use a string filepath to write data directly to disk. If `None` (the default), the HTML tree will be returned to the caller instead. animation: boolean, optional If `True`, return a representation of the changes to be made to the HTML tree for animation. style: dict, optional Dictionary of CSS styles that will be applied to the top-level output <div>. Returns ------- html: :class:`xml.etree.ElementTree.Element` or `None` HTML representation of `canvas`, as a DOM tree, or `None` if the caller specifies the `fobj` parameter. changes: JSON-compatible data structure, or `None` JSON-compatible representation of the animated changes to `canvas`. Notes ----- The output HTML is the "canonical" representation of a Toyplot canvas - the other toyplot backends operate by converting the output from toyplot.html.render() to the desired end target. Note that the output HTML is a fragment wrapped in a <div>, suitable for embedding in a larger document. It is the caller's responsibility to supply the <html>, <body> etc. if the result is intended as a standalone HTML document. """ canvas = toyplot.require.instance(canvas, toyplot.canvas.Canvas) canvas.autorender(False) # Create the top-level HTML element. root_xml = xml.Element( "div", attrib={"class": "toyplot"}, id="t" + uuid.uuid4().hex, ) if style is not None: root_xml.set("style", toyplot.style.to_css(style)) # Setup a render context context = RenderContext(scenegraph=canvas._scenegraph, root=root_xml) # Register a Javascript module to keep track of the root id context.define("toyplot/root/id", value=root_xml.get("id")) # Register a Javascript module to keep track of the root context.define("toyplot/root", ["toyplot/root/id"], factory="""function(root_id) { return document.querySelector("#" + root_id); }""") # Render the canvas. _render(canvas, context.copy(parent=root_xml)) # pylint: disable=no-value-for-parameter # Return / write the results. if isinstance(fobj, str): with open(fobj, "wb") as stream: stream.write(xml.tostring(root_xml, method="html")) elif fobj is not None: fobj.write(xml.tostring(root_xml, method="html")) else: if animation: return root_xml, context.animation return root_xml
[docs]def tostring(canvas, style=None): """Convert a canvas to its HTML string representation. Generates HTML markup with an embedded SVG representation of the canvas, plus JavaScript code for interactivity. If the canvas contains animation, the markup will include an HTML user interface to control playback. Parameters ---------- canvas: :class:`toyplot.canvas.Canvas` The canvas to be rendered. style: dict, optional Dictionary of CSS styles that will be applied to the top-level output <div>. Returns ------- html: str HTML representation of `canvas` as a string. Notes ----- The output HTML is a fragment wrapped in a <div>, suitable for embedding in a larger document. It is the caller's responsibility to supply the <html>, <body> etc. if the result is intended as a standalone HTML document. """ return xml.tostring(render(canvas=canvas, style=style), encoding="unicode", method="html")
def _color_fixup(styles): """It turns-out that many applications and libraries (Inkscape, Adobe Illustrator, Qt) don't handle CSS rgba() colors correctly. So convert them to CSS rgb colors and use fill-opacity / stroke-opacity instead.""" if "fill" in styles: color = toyplot.color.css(styles["fill"]) if color is not None: opacity = float(styles.get("fill-opacity", 1.0)) styles["fill"] = "rgb(%.3g%%,%.3g%%,%.3g%%)" % ( color["r"] * 100, color["g"] * 100, color["b"] * 100) styles["fill-opacity"] = str(color["a"] * opacity) if "stroke" in styles: color = toyplot.color.css(styles["stroke"]) if color is not None: opacity = float(styles.get("stroke-opacity", 1.0)) styles["stroke"] = "rgb(%.3g%%,%.3g%%,%.3g%%)" % ( color["r"] * 100, color["g"] * 100, color["b"] * 100) styles["stroke-opacity"] = str(color["a"] * opacity) return styles def _css_style(*styles): style = _color_fixup(toyplot.style.combine(*styles)) return ";".join(["%s:%s" % (key, value) for key, value in sorted(style.items())]) def _css_attrib(*styles): style = _color_fixup(toyplot.style.combine(*styles)) attrib = {} if style: attrib["style"] = ";".join( ["%s:%s" % (key, value) for key, value in sorted(style.items())]) return attrib def _flat_contiguous(a): i = 0 result = [] for (k, g) in itertools.groupby(a.ravel()): n = len(list(g)) if k: result.append(slice(i, i + n)) i += n return result def _walk_tree(node): yield ("start", node.tag, node.attrib) if node.text: yield ("text", node.text) for child in node: for item in _walk_tree(child): yield item yield ("end", node.tag) if node.tail: yield ("text", node.tail) def _draw_text( root, text, x=0, y=0, style=None, angle=None, title=None, attributes=None, ): if not text: return style = toyplot.style.combine({"font-family": "helvetica"}, style) if attributes is None: attributes = {} fonts = toyplot.font.ReportlabLibrary() layout = text if isinstance(text, toyplot.text.Layout) else toyplot.text.layout(text, style, fonts) transform = "" if x or y: transform += "translate(%r,%r)" % (x, y) if angle: transform += "rotate(%r)" % (-angle) # pylint: disable=invalid-unary-operand-type group = xml.SubElement( root, "g", attrib=attributes, ) if transform: group.set("transform", transform) if title is not None: xml.SubElement(group, "title").text = str(title) layout_opacity = 0.5 layout_stroke_width = 1 if layout.style.get("-toyplot-text-layout-visibility", None) == "visible": # pragma: no cover xml.SubElement( group, "rect", x=str(layout.left), y=str(layout.top), width=str(layout.width), height=str(layout.height), stroke="red", fill="none", opacity=str(layout_opacity), attrib={"stroke-width": str(layout_stroke_width)}, ) xml.SubElement( group, "circle", x="0", y="0", r="1.5", stroke="red", fill="none", opacity=str(layout_opacity), attrib={"stroke-width": str(layout_stroke_width)}, ) hyperlink = [] for line in layout.children: if line.style.get("-toyplot-text-layout-line-visibility", None) == "visible": # pragma: no cover xml.SubElement( group, "rect", x=str(line.left), y=str(line.top), width=str(line.width), height=str(line.height), stroke="green", fill="none", opacity=str(layout_opacity), attrib={"stroke-width": str(layout_stroke_width)}, ) xml.SubElement( group, "line", x1=str(line.left), y1=str(line.baseline), x2=str(line.right), y2=str(line.baseline), stroke="green", fill="none", opacity=str(layout_opacity), attrib={"stroke-width": str(layout_stroke_width)}, ) for box in line.children: if isinstance(box, toyplot.text.TextBox): xml.SubElement( group, "text", x=str(box.left), y=str(box.baseline), style=toyplot.style.to_css(box.style), ).text = box.text if box.style.get("-toyplot-text-layout-box-visibility", None) == "visible": # pragma: no cover xml.SubElement( group, "rect", x=str(box.left), y=str(box.top), width=str(box.width), height=str(box.height), stroke="blue", fill="none", opacity=str(layout_opacity), attrib={"stroke-width": str(layout_stroke_width)}, ) xml.SubElement( group, "line", x1=str(box.left), y1=str(box.baseline), x2=str(box.right), y2=str(box.baseline), stroke="blue", fill="none", opacity=str(layout_opacity), attrib={"stroke-width": str(layout_stroke_width)}, ) elif isinstance(box, toyplot.text.MarkerBox): if box.marker: _draw_marker( group, cx=(box.left + box.right) * 0.5, cy=(box.top + box.bottom) * 0.5, marker=toyplot.marker.create(size=box.height) + box.marker, ) if box.style.get("-toyplot-text-layout-box-visibility", None) == "visible": # pragma: no cover xml.SubElement( group, "rect", x=str(box.left), y=str(box.top), width=str(box.width), height=str(box.height), stroke="blue", fill="none", opacity=str(layout_opacity), attrib={"stroke-width": str(layout_stroke_width)}, ) xml.SubElement( group, "line", x1=str(box.left), y1=str(box.baseline), x2=str(box.right), y2=str(box.baseline), stroke="blue", fill="none", opacity=str(layout_opacity), attrib={"stroke-width": str(layout_stroke_width)}, ) elif isinstance(box, toyplot.text.PushHyperlink): hyperlink.append(group) group = xml.SubElement( group, "a", style=toyplot.style.to_css(box.style), ) group.set("xlink:href", box.href) if box.target is not None: group.set("target", box.target) elif isinstance(box, toyplot.text.PopHyperlink): group = hyperlink.pop() def _draw_bar(parent_xml, size, angle=0): markup = xml.SubElement( parent_xml, "line", y1=repr(-size / 2), y2=repr(size / 2), ) if angle: markup.set("transform", "rotate(%r)" % (-angle,)) def _draw_rect(parent_xml, size, width=1, height=1, angle=0): markup = xml.SubElement( parent_xml, "rect", x=repr(-size / 2 * width), y=repr(-size / 2 * height), width=repr(size * width), height=repr(size * height), ) if angle: markup.set("transform", "rotate(%r)" % (-angle,)) def _draw_triangle(parent_xml, size, angle=0): markup = xml.SubElement( parent_xml, "polygon", points=" ".join(["%r,%r" % (xp, yp) for xp, yp in [ (-size / 2, size / 2), (0, -size / 2), (size / 2, size / 2), ]]), ) if angle: markup.set("transform", "rotate(%r)" % (-angle,)) def _draw_circle(parent_xml, size): xml.SubElement( parent_xml, "circle", r=repr(size / 2), ) def _draw_marker( root, marker, cx=None, cy=None, extra_class=None, title=None, transform=None, ): attrib = _css_attrib(marker.mstyle) if extra_class is not None: attrib["class"] = extra_class marker_xml = xml.SubElement(root, "g", attrib=attrib) if title is not None: xml.SubElement(marker_xml, "title").text = str(title) if transform is None: transform = "translate(%r, %r)" % (cx, cy) if marker.angle: transform += " rotate(%r)" % (-marker.angle,) marker_xml.set("transform", transform) if marker.shape == "|": _draw_bar(marker_xml, marker.size) elif marker.shape == "/": _draw_bar(marker_xml, marker.size, angle=-45) elif marker.shape == "-": _draw_bar(marker_xml, marker.size, angle=90) elif marker.shape == "\\": _draw_bar(marker_xml, marker.size, angle=45) elif marker.shape == "+": _draw_bar(marker_xml, marker.size) _draw_bar(marker_xml, marker.size, angle=90) elif marker.shape == "x": _draw_bar(marker_xml, marker.size, angle=-45) _draw_bar(marker_xml, marker.size, angle=45) elif marker.shape == "*": _draw_bar(marker_xml, marker.size) _draw_bar(marker_xml, marker.size, angle=-60) _draw_bar(marker_xml, marker.size, angle=60) elif marker.shape == "^": _draw_triangle(marker_xml, marker.size) elif marker.shape == ">": _draw_triangle(marker_xml, marker.size, angle=-90) elif marker.shape == "v": _draw_triangle(marker_xml, marker.size, angle=180) elif marker.shape == "<": _draw_triangle(marker_xml, marker.size, angle=90) elif marker.shape == "s": _draw_rect(marker_xml, marker.size) elif marker.shape == "d": _draw_rect(marker_xml, marker.size, angle=45) elif marker.shape and marker.shape[0] == "r": width, height = marker.shape[1:].split("x") _draw_rect(marker_xml, marker.size, width=float(width), height=float(height)) elif marker.shape == "o": _draw_circle(marker_xml, marker.size) elif marker.shape == "oo": _draw_circle(marker_xml, marker.size) _draw_circle(marker_xml, marker.size / 2) elif marker.shape == "o|": _draw_circle(marker_xml, marker.size) _draw_bar(marker_xml, marker.size) elif marker.shape == "o/": _draw_circle(marker_xml, marker.size) _draw_bar(marker_xml, marker.size, -45) elif marker.shape == "o-": _draw_circle(marker_xml, marker.size) _draw_bar(marker_xml, marker.size, 90) elif marker.shape == "o\\": _draw_circle(marker_xml, marker.size) _draw_bar(marker_xml, marker.size, 45) elif marker.shape == "o+": _draw_circle(marker_xml, marker.size) _draw_bar(marker_xml, marker.size) _draw_bar(marker_xml, marker.size, 90) elif marker.shape == "ox": _draw_circle(marker_xml, marker.size) _draw_bar(marker_xml, marker.size, -45) _draw_bar(marker_xml, marker.size, 45) elif marker.shape == "o*": _draw_circle(marker_xml, marker.size) _draw_bar(marker_xml, marker.size) _draw_bar(marker_xml, marker.size, -60) _draw_bar(marker_xml, marker.size, 60) if marker.label: # Never compute a text layout unless we have to. _draw_text( root=marker_xml, text=marker.label, style=toyplot.style.combine( { "-toyplot-vertical-align": "middle", "fill": toyplot.color.black, "font-size": "%rpx" % (marker.size * 0.75), "stroke": "none", "text-anchor": "middle", }, marker.lstyle), ) return marker_xml def _axis_transform(x1, y1, x2, y2, offset, return_length=False): p = numpy.row_stack(((x1, y1), (x2, y2))) basis = p[1] - p[0] length = numpy.linalg.norm(basis) theta = numpy.rad2deg(numpy.arctan2(basis[1], basis[0])) transform = str() if p[0][0] or p[0][1]: transform += "translate(%s,%s)" % (p[0][0], p[0][1]) if theta: transform += "rotate(%s)" % theta if offset: transform += "translate(0,%s)" % offset if return_length: return transform, length return transform @dispatch(toyplot.canvas.Canvas, RenderContext) def _render(canvas, context): # Optionally apply a hyperlink to the entire canvas. parent_xml = context.parent if canvas._hyperlink: hyperlink_xml = xml.SubElement(parent_xml, "a", attrib={"href": canvas._hyperlink}) parent_xml = hyperlink_xml # Create the root SVG element. svg_xml = xml.SubElement( parent_xml, "svg", xmlns="http://www.w3.org/2000/svg", attrib={ "class": "toyplot-canvas-Canvas", "xmlns:toyplot": "http://www.sandia.gov/toyplot", "xmlns:xlink": "http://www.w3.org/1999/xlink", }, width="%rpx" % canvas.width, height="%rpx" % canvas.height, viewBox="0 0 %r %r" % (canvas.width, canvas.height), preserveAspectRatio="xMidYMid meet", style=_css_style(canvas._style), id=context.get_id(canvas)) # Render everything on the canvas. for node in context.scenegraph.targets(canvas, "render"): _render(node._finalize(), context.copy(parent=svg_xml)) # Create a container for any Javascript code. javascript_xml = xml.SubElement( context.parent, "div", attrib={"class": "toyplot-behavior"}, ) # Register a Javascript module to keep track of the canvas id. context.define("toyplot/canvas/id", value=context.get_id(canvas)) # Register a Javascript module to keep track of the canvas. context.define("toyplot/canvas", ["toyplot/canvas/id"], factory="""function(canvas_id) { return document.querySelector("#" + canvas_id); }""") # Register a Javascript module for storing table data. context.define("toyplot/tables", factory="""function() { var tables = []; var module = {}; module.set = function(owner, key, names, columns) { tables.push({owner: owner, key: key, names: names, columns: columns}); } module.get = function(owner, key) { for(var i = 0; i != tables.length; ++i) { var table = tables[i]; if(table.owner != owner) continue; if(table.key != key) continue; return {names: table.names, columns: table.columns}; } } module.get_csv = function(owner, key) { var table = module.get(owner, key); if(table != undefined) { var csv = ""; csv += table.names.join(",") + "\\n"; for(var i = 0; i != table.columns[0].length; ++i) { for(var j = 0; j != table.columns.length; ++j) { if(j) csv += ","; csv += table.columns[j][i]; } csv += "\\n"; } return csv; } } return module; }""") # Register a Javascript module for saving data from the browser. context.define("toyplot/io", factory="""function() { var module = {}; module.save_file = function(mime_type, charset, data, filename) { var uri = "data:" + mime_type + ";charset=" + charset + "," + data; uri = encodeURI(uri); var link = document.createElement("a"); if(typeof link.download != "undefined") { link.href = uri; link.style = "visibility:hidden"; link.download = filename; document.body.appendChild(link); link.click(); document.body.removeChild(link); } else { window.open(uri); } }; return module; }""") # Register a Javascript module to provide a popup context menu. context.define("toyplot/menus/context", ["toyplot/root", "toyplot/canvas"], factory="""function(root, canvas) { var wrapper = document.createElement("div"); wrapper.innerHTML = "<ul class='toyplot-context-menu' style='background:#eee; border:1px solid #b8b8b8; border-radius:5px; box-shadow: 0px 0px 8px rgba(0%,0%,0%,0.25); margin:0; padding:3px 0; position:fixed; visibility:hidden;'></ul>" var menu = wrapper.firstChild; root.appendChild(menu); var items = []; var ignore_mouseup = null; function open_menu(e) { var show_menu = false; for(var index=0; index != items.length; ++index) { var item = items[index]; if(item.show(e)) { item.item.style.display = "block"; show_menu = true; } else { item.item.style.display = "none"; } } if(show_menu) { ignore_mouseup = true; menu.style.left = (e.clientX + 1) + "px"; menu.style.top = (e.clientY - 5) + "px"; menu.style.visibility = "visible"; e.stopPropagation(); e.preventDefault(); } } function close_menu() { menu.style.visibility = "hidden"; } function contextmenu(e) { open_menu(e); } function mousemove(e) { ignore_mouseup = false; } function mouseup(e) { if(ignore_mouseup) { ignore_mouseup = false; return; } close_menu(); } function keydown(e) { if(e.key == "Escape" || e.key == "Esc" || e.keyCode == 27) { close_menu(); } } canvas.addEventListener("contextmenu", contextmenu); canvas.addEventListener("mousemove", mousemove); document.addEventListener("mouseup", mouseup); document.addEventListener("keydown", keydown); var module = {}; module.add_item = function(label, show, activate) { var wrapper = document.createElement("div"); wrapper.innerHTML = "<li class='toyplot-context-menu-item' style='background:#eee; color:#333; padding:2px 20px; list-style:none; margin:0; text-align:left;'>" + label + "</li>" var item = wrapper.firstChild; items.push({item: item, show: show}); function mouseover() { this.style.background = "steelblue"; this.style.color = "white"; } function mouseout() { this.style.background = "#eee"; this.style.color = "#333"; } function choose_item(e) { close_menu(); activate(); e.stopPropagation(); e.preventDefault(); } item.addEventListener("mouseover", mouseover); item.addEventListener("mouseout", mouseout); item.addEventListener("mouseup", choose_item); item.addEventListener("contextmenu", choose_item); menu.appendChild(item); }; return module; }""") # Embed Javascript code and dependencies in the container. _render_javascript(context.copy(parent=javascript_xml)) _render_animation(canvas, context.copy(parent=javascript_xml)) # pylint: disable=no-value-for-parameter def _render_javascript(context): # Convert module dependencies into an adjacency list. adjacency_list = collections.defaultdict(list) for name, (requirements, factory, value) in context._javascript_modules.items(): for requirement in requirements: adjacency_list[name].append(requirement) # Identify required modules and sort them into topological order. modules = [] visited = {} def search(name, visited, modules): visited[name] = True for neighbor in adjacency_list[name]: if not visited.get(neighbor, False): search(neighbor, visited, modules) modules.append((name, context._javascript_modules[name])) for requirements, arguments, code in context._javascript_calls: for requirement in requirements: if not visited.get(requirement, False): search(requirement, visited, modules) # Generate the code. script = """(function() { var modules={}; """ # Initialize required modules. for name, (requirements, factory, value) in modules: script += """modules["%s"] = """ % name if factory is not None: script += "(" script += factory script += ")(" argument_list = ["""modules["%s"]""" % requirement for requirement in requirements] script += ",".join(argument_list) script += ");\n" if value is not None: script += json.dumps(value, cls=_CustomJSONEncoder, sort_keys=True) script += ";\n" # Make all calls. for requirements, arguments, code in context._javascript_calls: script += """(""" script += code script += """)(""" argument_list = ["""modules["%s"]""" % requirement for requirement in requirements] argument_list += [json.dumps(argument, cls=_CustomJSONEncoder, sort_keys=True) for argument in arguments] script += ",".join(argument_list) script += """);\n""" script += """})();""" # Create the DOM elements. xml.SubElement(context.parent, "script").text = script def _render_table(owner, key, label, table, filename, context): if isinstance(owner, toyplot.mark.Mark) and owner.annotation: return if isinstance(owner, toyplot.coordinates.Table) and owner.annotation: return names = [] columns = [] if isinstance(table, toyplot.data.Table): for name, column in table.items(): if "toyplot:exportable" in table.metadata(name) and table.metadata(name)["toyplot:exportable"]: if column.dtype == toyplot.color.dtype: raise ValueError("Color column table export isn't supported.") # pragma: no cover else: names.append(name) columns.append(column.tolist()) else: # Assume numpy matrix for column in table.T: names.append(column[0]) columns.append(column[1:].tolist()) if not (names and columns): return owner_id = context.get_id(owner) if filename is None: filename = "toyplot" context.require( dependencies=["toyplot/tables", "toyplot/menus/context", "toyplot/io"], arguments=[owner_id, key, label, names, columns, filename], code="""function(tables, context_menu, io, owner_id, key, label, names, columns, filename) { tables.set(owner_id, key, names, columns); var owner = document.querySelector("#" + owner_id); function show_item(e) { return owner.contains(e.target); } function choose_item() { io.save_file("text/csv", "utf-8", tables.get_csv(owner_id, key), filename + ".csv"); } context_menu.add_item("Save " + label + " as CSV", show_item, choose_item); }""", ) @dispatch(toyplot.canvas.Canvas, RenderContext) def _render_animation(canvas, context): # Collect animation changes, alter them so they can be used with the DOM, # and store them in the render context for later use by callers. begin, end, changes = canvas.animation() for time, change in changes.items(): context.animation[time] = {} for key, states in change.items(): context.animation[time][key] = [dict(state) for state in states] for state in context.animation[time][key]: if "mark" in state: state["mark"] = context.get_id(state["mark"]) if key == "set-datum-text": layout_xml = xml.Element("temp") _draw_text(layout_xml, text=state.pop("text"), style=state.pop("style")) state["layout"] = layout_xml.find("g") # If we don't have any animation, we're done. if len(context.animation) < 1: return # We do have animation, so reconfigure our animation changes for use with # JavaScript. times = numpy.concatenate((sorted(context.animation.keys()), [end])) durations = times[1:] - times[:-1] changes = [change for time, change in sorted(context.animation.items())] context.parent.append(xml.XML( """<div class="toyplot-vcr-controls"> <input class="toyplot-current-frame" title="Frame" type="range" min="0" max="{frames}" step="1" value="0"/> <button class="toyplot-rewind" title="Rewind" style="width:40px;height:24px"> <svg width="20" height="20"> <polygon points="10,5 0,10 10,15" stroke="none" fill="{black}"/> <polygon points="20,5 10,10 20,15" stroke="none" fill="{black}"/> </svg> </button> <button class="toyplot-reverse-play" title="Reverse Play" style="width:40px;height:24px"> <svg width="20" height="20"> <polygon points="15,5 5,10 15,15" stroke="none" fill="{black}"/> </svg> </button> <button class="toyplot-frame-rewind" title="Frame Rewind" style="width:40px;height:24px"> <svg width="20" height="20"> <polygon points="15,5 5,10 15,15" stroke="none" fill="{black}"/> <rect x="17" y="5" width="2" height="10" stroke="none" fill="{black}"/> </svg> </button> <button class="toyplot-stop" title="Stop" style="width:40px;height:24px"> <svg width="20" height="20"> <rect x="5" y="5" width="10" height="10" stroke="none" fill="{black}"/> </svg> </button> <button class="toyplot-frame-advance" title="Frame Advance" style="width:40px;height:24px"> <svg width="20" height="20"> <polygon points="5,5 15,10 5,15" stroke="none" fill="{black}"/> <rect x="1" y="5" width="2" height="10" stroke="none" fill="{black}"/> </svg> </button> <button class="toyplot-forward-play" title="Play" style="width:40px;height:24px"> <svg width="20" height="20"> <polygon points="5,5 15,10 5,15" stroke="none" fill="{black}"/> </svg> </button> <button class="toyplot-fast-forward" title="Fast Forward" style="width:40px;height:24px"> <svg width="20" height="20"> <polygon points="0,5 10,10 0,15" stroke="none" fill="{black}"/> <polygon points="10,5 20,10 10,15" stroke="none" fill="{black}"/> </svg> </button> </div>""".format( frames=len(context.animation), black=toyplot.color.black, ))) xml.SubElement(context.parent, "script").text = string.Template(""" (function() { var root_id = "$root_id"; var frame_durations = $frame_durations; var state_changes = $state_changes; var current_frame = null; var timeout = null; function set_timeout(value) { if(timeout !== null) window.clearTimeout(timeout); timeout = value; } function set_current_frame(frame) { current_frame = frame; document.querySelector("#" + root_id + " .toyplot-current-frame").value = frame; } function play_reverse() { set_current_frame((current_frame - 1 + frame_durations.length) % frame_durations.length); render_changes(0, current_frame+1) set_timeout(window.setTimeout(play_reverse, frame_durations[(current_frame - 1 + frame_durations.length) % frame_durations.length] * 1000)); } function play_forward() { set_current_frame((current_frame + 1) % frame_durations.length); render_changes(current_frame, current_frame+1); set_timeout(window.setTimeout(play_forward, frame_durations[current_frame] * 1000)); } var item_cache = {}; function get_item(id) { if(!(id in item_cache)) item_cache[id] = document.getElementById(id); return item_cache[id]; } function render_changes(begin, end) { for(var frame = begin; frame != end; ++frame) { var changes = state_changes[frame]; for(var type in changes) { var states = changes[type] if(type == "set-mark-style") { for(var i = 0; i != states.length; ++i) { var state = states[i]; var mark = get_item(state.mark); for(var key in state.style) { mark.style.setProperty(key, state[1][key]); } } } else if(type == "set-datum-style") { for(var i = 0; i != states.length; ++i) { var state = states[i]; var datum = get_item(state.mark).querySelectorAll(".toyplot-Series")[state.series].querySelectorAll(".toyplot-Datum")[state.datum]; for(var key in state.style) { datum.style.setProperty(key, state.style[key]); } } } else if(type == "set-datum-text") { for(var i = 0; i != states.length; ++i) { var state = states[i]; var datum = get_item(state.mark).querySelectorAll(".toyplot-Series")[state.series].querySelectorAll(".toyplot-Datum")[state.datum]; var layout = document.createElementNS("http://www.w3.org/2000/svg", "g"); layout.innerHTML = state.layout; layout = layout.firstChild; while(datum.firstElementChild) datum.removeChild(datum.firstElementChild); while(layout.firstElementChild) datum.appendChild(layout.removeChild(layout.firstElementChild)); } } } } } function on_set_frame() { set_timeout(null); set_current_frame(document.querySelector("#" + root_id + " .toyplot-current-frame").valueAsNumber); render_changes(0, current_frame+1); } function on_frame_rewind() { set_timeout(null); set_current_frame((current_frame - 1 + frame_durations.length) % frame_durations.length); render_changes(0, current_frame+1); } function on_rewind() { set_current_frame(0); render_changes(0, current_frame+1); } function on_play_reverse() { set_timeout(window.setTimeout(play_reverse, frame_durations[(current_frame - 1 + frame_durations.length) % frame_durations.length] * 1000)); } function on_stop() { set_timeout(null); } function on_play_forward() { set_timeout(window.setTimeout(play_forward, frame_durations[current_frame] * 1000)); } function on_fast_forward() { set_timeout(null); set_current_frame(frame_durations.length - 1); render_changes(0, current_frame + 1) } function on_frame_advance() { set_timeout(null); set_current_frame((current_frame + 1) % frame_durations.length); render_changes(current_frame, current_frame+1); } set_current_frame(0); render_changes(0, current_frame+1); document.querySelector("#" + root_id + " .toyplot-current-frame").oninput = on_set_frame; document.querySelector("#" + root_id + " .toyplot-rewind").onclick = on_rewind; document.querySelector("#" + root_id + " .toyplot-reverse-play").onclick = on_play_reverse; document.querySelector("#" + root_id + " .toyplot-frame-rewind").onclick = on_frame_rewind; document.querySelector("#" + root_id + " .toyplot-stop").onclick = on_stop; document.querySelector("#" + root_id + " .toyplot-frame-advance").onclick = on_frame_advance; document.querySelector("#" + root_id + " .toyplot-forward-play").onclick = on_play_forward; document.querySelector("#" + root_id + " .toyplot-fast-forward").onclick = on_fast_forward; })(); """).substitute( root_id=context.root.get("id"), frame_durations=json.dumps(durations.tolist()), state_changes=json.dumps(changes, cls=_CustomJSONEncoder), ) @dispatch(toyplot.coordinates.Axis, RenderContext) def _render(axis, context): if context.already_rendered(axis): return if not axis.show: return transform, length = _axis_transform(axis._x1, axis._y1, axis._x2, axis._y2, offset=axis._offset, return_length=True) axis_xml = xml.SubElement( context.parent, "g", id=context.get_id(axis), transform=transform, attrib={"class": "toyplot-coordinates-Axis"}, ) if axis.spine.show: x1 = 0 x2 = length if axis.domain.show and axis._data_min is not None and axis._data_max is not None: x1 = max( x1, axis.projection(axis._data_min)) x2 = min( x2, axis.projection(axis._data_max)) xml.SubElement( axis_xml, "line", x1=repr(x1), y1=repr(0), x2=repr(x2), y2=repr(0), style=_css_style( axis.spine._style)) if axis.ticks.show: y1 = axis._ticks_near if axis._tick_location == "below" else -axis._ticks_near y2 = -axis._ticks_far if axis._tick_location == "below" else axis._ticks_far ticks_group = xml.SubElement(axis_xml, "g") for location, tick_style in zip( axis._tick_locations, axis.ticks.tick.styles(axis._tick_locations), ): x = axis.projection(location) xml.SubElement( ticks_group, "line", x1=repr(x), y1=repr(y1), x2=repr(x), y2=repr(y2), style=_css_style( axis.ticks._style, tick_style)) if axis.ticks.labels.show: location = axis._tick_labels_location if axis.ticks.labels.angle: vertical_align = "middle" if location == "above": text_anchor = "start" if axis.ticks.labels.angle > 0 else "end" elif location == "below": text_anchor = "end" if axis.ticks.labels.angle > 0 else "start" else: vertical_align = "last-baseline" if location == "above" else "top" text_anchor = "middle" y = axis._tick_labels_offset if location == "below" else -axis._tick_labels_offset ticks_group = xml.SubElement(axis_xml, "g") for location, label, title, label_style in zip( axis._tick_locations, axis._tick_labels, axis._tick_titles, axis.ticks.labels.label.styles(axis._tick_locations), ): x = axis.projection(location) style = toyplot.style.combine( { "-toyplot-vertical-align": vertical_align, "text-anchor": text_anchor, }, axis.ticks.labels.style, label_style, ) _draw_text( root=ticks_group, text=label, x=x, y=y, style=style, angle=axis.ticks.labels.angle, title=title, ) location = axis._label_location vertical_align = "last-baseline" if location == "above" else "top" text_anchor = "middle" y = axis._label_offset if location == "below" else -axis._label_offset _draw_text( root=axis_xml, text=axis.label.text, x=length * 0.5, y=y, style=toyplot.style.combine( { "-toyplot-vertical-align": vertical_align, "text-anchor": text_anchor, }, axis.label.style, ), ) if axis.interactive.coordinates.show: coordinates_xml = xml.SubElement( axis_xml, "g", attrib={"class": "toyplot-coordinates-Axis-coordinates"}, style=_css_style({"visibility": "hidden"}), transform="", ) if axis.interactive.coordinates.tick.show: y1 = axis._tick_labels_offset if axis._interactive_coordinates_location == "below" else -axis._tick_labels_offset y1 *= 0.5 y2 = -axis._tick_labels_offset if axis._interactive_coordinates_location == "below" else axis._tick_labels_offset y2 *= 0.75 xml.SubElement( coordinates_xml, "line", x1="0", x2="0", y1=repr(y1), y2=repr(y2), style=_css_style(axis.interactive.coordinates.tick.style), ) if axis.interactive.coordinates.label.show: y = axis._tick_labels_offset if axis._interactive_coordinates_location == "below" else -axis._tick_labels_offset alignment_baseline = "hanging" if axis._interactive_coordinates_location == "below" else "alphabetic" xml.SubElement( coordinates_xml, "text", x="0", y=repr(y), style=_css_style(toyplot.style.combine( {"alignment-baseline": alignment_baseline}, axis.interactive.coordinates.label.style, )), ) context.define("toyplot.coordinates.Axis", ["toyplot/canvas"], """ function(canvas) { function sign(x) { return x < 0 ? -1 : x > 0 ? 1 : 0; } function mix(a, b, amount) { return ((1.0 - amount) * a) + (amount * b); } function log(x, base) { return Math.log(Math.abs(x)) / Math.log(base); } function in_range(a, x, b) { var left = Math.min(a, b); var right = Math.max(a, b); return left <= x && x <= right; } function inside(range, projection) { for(var i = 0; i != projection.length; ++i) { var segment = projection[i]; if(in_range(segment.range.min, range, segment.range.max)) return true; } return false; } function to_domain(range, projection) { for(var i = 0; i != projection.length; ++i) { var segment = projection[i]; if(in_range(segment.range.bounds.min, range, segment.range.bounds.max)) { if(segment.scale == "linear") { var amount = (range - segment.range.min) / (segment.range.max - segment.range.min); return mix(segment.domain.min, segment.domain.max, amount) } else if(segment.scale[0] == "log") { var amount = (range - segment.range.min) / (segment.range.max - segment.range.min); var base = segment.scale[1]; return sign(segment.domain.min) * Math.pow(base, mix(log(segment.domain.min, base), log(segment.domain.max, base), amount)); } } } } var axes = {}; function display_coordinates(e) { var current = canvas.createSVGPoint(); current.x = e.clientX; current.y = e.clientY; for(var axis_id in axes) { var axis = document.querySelector("#" + axis_id); var coordinates = axis.querySelector(".toyplot-coordinates-Axis-coordinates"); if(coordinates) { var projection = axes[axis_id]; var local = current.matrixTransform(axis.getScreenCTM().inverse()); if(inside(local.x, projection)) { var domain = to_domain(local.x, projection); coordinates.style.visibility = "visible"; coordinates.setAttribute("transform", "translate(" + local.x + ")"); var text = coordinates.querySelector("text"); text.textContent = domain.toFixed(2); } else { coordinates.style.visibility= "hidden"; } } } } canvas.addEventListener("click", display_coordinates); var module = {}; module.show_coordinates = function(axis_id, projection) { axes[axis_id] = projection; } return module; }""", ) projection = [] for segment in axis.projection._segments: projection.append({ "scale": segment.scale, "domain": { "min": segment.domain.min, "max": segment.domain.max, "bounds": { "min": segment.domain.bounds.min, "max": segment.domain.bounds.max, }, }, "range": { "min": segment.range.min, "max": segment.range.max, "bounds": { "min": segment.range.bounds.min, "max": segment.range.bounds.max, }, }, }) context.require( dependencies=["toyplot.coordinates.Axis"], arguments=[context.get_id(axis), projection], code="""function(axis, axis_id, projection) { axis.show_coordinates(axis_id, projection); }""", ) @dispatch(toyplot.coordinates.Numberline, RenderContext) def _render(numberline, context): numberline_xml = xml.SubElement(context.parent, "g", id=context.get_id( numberline), attrib={"class": "toyplot-coordinates-Numberline"}) clip_xml = xml.SubElement( numberline_xml, "clipPath", id="t" + uuid.uuid4().hex, ) transform, length = _axis_transform(numberline._x1, numberline._y1, numberline._x2, numberline._y2, offset=0, return_length=True) height = numberline.axis._offset if numberline._child_offset: height += numpy.amax(list(numberline._child_offset.values())) xml.SubElement( clip_xml, "rect", x=repr(0), y=repr(-height), width=repr(length), height=repr(height + numberline.axis._offset), ) children_xml = xml.SubElement( numberline_xml, "g", attrib={"clip-path": "url(#%s)" % clip_xml.get("id")}, transform=transform, ) for child in numberline._scenegraph.targets(numberline, "render"): _render(numberline, child._finalize(), context.copy(parent=children_xml)) _render(numberline.axis, context.copy(parent=numberline_xml)) @dispatch(toyplot.coordinates.Numberline, toyplot.color.CategoricalMap, RenderContext) def _render(numberline, colormap, context): offset = numberline._child_offset[colormap] width = numberline._child_width[colormap] style = numberline._child_style[colormap] mark_xml = xml.SubElement( context.parent, "g", id=context.get_id(colormap), attrib={"class": "toyplot-color-CategoricalMap"}, ) if offset: mark_xml.set("transform", "translate(0,%s)" % -offset) samples = numpy.linspace(colormap.domain.min, colormap.domain.max, len(colormap._palette), endpoint=True) projected = numberline.axis.projection(samples) colormap_range_min, colormap_range_max = numberline.axis.projection([colormap.domain.min, colormap.domain.max]) for index, (x1, x2), in enumerate(zip(projected[:-1], projected[1:])): color = colormap._palette[index] xml.SubElement( mark_xml, "rect", x=repr(x1), y=repr(-width * 0.5), width=repr(x2 - x1), height=repr(width), style=_css_style({"stroke": "none", "fill": toyplot.color.to_css(color)}), ) style = toyplot.style.combine( {"stroke": "none", "stroke-width":1.0, "fill": "none"}, style, ) xml.SubElement( mark_xml, "rect", x=repr(colormap_range_min), y=repr(-width * 0.5), width=repr(colormap_range_max - colormap_range_min), height=repr(width), style=_css_style(style), ) @dispatch(toyplot.coordinates.Numberline, toyplot.color.Map, RenderContext) def _render(numberline, colormap, context): offset = numberline._child_offset[colormap] width = numberline._child_width[colormap] style = numberline._child_style[colormap] colormap_range_min, colormap_range_max = numberline.axis.projection([colormap.domain.min, colormap.domain.max]) mark_xml = xml.SubElement( context.parent, "g", id=context.get_id(colormap), attrib={"class": "toyplot-color-Map"}, ) if offset: mark_xml.set("transform", "translate(0, %s)" % -offset) defs_xml = xml.SubElement( mark_xml, "defs", ) gradient_xml = xml.SubElement( defs_xml, "linearGradient", id="t" + uuid.uuid4().hex, x1=repr(colormap_range_min), x2=repr(colormap_range_max), y1=repr(0), y2=repr(0), gradientUnits="userSpaceOnUse", ) samples = numpy.linspace(colormap.domain.min, colormap.domain.max, 64, endpoint=True) for sample in samples: color = colormap.colors(sample) psample = numberline.axis.projection(sample) offset = (psample - colormap_range_min) / (colormap_range_max - colormap_range_min) xml.SubElement( gradient_xml, "stop", offset="%s" % offset, attrib={ "stop-color": "rgb(%.3g%%,%.3g%%,%.3g%%)" % (color["r"] * 100, color["g"] * 100, color["b"] * 100), "stop-opacity": str(color["a"]), }, ) style = toyplot.style.combine( {"stroke": "none", "stroke-width":1.0, "fill": "url(#%s)" % gradient_xml.get("id")}, style, ) xml.SubElement( mark_xml, "rect", x=repr(colormap_range_min), y=repr(-width * 0.5), width=repr(colormap_range_max - colormap_range_min), height=repr(width), style=_css_style(style), ) @dispatch(toyplot.coordinates.Numberline, toyplot.mark.Point, RenderContext) def _render(numberline, mark, context): offset = numberline._child_offset[mark] mark_xml = xml.SubElement( context.parent, "g", id=context.get_id(mark), attrib={"class": "toyplot-mark-Point"}, ) if offset: mark_xml.set("transform", "translate(0,%s)" % -offset) _render_table(owner=mark, key="data", label="point data", table=mark._table, filename=mark._filename, context=context) dimension1 = numpy.ma.column_stack([mark._table[key] for key in mark._coordinates]) X = numberline.axis.projection(dimension1) for x, marker, msize, mfill, mstroke, mopacity, mtitle, mhyperlink in zip( X.T, [mark._table[key] for key in mark._marker], [mark._table[key] for key in mark._msize], [mark._table[key] for key in mark._mfill], [mark._table[key] for key in mark._mstroke], [mark._table[key] for key in mark._mopacity], [mark._table[key] for key in mark._mtitle], [mark._table[key] for key in mark._mhyperlink], ): not_null = numpy.invert(numpy.ma.getmaskarray(x)) series_xml = xml.SubElement(mark_xml, "g", attrib={"class": "toyplot-Series"}) for dx, dmarker, dsize, dfill, dstroke, dopacity, dtitle, dhyperlink in zip( x[not_null], marker[not_null], msize[not_null], mfill[not_null], mstroke[not_null], mopacity[not_null], mtitle[not_null], mhyperlink[not_null], ): if dmarker: if dhyperlink: datum_xml = xml.SubElement(series_xml, "a", attrib={"xlink:href": dhyperlink}) else: datum_xml = series_xml dstyle = toyplot.style.combine( { "fill": toyplot.color.to_css(dfill), "stroke": toyplot.color.to_css(dstroke), "opacity": dopacity, }, mark._mstyle) _draw_marker( datum_xml, cx=dx, cy=0, marker=toyplot.marker.create(size=dsize, mstyle=dstyle, lstyle=mark._mlstyle) + toyplot.marker.convert(dmarker), extra_class="toyplot-Datum", title=dtitle, ) @dispatch(toyplot.coordinates.Numberline, toyplot.mark.Range, RenderContext) def _render(numberline, mark, context): offset = numberline._child_offset[mark] width = numberline._child_width[mark] mark_xml = xml.SubElement(context.parent, "g", id=context.get_id(mark), attrib={"class": "toyplot-mark-Range"}) if offset: mark_xml.set("transform", "translate(0,%s)" % -offset) _render_table(owner=mark, key="data", label="range data", table=mark._table, filename=mark._filename, context=context) x1 = numberline.axis.projection(mark._table[mark._coordinates[0]]) x2 = numberline.axis.projection(mark._table[mark._coordinates[1]]) series_xml = xml.SubElement(mark_xml, "g", attrib={"class": "toyplot-Series"}) for dx1, dx2, dfill, dopacity, dtitle in zip( x1, x2, mark._table[mark._fill[0]], mark._table[mark._opacity[0]], mark._table[mark._title[0]], ): dstyle = toyplot.style.combine({"fill": toyplot.color.to_css(dfill), "opacity": dopacity}, mark._style) datum_xml = xml.SubElement( series_xml, "rect", attrib={"class": "toyplot-Datum"}, x=repr(min(dx1, dx2)), y=repr(-width * 0.5), width=repr(numpy.abs(dx1 - dx2)), height=repr(width), style=_css_style(dstyle), ) if dtitle is not None: xml.SubElement(datum_xml, "title").text = str(dtitle) @dispatch(toyplot.coordinates.Cartesian, RenderContext) def _render(axes, context): cartesian_xml = xml.SubElement(context.parent, "g", id=context.get_id( axes), attrib={"class": "toyplot-coordinates-Cartesian"}) clip_xml = xml.SubElement(cartesian_xml, "clipPath", id="t" + uuid.uuid4().hex) xml.SubElement( clip_xml, "rect", x=repr(axes._xmin_range - axes.padding), y=repr(axes._ymin_range - axes.padding), width=repr(axes._xmax_range - axes._xmin_range + axes.padding * 2), height=repr(axes._ymax_range - axes._ymin_range + axes.padding * 2), ) if axes._hyperlink: hyperlink_xml = xml.SubElement(cartesian_xml, "a", attrib={"xlink:href": axes._hyperlink}) xml.SubElement( hyperlink_xml, "rect", x=repr(axes._xmin_range), y=repr(axes._ymin_range), width=repr(axes._xmax_range - axes._xmin_range), height=repr(axes._ymax_range - axes._ymin_range), attrib={"fill": "none", "stroke": "none", "pointer-events": "fill"}, ) children_xml = xml.SubElement( cartesian_xml, "g", attrib={"clip-path" : "url(#%s)" % clip_xml.get("id")}, ) for child in context.scenegraph.targets(axes, "render"): _render(axes, child._finalize(), context.copy(parent=children_xml)) if axes._show: _render(axes.x, context.copy(parent=cartesian_xml)) _render(axes.y, context.copy(parent=cartesian_xml)) _draw_text( root=cartesian_xml, text=axes.label._text, x=(axes._xmin_range + axes._xmax_range) * 0.5, y=axes._ymin_range - axes.label._offset, style=axes.label._style, ) @dispatch(toyplot.coordinates.Table, RenderContext) def _render(axes, context): axes_xml = xml.SubElement(context.parent, "g", id=context.get_id( axes), attrib={"class": "toyplot-coordinates-Table"}) _render_table(owner=axes, key="data", label="table data", table=axes._cell_data, filename=axes._filename, context=context) # Render title _draw_text( root=axes_xml, text=axes._label._text, x=(axes._xmin_range + axes._xmax_range) * 0.5, y=axes._ymin_range, style=axes._label._style, ) # For each unique group of cells. for cell_group in numpy.unique(axes._cell_group): cell_selection = (axes._cell_group == cell_group) # Skip hidden groups. cell_show = axes._cell_show[cell_selection][0] if not cell_show: continue # Identify the closed range of rows and columns that contain the cell. cell_rows, cell_columns = numpy.nonzero(cell_selection) row_min = cell_rows.min() row_max = cell_rows.max() column_min = cell_columns.min() column_max = cell_columns.max() # Optionally render the cell background. cell_style = axes._cell_style[cell_selection][0] cell_hyperlink = axes._cell_hyperlink[cell_selection][0] cell_title = axes._cell_title[cell_selection][0] if cell_style is not None or cell_hyperlink is not None or cell_title is not None: # Compute the cell boundaries. cell_top = axes._cell_top[row_min] cell_bottom = axes._cell_bottom[row_max] cell_left = axes._cell_left[column_min] cell_right = axes._cell_right[column_max] cell_parent_xml = axes_xml if cell_hyperlink is not None: cell_parent_xml = xml.SubElement( cell_parent_xml, "a", attrib={"xlink:href": cell_hyperlink}, ) cell_xml = xml.SubElement( cell_parent_xml, "rect", x=repr(cell_left), y=repr(cell_top), width=repr(cell_right - cell_left), height=repr(cell_bottom - cell_top), style=_css_style({"fill":"transparent", "stroke":"none"}, cell_style), ) if cell_title is not None: xml.SubElement(cell_xml, "title").text = str(cell_title) # Render the cell data. cell_data = axes._cell_data[cell_selection][0] if cell_data is not None: # Compute the cell boundaries. padding = 5 cell_top = axes._cell_top[row_min] cell_bottom = axes._cell_bottom[row_max] cell_left = axes._cell_left[column_min] + padding cell_right = axes._cell_right[column_max] - padding # Compute the text placement within the cell boundaries. cell_align = axes._cell_align[cell_selection][0] if cell_align is None: cell_align = "left" cell_angle = axes._cell_angle[cell_selection][0] y = (cell_top + cell_bottom) / 2 # Format the cell data. cell_format = axes._cell_format[cell_selection][0] prefix, separator, suffix = cell_format.format(cell_data) # Get the cell style. cell_lstyle = axes._cell_lstyle[cell_selection][0] # Render the cell data. if cell_align == "left": x = cell_left _draw_text( root=axes_xml, x=x, y=y, angle=cell_angle, style=toyplot.style.combine(cell_lstyle, {"text-anchor": "start"}), text=prefix + separator + suffix, ) elif cell_align == "center": x = (cell_left + cell_right) / 2 _draw_text( root=axes_xml, x=x, y=y, angle=cell_angle, style=toyplot.style.combine(cell_lstyle, {"text-anchor": "middle"}), text=prefix + separator + suffix, ) elif cell_align == "right": x = cell_right _draw_text( root=axes_xml, x=x, y=y, angle=cell_angle, style=toyplot.style.combine(cell_lstyle, {"text-anchor": "end"}), text=prefix + separator + suffix, ) elif cell_align == "separator": x = (cell_left + cell_right) / 2 _draw_text( root=axes_xml, x=x - 2, y=y, style=toyplot.style.combine(cell_lstyle, {"text-anchor": "end"}), text=prefix, ) _draw_text( root=axes_xml, x=x, y=y, style=toyplot.style.combine(cell_lstyle, {"text-anchor": "middle"}), text=separator, ) _draw_text( root=axes_xml, x=x + 2, y=y, style=toyplot.style.combine(cell_lstyle, {"text-anchor": "start"}), text=suffix, ) # Render children. for child in axes._axes: _render(child._finalize(), context.copy(parent=axes_xml)) # Render grid lines. row_boundaries = axes._row_boundaries column_boundaries = axes._column_boundaries separation = axes._separation / 2 def contiguous(a): i = 0 result = [] for (k, g) in itertools.groupby(a.ravel()): n = len(list(g)) if k: result.append((i, i + n, k)) i += n return result hlines = numpy.copy(axes._hlines) hlines[numpy.logical_not(axes._hlines_show)] = False for row_index, row in enumerate(hlines): y = row_boundaries[row_index] for start, end, line_type in contiguous(row): if line_type == "single": xml.SubElement( axes_xml, "line", x1=repr(column_boundaries[start]), y1=repr(y), x2=repr(column_boundaries[end]), y2=repr(y), style=_css_style(axes._gstyle), ) elif line_type == "double": xml.SubElement( axes_xml, "line", x1=repr( column_boundaries[start]), y1=repr( y - separation), x2=repr( column_boundaries[end]), y2=repr( y - separation), style=_css_style( axes._gstyle)) xml.SubElement( axes_xml, "line", x1=repr( column_boundaries[start]), y1=repr( y + separation), x2=repr( column_boundaries[end]), y2=repr( y + separation), style=_css_style( axes._gstyle)) vlines = numpy.copy(axes._vlines) vlines[numpy.logical_not(axes._vlines_show)] = False for column_index, column in enumerate(vlines.T): x = column_boundaries[column_index] for start, end, line_type in contiguous(column): if line_type == "single": xml.SubElement( axes_xml, "line", x1=repr(x), y1=repr(row_boundaries[start]), x2=repr(x), y2=repr(row_boundaries[end]), style=_css_style(axes._gstyle), ) elif line_type == "double": xml.SubElement( axes_xml, "line", x1=repr(x - separation), y1=repr(row_boundaries[start]), x2=repr(x - separation), y2=repr(row_boundaries[end]), style=_css_style(axes._gstyle), ) xml.SubElement( axes_xml, "line", x1=repr(x + separation), y1=repr(row_boundaries[start]), x2=repr(x + separation), y2=repr(row_boundaries[end]), style=_css_style(axes._gstyle), ) @dispatch(toyplot.coordinates.Cartesian, type(None), RenderContext) def _render(axes, mark, context): pass @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.BarBoundaries, RenderContext) def _render(axes, mark, context): left = mark._table[mark._left[0]] right = mark._table[mark._right[0]] boundaries = numpy.ma.column_stack( [mark._table[key] for key in mark._boundaries]) if mark._coordinate_axes.tolist() == ["x", "y"]: axis1 = "x" axis2 = "y" distance1 = "width" distance2 = "height" left = axes.project("x", left) right = axes.project("x", right) boundaries = axes.project("y", boundaries) elif mark._coordinate_axes.tolist() == ["y", "x"]: axis1 = "y" axis2 = "x" distance1 = "height" distance2 = "width" left = axes.project("y", left) right = axes.project("y", right) boundaries = axes.project("x", boundaries) mark_xml = xml.SubElement( context.parent, "g", style=_css_style( mark._style), id=context.get_id(mark), attrib={ "class": "toyplot-mark-BarBoundaries"}) _render_table(owner=mark, key="data", label="bar data", table=mark._table, filename=mark._filename, context=context) for boundary1, boundary2, fill, opacity, title, hyperlink in zip( boundaries.T[:-1], boundaries.T[1:], [mark._table[key] for key in mark._fill], [mark._table[key] for key in mark._opacity], [mark._table[key] for key in mark._title], [mark._table[key] for key in mark._hyperlink], ): not_null = numpy.invert( numpy.logical_or( numpy.ma.getmaskarray(boundary1), numpy.ma.getmaskarray(boundary2))) series_xml = xml.SubElement( mark_xml, "g", attrib={"class": "toyplot-Series"}) for dleft, dright, dboundary1, dboundary2, dfill, dopacity, dtitle, dhyperlink in zip( left[not_null], right[not_null], boundary1[not_null], boundary2[not_null], fill[not_null], opacity[not_null], title[not_null], hyperlink[not_null], ): dstyle = toyplot.style.combine({ "fill": toyplot.color.to_css(dfill), "opacity": dopacity, }, mark._style) if dhyperlink: parent_xml = xml.SubElement(series_xml, "a", attrib={"xlink:href": dhyperlink}) else: parent_xml = series_xml datum_xml = xml.SubElement( parent_xml, "rect", attrib={ "class": "toyplot-Datum", axis1: repr(min(dleft, dright)), axis2: repr(min(dboundary1, dboundary2)), distance1: repr(numpy.abs(dleft - dright)), distance2: repr(numpy.abs(dboundary1 - dboundary2)), }, style=_css_style(dstyle), ) if dtitle is not None: xml.SubElement(datum_xml, "title").text = str(dtitle) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.BarMagnitudes, RenderContext) def _render(axes, mark, context): left = mark._table[mark._left[0]] right = mark._table[mark._right[0]] boundaries = numpy.ma.cumsum(numpy.ma.column_stack( [mark._table[mark._baseline[0]]] + [mark._table[key] for key in mark._magnitudes]), axis=1) not_null = numpy.invert( numpy.ma.any(numpy.ma.getmaskarray(boundaries), axis=1)) if mark._coordinate_axes.tolist() == ["x", "y"]: axis1 = "x" axis2 = "y" distance1 = "width" distance2 = "height" left = axes.project("x", left) right = axes.project("x", right) boundaries = axes.project("y", boundaries) elif mark._coordinate_axes.tolist() == ["y", "x"]: axis1 = "y" axis2 = "x" distance1 = "height" distance2 = "width" left = axes.project("y", left) right = axes.project("y", right) boundaries = axes.project("x", boundaries) mark_xml = xml.SubElement( context.parent, "g", style=_css_style( mark._style), id=context.get_id(mark), attrib={ "class": "toyplot-mark-BarMagnitudes"}) _render_table(owner=mark, key="data", label="bar data", table=mark._table, filename=mark._filename, context=context) for boundary1, boundary2, fill, opacity, title, hyperlink in zip( boundaries.T[:-1], boundaries.T[1:], [mark._table[key] for key in mark._fill], [mark._table[key] for key in mark._opacity], [mark._table[key] for key in mark._title], [mark._table[key] for key in mark._hyperlink], ): series_xml = xml.SubElement( mark_xml, "g", attrib={"class": "toyplot-Series"}) for dleft, dright, dboundary1, dboundary2, dfill, dopacity, dtitle, dhyperlink in zip( left[not_null], right[not_null], boundary1[not_null], boundary2[not_null], fill[not_null], opacity[not_null], title[not_null], hyperlink[not_null], ): dstyle = toyplot.style.combine( {"fill": toyplot.color.to_css(dfill), "opacity": dopacity}, mark._style) if dhyperlink: parent_xml = xml.SubElement(series_xml, "a", attrib={"xlink:href": dhyperlink}) else: parent_xml = series_xml datum_xml = xml.SubElement( parent_xml, "rect", attrib={ "class": "toyplot-Datum", axis1: repr(min(dleft, dright)), axis2: repr(min(dboundary1, dboundary2)), distance1: repr(numpy.abs(dleft - dright)), distance2: repr(numpy.abs(dboundary1 - dboundary2)), }, style=_css_style(dstyle), ) if dtitle is not None: xml.SubElement(datum_xml, "title").text = str(dtitle) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.FillBoundaries, RenderContext) def _render(axes, mark, context): boundaries = numpy.ma.column_stack( [mark._table[key] for key in mark._boundaries]) if mark._coordinate_axes.tolist() == ["x", "y"]: position = axes.project("x", mark._table[mark._position[0]]) boundaries = axes.project("y", boundaries) elif mark._coordinate_axes.tolist() == ["y", "x"]: position = axes.project("y", mark._table[mark._position[0]]) boundaries = axes.project("x", boundaries) mark_xml = xml.SubElement( context.parent, "g", style=_css_style( mark._style), id=context.get_id(mark), attrib={ "class": "toyplot-mark-FillBoundaries"}) _render_table(owner=mark, key="data", label="fill data", table=mark._table, filename=mark._filename, context=context) for boundary1, boundary2, fill, opacity, title in zip( boundaries.T[:-1], boundaries.T[1:], mark._fill, mark._opacity, mark._title): not_null = numpy.invert( numpy.logical_or( numpy.ma.getmaskarray(boundary1), numpy.ma.getmaskarray(boundary2))) segments = _flat_contiguous(not_null) series_style = toyplot.style.combine( {"fill": toyplot.color.to_css(fill), "opacity": opacity}, mark._style) for segment in segments: if mark._coordinate_axes[0] == "x": coordinates = zip( numpy.concatenate((position[segment], position[segment][::-1])), numpy.concatenate((boundary1[segment], boundary2[segment][::-1]))) elif mark._coordinate_axes[0] == "y": coordinates = zip( numpy.concatenate((boundary1[segment], boundary2[segment][::-1])), numpy.concatenate((position[segment], position[segment][::-1]))) series_xml = xml.SubElement(mark_xml, "polygon", points=" ".join( ["%r,%r" % (xi, yi) for xi, yi in coordinates]), style=_css_style(series_style)) if title is not None: xml.SubElement(series_xml, "title").text = str(title) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.FillMagnitudes, RenderContext) def _render(axes, mark, context): magnitudes = numpy.ma.column_stack( [mark._table[mark._baseline[0]]] + [mark._table[key] for key in mark._magnitudes]) boundaries = numpy.ma.cumsum(magnitudes, axis=1) not_null = numpy.invert( numpy.ma.any(numpy.ma.getmaskarray(boundaries), axis=1)) segments = _flat_contiguous(not_null) if mark._coordinate_axes.tolist() == ["x", "y"]: position = axes.project("x", mark._table[mark._position[0]]) boundaries = axes.project("y", boundaries) elif mark._coordinate_axes.tolist() == ["y", "x"]: position = axes.project("y", mark._table[mark._position[0]]) boundaries = axes.project("x", boundaries) mark_xml = xml.SubElement( context.parent, "g", style=_css_style( mark._style), id=context.get_id(mark), attrib={ "class": "toyplot-mark-FillMagnitudes"}) _render_table(owner=mark, key="data", label="fill data", table=mark._table, filename=mark._filename, context=context) for boundary1, boundary2, fill, opacity, title in zip( boundaries.T[:-1], boundaries.T[1:], mark._fill, mark._opacity, mark._title): series_style = toyplot.style.combine( {"fill": toyplot.color.to_css(fill), "opacity": opacity}, mark._style) for segment in segments: if mark._coordinate_axes[0] == "x": coordinates = zip( numpy.concatenate((position[segment], position[segment][::-1])), numpy.concatenate((boundary1[segment], boundary2[segment][::-1]))) elif mark._coordinate_axes[0] == "y": coordinates = zip( numpy.concatenate((boundary1[segment], boundary2[segment][::-1])), numpy.concatenate((position[segment], position[segment][::-1]))) series_xml = xml.SubElement(mark_xml, "polygon", points=" ".join( ["%r,%r" % (xi, yi) for xi, yi in coordinates]), style=_css_style(series_style)) if title is not None: xml.SubElement(series_xml, "title").text = str(title) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.AxisLines, RenderContext) def _render(axes, mark, context): if mark._coordinate_axes[0] == "x": p1 = "x1" p2 = "x2" b1 = "y1" b2 = "y2" position = axes.project("x", mark._table[mark._coordinates[0]]) boundary1 = axes._ymin_range boundary2 = axes._ymax_range elif mark._coordinate_axes[0] == "y": p1 = "y1" p2 = "y2" b1 = "x1" b2 = "x2" position = axes.project("y", mark._table[mark._coordinates[0]]) boundary1 = axes._xmin_range boundary2 = axes._xmax_range mark_xml = xml.SubElement( context.parent, "g", style=_css_style( mark._style), id=context.get_id(mark), attrib={ "class": "toyplot-mark-AxisLines"}) series_xml = xml.SubElement( mark_xml, "g", attrib={"class": "toyplot-Series"}) for dposition, dstroke, dopacity, dtitle in zip( position, mark._table[mark._stroke[0]], mark._table[mark._opacity[0]], mark._table[mark._title[0]], ): dstyle = toyplot.style.combine( {"stroke": toyplot.color.to_css(dstroke), "opacity": dopacity}, mark._style) datum_xml = xml.SubElement( series_xml, "line", attrib={ "class": "toyplot-Datum", p1: repr(dposition), p2: repr(dposition), b1: repr(boundary1), b2: repr(boundary2), }, style=_css_style(dstyle), ) if dtitle is not None: xml.SubElement(datum_xml, "title").text = str(dtitle) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.Ellipse, RenderContext) def _render(axes, mark, context): assert(mark._coordinate_axes.tolist() == ["x", "y"]) mark_xml = xml.SubElement( context.parent, "g", style=_css_style( mark._style), id=context.get_id(mark), attrib={ "class": "toyplot-mark-Ellipse"}) _render_table(owner=mark, key="data", label="ellipse data", table=mark._table, filename=mark._filename, context=context) series_xml = xml.SubElement( mark_xml, "g", attrib={"class": "toyplot-Series"}) for dx, dy, drx, dry, dangle, dfill, dopacity, dtitle in zip( mark._table[mark._x[0]], mark._table[mark._y[0]], mark._table[mark._rx[0]], mark._table[mark._ry[0]], mark._table[mark._angle[0]], mark._table[mark._fill[0]], mark._table[mark._opacity[0]], mark._table[mark._title[0]], ): dstyle = toyplot.style.combine( {"fill": toyplot.color.to_css(dfill), "opacity": dopacity}, mark._style) theta = numpy.radians(dangle) u = numpy.array((numpy.cos(theta), numpy.sin(theta))) * drx v = numpy.array((numpy.cos(theta + numpy.pi / 2), numpy.sin(theta + numpy.pi / 2))) * dry mix = numpy.linspace(0, numpy.pi * 2, 100) p = numpy.cos(mix)[:,None] * u + numpy.sin(mix)[:,None] * v x = axes.project("x", dx + p[:,0]) y = axes.project("y", dy + p[:,1]) points = ["%r,%r" % point for point in zip(x, y)] datum_xml = xml.SubElement( series_xml, "polygon", attrib={"class": "toyplot-Datum"}, points=" ".join(points), style=_css_style(dstyle), ) if dtitle is not None: xml.SubElement(datum_xml, "title").text = str(dtitle) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.Graph, RenderContext) def _render(axes, mark, context): # pragma: no cover # Project edge coordinates. for i in range(2): if mark._coordinate_axes[i] == "x": edge_x = axes.project("x", mark._ecoordinates.T[i]) elif mark._coordinate_axes[i] == "y": edge_y = axes.project("y", mark._ecoordinates.T[i]) edge_coordinates = numpy.column_stack((edge_x, edge_y)) # Project vertex coordinates. for i in range(2): if mark._coordinate_axes[i] == "x": vertex_x = axes.project("x", mark._vtable[mark._vcoordinates[i]]) elif mark._coordinate_axes[i] == "y": vertex_y = axes.project("y", mark._vtable[mark._vcoordinates[i]]) # Create final vertex markers. vertex_markers = [] for vmarker, vsize, vcolor, vopacity in zip( mark._vtable[mark._vmarker[0]], mark._vtable[mark._vsize[0]], mark._vtable[mark._vcolor[0]], mark._vtable[mark._vopacity[0]], ): if vmarker: vstyle = toyplot.style.combine( { "fill": toyplot.color.to_css(vcolor), "stroke": toyplot.color.to_css(vcolor), "opacity": vopacity, }, mark._vstyle) vertex_marker = toyplot.marker.create(size=vsize, mstyle=vstyle, lstyle=mark._vlstyle) + toyplot.marker.convert(vmarker) vertex_markers.append(vertex_marker) else: vertex_markers.append(None) # Create final edge styles. edge_styles = [] for ecolor, ewidth, eopacity in zip( mark._etable[mark._ecolor[0]], mark._etable[mark._ewidth[0]], mark._etable[mark._eopacity[0]], ): edge_styles.append( toyplot.style.combine( { "fill": "none", "stroke": toyplot.color.to_css(ecolor), "stroke-width": ewidth, "stroke-opacity": eopacity, }, mark._estyle, ) ) edge_marker_styles = [] for ecolor, estyle in zip( mark._etable[mark._ecolor[0]], edge_styles, ): edge_marker_styles.append(toyplot.style.combine(estyle, {"fill": toyplot.color.to_css(ecolor)})) # Identify ranges of edge coordinates for each edge. index = 0 edge_start = [] edge_end = [] for eshape in mark._etable[mark._eshape[0]]: edge_start.append(index) for segment in eshape: if segment == "M": count = 1 elif segment == "L": count = 1 elif segment == "Q": count = 2 elif segment == "C": count = 3 index += count edge_end.append(index) # Adjust edge coordinates so edges don't overlap vertex markers. for esource, etarget, start, end in zip( mark._etable[mark._esource[0]], mark._etable[mark._etarget[0]], edge_start, edge_end, ): # Skip loop edges. if esource == etarget: continue source_vertex_marker = vertex_markers[esource] target_vertex_marker = vertex_markers[etarget] if source_vertex_marker: dp = source_vertex_marker.intersect(edge_coordinates[start + 1] - edge_coordinates[start]) edge_coordinates[start] += dp if target_vertex_marker: dp = target_vertex_marker.intersect(edge_coordinates[end - 2] - edge_coordinates[end - 1]) edge_coordinates[end - 1] += dp # Render the graph. mark_xml = xml.SubElement(context.parent, "g", id=context.get_id(mark), attrib={"class": "toyplot-mark-Graph"}) _render_table(owner=mark, key="vertex_data", label="graph vertex data", table=mark._vtable, filename=mark._vfilename, context=context) _render_table(owner=mark, key="edge_data", label="graph edge data", table=mark._etable, filename=mark._efilename, context=context) # Render edges. edge_xml = xml.SubElement(mark_xml, "g", attrib={"class": "toyplot-Edges"}) for esource, etarget, eshape, estyle, hmarker, mmarker, mposition, tmarker, start, end in zip( mark._etable[mark._esource[0]], mark._etable[mark._etarget[0]], mark._etable[mark._eshape[0]], edge_styles, mark._etable[mark._hmarker[0]], mark._etable[mark._mmarker[0]], mark._etable[mark._mposition[0]], mark._etable[mark._tmarker[0]], edge_start, edge_end, ): path = [] index = 0 for segment in eshape: if segment == "M": count = 1 elif segment == "L": count = 1 elif segment == "Q": count = 2 elif segment == "C": count = 3 path.append(segment) for _ in range(count): path.append(str(edge_coordinates[start + index][0])) path.append(str(edge_coordinates[start + index][1])) index += 1 xml.SubElement( edge_xml, "path", d=" ".join(path), style=_css_style(estyle), ) # Render edge head markers. marker_xml = xml.SubElement(edge_xml, "g", attrib={"class": "toyplot-HeadMarkers"}) for marker, mstyle, estart, eend in zip( mark._etable[mark._hmarker[0]], edge_marker_styles, edge_start, edge_end, ): if marker: # Create the marker with defaults. marker = toyplot.marker.create(size=10, mstyle=mstyle) + toyplot.marker.convert(marker) # Compute the marker angle using the first edge segment. edge_angle = -numpy.rad2deg(numpy.arctan2( edge_coordinates[estart+1][1] - edge_coordinates[estart][1], edge_coordinates[estart+1][0] - edge_coordinates[estart][0], )) transform = "translate(%r, %r)" % (edge_coordinates[estart][0], edge_coordinates[estart][1]) if edge_angle: transform += " rotate(%r)" % (-edge_angle,) transform += " translate(%r, 0)" % (marker.size / 2,) if marker.angle is not None: if isinstance(marker.angle, str) and marker.angle[0:1] == "r": angle = float(marker.angle[1:]) else: angle = -edge_angle + float(marker.angle) transform += " rotate(%r)" % (-angle,) _draw_marker( marker_xml, marker=marker, transform=transform, ) # Render edge middle markers. marker_xml = xml.SubElement(edge_xml, "g", attrib={"class": "toyplot-MiddleMarkers"}) for mstyle, marker, mposition, start, end in zip( edge_marker_styles, mark._etable[mark._mmarker[0]], mark._etable[mark._mposition[0]], edge_start, edge_end, ): if marker: # Create the marker with defaults. marker = toyplot.marker.create(size=10, mstyle=mstyle) + toyplot.marker.convert(marker) # Place the marker within the first edge segment. x, y = edge_coordinates[start] * (1 - mposition) + edge_coordinates[start+1] * mposition # Compute the marker angle using the first edge segment. angle = -numpy.rad2deg(numpy.arctan2( edge_coordinates[start+1][1] - edge_coordinates[start][1], edge_coordinates[start+1][0] - edge_coordinates[start][0], )) if marker.angle is not None: if isinstance(marker.angle, str) and marker.angle[0:1] == "r": angle += float(marker.angle[1:]) else: angle = float(marker.angle) marker = marker + toyplot.marker.create(angle=angle) _draw_marker( marker_xml, cx=x, cy=y, marker=marker, ) # Render edge tail markers. marker_xml = xml.SubElement(edge_xml, "g", attrib={"class": "toyplot-TailMarkers"}) for mstyle, marker, start, end in zip( edge_marker_styles, mark._etable[mark._tmarker[0]], edge_start, edge_end, ): if marker: # Create the marker with defaults. marker = toyplot.marker.create(size=10, mstyle=mstyle, lstyle={}) + toyplot.marker.convert(marker) # Compute the marker angle using the last edge segment. edge_angle = -numpy.rad2deg(numpy.arctan2( edge_coordinates[end-1][1] - edge_coordinates[end-2][1], edge_coordinates[end-1][0] - edge_coordinates[end-2][0], )) transform = "translate(%r, %r)" % (edge_coordinates[end-1][0], edge_coordinates[end-1][1]) if edge_angle: transform += " rotate(%r)" % (-edge_angle,) transform += " translate(%r, 0)" % (-marker.size / 2,) if marker.angle is not None: if isinstance(marker.angle, str) and marker.angle[0:1] == "r": angle = float(marker.angle[1:]) else: angle = -edge_angle + float(marker.angle) transform += " rotate(%r)" % (-angle,) _draw_marker( marker_xml, marker=marker, transform=transform, ) # Render vertex markers vertex_xml = xml.SubElement(mark_xml, "g", attrib={"class": "toyplot-Vertices"}) for vx, vy, vmarker, vtitle in zip( vertex_x, vertex_y, vertex_markers, mark._vtable[mark._vtitle[0]], ): if vmarker: _draw_marker( vertex_xml, cx=vx, cy=vy, marker=vmarker, extra_class="toyplot-Datum", title=vtitle, ) # Render vertex labels if mark._vlshow: vlabel_xml = xml.SubElement(mark_xml, "g", attrib={"class": "toyplot-Labels"}) for dx, dy, dtext in zip(vertex_x, vertex_y, mark._vtable[mark._vlabel[0]]): _draw_text( root=vlabel_xml, text=str(dtext), x=dx, y=dy, style=mark._vlstyle, attributes={"class": "toyplot-Datum"}, ) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.Plot, RenderContext) def _render(axes, mark, context): position = mark._table[mark._coordinates[0]] series = numpy.ma.column_stack([mark._table[key] for key in mark._series]) if mark._coordinate_axes[0] == "x": position = axes.project("x", position) series = axes.project("y", series) elif mark._coordinate_axes[0] == "y": position = axes.project("y", position) series = axes.project("x", series) mark_xml = xml.SubElement( context.parent, "g", style=_css_style(toyplot.style.combine({"fill":"none"}, mark._style)), id=context.get_id(mark), attrib={ "class": "toyplot-mark-Plot"}) _render_table(owner=mark, key="data", label="plot data", table=mark._table, filename=mark._filename, context=context) for series, stroke, stroke_width, stroke_opacity, stroke_title, marker, msize, mfill, mstroke, mopacity, mtitle in zip( series.T, mark._stroke.T, mark._stroke_width.T, mark._stroke_opacity.T, mark._stroke_title.T, [mark._table[key] for key in mark._marker], [mark._table[key] for key in mark._msize], [mark._table[key] for key in mark._mfill], [mark._table[key] for key in mark._mstroke], [mark._table[key] for key in mark._mopacity], [mark._table[key] for key in mark._mtitle], ): not_null = numpy.invert(numpy.logical_or( numpy.ma.getmaskarray(position), numpy.ma.getmaskarray(series))) segments = _flat_contiguous(not_null) stroke_style = toyplot.style.combine( { "stroke": toyplot.color.to_css(stroke), "stroke-width": stroke_width, "stroke-opacity": stroke_opacity}, mark._style) if mark._coordinate_axes[0] == "x": x = position y = series elif mark._coordinate_axes[0] == "y": x = series y = position series_xml = xml.SubElement( mark_xml, "g", attrib={"class": "toyplot-Series"}) if stroke_title is not None: xml.SubElement(series_xml, "title").text = str(stroke_title) d = [] for segment in segments: start, stop, step = segment.indices(len(not_null)) for i in range(start, start + 1): d.append("M %r %r" % (x[i], y[i])) for i in range(start + 1, stop): d.append("L %r %r" % (x[i], y[i])) xml.SubElement( series_xml, "path", d=" ".join(d), style=_css_style(stroke_style)) for dx, dy, dmarker, dsize, dfill, dstroke, dopacity, dtitle in zip( x[not_null], y[not_null], marker[not_null], msize[not_null], mfill[not_null], mstroke[not_null], mopacity[not_null], mtitle[not_null], ): if dmarker: dstyle = toyplot.style.combine( { "fill": toyplot.color.to_css(dfill), "stroke": toyplot.color.to_css(dstroke), "opacity": dopacity}, mark._mstyle) _draw_marker( series_xml, cx=dx, cy=dy, marker=toyplot.marker.create(size=dsize, mstyle=dstyle, lstyle=mark._mlstyle) + toyplot.marker.convert(dmarker), extra_class="toyplot-Datum", title=dtitle, ) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.Range, RenderContext) def _render(axes, mark, context): if mark._coordinate_axes[0] == "x": x1 = axes.project("x", mark._table[mark._coordinates[0]]) x2 = axes.project("x", mark._table[mark._coordinates[1]]) y1 = axes.project("y", mark._table[mark._coordinates[2]]) y2 = axes.project("y", mark._table[mark._coordinates[3]]) elif mark._coordinate_axes[0] == "y": x1 = axes.project("x", mark._table[mark._coordinates[2]]) x2 = axes.project("x", mark._table[mark._coordinates[3]]) y1 = axes.project("y", mark._table[mark._coordinates[0]]) y2 = axes.project("y", mark._table[mark._coordinates[1]]) mark_xml = xml.SubElement(context.parent, "g", style=_css_style(mark._style), id=context.get_id(mark), attrib={"class": "toyplot-mark-Range"}) _render_table(owner=mark, key="data", label="rect data", table=mark._table, filename=mark._filename, context=context) series_xml = xml.SubElement( mark_xml, "g", attrib={"class": "toyplot-Series"}) for dx1, dx2, dy1, dy2, dfill, dopacity, dtitle in zip( x1, x2, y1, y2, mark._table[mark._fill[0]], mark._table[mark._opacity[0]], mark._table[mark._title[0]], ): dstyle = toyplot.style.combine({"fill": toyplot.color.to_css(dfill), "opacity": dopacity}, mark._style) datum_xml = xml.SubElement( series_xml, "rect", attrib={"class": "toyplot-Datum"}, x=repr(min(dx1, dx2)), y=repr(min(dy1, dy2)), width=repr(numpy.abs(dx1 - dx2)), height=repr(numpy.abs(dy1 - dy2)), style=_css_style(dstyle), ) if dtitle is not None: xml.SubElement(datum_xml, "title").text = str(dtitle) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.Point, RenderContext) def _render(axes, mark, context): dimension1 = numpy.ma.column_stack([mark._table[key] for key in mark._coordinates[0::2]]) dimension2 = numpy.ma.column_stack([mark._table[key] for key in mark._coordinates[1::2]]) if mark._coordinate_axes[0] == "x": X = axes.project("x", dimension1) Y = axes.project("y", dimension2) elif mark._coordinate_axes[0] == "y": X = axes.project("x", dimension2) Y = axes.project("y", dimension1) mark_xml = xml.SubElement( context.parent, "g", id=context.get_id(mark), attrib={"class": "toyplot-mark-Point"}, ) _render_table(owner=mark, key="data", label="point", table=mark._table, filename=mark._filename, context=context) for x, y, marker, msize, mfill, mstroke, mopacity, mtitle, mhyperlink in zip( X.T, Y.T, [mark._table[key] for key in mark._marker], [mark._table[key] for key in mark._msize], [mark._table[key] for key in mark._mfill], [mark._table[key] for key in mark._mstroke], [mark._table[key] for key in mark._mopacity], [mark._table[key] for key in mark._mtitle], [mark._table[key] for key in mark._mhyperlink], ): not_null = numpy.invert(numpy.logical_or( numpy.ma.getmaskarray(x), numpy.ma.getmaskarray(y))) series_xml = xml.SubElement( mark_xml, "g", attrib={"class": "toyplot-Series"}) for dx, dy, dmarker, dsize, dfill, dstroke, dopacity, dtitle, dhyperlink in zip( x[not_null], y[not_null], marker[not_null], msize[not_null], mfill[not_null], mstroke[not_null], mopacity[not_null], mtitle[not_null], mhyperlink[not_null], ): if dmarker: if dhyperlink: datum_xml = xml.SubElement(series_xml, "a", attrib={"xlink:href": dhyperlink}) else: datum_xml = series_xml dstyle = toyplot.style.combine( { "fill": toyplot.color.to_css(dfill), "stroke": toyplot.color.to_css(dstroke), "opacity": dopacity, }, mark._mstyle) _draw_marker( datum_xml, cx=dx, cy=dy, marker=toyplot.marker.create(size=dsize, mstyle=dstyle, lstyle=mark._mlstyle) + toyplot.marker.convert(dmarker), extra_class="toyplot-Datum", title=dtitle, ) @dispatch(toyplot.mark.Text, RenderContext) def _render(mark, context): x = mark._table[mark._coordinates[numpy.where(mark._coordinate_axes == "x")[0][0]]] y = mark._table[mark._coordinates[numpy.where(mark._coordinate_axes == "y")[0][0]]] # if isinstance(parent, toyplot.coordinates.Cartesian): # x = parent.project("x", x) # y = parent.project("y", y) mark_xml = xml.SubElement( context.parent, "g", id=context.get_id(mark), attrib={"class": "toyplot-mark-Text"}, ) _render_table(owner=mark, key="data", label="text data", table=mark._table, filename=mark._filename, context=context) series_xml = xml.SubElement( mark_xml, "g", attrib={"class": "toyplot-Series"}) for dx, dy, dtext, dangle, dfill, dopacity, dtitle in zip( x, y, mark._table[mark._text[0]], mark._table[mark._angle[0]], mark._table[mark._fill[0]], mark._table[mark._opacity[0]], mark._table[mark._title[0]], ): _draw_text( root=series_xml, text=str(dtext), x=dx, y=dy, angle=dangle, attributes={"class": "toyplot-Datum"}, style=toyplot.style.combine({"fill": toyplot.color.to_css(dfill), "opacity": dopacity}, mark._style), title=dtitle, ) @dispatch(toyplot.coordinates.Cartesian, toyplot.mark.Text, RenderContext) def _render(axes, mark, context): x = mark._table[mark._coordinates[numpy.where(mark._coordinate_axes == "x")[0][0]]] y = mark._table[mark._coordinates[numpy.where(mark._coordinate_axes == "y")[0][0]]] x = axes.project("x", x) y = axes.project("y", y) mark_xml = xml.SubElement( context.parent, "g", id=context.get_id(mark), attrib={"class": "toyplot-mark-Text"}, ) _render_table(owner=mark, key="data", label="text data", table=mark._table, filename=mark._filename, context=context) series_xml = xml.SubElement( mark_xml, "g", attrib={"class": "toyplot-Series"}) for dx, dy, dtext, dangle, dfill, dopacity, dtitle in zip( x, y, mark._table[mark._text[0]], mark._table[mark._angle[0]], mark._table[mark._fill[0]], mark._table[mark._opacity[0]], mark._table[mark._title[0]], ): _draw_text( root=series_xml, text=str(dtext), x=dx, y=dy, angle=dangle, attributes={"class": "toyplot-Datum"}, style=toyplot.style.combine({"fill": toyplot.color.to_css(dfill), "opacity": dopacity}, mark._style), title=dtitle, ) @dispatch(toyplot.mark.Image, RenderContext) def _render(mark, context): mark_xml = xml.SubElement( context.parent, "g", id=context.get_id(mark), attrib={"class": "toyplot-mark-Image"}, ) xml.SubElement( mark_xml, "image", x=repr(mark._xmin_range), y=repr(mark._ymin_range), width=repr(mark._xmax_range - mark._xmin_range), height=repr(mark._ymax_range - mark._ymin_range), attrib={"xlink:href": toyplot.bitmap.to_png_data_uri(mark._data)}, )