9912662049

Committed 12 Jul 2024 06:45PM UTC coverage: 94.497% (-0.1%) from 94.629%

Build # 9912662049

Build Type

Pull #214

github

Committed by

web-flow

Commit Message

Merge cce091bb5 into 93ab5d60c

Pull Request Pull Request #214: add as_float, change repr(x) -> str(x)

Run Details

70 of 87 new or added lines in 10 files covered. (80.46%)

31 existing lines in 2 files now uncovered.

5409 of 5724 relevant lines covered (94.5%)

8.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.2

/toyplot/html.py

# 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
from toyplot.require import as_float

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 o.item()
        if isinstance(o, xml.Element):
            return xml.tostring(o, encoding="unicode", method="html")
        return json.JSONEncoder.default(self, o)


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

    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

    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]

    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

    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)

    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


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)


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


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 = as_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 = as_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(%s,%s)" % (x, y)
    if angle:
        transform += "rotate(%s)" % (-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=str(-size / 2),
        y2=str(size / 2),
        )
    if angle:
        markup.set("transform", "rotate(%s)" % (-angle,))


def _draw_rect(parent_xml, size, width=1, height=1, angle=0):
    markup = xml.SubElement(
        parent_xml,
        "rect",
        x=str(-size / 2 * width),
        y=str(-size / 2 * height),
        width=str(size * width),
        height=str(size * height),
        )
    if angle:
        markup.set("transform", "rotate(%s)" % (-angle,))


def _draw_triangle(parent_xml, size, angle=0):
    markup = xml.SubElement(
        parent_xml,
        "polygon",
        points=" ".join(["%s,%s" % (xp, yp) for xp, yp in [
           (-size / 2, size / 2),
           (0, -size / 2),
           (size / 2, size / 2),
           ]]),
        )
    if angle:
        markup.set("transform", "rotate(%s)" % (-angle,))


def _draw_circle(parent_xml, size):
    xml.SubElement(
        parent_xml,
        "circle",
        r=str(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(%s, %s)" % (cx, cy)
        if marker.angle:
            transform += " rotate(%s)" % (-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=as_float(width), height=as_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": "%spx" % (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="%spx" % canvas.width,
        height="%spx" % canvas.height,
        viewBox="0 0 %s %s" % (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))


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.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=str(x1),
            y1=str(0),
            x2=str(x2),
            y2=str(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=str(x),
                    y1=str(y1),
                    x2=str(x),
                    y2=str(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=str(y1),
                y2=str(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=str(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=str(0),
        y=str(-height),
        width=str(length),
        height=str(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=str(x1),
            y=str(-width * 0.5),
            width=str(x2 - x1),
            height=str(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=str(colormap_range_min),
        y=str(-width * 0.5),
        width=str(colormap_range_max - colormap_range_min),
        height=str(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=str(colormap_range_min),
        x2=str(colormap_range_max),
        y1=str(0),
        y2=str(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=str(colormap_range_min),
        y=str(-width * 0.5),
        width=str(colormap_range_max - colormap_range_min),
        height=str(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=str(min(dx1, dx2)),
            y=str(-width * 0.5),
            width=str(numpy.abs(dx1 - dx2)),
            height=str(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=str(axes._xmin_range - axes.padding),
        y=str(axes._ymin_range - axes.padding),
        width=str(axes._xmax_range - axes._xmin_range + axes.padding * 2),
        height=str(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=str(axes._xmin_range),
            y=str(axes._ymin_range),
            width=str(axes._xmax_range - axes._xmin_range),
            height=str(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=str(cell_left),
                y=str(cell_top),
                width=str(cell_right - cell_left),
                height=str(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=str(column_boundaries[start]),
                    y1=str(y),
                    x2=str(column_boundaries[end]),
                    y2=str(y),
                    style=_css_style(axes._gstyle),
                    )
            elif line_type == "double":
                xml.SubElement(
                    axes_xml,
                    "line",
                    x1=str(
                        column_boundaries[start]),
                    y1=str(
                        y - separation),
                    x2=str(
                        column_boundaries[end]),
                    y2=str(
                        y - separation),
                    style=_css_style(
                        axes._gstyle))
                xml.SubElement(
                    axes_xml,
                    "line",
                    x1=str(
                        column_boundaries[start]),
                    y1=str(
                        y + separation),
                    x2=str(
                        column_boundaries[end]),
                    y2=str(
                        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=str(x),
                    y1=str(row_boundaries[start]),
                    x2=str(x),
                    y2=str(row_boundaries[end]),
                    style=_css_style(axes._gstyle),
                    )
            elif line_type == "double":
                xml.SubElement(
                    axes_xml,
                    "line",
                    x1=str(x - separation),
                    y1=str(row_boundaries[start]),
                    x2=str(x - separation),
                    y2=str(row_boundaries[end]),
                    style=_css_style(axes._gstyle),
                    )
                xml.SubElement(
                    axes_xml,
                    "line",
                    x1=str(x + separation),
                    y1=str(row_boundaries[start]),
                    x2=str(x + separation),
                    y2=str(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: str(min(dleft, dright)),
                    axis2: str(min(dboundary1, dboundary2)),
                    distance1: str(numpy.abs(dleft - dright)),
                    distance2: str(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: str(min(dleft, dright)),
                    axis2: str(min(dboundary1, dboundary2)),
                    distance1: str(numpy.abs(dleft - dright)),
                    distance2: str(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(
                ["%s,%s" % (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(
                ["%s,%s" % (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: str(dposition),
                p2: str(dposition),
                b1: str(boundary1),
                b2: str(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 = ["%s,%s" % 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(%s, %s)" % (edge_coordinates[estart][0], edge_coordinates[estart][1])
            if edge_angle:
                transform += " rotate(%s)" % (-edge_angle,)
            transform += " translate(%s, 0)" % (marker.size / 2,)
            if marker.angle is not None:
                if isinstance(marker.angle, str) and marker.angle[0:1] == "r":
                    angle = as_float(marker.angle[1:])
                else:
                    angle = -edge_angle + as_float(marker.angle)
                transform += " rotate(%s)" % (-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 += as_float(marker.angle[1:])
                else:
                    angle = as_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(%s, %s)" % (edge_coordinates[end-1][0], edge_coordinates[end-1][1])
            if edge_angle:
                transform += " rotate(%s)" % (-edge_angle,)
            transform += " translate(%s, 0)" % (-marker.size / 2,)
            if marker.angle is not None:
                if isinstance(marker.angle, str) and marker.angle[0:1] == "r":
                    angle = as_float(marker.angle[1:])
                else:
                    angle = -edge_angle + as_float(marker.angle)
                transform += " rotate(%s)" % (-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 %s %s" % (x[i], y[i]))
            for i in range(start + 1, stop):
                d.append("L %s %s" % (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=str(min(dx1, dx2)),
            y=str(min(dy1, dy2)),
            width=str(numpy.abs(dx1 - dx2)),
            height=str(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=str(mark._xmin_range),
        y=str(mark._ymin_range),
        width=str(mark._xmax_range - mark._xmin_range),
        height=str(mark._ymax_range - mark._ymin_range),
        attrib={"xlink:href": toyplot.bitmap.to_png_data_uri(mark._data)},
        )

sandialabs / toyplot / 9912662049

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous