"""
This is a matplotlib backend to save in the Ipe file format.
(ipe7.sourceforge.net).
(c) 2014 Soyeon Baek, Otfried Cheong
You can find the most current version at:
http://www.github.com/otfried/ipe-tools/matplotlib
You can use this backend by saving it anywhere on your PYTHONPATH.
Use it as an external backend from matplotlib like this:
import matplotlib
matplotlib.use('module://backend_ipe')
"""
# --------------------------------------------------------------------
from __future__ import division, print_function, unicode_literals
import os, base64, tempfile, urllib, gzip, io, sys, codecs, re
from six import string_types
import matplotlib
from matplotlib import rcParams
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_bases import RendererBase, GraphicsContextBase
from matplotlib.backend_bases import FigureManagerBase, FigureCanvasBase
from matplotlib.figure import Figure
from matplotlib.transforms import Bbox
from matplotlib.cbook import is_writable_file_like, maxdict
from matplotlib.path import Path
from xml.sax.saxutils import escape as escape_xml_text
from math import sin, cos, radians
from matplotlib.backends.backend_pgf import LatexManagerFactory, \
LatexManager, common_texification
import atexit
from matplotlib.rcsetup import validate_bool, validate_path_exists
negative_number = re.compile(u"^\u2212([0-9]+)(\.[0-9]*)?$")
rcParams.validate['ipe.textsize'] = validate_bool
rcParams.validate['ipe.stylesheet'] = validate_path_exists
rcParams.validate['ipe.preamble'] = lambda s : s
# ----------------------------------------------------------------------
# SimpleXMLWriter class
#
# Based on an original by Fredrik Lundh, but modified here to:
# 1. Support modern Python idioms
# 2. Remove encoding support (it's handled by the file writer instead)
# 3. Support proper indentation
# 4. Minify things a little bit
# --------------------------------------------------------------------
# The SimpleXMLWriter module is
#
# Copyright (c) 2001-2004 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------
def escape_cdata(s):
s = s.replace(u"&", u"&")
s = s.replace(u"<", u"<")
s = s.replace(u">", u">")
return s
def escape_attrib(s):
s = s.replace(u"&", u"&")
s = s.replace(u"'", u"'")
s = s.replace(u"\"", u""")
s = s.replace(u"<", u"<")
s = s.replace(u">", u">")
return s
##
# XML writer class.
#
# @param file A file or file-like object. This object must implement
# a write method that takes an 8-bit string.
class XMLWriter:
def __init__(self, file):
self.__write = file.write
if hasattr(file, "flush"):
self.flush = file.flush
self.__open = 0 # true if start tag is open
self.__tags = []
self.__data = []
self.__indentation = u" " * 64
def __flush(self, indent=True):
# flush internal buffers
if self.__open:
if indent:
self.__write(u">\n")
else:
self.__write(u">")
self.__open = 0
if self.__data:
data = u''.join(self.__data)
self.__write(escape_cdata(data))
self.__data = []
## Opens a new element. Attributes can be given as keyword
# arguments, or as a string/string dictionary. The method returns
# an opaque identifier that can be passed to the close
# method, to close all open elements up to and including this one.
#
# @param tag Element tag.
# @param attrib Attribute dictionary. Alternatively, attributes
# can be given as keyword arguments.
# @return An element identifier.
def start(self, tag, attrib={}, **extra):
self.__flush()
tag = escape_cdata(tag)
self.__data = []
self.__tags.append(tag)
self.__write(self.__indentation[:len(self.__tags) - 1])
self.__write(u"<%s" % tag)
if attrib or extra:
attrib = attrib.copy()
attrib.update(extra)
attrib = sorted(attrib.items())
for k, v in attrib:
if not v == '':
k = escape_cdata(k)
v = escape_attrib(v)
self.__write(u" %s=\"%s\"" % (k, v))
self.__open = 1
return len(self.__tags)-1
##
# Adds a comment to the output stream.
#
# @param comment Comment text, as a Unicode string.
def comment(self, comment):
self.__flush()
self.__write(self.__indentation[:len(self.__tags)])
self.__write(u"\n" % escape_cdata(comment))
##
# Adds character data to the output stream.
#
# @param text Character data, as a Unicode string.
def data(self, text):
self.__data.append(text)
##
# Closes the current element (opened by the most recent call to
# start).
#
# @param tag Element tag. If given, the tag must match the start
# tag. If omitted, the current element is closed.
def end(self, tag=None, indent=True):
if tag:
assert self.__tags, "unbalanced end(%s)" % tag
assert escape_cdata(tag) == self.__tags[-1],\
"expected end(%s), got %s" % (self.__tags[-1], tag)
else:
assert self.__tags, "unbalanced end()"
tag = self.__tags.pop()
if self.__data:
self.__flush(indent)
elif self.__open:
self.__open = 0
self.__write(u"/>\n")
return
if indent:
self.__write(self.__indentation[:len(self.__tags)])
self.__write(u"\n" % tag)
##
# Closes open elements, up to (and including) the element identified
# by the given identifier.
#
# @param id Element identifier, as returned by the start method.
def close(self, id):
while len(self.__tags) > id:
self.end()
##
# Adds an entire element. This is the same as calling start,
# data, and end in sequence. The text argument
# can be omitted.
def element(self, tag, text=None, attrib={}, **extra):
self.start(*(tag, attrib), **extra)
if text:
self.data(text)
self.end(indent=False)
def insertSheet(self, fname):
self.__flush()
data = open(fname, "rb").read()
i = data.find("= 0:
self.__write(data[i:].decode("utf-8"))
# ----------------------------------------------------------------------
class RendererIpe(RendererBase):
"""
The renderer handles drawing/rendering operations.
Refer to backend_bases.RendererBase for documentation of
the classes methods.
"""
def __init__(self, width, height, ipewriter, basename):
self.width = width
self.height = height
self.writer = XMLWriter(ipewriter)
self.basename = basename
RendererBase.__init__(self)
# use same latex as Ipe (default is xelatex)
rcParams['pgf.texsystem'] = "pdflatex"
self.latexManager = None
if rcParams.get("ipe.textsize", False):
self.latexManager = LatexManagerFactory.get_latex_manager()
self._start_id = self.writer.start(
u'ipe',
version=u"70005",
creator="matplotlib")
pre = rcParams.get('ipe.preamble', "")
if pre != "":
self.writer.start(u'preamble')
self.writer.data(pre)
self.writer.end(indent=False)
sheet = rcParams.get('ipe.stylesheet', "")
if sheet != "":
self.writer.insertSheet(sheet)
self.writer.start(u'ipestyle', name=u"opacity")
for i in range(10,100,10):
self.writer.element(u'opacity', name=u'%02d%%'% i,
value=u'%g'% (i/100.0))
self.writer.end()
self.writer.start(u'page')
def finalize(self):
self.writer.close(self._start_id)
self.writer.flush()
def draw_path(self, gc, path, transform, rgbFace=None):
capnames = ('butt', 'round', 'projecting')
cap = capnames.index(gc.get_capstyle())
joinnames = ('miter', 'round', 'bevel')
join = joinnames.index(gc.get_joinstyle())
# filling
has_fill = rgbFace is not None
offs, dl = gc.get_dashes()
attrib = {}
if offs != None and dl != None:
if type(dl) == float:
dashes = "[%g] %g" % (dl, offs)
else:
dashes = "[" + " ".join(["%g" % x for x in dl]) + "] %g" % offs
attrib['dash'] = dashes
if has_fill:
attrib['fill'] = "%g %g %g" % tuple(rgbFace)[:3]
opaq = gc.get_rgb()[3]
if rgbFace is not None and len(rgbFace) > 3:
opaq = rgbFace[3]
self.gen_opacity(attrib, opaq)
self._print_ipe_clip(gc)
self.writer.start(
u'path',
attrib=attrib,
stroke="%g %g %g" % gc.get_rgb()[:3],
pen="%g" % gc.get_linewidth(),
cap="%d" % cap,
join="%d" % join,
fillrule="wind"
)
self.writer.data(self._make_ipe_path(gc, path, transform))
self.writer.end()
self._print_ipe_clip_end()
def draw_image(self, gc, x, y, im, dx=None, dy=None, transform=None):
h,w = im.get_size_out()
if dx is not None:
w = dx
if dy is not None:
h = dy
rows, cols, buffer = im.as_rgba_str()
self._print_ipe_clip(gc)
self.writer.start(
u'image',
width=u"%d" % cols,
height=u"%d" % rows,
ColorSpace=u"DeviceRGB",
BitsPerComponent=u"8",
matrix=u"1 0 0 -1 %g %g" % (x, y),
rect="%g %g %g %g" % (0, -h, w, 0)
)
for i in xrange(rows * cols):
rgb = buffer[4*i:4*i+3]
self.writer.data(u"%02x%02x%02x" % (ord(rgb[0]), ord(rgb[1]),
ord(rgb[2])))
self.writer.end()
self._print_ipe_clip_end()
def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
if negative_number.match(s):
s = u"$" + s.replace(u'\u2212', u'-') + "$"
attrib = {}
if mtext:
# if text anchoring can be supported, get the original coordinates
# and add alignment information
x, y = mtext.get_transform().transform_point(mtext.get_position())
attrib['halign'] = mtext.get_ha()
attrib['valign'] = mtext.get_va()
if angle != 0.0:
ra = radians(angle)
sa = sin(ra); ca = cos(ra)
attrib['matrix'] = "%g %g %g %g %g %g" % (ca, sa, -sa, ca, x, y)
x, y = 0, 0
self.gen_opacity(attrib, gc.get_rgb()[3])
self.writer.start(
u'text',
stroke="%g %g %g" % gc.get_rgb()[:3],
type="label",
size="%g" % prop.get_size_in_points(),
pos="%g %g" % (x,y),
attrib=attrib
)
s = common_texification(s)
self.writer.data(u"%s" % s)
self.writer.end(indent=False)
def _make_ipe_path(self, gc, path, transform):
elem = ""
for points, code in path.iter_segments(transform):
if code == Path.MOVETO:
x, y = tuple(points)
elem += "%g %g m\n" % (x, y)
elif code == Path.CLOSEPOLY:
elem += "h\n"
elif code == Path.LINETO:
x, y = tuple(points)
elem += "%g %g l\n" % (x, y)
elif code == Path.CURVE3:
cx, cy, px, py = tuple(points)
elem += "%g %g %g %g q\n" % (cx, cy, px, py)
elif code == Path.CURVE4:
c1x, c1y, c2x, c2y, px, py = tuple(points)
elem += ("%g %g %g %g %g %g c\n" %
(c1x, c1y, c2x, c2y, px, py))
return elem
def _print_ipe_clip(self, gc):
bbox = gc.get_clip_rectangle()
self.use_clip_box = bbox is not None
if self.use_clip_box:
p1, p2 = bbox.get_points()
x1, y1 = p1
x2, y2 = p2
self.writer.start(
u'group',
clip=u"%g %g m %g %g l %g %g l %g %g l h" %
(x1, y1, x2, y1, x2, y2, x1, y2)
)
# check for clip path
clippath, clippath_trans = gc.get_clip_path()
self.use_clip_group = clippath is not None
if self.use_clip_group:
self.writer.start(
u'group',
clip=u"%s" % self._make_ipe_path(gc, clippath, clippath_trans)
)
def _print_ipe_clip_end(self):
if self.use_clip_group:
self.writer.end()
if self.use_clip_box:
self.writer.end()
def flipy(self):
return True
def get_canvas_width_height(self):
return self.width, self.height
def get_text_width_height_descent(self, s, prop, ismath):
if self.latexManager:
s = common_texification(s)
w, h, d = self.latexManager.get_width_height_descent(s, prop)
return w, h, d
else:
return 1, 1, 1
def new_gc(self):
return GraphicsContextIpe()
def points_to_pixels(self, points):
return points
def gen_opacity(self, attrib, opaq):
if opaq > 0.99: return
opaq += 0.05
o = int(opaq * 10) * 10
if o > 90: o = 90
if o < 10: o = 10
attrib["opacity"] = u"%02d%%" % o
# --------------------------------------------------------------------
class GraphicsContextIpe(GraphicsContextBase):
pass
# --------------------------------------------------------------------
class FigureCanvasIpe(FigureCanvasBase):
filetypes = FigureCanvasBase.filetypes.copy()
filetypes['ipe'] = 'Ipe 7 file format'
def print_ipe(self, filename, *args, **kwargs):
if isinstance(filename, string_types):
fh_to_close = ipewriter = io.open(filename, 'w', encoding='utf-8')
elif is_writable_file_like(filename):
if not isinstance(filename, io.TextIOBase):
if sys.version_info[0] >= 3:
ipewriter = io.TextIOWrapper(filename, 'utf-8')
else:
ipewriter = codecs.getwriter('utf-8')(filename)
else:
ipewriter = filename
fh_to_close = None
else:
raise ValueError("filename must be a path or a file-like object")
return self._print_ipe(filename, ipewriter, fh_to_close, **kwargs)
def _print_ipe(self, filename, ipewriter, fh_to_close=None, **kwargs):
try:
self.figure.set_dpi(72.0)
width, height = self.figure.get_size_inches()
w, h = width*72, height*72
renderer = RendererIpe(w, h, ipewriter, filename)
self.figure.draw(renderer)
renderer.finalize()
finally:
if fh_to_close is not None:
ipewriter.close()
def get_default_filetype(self):
return 'ipe'
# --------------------------------------------------------------------
# Provide the standard names that backend.__init__ is expecting
class FigureManagerIpe(FigureManagerBase):
def __init__(self, *args):
FigureManagerBase.__init__(self, *args)
FigureCanvas = FigureCanvasIpe
FigureManager = FigureManagerIpe
def new_figure_manager(num, *args, **kwargs):
FigureClass = kwargs.pop('FigureClass', Figure)
thisFig = FigureClass(*args, **kwargs)
return new_figure_manager_given_figure(num, thisFig)
def new_figure_manager_given_figure(num, figure):
"""
Create a new figure manager instance for the given figure.
"""
canvas = FigureCanvasIpe(figure)
manager = FigureManagerIpe(canvas, num)
return manager
# --------------------------------------------------------------------
def _cleanup():
LatexManager._cleanup_remaining_instances()
# This is necessary to avoid a spurious error
# caused by the atexit at the end of the PGF backend
LatexManager.__del__ = lambda self : None
atexit.register(_cleanup)
# --------------------------------------------------------------------