mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-12-23 07:37:55 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
5b2271c6fb
opencv/doc/pattern_tools/svgfig.py

3669 lines
148 KiB
Python
Raw Blame History

# svgfig.py copyright (C) 2008 Jim Pivarski <jpivarski@gmail.com>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#
# Full licence is in the file COPYING and at http://www.gnu.org/copyleft/gpl.html
import re, codecs, os, platform, copy, itertools, math, cmath, random, sys, copy
_epsilon = 1e-5
if re.search("windows", platform.system(), re.I):
try:
import _winreg
_default_directory = _winreg.QueryValueEx(_winreg.OpenKey(_winreg.HKEY_CURRENT_USER,
r"Software\Microsoft\Windows\Current Version\Explorer\Shell Folders"), "Desktop")[0]
# tmpdir = _winreg.QueryValueEx(_winreg.OpenKey(_winreg.HKEY_CURRENT_USER, "Environment"), "TEMP")[0]
# if tmpdir[0:13] != "%USERPROFILE%":
# tmpdir = os.path.expanduser("~") + tmpdir[13:]
except:
_default_directory = os.path.expanduser("~") + os.sep + "Desktop"
_default_fileName = "tmp.svg"
_hacks = {}
_hacks["inkscape-text-vertical-shift"] = False
def rgb(r, g, b, maximum=1.):
"""Create an SVG color string "#xxyyzz" from r, g, and b.
r,g,b = 0 is black and r,g,b = maximum is white.
"""
return "#%02x%02x%02x" % (max(0, min(r*255./maximum, 255)),
max(0, min(g*255./maximum, 255)),
max(0, min(b*255./maximum, 255)))
def attr_preprocess(attr):
for name in attr.keys():
name_colon = re.sub("__", ":", name)
if name_colon != name:
attr[name_colon] = attr[name]
del attr[name]
name = name_colon
name_dash = re.sub("_", "-", name)
if name_dash != name:
attr[name_dash] = attr[name]
del attr[name]
name = name_dash
return attr
class SVG:
"""A tree representation of an SVG image or image fragment.
SVG(t, sub, sub, sub..., attribute=value)
t required SVG type name
sub optional list nested SVG elements or text/Unicode
attribute=value pairs optional keywords SVG attributes
In attribute names, "__" becomes ":" and "_" becomes "-".
SVG in XML
<g id="mygroup" fill="blue">
<rect x="1" y="1" width="2" height="2" />
<rect x="3" y="3" width="2" height="2" />
</g>
SVG in Python
>>> svg = SVG("g", SVG("rect", x=1, y=1, width=2, height=2), \
... SVG("rect", x=3, y=3, width=2, height=2), \
... id="mygroup", fill="blue")
Sub-elements and attributes may be accessed through tree-indexing:
>>> svg = SVG("text", SVG("tspan", "hello there"), stroke="none", fill="black")
>>> svg[0]
<tspan (1 sub) />
>>> svg[0, 0]
'hello there'
>>> svg["fill"]
'black'
Iteration is depth-first:
>>> svg = SVG("g", SVG("g", SVG("line", x1=0, y1=0, x2=1, y2=1)), \
... SVG("text", SVG("tspan", "hello again")))
...
>>> for ti, s in svg:
... print ti, repr(s)
...
(0,) <g (1 sub) />
(0, 0) <line x2=1 y1=0 x1=0 y2=1 />
(0, 0, 'x2') 1
(0, 0, 'y1') 0
(0, 0, 'x1') 0
(0, 0, 'y2') 1
(1,) <text (1 sub) />
(1, 0) <tspan (1 sub) />
(1, 0, 0) 'hello again'
Use "print" to navigate:
>>> print svg
None <g (2 sub) />
[0] <g (1 sub) />
[0, 0] <line x2=1 y1=0 x1=0 y2=1 />
[1] <text (1 sub) />
[1, 0] <tspan (1 sub) />
"""
def __init__(self, *t_sub, **attr):
if len(t_sub) == 0:
raise TypeError, "SVG element must have a t (SVG type)"
# first argument is t (SVG type)
self.t = t_sub[0]
# the rest are sub-elements
self.sub = list(t_sub[1:])
# keyword arguments are attributes
# need to preprocess to handle differences between SVG and Python syntax
self.attr = attr_preprocess(attr)
def __getitem__(self, ti):
"""Index is a list that descends tree, returning a sub-element if
it ends with a number and an attribute if it ends with a string."""
obj = self
if isinstance(ti, (list, tuple)):
for i in ti[:-1]:
obj = obj[i]
ti = ti[-1]
if isinstance(ti, (int, long, slice)):
return obj.sub[ti]
else:
return obj.attr[ti]
def __setitem__(self, ti, value):
"""Index is a list that descends tree, returning a sub-element if
it ends with a number and an attribute if it ends with a string."""
obj = self
if isinstance(ti, (list, tuple)):
for i in ti[:-1]:
obj = obj[i]
ti = ti[-1]
if isinstance(ti, (int, long, slice)):
obj.sub[ti] = value
else:
obj.attr[ti] = value
def __delitem__(self, ti):
"""Index is a list that descends tree, returning a sub-element if
it ends with a number and an attribute if it ends with a string."""
obj = self
if isinstance(ti, (list, tuple)):
for i in ti[:-1]:
obj = obj[i]
ti = ti[-1]
if isinstance(ti, (int, long, slice)):
del obj.sub[ti]
else:
del obj.attr[ti]
def __contains__(self, value):
"""x in svg == True iff x is an attribute in svg."""
return value in self.attr
def __eq__(self, other):
"""x == y iff x represents the same SVG as y."""
if id(self) == id(other):
return True
return (isinstance(other, SVG) and
self.t == other.t and self.sub == other.sub and self.attr == other.attr)
def __ne__(self, other):
"""x != y iff x does not represent the same SVG as y."""
return not (self == other)
def append(self, x):
"""Appends x to the list of sub-elements (drawn last, overlaps
other primitives)."""
self.sub.append(x)
def prepend(self, x):
"""Prepends x to the list of sub-elements (drawn first may be
overlapped by other primitives)."""
self.sub[0:0] = [x]
def extend(self, x):
"""Extends list of sub-elements by a list x."""
self.sub.extend(x)
def clone(self, shallow=False):
"""Deep copy of SVG tree. Set shallow=True for a shallow copy."""
if shallow:
return copy.copy(self)
else:
return copy.deepcopy(self)
### nested class
class SVGDepthIterator:
"""Manages SVG iteration."""
def __init__(self, svg, ti, depth_limit):
self.svg = svg
self.ti = ti
self.shown = False
self.depth_limit = depth_limit
def __iter__(self):
return self
def next(self):
if not self.shown:
self.shown = True
if self.ti != ():
return self.ti, self.svg
if not isinstance(self.svg, SVG):
raise StopIteration
if self.depth_limit is not None and len(self.ti) >= self.depth_limit:
raise StopIteration
if "iterators" not in self.__dict__:
self.iterators = []
for i, s in enumerate(self.svg.sub):
self.iterators.append(self.__class__(s, self.ti + (i,), self.depth_limit))
for k, s in self.svg.attr.items():
self.iterators.append(self.__class__(s, self.ti + (k,), self.depth_limit))
self.iterators = itertools.chain(*self.iterators)
return self.iterators.next()
### end nested class
def depth_first(self, depth_limit=None):
"""Returns a depth-first generator over the SVG. If depth_limit
is a number, stop recursion at that depth."""
return self.SVGDepthIterator(self, (), depth_limit)
def breadth_first(self, depth_limit=None):
"""Not implemented yet. Any ideas on how to do it?
Returns a breadth-first generator over the SVG. If depth_limit
is a number, stop recursion at that depth."""
raise NotImplementedError, "Got an algorithm for breadth-first searching a tree without effectively copying the tree?"
def __iter__(self):
return self.depth_first()
def items(self, sub=True, attr=True, text=True):
"""Get a recursively-generated list of tree-index, sub-element/attribute pairs.
If sub == False, do not show sub-elements.
If attr == False, do not show attributes.
If text == False, do not show text/Unicode sub-elements.
"""
output = []
for ti, s in self:
show = False
if isinstance(ti[-1], (int, long)):
if isinstance(s, basestring):
show = text
else:
show = sub
else:
show = attr
if show:
output.append((ti, s))
return output
def keys(self, sub=True, attr=True, text=True):
"""Get a recursively-generated list of tree-indexes.
If sub == False, do not show sub-elements.
If attr == False, do not show attributes.
If text == False, do not show text/Unicode sub-elements.
"""
return [ti for ti, s in self.items(sub, attr, text)]
def values(self, sub=True, attr=True, text=True):
"""Get a recursively-generated list of sub-elements and attributes.
If sub == False, do not show sub-elements.
If attr == False, do not show attributes.
If text == False, do not show text/Unicode sub-elements.
"""
return [s for ti, s in self.items(sub, attr, text)]
def __repr__(self):
return self.xml(depth_limit=0)
def __str__(self):
"""Print (actually, return a string of) the tree in a form useful for browsing."""
return self.tree(sub=True, attr=False, text=False)
def tree(self, depth_limit=None, sub=True, attr=True, text=True, tree_width=20, obj_width=80):
"""Print (actually, return a string of) the tree in a form useful for browsing.
If depth_limit == a number, stop recursion at that depth.
If sub == False, do not show sub-elements.
If attr == False, do not show attributes.
If text == False, do not show text/Unicode sub-elements.
tree_width is the number of characters reserved for printing tree indexes.
obj_width is the number of characters reserved for printing sub-elements/attributes.
"""
output = []
line = "%s %s" % (("%%-%ds" % tree_width) % repr(None),
("%%-%ds" % obj_width) % (repr(self))[0:obj_width])
output.append(line)
for ti, s in self.depth_first(depth_limit):
show = False
if isinstance(ti[-1], (int, long)):
if isinstance(s, basestring):
show = text
else:
show = sub
else:
show = attr
if show:
line = "%s %s" % (("%%-%ds" % tree_width) % repr(list(ti)),
("%%-%ds" % obj_width) % (" "*len(ti) + repr(s))[0:obj_width])
output.append(line)
return "\n".join(output)
def xml(self, indent=u" ", newl=u"\n", depth_limit=None, depth=0):
"""Get an XML representation of the SVG.
indent string used for indenting
newl string used for newlines
If depth_limit == a number, stop recursion at that depth.
depth starting depth (not useful for users)
print svg.xml()
"""
attrstr = []
for n, v in self.attr.items():
if isinstance(v, dict):
v = u"; ".join([u"%s:%s" % (ni, vi) for ni, vi in v.items()])
elif isinstance(v, (list, tuple)):
v = u", ".join(v)
attrstr.append(u" %s=%s" % (n, repr(v)))
attrstr = u"".join(attrstr)
if len(self.sub) == 0:
return u"%s<%s%s />" % (indent * depth, self.t, attrstr)
if depth_limit is None or depth_limit > depth:
substr = []
for s in self.sub:
if isinstance(s, SVG):
substr.append(s.xml(indent, newl, depth_limit, depth + 1) + newl)
elif isinstance(s, basestring):
substr.append(u"%s%s%s" % (indent * (depth + 1), s, newl))
else:
substr.append("%s%s%s" % (indent * (depth + 1), repr(s), newl))
substr = u"".join(substr)
return u"%s<%s%s>%s%s%s</%s>" % (indent * depth, self.t, attrstr, newl, substr, indent * depth, self.t)
else:
return u"%s<%s (%d sub)%s />" % (indent * depth, self.t, len(self.sub), attrstr)
def standalone_xml(self, indent=u" ", newl=u"\n", encoding=u"utf-8"):
"""Get an XML representation of the SVG that can be saved/rendered.
indent string used for indenting
newl string used for newlines
"""
if self.t == "svg":
top = self
else:
top = canvas(self)
return u"""\
<?xml version="1.0" encoding="%s" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
""" % encoding + (u"".join(top.__standalone_xml(indent, newl))) # end of return statement
def __standalone_xml(self, indent, newl):
output = [u"<%s" % self.t]
for n, v in self.attr.items():
if isinstance(v, dict):
v = u"; ".join([u"%s:%s" % (ni, vi) for ni, vi in v.items()])
elif isinstance(v, (list, tuple)):
v = u", ".join(v)
output.append(u' %s="%s"' % (n, v))
if len(self.sub) == 0:
output.append(u" />%s%s" % (newl, newl))
return output
elif self.t == "text" or self.t == "tspan" or self.t == "style":
output.append(u">")
else:
output.append(u">%s%s" % (newl, newl))
for s in self.sub:
if isinstance(s, SVG):
output.extend(s.__standalone_xml(indent, newl))
else:
output.append(unicode(s))
if self.t == "tspan":
output.append(u"</%s>" % self.t)
else:
output.append(u"</%s>%s%s" % (self.t, newl, newl))
return output
def interpret_fileName(self, fileName=None):
if fileName is None:
fileName = _default_fileName
if re.search("windows", platform.system(), re.I) and not os.path.isabs(fileName):
fileName = _default_directory + os.sep + fileName
return fileName
def save(self, fileName=None, encoding="utf-8", compresslevel=None):
"""Save to a file for viewing. Note that svg.save() overwrites the file named _default_fileName.
fileName default=None note that _default_fileName will be overwritten if
no fileName is specified. If the extension
is ".svgz" or ".gz", the output will be gzipped
encoding default="utf-8" file encoding
compresslevel default=None if a number, the output will be gzipped with that
compression level (1-9, 1 being fastest and 9 most
thorough)
"""
fileName = self.interpret_fileName(fileName)
if compresslevel is not None or re.search(r"\.svgz$", fileName, re.I) or re.search(r"\.gz$", fileName, re.I):
import gzip
if compresslevel is None:
f = gzip.GzipFile(fileName, "w")
else:
f = gzip.GzipFile(fileName, "w", compresslevel)
f = codecs.EncodedFile(f, "utf-8", encoding)
f.write(self.standalone_xml(encoding=encoding))
f.close()
else:
f = codecs.open(fileName, "w", encoding=encoding)
f.write(self.standalone_xml(encoding=encoding))
f.close()
def inkview(self, fileName=None, encoding="utf-8"):
"""View in "inkview", assuming that program is available on your system.
fileName default=None note that any file named _default_fileName will be
overwritten if no fileName is specified. If the extension
is ".svgz" or ".gz", the output will be gzipped
encoding default="utf-8" file encoding
"""
fileName = self.interpret_fileName(fileName)
self.save(fileName, encoding)
os.spawnvp(os.P_NOWAIT, "inkview", ("inkview", fileName))
def inkscape(self, fileName=None, encoding="utf-8"):
"""View in "inkscape", assuming that program is available on your system.
fileName default=None note that any file named _default_fileName will be
overwritten if no fileName is specified. If the extension
is ".svgz" or ".gz", the output will be gzipped
encoding default="utf-8" file encoding
"""
fileName = self.interpret_fileName(fileName)
self.save(fileName, encoding)
os.spawnvp(os.P_NOWAIT, "inkscape", ("inkscape", fileName))
def firefox(self, fileName=None, encoding="utf-8"):
"""View in "firefox", assuming that program is available on your system.
fileName default=None note that any file named _default_fileName will be
overwritten if no fileName is specified. If the extension
is ".svgz" or ".gz", the output will be gzipped
encoding default="utf-8" file encoding
"""
fileName = self.interpret_fileName(fileName)
self.save(fileName, encoding)
os.spawnvp(os.P_NOWAIT, "firefox", ("firefox", fileName))
######################################################################
_canvas_defaults = {"width": "400px",
"height": "400px",
"viewBox": "0 0 100 100",
"xmlns": "http://www.w3.org/2000/svg",
"xmlns:xlink": "http://www.w3.org/1999/xlink",
"version": "1.1",
"style": {"stroke": "black",
"fill": "none",
"stroke-width": "0.5pt",
"stroke-linejoin": "round",
"text-anchor": "middle",
},
"font-family": ["Helvetica", "Arial", "FreeSans", "Sans", "sans", "sans-serif"],
}
def canvas(*sub, **attr):
"""Creates a top-level SVG object, allowing the user to control the
image size and aspect ratio.
canvas(sub, sub, sub..., attribute=value)
sub optional list nested SVG elements or text/Unicode
attribute=value pairs optional keywords SVG attributes
Default attribute values:
width "400px"
height "400px"
viewBox "0 0 100 100"
xmlns "http://www.w3.org/2000/svg"
xmlns:xlink "http://www.w3.org/1999/xlink"
version "1.1"
style "stroke:black; fill:none; stroke-width:0.5pt; stroke-linejoin:round; text-anchor:middle"
font-family "Helvetica,Arial,FreeSans?,Sans,sans,sans-serif"
"""
attributes = dict(_canvas_defaults)
attributes.update(attr)
if sub is None or sub == ():
return SVG("svg", **attributes)
else:
return SVG("svg", *sub, **attributes)
def canvas_outline(*sub, **attr):
"""Same as canvas(), but draws an outline around the drawable area,
so that you know how close your image is to the edges."""
svg = canvas(*sub, **attr)
match = re.match(r"[, \t]*([0-9e.+\-]+)[, \t]+([0-9e.+\-]+)[, \t]+([0-9e.+\-]+)[, \t]+([0-9e.+\-]+)[, \t]*", svg["viewBox"])
if match is None:
raise ValueError, "canvas viewBox is incorrectly formatted"
x, y, width, height = [float(x) for x in match.groups()]
svg.prepend(SVG("rect", x=x, y=y, width=width, height=height, stroke="none", fill="cornsilk"))
svg.append(SVG("rect", x=x, y=y, width=width, height=height, stroke="black", fill="none"))
return svg
def template(fileName, svg, replaceme="REPLACEME"):
"""Loads an SVG image from a file, replacing instances of
<REPLACEME /> with a given svg object.
fileName required name of the template SVG
svg required SVG object for replacement
replaceme default="REPLACEME" fake SVG element to be replaced by the given object
>>> print load("template.svg")
None <svg (2 sub) style=u'stroke:black; fill:none; stroke-width:0.5pt; stroke-linejoi
[0] <rect height=u'100' width=u'100' stroke=u'none' y=u'0' x=u'0' fill=u'yellow'
[1] <REPLACEME />
>>>
>>> print template("template.svg", SVG("circle", cx=50, cy=50, r=30))
None <svg (2 sub) style=u'stroke:black; fill:none; stroke-width:0.5pt; stroke-linejoi
[0] <rect height=u'100' width=u'100' stroke=u'none' y=u'0' x=u'0' fill=u'yellow'
[1] <circle cy=50 cx=50 r=30 />
"""
output = load(fileName)
for ti, s in output:
if isinstance(s, SVG) and s.t == replaceme:
output[ti] = svg
return output
######################################################################
def load(fileName):
"""Loads an SVG image from a file."""
return load_stream(file(fileName))
def load_stream(stream):
"""Loads an SVG image from a stream (can be a string or a file object)."""
from xml.sax import handler, make_parser
from xml.sax.handler import feature_namespaces, feature_external_ges, feature_external_pes
class ContentHandler(handler.ContentHandler):
def __init__(self):
self.stack = []
self.output = None
self.all_whitespace = re.compile(r"^\s*$")
def startElement(self, name, attr):
s = SVG(name)
s.attr = dict(attr.items())
if len(self.stack) > 0:
last = self.stack[-1]
last.sub.append(s)
self.stack.append(s)
def characters(self, ch):
if not isinstance(ch, basestring) or self.all_whitespace.match(ch) is None:
if len(self.stack) > 0:
last = self.stack[-1]
if len(last.sub) > 0 and isinstance(last.sub[-1], basestring):
last.sub[-1] = last.sub[-1] + "\n" + ch
else:
last.sub.append(ch)
def endElement(self, name):
if len(self.stack) > 0:
last = self.stack[-1]
if (isinstance(last, SVG) and last.t == "style" and
"type" in last.attr and last.attr["type"] == "text/css" and
len(last.sub) == 1 and isinstance(last.sub[0], basestring)):
last.sub[0] = "<![CDATA[\n" + last.sub[0] + "]]>"
self.output = self.stack.pop()
ch = ContentHandler()
parser = make_parser()
parser.setContentHandler(ch)
parser.setFeature(feature_namespaces, 0)
parser.setFeature(feature_external_ges, 0)
parser.parse(stream)
return ch.output
######################################################################
def set_func_name(f, name):
"""try to patch the function name string into a function object"""
try:
f.func_name = name
except TypeError:
# py 2.3 raises: TypeError: readonly attribute
pass
def totrans(expr, vars=("x", "y"), globals=None, locals=None):
"""Converts to a coordinate transformation (a function that accepts
two arguments and returns two values).
expr required a string expression or a function
of two real or one complex value
vars default=("x", "y") independent variable names; a singleton
("z",) is interpreted as complex
globals default=None dict of global variables
locals default=None dict of local variables
"""
if locals is None:
locals = {} # python 2.3's eval() won't accept None
if callable(expr):
if expr.func_code.co_argcount == 2:
return expr
elif expr.func_code.co_argcount == 1:
split = lambda z: (z.real, z.imag)
output = lambda x, y: split(expr(x + y*1j))
set_func_name(output, expr.func_name)
return output
else:
raise TypeError, "must be a function of 2 or 1 variables"
if len(vars) == 2:
g = math.__dict__
if globals is not None:
g.update(globals)
output = eval("lambda %s, %s: (%s)" % (vars[0], vars[1], expr), g, locals)
set_func_name(output, "%s,%s -> %s" % (vars[0], vars[1], expr))
return output
elif len(vars) == 1:
g = cmath.__dict__
if globals is not None:
g.update(globals)
output = eval("lambda %s: (%s)" % (vars[0], expr), g, locals)
split = lambda z: (z.real, z.imag)
output2 = lambda x, y: split(output(x + y*1j))
set_func_name(output2, "%s -> %s" % (vars[0], expr))
return output2
else:
raise TypeError, "vars must have 2 or 1 elements"
def window(xmin, xmax, ymin, ymax, x=0, y=0, width=100, height=100,
xlogbase=None, ylogbase=None, minusInfinity=-1000, flipx=False, flipy=True):
"""Creates and returns a coordinate transformation (a function that
accepts two arguments and returns two values) that transforms from
(xmin, ymin), (xmax, ymax)
to
(x, y), (x + width, y + height).
xlogbase, ylogbase default=None, None if a number, transform
logarithmically with given base
minusInfinity default=-1000 what to return if
log(0 or negative) is attempted
flipx default=False if true, reverse the direction of x
flipy default=True if true, reverse the direction of y
(When composing windows, be sure to set flipy=False.)
"""
if flipx:
ox1 = x + width
ox2 = x
else:
ox1 = x
ox2 = x + width
if flipy:
oy1 = y + height
oy2 = y
else:
oy1 = y
oy2 = y + height
ix1 = xmin
iy1 = ymin
ix2 = xmax
iy2 = ymax
if xlogbase is not None and (ix1 <= 0. or ix2 <= 0.):
raise ValueError, "x range incompatible with log scaling: (%g, %g)" % (ix1, ix2)
if ylogbase is not None and (iy1 <= 0. or iy2 <= 0.):
raise ValueError, "y range incompatible with log scaling: (%g, %g)" % (iy1, iy2)
def maybelog(t, it1, it2, ot1, ot2, logbase):
if t <= 0.:
return minusInfinity
else:
return ot1 + 1.*(math.log(t, logbase) - math.log(it1, logbase))/(math.log(it2, logbase) - math.log(it1, logbase)) * (ot2 - ot1)
xlogstr, ylogstr = "", ""
if xlogbase is None:
xfunc = lambda x: ox1 + 1.*(x - ix1)/(ix2 - ix1) * (ox2 - ox1)
else:
xfunc = lambda x: maybelog(x, ix1, ix2, ox1, ox2, xlogbase)
xlogstr = " xlog=%g" % xlogbase
if ylogbase is None:
yfunc = lambda y: oy1 + 1.*(y - iy1)/(iy2 - iy1) * (oy2 - oy1)
else:
yfunc = lambda y: maybelog(y, iy1, iy2, oy1, oy2, ylogbase)
ylogstr = " ylog=%g" % ylogbase
output = lambda x, y: (xfunc(x), yfunc(y))
set_func_name(output, "(%g, %g), (%g, %g) -> (%g, %g), (%g, %g)%s%s" % (
ix1, ix2, iy1, iy2, ox1, ox2, oy1, oy2, xlogstr, ylogstr))
return output
def rotate(angle, cx=0, cy=0):
"""Creates and returns a coordinate transformation which rotates
around (cx,cy) by "angle" degrees."""
angle *= math.pi/180.
return lambda x, y: (cx + math.cos(angle)*(x - cx) - math.sin(angle)*(y - cy), cy + math.sin(angle)*(x - cx) + math.cos(angle)*(y - cy))
class Fig:
"""Stores graphics primitive objects and applies a single coordinate
transformation to them. To compose coordinate systems, nest Fig
objects.
Fig(obj, obj, obj..., trans=function)
obj optional list a list of drawing primitives
trans default=None a coordinate transformation function
>>> fig = Fig(Line(0,0,1,1), Rect(0.2,0.2,0.8,0.8), trans="2*x, 2*y")
>>> print fig.SVG().xml()
<g>
<path d='M0 0L2 2' />
<path d='M0.4 0.4L1.6 0.4ZL1.6 1.6ZL0.4 1.6ZL0.4 0.4ZZ' />
</g>
>>> print Fig(fig, trans="x/2., y/2.").SVG().xml()
<g>
<path d='M0 0L1 1' />
<path d='M0.2 0.2L0.8 0.2ZL0.8 0.8ZL0.2 0.8ZL0.2 0.2ZZ' />
</g>
"""
def __repr__(self):
if self.trans is None:
return "<Fig (%d items)>" % len(self.d)
elif isinstance(self.trans, basestring):
return "<Fig (%d items) x,y -> %s>" % (len(self.d), self.trans)
else:
return "<Fig (%d items) %s>" % (len(self.d), self.trans.func_name)
def __init__(self, *d, **kwds):
self.d = list(d)
defaults = {"trans": None, }
defaults.update(kwds)
kwds = defaults
self.trans = kwds["trans"]; del kwds["trans"]
if len(kwds) != 0:
raise TypeError, "Fig() got unexpected keyword arguments %s" % kwds.keys()
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object.
Coordinate transformations in nested Figs will be composed.
"""
if trans is None:
trans = self.trans
if isinstance(trans, basestring):
trans = totrans(trans)
output = SVG("g")
for s in self.d:
if isinstance(s, SVG):
output.append(s)
elif isinstance(s, Fig):
strans = s.trans
if isinstance(strans, basestring):
strans = totrans(strans)
if trans is None:
subtrans = strans
elif strans is None:
subtrans = trans
else:
subtrans = lambda x, y: trans(*strans(x, y))
output.sub += s.SVG(subtrans).sub
elif s is None:
pass
else:
output.append(s.SVG(trans))
return output
class Plot:
"""Acts like Fig, but draws a coordinate axis. You also need to supply plot ranges.
Plot(xmin, xmax, ymin, ymax, obj, obj, obj..., keyword options...)
xmin, xmax required minimum and maximum x values (in the objs' coordinates)
ymin, ymax required minimum and maximum y values (in the objs' coordinates)
obj optional list drawing primitives
keyword options keyword list options defined below
The following are keyword options, with their default values:
trans None transformation function
x, y 5, 5 upper-left corner of the Plot in SVG coordinates
width, height 90, 90 width and height of the Plot in SVG coordinates
flipx, flipy False, True flip the sign of the coordinate axis
minusInfinity -1000 if an axis is logarithmic and an object is plotted at 0 or
a negative value, -1000 will be used as a stand-in for NaN
atx, aty 0, 0 the place where the coordinate axes cross
xticks -10 request ticks according to the standard tick specification
(see help(Ticks))
xminiticks True request miniticks according to the standard minitick
specification
xlabels True request tick labels according to the standard tick label
specification
xlogbase None if a number, the axis and transformation are logarithmic
with ticks at the given base (10 being the most common)
(same for y)
arrows None if a new identifier, create arrow markers and draw them
at the ends of the coordinate axes
text_attr {} a dictionary of attributes for label text
axis_attr {} a dictionary of attributes for the axis lines
"""
def __repr__(self):
if self.trans is None:
return "<Plot (%d items)>" % len(self.d)
else:
return "<Plot (%d items) %s>" % (len(self.d), self.trans.func_name)
def __init__(self, xmin, xmax, ymin, ymax, *d, **kwds):
self.xmin, self.xmax, self.ymin, self.ymax = xmin, xmax, ymin, ymax
self.d = list(d)
defaults = {"trans": None,
"x": 5, "y": 5, "width": 90, "height": 90,
"flipx": False, "flipy": True,
"minusInfinity": -1000,
"atx": 0, "xticks": -10, "xminiticks": True, "xlabels": True, "xlogbase": None,
"aty": 0, "yticks": -10, "yminiticks": True, "ylabels": True, "ylogbase": None,
"arrows": None,
"text_attr": {}, "axis_attr": {},
}
defaults.update(kwds)
kwds = defaults
self.trans = kwds["trans"]; del kwds["trans"]
self.x = kwds["x"]; del kwds["x"]
self.y = kwds["y"]; del kwds["y"]
self.width = kwds["width"]; del kwds["width"]
self.height = kwds["height"]; del kwds["height"]
self.flipx = kwds["flipx"]; del kwds["flipx"]
self.flipy = kwds["flipy"]; del kwds["flipy"]
self.minusInfinity = kwds["minusInfinity"]; del kwds["minusInfinity"]
self.atx = kwds["atx"]; del kwds["atx"]
self.xticks = kwds["xticks"]; del kwds["xticks"]
self.xminiticks = kwds["xminiticks"]; del kwds["xminiticks"]
self.xlabels = kwds["xlabels"]; del kwds["xlabels"]
self.xlogbase = kwds["xlogbase"]; del kwds["xlogbase"]
self.aty = kwds["aty"]; del kwds["aty"]
self.yticks = kwds["yticks"]; del kwds["yticks"]
self.yminiticks = kwds["yminiticks"]; del kwds["yminiticks"]
self.ylabels = kwds["ylabels"]; del kwds["ylabels"]
self.ylogbase = kwds["ylogbase"]; del kwds["ylogbase"]
self.arrows = kwds["arrows"]; del kwds["arrows"]
self.text_attr = kwds["text_attr"]; del kwds["text_attr"]
self.axis_attr = kwds["axis_attr"]; del kwds["axis_attr"]
if len(kwds) != 0:
raise TypeError, "Plot() got unexpected keyword arguments %s" % kwds.keys()
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
if trans is None:
trans = self.trans
if isinstance(trans, basestring):
trans = totrans(trans)
self.last_window = window(self.xmin, self.xmax, self.ymin, self.ymax,
x=self.x, y=self.y, width=self.width, height=self.height,
xlogbase=self.xlogbase, ylogbase=self.ylogbase,
minusInfinity=self.minusInfinity, flipx=self.flipx, flipy=self.flipy)
d = ([Axes(self.xmin, self.xmax, self.ymin, self.ymax, self.atx, self.aty,
self.xticks, self.xminiticks, self.xlabels, self.xlogbase,
self.yticks, self.yminiticks, self.ylabels, self.ylogbase,
self.arrows, self.text_attr, **self.axis_attr)]
+ self.d)
return Fig(Fig(*d, **{"trans": trans})).SVG(self.last_window)
class Frame:
text_defaults = {"stroke": "none", "fill": "black", "font-size": 5, }
axis_defaults = {}
tick_length = 1.5
minitick_length = 0.75
text_xaxis_offset = 1.
text_yaxis_offset = 2.
text_xtitle_offset = 6.
text_ytitle_offset = 12.
def __repr__(self):
return "<Frame (%d items)>" % len(self.d)
def __init__(self, xmin, xmax, ymin, ymax, *d, **kwds):
"""Acts like Fig, but draws a coordinate frame around the data. You also need to supply plot ranges.
Frame(xmin, xmax, ymin, ymax, obj, obj, obj..., keyword options...)
xmin, xmax required minimum and maximum x values (in the objs' coordinates)
ymin, ymax required minimum and maximum y values (in the objs' coordinates)
obj optional list drawing primitives
keyword options keyword list options defined below
The following are keyword options, with their default values:
x, y 20, 5 upper-left corner of the Frame in SVG coordinates
width, height 75, 80 width and height of the Frame in SVG coordinates
flipx, flipy False, True flip the sign of the coordinate axis
minusInfinity -1000 if an axis is logarithmic and an object is plotted at 0 or
a negative value, -1000 will be used as a stand-in for NaN
xtitle None if a string, label the x axis
xticks -10 request ticks according to the standard tick specification
(see help(Ticks))
xminiticks True request miniticks according to the standard minitick
specification
xlabels True request tick labels according to the standard tick label
specification
xlogbase None if a number, the axis and transformation are logarithmic
with ticks at the given base (10 being the most common)
(same for y)
text_attr {} a dictionary of attributes for label text
axis_attr {} a dictionary of attributes for the axis lines
"""
self.xmin, self.xmax, self.ymin, self.ymax = xmin, xmax, ymin, ymax
self.d = list(d)
defaults = {"x": 20, "y": 5, "width": 75, "height": 80,
"flipx": False, "flipy": True, "minusInfinity": -1000,
"xtitle": None, "xticks": -10, "xminiticks": True, "xlabels": True,
"x2labels": None, "xlogbase": None,
"ytitle": None, "yticks": -10, "yminiticks": True, "ylabels": True,
"y2labels": None, "ylogbase": None,
"text_attr": {}, "axis_attr": {},
}
defaults.update(kwds)
kwds = defaults
self.x = kwds["x"]; del kwds["x"]
self.y = kwds["y"]; del kwds["y"]
self.width = kwds["width"]; del kwds["width"]
self.height = kwds["height"]; del kwds["height"]
self.flipx = kwds["flipx"]; del kwds["flipx"]
self.flipy = kwds["flipy"]; del kwds["flipy"]
self.minusInfinity = kwds["minusInfinity"]; del kwds["minusInfinity"]
self.xtitle = kwds["xtitle"]; del kwds["xtitle"]
self.xticks = kwds["xticks"]; del kwds["xticks"]
self.xminiticks = kwds["xminiticks"]; del kwds["xminiticks"]
self.xlabels = kwds["xlabels"]; del kwds["xlabels"]
self.x2labels = kwds["x2labels"]; del kwds["x2labels"]
self.xlogbase = kwds["xlogbase"]; del kwds["xlogbase"]
self.ytitle = kwds["ytitle"]; del kwds["ytitle"]
self.yticks = kwds["yticks"]; del kwds["yticks"]
self.yminiticks = kwds["yminiticks"]; del kwds["yminiticks"]
self.ylabels = kwds["ylabels"]; del kwds["ylabels"]
self.y2labels = kwds["y2labels"]; del kwds["y2labels"]
self.ylogbase = kwds["ylogbase"]; del kwds["ylogbase"]
self.text_attr = dict(self.text_defaults)
self.text_attr.update(kwds["text_attr"]); del kwds["text_attr"]
self.axis_attr = dict(self.axis_defaults)
self.axis_attr.update(kwds["axis_attr"]); del kwds["axis_attr"]
if len(kwds) != 0:
raise TypeError, "Frame() got unexpected keyword arguments %s" % kwds.keys()
def SVG(self):
"""Apply the window transformation and return an SVG object."""
self.last_window = window(self.xmin, self.xmax, self.ymin, self.ymax,
x=self.x, y=self.y, width=self.width, height=self.height,
xlogbase=self.xlogbase, ylogbase=self.ylogbase,
minusInfinity=self.minusInfinity, flipx=self.flipx, flipy=self.flipy)
left = YAxis(self.ymin, self.ymax, self.xmin, self.yticks, self.yminiticks, self.ylabels, self.ylogbase,
None, None, None, self.text_attr, **self.axis_attr)
right = YAxis(self.ymin, self.ymax, self.xmax, self.yticks, self.yminiticks, self.y2labels, self.ylogbase,
None, None, None, self.text_attr, **self.axis_attr)
bottom = XAxis(self.xmin, self.xmax, self.ymin, self.xticks, self.xminiticks, self.xlabels, self.xlogbase,
None, None, None, self.text_attr, **self.axis_attr)
top = XAxis(self.xmin, self.xmax, self.ymax, self.xticks, self.xminiticks, self.x2labels, self.xlogbase,
None, None, None, self.text_attr, **self.axis_attr)
left.tick_start = -self.tick_length
left.tick_end = 0
left.minitick_start = -self.minitick_length
left.minitick_end = 0.
left.text_start = self.text_yaxis_offset
right.tick_start = 0.
right.tick_end = self.tick_length
right.minitick_start = 0.
right.minitick_end = self.minitick_length
right.text_start = -self.text_yaxis_offset
right.text_attr["text-anchor"] = "start"
bottom.tick_start = 0.
bottom.tick_end = self.tick_length
bottom.minitick_start = 0.
bottom.minitick_end = self.minitick_length
bottom.text_start = -self.text_xaxis_offset
top.tick_start = -self.tick_length
top.tick_end = 0.
top.minitick_start = -self.minitick_length
top.minitick_end = 0.
top.text_start = self.text_xaxis_offset
top.text_attr["dominant-baseline"] = "text-after-edge"
output = Fig(*self.d).SVG(self.last_window)
output.prepend(left.SVG(self.last_window))
output.prepend(bottom.SVG(self.last_window))
output.prepend(right.SVG(self.last_window))
output.prepend(top.SVG(self.last_window))
if self.xtitle is not None:
output.append(SVG("text", self.xtitle, transform="translate(%g, %g)" % ((self.x + self.width/2.), (self.y + self.height + self.text_xtitle_offset)), dominant_baseline="text-before-edge", **self.text_attr))
if self.ytitle is not None:
output.append(SVG("text", self.ytitle, transform="translate(%g, %g) rotate(-90)" % ((self.x - self.text_ytitle_offset), (self.y + self.height/2.)), **self.text_attr))
return output
######################################################################
def pathtoPath(svg):
"""Converts SVG("path", d="...") into Path(d=[...])."""
if not isinstance(svg, SVG) or svg.t != "path":
raise TypeError, "Only SVG <path /> objects can be converted into Paths"
attr = dict(svg.attr)
d = attr["d"]
del attr["d"]
for key in attr.keys():
if not isinstance(key, str):
value = attr[key]
del attr[key]
attr[str(key)] = value
return Path(d, **attr)
class Path:
"""Path represents an SVG path, an arbitrary set of curves and
straight segments. Unlike SVG("path", d="..."), Path stores
coordinates as a list of numbers, rather than a string, so that it is
transformable in a Fig.
Path(d, attribute=value)
d required path data
attribute=value pairs keyword list SVG attributes
See http://www.w3.org/TR/SVG/paths.html for specification of paths
from text.
Internally, Path data is a list of tuples with these definitions:
* ("Z/z",): close the current path
* ("H/h", x) or ("V/v", y): a horizontal or vertical line
segment to x or y
* ("M/m/L/l/T/t", x, y, global): moveto, lineto, or smooth
quadratic curveto point (x, y). If global=True, (x, y) should
not be transformed.
* ("S/sQ/q", cx, cy, cglobal, x, y, global): polybezier or
smooth quadratic curveto point (x, y) using (cx, cy) as a
control point. If cglobal or global=True, (cx, cy) or (x, y)
should not be transformed.
* ("C/c", c1x, c1y, c1global, c2x, c2y, c2global, x, y, global):
cubic curveto point (x, y) using (c1x, c1y) and (c2x, c2y) as
control points. If c1global, c2global, or global=True, (c1x, c1y),
(c2x, c2y), or (x, y) should not be transformed.
* ("A/a", rx, ry, rglobal, x-axis-rotation, angle, large-arc-flag,
sweep-flag, x, y, global): arcto point (x, y) using the
aforementioned parameters.
* (",/.", rx, ry, rglobal, angle, x, y, global): an ellipse at
point (x, y) with radii (rx, ry). If angle is 0, the whole
ellipse is drawn; otherwise, a partial ellipse is drawn.
"""
defaults = {}
def __repr__(self):
return "<Path (%d nodes) %s>" % (len(self.d), self.attr)
def __init__(self, d=[], **attr):
if isinstance(d, basestring):
self.d = self.parse(d)
else:
self.d = list(d)
self.attr = dict(self.defaults)
self.attr.update(attr)
def parse_whitespace(self, index, pathdata):
"""Part of Path's text-command parsing algorithm; used internally."""
while index < len(pathdata) and pathdata[index] in (" ", "\t", "\r", "\n", ","):
index += 1
return index, pathdata
def parse_command(self, index, pathdata):
"""Part of Path's text-command parsing algorithm; used internally."""
index, pathdata = self.parse_whitespace(index, pathdata)
if index >= len(pathdata):
return None, index, pathdata
command = pathdata[index]
if "A" <= command <= "Z" or "a" <= command <= "z":
index += 1
return command, index, pathdata
else:
return None, index, pathdata
def parse_number(self, index, pathdata):
"""Part of Path's text-command parsing algorithm; used internally."""
index, pathdata = self.parse_whitespace(index, pathdata)
if index >= len(pathdata):
return None, index, pathdata
first_digit = pathdata[index]
if "0" <= first_digit <= "9" or first_digit in ("-", "+", "."):
start = index
while index < len(pathdata) and ("0" <= pathdata[index] <= "9" or pathdata[index] in ("-", "+", ".", "e", "E")):
index += 1
end = index
index = end
return float(pathdata[start:end]), index, pathdata
else:
return None, index, pathdata
def parse_boolean(self, index, pathdata):
"""Part of Path's text-command parsing algorithm; used internally."""
index, pathdata = self.parse_whitespace(index, pathdata)
if index >= len(pathdata):
return None, index, pathdata
first_digit = pathdata[index]
if first_digit in ("0", "1"):
index += 1
return int(first_digit), index, pathdata
else:
return None, index, pathdata
def parse(self, pathdata):
"""Parses text-commands, converting them into a list of tuples.
Called by the constructor."""
output = []
index = 0
while True:
command, index, pathdata = self.parse_command(index, pathdata)
index, pathdata = self.parse_whitespace(index, pathdata)
if command is None and index == len(pathdata):
break # this is the normal way out of the loop
if command in ("Z", "z"):
output.append((command,))
######################
elif command in ("H", "h", "V", "v"):
errstring = "Path command \"%s\" requires a number at index %d" % (command, index)
num1, index, pathdata = self.parse_number(index, pathdata)
if num1 is None:
raise ValueError, errstring
while num1 is not None:
output.append((command, num1))
num1, index, pathdata = self.parse_number(index, pathdata)
######################
elif command in ("M", "m", "L", "l", "T", "t"):
errstring = "Path command \"%s\" requires an x,y pair at index %d" % (command, index)
num1, index, pathdata = self.parse_number(index, pathdata)
num2, index, pathdata = self.parse_number(index, pathdata)
if num1 is None:
raise ValueError, errstring
while num1 is not None:
if num2 is None:
raise ValueError, errstring
output.append((command, num1, num2, False))
num1, index, pathdata = self.parse_number(index, pathdata)
num2, index, pathdata = self.parse_number(index, pathdata)
######################
elif command in ("S", "s", "Q", "q"):
errstring = "Path command \"%s\" requires a cx,cy,x,y quadruplet at index %d" % (command, index)
num1, index, pathdata = self.parse_number(index, pathdata)
num2, index, pathdata = self.parse_number(index, pathdata)
num3, index, pathdata = self.parse_number(index, pathdata)
num4, index, pathdata = self.parse_number(index, pathdata)
if num1 is None:
raise ValueError, errstring
while num1 is not None:
if num2 is None or num3 is None or num4 is None:
raise ValueError, errstring
output.append((command, num1, num2, False, num3, num4, False))
num1, index, pathdata = self.parse_number(index, pathdata)
num2, index, pathdata = self.parse_number(index, pathdata)
num3, index, pathdata = self.parse_number(index, pathdata)
num4, index, pathdata = self.parse_number(index, pathdata)
######################
elif command in ("C", "c"):
errstring = "Path command \"%s\" requires a c1x,c1y,c2x,c2y,x,y sextuplet at index %d" % (command, index)
num1, index, pathdata = self.parse_number(index, pathdata)
num2, index, pathdata = self.parse_number(index, pathdata)
num3, index, pathdata = self.parse_number(index, pathdata)
num4, index, pathdata = self.parse_number(index, pathdata)
num5, index, pathdata = self.parse_number(index, pathdata)
num6, index, pathdata = self.parse_number(index, pathdata)
if num1 is None:
raise ValueError, errstring
while num1 is not None:
if num2 is None or num3 is None or num4 is None or num5 is None or num6 is None:
raise ValueError, errstring
output.append((command, num1, num2, False, num3, num4, False, num5, num6, False))
num1, index, pathdata = self.parse_number(index, pathdata)
num2, index, pathdata = self.parse_number(index, pathdata)
num3, index, pathdata = self.parse_number(index, pathdata)
num4, index, pathdata = self.parse_number(index, pathdata)
num5, index, pathdata = self.parse_number(index, pathdata)
num6, index, pathdata = self.parse_number(index, pathdata)
######################
elif command in ("A", "a"):
errstring = "Path command \"%s\" requires a rx,ry,angle,large-arc-flag,sweep-flag,x,y septuplet at index %d" % (command, index)
num1, index, pathdata = self.parse_number(index, pathdata)
num2, index, pathdata = self.parse_number(index, pathdata)
num3, index, pathdata = self.parse_number(index, pathdata)
num4, index, pathdata = self.parse_boolean(index, pathdata)
num5, index, pathdata = self.parse_boolean(index, pathdata)
num6, index, pathdata = self.parse_number(index, pathdata)
num7, index, pathdata = self.parse_number(index, pathdata)
if num1 is None:
raise ValueError, errstring
while num1 is not None:
if num2 is None or num3 is None or num4 is None or num5 is None or num6 is None or num7 is None:
raise ValueError, errstring
output.append((command, num1, num2, False, num3, num4, num5, num6, num7, False))
num1, index, pathdata = self.parse_number(index, pathdata)
num2, index, pathdata = self.parse_number(index, pathdata)
num3, index, pathdata = self.parse_number(index, pathdata)
num4, index, pathdata = self.parse_boolean(index, pathdata)
num5, index, pathdata = self.parse_boolean(index, pathdata)
num6, index, pathdata = self.parse_number(index, pathdata)
num7, index, pathdata = self.parse_number(index, pathdata)
return output
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
if isinstance(trans, basestring):
trans = totrans(trans)
x, y, X, Y = None, None, None, None
output = []
for datum in self.d:
if not isinstance(datum, (tuple, list)):
raise TypeError, "pathdata elements must be tuples/lists"
command = datum[0]
######################
if command in ("Z", "z"):
x, y, X, Y = None, None, None, None
output.append("Z")
######################
elif command in ("H", "h", "V", "v"):
command, num1 = datum
if command == "H" or (command == "h" and x is None):
x = num1
elif command == "h":
x += num1
elif command == "V" or (command == "v" and y is None):
y = num1
elif command == "v":
y += num1
if trans is None:
X, Y = x, y
else:
X, Y = trans(x, y)
output.append("L%g %g" % (X, Y))
######################
elif command in ("M", "m", "L", "l", "T", "t"):
command, num1, num2, isglobal12 = datum
if trans is None or isglobal12:
if command.isupper() or X is None or Y is None:
X, Y = num1, num2
else:
X += num1
Y += num2
x, y = X, Y
else:
if command.isupper() or x is None or y is None:
x, y = num1, num2
else:
x += num1
y += num2
X, Y = trans(x, y)
COMMAND = command.capitalize()
output.append("%s%g %g" % (COMMAND, X, Y))
######################
elif command in ("S", "s", "Q", "q"):
command, num1, num2, isglobal12, num3, num4, isglobal34 = datum
if trans is None or isglobal12:
if command.isupper() or X is None or Y is None:
CX, CY = num1, num2
else:
CX = X + num1
CY = Y + num2
else:
if command.isupper() or x is None or y is None:
cx, cy = num1, num2
else:
cx = x + num1
cy = y + num2
CX, CY = trans(cx, cy)
if trans is None or isglobal34:
if command.isupper() or X is None or Y is None:
X, Y = num3, num4
else:
X += num3
Y += num4
x, y = X, Y
else:
if command.isupper() or x is None or y is None:
x, y = num3, num4
else:
x += num3
y += num4
X, Y = trans(x, y)
COMMAND = command.capitalize()
output.append("%s%g %g %g %g" % (COMMAND, CX, CY, X, Y))
######################
elif command in ("C", "c"):
command, num1, num2, isglobal12, num3, num4, isglobal34, num5, num6, isglobal56 = datum
if trans is None or isglobal12:
if command.isupper() or X is None or Y is None:
C1X, C1Y = num1, num2
else:
C1X = X + num1
C1Y = Y + num2
else:
if command.isupper() or x is None or y is None:
c1x, c1y = num1, num2
else:
c1x = x + num1
c1y = y + num2
C1X, C1Y = trans(c1x, c1y)
if trans is None or isglobal34:
if command.isupper() or X is None or Y is None:
C2X, C2Y = num3, num4
else:
C2X = X + num3
C2Y = Y + num4
else:
if command.isupper() or x is None or y is None:
c2x, c2y = num3, num4
else:
c2x = x + num3
c2y = y + num4
C2X, C2Y = trans(c2x, c2y)
if trans is None or isglobal56:
if command.isupper() or X is None or Y is None:
X, Y = num5, num6
else:
X += num5
Y += num6
x, y = X, Y
else:
if command.isupper() or x is None or y is None:
x, y = num5, num6
else:
x += num5
y += num6
X, Y = trans(x, y)
COMMAND = command.capitalize()
output.append("%s%g %g %g %g %g %g" % (COMMAND, C1X, C1Y, C2X, C2Y, X, Y))
######################
elif command in ("A", "a"):
command, num1, num2, isglobal12, angle, large_arc_flag, sweep_flag, num3, num4, isglobal34 = datum
oldx, oldy = x, y
OLDX, OLDY = X, Y
if trans is None or isglobal34:
if command.isupper() or X is None or Y is None:
X, Y = num3, num4
else:
X += num3
Y += num4
x, y = X, Y
else:
if command.isupper() or x is None or y is None:
x, y = num3, num4
else:
x += num3
y += num4
X, Y = trans(x, y)
if x is not None and y is not None:
centerx, centery = (x + oldx)/2., (y + oldy)/2.
CENTERX, CENTERY = (X + OLDX)/2., (Y + OLDY)/2.
if trans is None or isglobal12:
RX = CENTERX + num1
RY = CENTERY + num2
else:
rx = centerx + num1
ry = centery + num2
RX, RY = trans(rx, ry)
COMMAND = command.capitalize()
output.append("%s%g %g %g %d %d %g %g" % (COMMAND, RX - CENTERX, RY - CENTERY, angle, large_arc_flag, sweep_flag, X, Y))
elif command in (",", "."):
command, num1, num2, isglobal12, angle, num3, num4, isglobal34 = datum
if trans is None or isglobal34:
if command == "." or X is None or Y is None:
X, Y = num3, num4
else:
X += num3
Y += num4
x, y = None, None
else:
if command == "." or x is None or y is None:
x, y = num3, num4
else:
x += num3
y += num4
X, Y = trans(x, y)
if trans is None or isglobal12:
RX = X + num1
RY = Y + num2
else:
rx = x + num1
ry = y + num2
RX, RY = trans(rx, ry)
RX, RY = RX - X, RY - Y
X1, Y1 = X + RX * math.cos(angle*math.pi/180.), Y + RX * math.sin(angle*math.pi/180.)
X2, Y2 = X + RY * math.sin(angle*math.pi/180.), Y - RY * math.cos(angle*math.pi/180.)
X3, Y3 = X - RX * math.cos(angle*math.pi/180.), Y - RX * math.sin(angle*math.pi/180.)
X4, Y4 = X - RY * math.sin(angle*math.pi/180.), Y + RY * math.cos(angle*math.pi/180.)
output.append("M%g %gA%g %g %g 0 0 %g %gA%g %g %g 0 0 %g %gA%g %g %g 0 0 %g %gA%g %g %g 0 0 %g %g" % (
X1, Y1, RX, RY, angle, X2, Y2, RX, RY, angle, X3, Y3, RX, RY, angle, X4, Y4, RX, RY, angle, X1, Y1))
return SVG("path", d="".join(output), **self.attr)
######################################################################
def funcRtoC(expr, var="t", globals=None, locals=None):
"""Converts a complex "z(t)" string to a function acceptable for Curve.
expr required string in the form "z(t)"
var default="t" name of the independent variable
globals default=None dict of global variables used in the expression;
you may want to use Python's builtin globals()
locals default=None dict of local variables
"""
if locals is None:
locals = {} # python 2.3's eval() won't accept None
g = cmath.__dict__
if globals is not None:
g.update(globals)
output = eval("lambda %s: (%s)" % (var, expr), g, locals)
split = lambda z: (z.real, z.imag)
output2 = lambda t: split(output(t))
set_func_name(output2, "%s -> %s" % (var, expr))
return output2
def funcRtoR2(expr, var="t", globals=None, locals=None):
"""Converts a "f(t), g(t)" string to a function acceptable for Curve.
expr required string in the form "f(t), g(t)"
var default="t" name of the independent variable
globals default=None dict of global variables used in the expression;
you may want to use Python's builtin globals()
locals default=None dict of local variables
"""
if locals is None:
locals = {} # python 2.3's eval() won't accept None
g = math.__dict__
if globals is not None:
g.update(globals)
output = eval("lambda %s: (%s)" % (var, expr), g, locals)
set_func_name(output, "%s -> %s" % (var, expr))
return output
def funcRtoR(expr, var="x", globals=None, locals=None):
"""Converts a "f(x)" string to a function acceptable for Curve.
expr required string in the form "f(x)"
var default="x" name of the independent variable
globals default=None dict of global variables used in the expression;
you may want to use Python's builtin globals()
locals default=None dict of local variables
"""
if locals is None:
locals = {} # python 2.3's eval() won't accept None
g = math.__dict__
if globals is not None:
g.update(globals)
output = eval("lambda %s: (%s, %s)" % (var, var, expr), g, locals)
set_func_name(output, "%s -> %s" % (var, expr))
return output
class Curve:
"""Draws a parametric function as a path.
Curve(f, low, high, loop, attribute=value)
f required a Python callable or string in
the form "f(t), g(t)"
low, high required left and right endpoints
loop default=False if True, connect the endpoints
attribute=value pairs keyword list SVG attributes
"""
defaults = {}
random_sampling = True
recursion_limit = 15
linearity_limit = 0.05
discontinuity_limit = 5.
def __repr__(self):
return "<Curve %s [%s, %s] %s>" % (self.f, self.low, self.high, self.attr)
def __init__(self, f, low, high, loop=False, **attr):
self.f = f
self.low = low
self.high = high
self.loop = loop
self.attr = dict(self.defaults)
self.attr.update(attr)
### nested class Sample
class Sample:
def __repr__(self):
t, x, y, X, Y = self.t, self.x, self.y, self.X, self.Y
if t is not None:
t = "%g" % t
if x is not None:
x = "%g" % x
if y is not None:
y = "%g" % y
if X is not None:
X = "%g" % X
if Y is not None:
Y = "%g" % Y
return "<Curve.Sample t=%s x=%s y=%s X=%s Y=%s>" % (t, x, y, X, Y)
def __init__(self, t):
self.t = t
def link(self, left, right):
self.left, self.right = left, right
def evaluate(self, f, trans):
self.x, self.y = f(self.t)
if trans is None:
self.X, self.Y = self.x, self.y
else:
self.X, self.Y = trans(self.x, self.y)
### end Sample
### nested class Samples
class Samples:
def __repr__(self):
return "<Curve.Samples (%d samples)>" % len(self)
def __init__(self, left, right):
self.left, self.right = left, right
def __len__(self):
count = 0
current = self.left
while current is not None:
count += 1
current = current.right
return count
def __iter__(self):
self.current = self.left
return self
def next(self):
current = self.current
if current is None:
raise StopIteration
self.current = self.current.right
return current
### end nested class
def sample(self, trans=None):
"""Adaptive-sampling algorithm that chooses the best sample points
for a parametric curve between two endpoints and detects
discontinuities. Called by SVG()."""
oldrecursionlimit = sys.getrecursionlimit()
sys.setrecursionlimit(self.recursion_limit + 100)
try:
# the best way to keep all the information while sampling is to make a linked list
if not (self.low < self.high):
raise ValueError, "low must be less than high"
low, high = self.Sample(float(self.low)), self.Sample(float(self.high))
low.link(None, high)
high.link(low, None)
low.evaluate(self.f, trans)
high.evaluate(self.f, trans)
# adaptive sampling between the low and high points
self.subsample(low, high, 0, trans)
# Prune excess points where the curve is nearly linear
left = low
while left.right is not None:
# increment mid and right
mid = left.right
right = mid.right
if (right is not None and
left.X is not None and left.Y is not None and
mid.X is not None and mid.Y is not None and
right.X is not None and right.Y is not None):
numer = left.X*(right.Y - mid.Y) + mid.X*(left.Y - right.Y) + right.X*(mid.Y - left.Y)
denom = math.sqrt((left.X - right.X)**2 + (left.Y - right.Y)**2)
if denom != 0. and abs(numer/denom) < self.linearity_limit:
# drop mid (the garbage collector will get it)
left.right = right
right.left = left
else:
# increment left
left = left.right
else:
left = left.right
self.last_samples = self.Samples(low, high)
finally:
sys.setrecursionlimit(oldrecursionlimit)
def subsample(self, left, right, depth, trans=None):
"""Part of the adaptive-sampling algorithm that chooses the best
sample points. Called by sample()."""
if self.random_sampling:
mid = self.Sample(left.t + random.uniform(0.3, 0.7) * (right.t - left.t))
else:
mid = self.Sample(left.t + 0.5 * (right.t - left.t))
left.right = mid
right.left = mid
mid.link(left, right)
mid.evaluate(self.f, trans)
# calculate the distance of closest approach of mid to the line between left and right
numer = left.X*(right.Y - mid.Y) + mid.X*(left.Y - right.Y) + right.X*(mid.Y - left.Y)
denom = math.sqrt((left.X - right.X)**2 + (left.Y - right.Y)**2)
# if we haven't sampled enough or left fails to be close enough to right, or mid fails to be linear enough...
if (depth < 3 or
(denom == 0 and left.t != right.t) or
denom > self.discontinuity_limit or
(denom != 0. and abs(numer/denom) > self.linearity_limit)):
# and we haven't sampled too many points
if depth < self.recursion_limit:
self.subsample(left, mid, depth+1, trans)
self.subsample(mid, right, depth+1, trans)
else:
# We've sampled many points and yet it's still not a small linear gap.
# Break the line: it's a discontinuity
mid.y = mid.Y = None
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
return self.Path(trans).SVG()
def Path(self, trans=None, local=False):
"""Apply the transformation "trans" and return a Path object in
global coordinates. If local=True, return a Path in local coordinates
(which must be transformed again)."""
if isinstance(trans, basestring):
trans = totrans(trans)
if isinstance(self.f, basestring):
self.f = funcRtoR2(self.f)
self.sample(trans)
output = []
for s in self.last_samples:
if s.X is not None and s.Y is not None:
if s.left is None or s.left.Y is None:
command = "M"
else:
command = "L"
if local:
output.append((command, s.x, s.y, False))
else:
output.append((command, s.X, s.Y, True))
if self.loop:
output.append(("Z",))
return Path(output, **self.attr)
######################################################################
class Poly:
"""Draws a curve specified by a sequence of points. The curve may be
piecewise linear, like a polygon, or a Bezier curve.
Poly(d, mode, loop, attribute=value)
d required list of tuples representing points
and possibly control points
mode default="L" "lines", "bezier", "velocity",
"foreback", "smooth", or an abbreviation
loop default=False if True, connect the first and last
point, closing the loop
attribute=value pairs keyword list SVG attributes
The format of the tuples in d depends on the mode.
"lines"/"L" d=[(x,y), (x,y), ...]
piecewise-linear segments joining the (x,y) points
"bezier"/"B" d=[(x, y, c1x, c1y, c2x, c2y), ...]
Bezier curve with two control points (control points
preceed (x,y), as in SVG paths). If (c1x,c1y) and
(c2x,c2y) both equal (x,y), you get a linear
interpolation ("lines")
"velocity"/"V" d=[(x, y, vx, vy), ...]
curve that passes through (x,y) with velocity (vx,vy)
(one unit of arclength per unit time); in other words,
(vx,vy) is the tangent vector at (x,y). If (vx,vy) is
(0,0), you get a linear interpolation ("lines").
"foreback"/"F" d=[(x, y, bx, by, fx, fy), ...]
like "velocity" except that there is a left derivative
(bx,by) and a right derivative (fx,fy). If (bx,by)
equals (fx,fy) (with no minus sign), you get a
"velocity" curve
"smooth"/"S" d=[(x,y), (x,y), ...]
a "velocity" interpolation with (vx,vy)[i] equal to
((x,y)[i+1] - (x,y)[i-1])/2: the minimal derivative
"""
defaults = {}
def __repr__(self):
return "<Poly (%d nodes) mode=%s loop=%s %s>" % (
len(self.d), self.mode, repr(self.loop), self.attr)
def __init__(self, d=[], mode="L", loop=False, **attr):
self.d = list(d)
self.mode = mode
self.loop = loop
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
return self.Path(trans).SVG()
def Path(self, trans=None, local=False):
"""Apply the transformation "trans" and return a Path object in
global coordinates. If local=True, return a Path in local coordinates
(which must be transformed again)."""
if isinstance(trans, basestring):
trans = totrans(trans)
if self.mode[0] == "L" or self.mode[0] == "l":
mode = "L"
elif self.mode[0] == "B" or self.mode[0] == "b":
mode = "B"
elif self.mode[0] == "V" or self.mode[0] == "v":
mode = "V"
elif self.mode[0] == "F" or self.mode[0] == "f":
mode = "F"
elif self.mode[0] == "S" or self.mode[0] == "s":
mode = "S"
vx, vy = [0.]*len(self.d), [0.]*len(self.d)
for i in xrange(len(self.d)):
inext = (i+1) % len(self.d)
iprev = (i-1) % len(self.d)
vx[i] = (self.d[inext][0] - self.d[iprev][0])/2.
vy[i] = (self.d[inext][1] - self.d[iprev][1])/2.
if not self.loop and (i == 0 or i == len(self.d)-1):
vx[i], vy[i] = 0., 0.
else:
raise ValueError, "mode must be \"lines\", \"bezier\", \"velocity\", \"foreback\", \"smooth\", or an abbreviation"
d = []
indexes = range(len(self.d))
if self.loop and len(self.d) > 0:
indexes.append(0)
for i in indexes:
inext = (i+1) % len(self.d)
iprev = (i-1) % len(self.d)
x, y = self.d[i][0], self.d[i][1]
if trans is None:
X, Y = x, y
else:
X, Y = trans(x, y)
if d == []:
if local:
d.append(("M", x, y, False))
else:
d.append(("M", X, Y, True))
elif mode == "L":
if local:
d.append(("L", x, y, False))
else:
d.append(("L", X, Y, True))
elif mode == "B":
c1x, c1y = self.d[i][2], self.d[i][3]
if trans is None:
C1X, C1Y = c1x, c1y
else:
C1X, C1Y = trans(c1x, c1y)
c2x, c2y = self.d[i][4], self.d[i][5]
if trans is None:
C2X, C2Y = c2x, c2y
else:
C2X, C2Y = trans(c2x, c2y)
if local:
d.append(("C", c1x, c1y, False, c2x, c2y, False, x, y, False))
else:
d.append(("C", C1X, C1Y, True, C2X, C2Y, True, X, Y, True))
elif mode == "V":
c1x, c1y = self.d[iprev][2]/3. + self.d[iprev][0], self.d[iprev][3]/3. + self.d[iprev][1]
c2x, c2y = self.d[i][2]/-3. + x, self.d[i][3]/-3. + y
if trans is None:
C1X, C1Y = c1x, c1y
else:
C1X, C1Y = trans(c1x, c1y)
if trans is None:
C2X, C2Y = c2x, c2y
else:
C2X, C2Y = trans(c2x, c2y)
if local:
d.append(("C", c1x, c1y, False, c2x, c2y, False, x, y, False))
else:
d.append(("C", C1X, C1Y, True, C2X, C2Y, True, X, Y, True))
elif mode == "F":
c1x, c1y = self.d[iprev][4]/3. + self.d[iprev][0], self.d[iprev][5]/3. + self.d[iprev][1]
c2x, c2y = self.d[i][2]/-3. + x, self.d[i][3]/-3. + y
if trans is None:
C1X, C1Y = c1x, c1y
else:
C1X, C1Y = trans(c1x, c1y)
if trans is None:
C2X, C2Y = c2x, c2y
else:
C2X, C2Y = trans(c2x, c2y)
if local:
d.append(("C", c1x, c1y, False, c2x, c2y, False, x, y, False))
else:
d.append(("C", C1X, C1Y, True, C2X, C2Y, True, X, Y, True))
elif mode == "S":
c1x, c1y = vx[iprev]/3. + self.d[iprev][0], vy[iprev]/3. + self.d[iprev][1]
c2x, c2y = vx[i]/-3. + x, vy[i]/-3. + y
if trans is None:
C1X, C1Y = c1x, c1y
else:
C1X, C1Y = trans(c1x, c1y)
if trans is None:
C2X, C2Y = c2x, c2y
else:
C2X, C2Y = trans(c2x, c2y)
if local:
d.append(("C", c1x, c1y, False, c2x, c2y, False, x, y, False))
else:
d.append(("C", C1X, C1Y, True, C2X, C2Y, True, X, Y, True))
if self.loop and len(self.d) > 0:
d.append(("Z",))
return Path(d, **self.attr)
######################################################################
class Text:
"""Draws a text string at a specified point in local coordinates.
x, y required location of the point in local coordinates
d required text/Unicode string
attribute=value pairs keyword list SVG attributes
"""
defaults = {"stroke": "none", "fill": "black", "font-size": 5, }
def __repr__(self):
return "<Text %s at (%g, %g) %s>" % (repr(self.d), self.x, self.y, self.attr)
def __init__(self, x, y, d, **attr):
self.x = x
self.y = y
self.d = unicode(d)
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
if isinstance(trans, basestring):
trans = totrans(trans)
X, Y = self.x, self.y
if trans is not None:
X, Y = trans(X, Y)
return SVG("text", self.d, x=X, y=Y, **self.attr)
class TextGlobal:
"""Draws a text string at a specified point in global coordinates.
x, y required location of the point in global coordinates
d required text/Unicode string
attribute=value pairs keyword list SVG attributes
"""
defaults = {"stroke": "none", "fill": "black", "font-size": 5, }
def __repr__(self):
return "<TextGlobal %s at (%s, %s) %s>" % (repr(self.d), str(self.x), str(self.y), self.attr)
def __init__(self, x, y, d, **attr):
self.x = x
self.y = y
self.d = unicode(d)
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
return SVG("text", self.d, x=self.x, y=self.y, **self.attr)
######################################################################
_symbol_templates = {"dot": SVG("symbol", SVG("circle", cx=0, cy=0, r=1, stroke="none", fill="black"), viewBox="0 0 1 1", overflow="visible"),
"box": SVG("symbol", SVG("rect", x1=-1, y1=-1, x2=1, y2=1, stroke="none", fill="black"), viewBox="0 0 1 1", overflow="visible"),
"uptri": SVG("symbol", SVG("path", d="M -1 0.866 L 1 0.866 L 0 -0.866 Z", stroke="none", fill="black"), viewBox="0 0 1 1", overflow="visible"),
"downtri": SVG("symbol", SVG("path", d="M -1 -0.866 L 1 -0.866 L 0 0.866 Z", stroke="none", fill="black"), viewBox="0 0 1 1", overflow="visible"),
}
def make_symbol(id, shape="dot", **attr):
"""Creates a new instance of an SVG symbol to avoid cross-linking objects.
id required a new identifier (string/Unicode)
shape default="dot" the shape name from _symbol_templates
attribute=value list keyword list modify the SVG attributes of the new symbol
"""
output = copy.deepcopy(_symbol_templates[shape])
for i in output.sub:
i.attr.update(attr_preprocess(attr))
output["id"] = id
return output
_circular_dot = make_symbol("circular_dot")
class Dots:
"""Dots draws SVG symbols at a set of points.
d required list of (x,y) points
symbol default=None SVG symbol or a new identifier to
label an auto-generated symbol;
if None, use pre-defined _circular_dot
width, height default=1, 1 width and height of the symbols
in SVG coordinates
attribute=value pairs keyword list SVG attributes
"""
defaults = {}
def __repr__(self):
return "<Dots (%d nodes) %s>" % (len(self.d), self.attr)
def __init__(self, d=[], symbol=None, width=1., height=1., **attr):
self.d = list(d)
self.width = width
self.height = height
self.attr = dict(self.defaults)
self.attr.update(attr)
if symbol is None:
self.symbol = _circular_dot
elif isinstance(symbol, SVG):
self.symbol = symbol
else:
self.symbol = make_symbol(symbol)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
if isinstance(trans, basestring):
trans = totrans(trans)
output = SVG("g", SVG("defs", self.symbol))
id = "#%s" % self.symbol["id"]
for p in self.d:
x, y = p[0], p[1]
if trans is None:
X, Y = x, y
else:
X, Y = trans(x, y)
item = SVG("use", x=X, y=Y, xlink__href=id)
if self.width is not None:
item["width"] = self.width
if self.height is not None:
item["height"] = self.height
output.append(item)
return output
######################################################################
_marker_templates = {"arrow_start": SVG("marker", SVG("path", d="M 9 3.6 L 10.5 0 L 0 3.6 L 10.5 7.2 L 9 3.6 Z"), viewBox="0 0 10.5 7.2", refX="9", refY="3.6", markerWidth="10.5", markerHeight="7.2", markerUnits="strokeWidth", orient="auto", stroke="none", fill="black"),
"arrow_end": SVG("marker", SVG("path", d="M 1.5 3.6 L 0 0 L 10.5 3.6 L 0 7.2 L 1.5 3.6 Z"), viewBox="0 0 10.5 7.2", refX="1.5", refY="3.6", markerWidth="10.5", markerHeight="7.2", markerUnits="strokeWidth", orient="auto", stroke="none", fill="black"),
}
def make_marker(id, shape, **attr):
"""Creates a new instance of an SVG marker to avoid cross-linking objects.
id required a new identifier (string/Unicode)
shape required the shape name from _marker_templates
attribute=value list keyword list modify the SVG attributes of the new marker
"""
output = copy.deepcopy(_marker_templates[shape])
for i in output.sub:
i.attr.update(attr_preprocess(attr))
output["id"] = id
return output
class Line(Curve):
"""Draws a line between two points.
Line(x1, y1, x2, y2, arrow_start, arrow_end, attribute=value)
x1, y1 required the starting point
x2, y2 required the ending point
arrow_start default=None if an identifier string/Unicode,
draw a new arrow object at the
beginning of the line; if a marker,
draw that marker instead
arrow_end default=None same for the end of the line
attribute=value pairs keyword list SVG attributes
"""
defaults = {}
def __repr__(self):
return "<Line (%g, %g) to (%g, %g) %s>" % (
self.x1, self.y1, self.x2, self.y2, self.attr)
def __init__(self, x1, y1, x2, y2, arrow_start=None, arrow_end=None, **attr):
self.x1, self.y1, self.x2, self.y2 = x1, y1, x2, y2
self.arrow_start, self.arrow_end = arrow_start, arrow_end
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
line = self.Path(trans).SVG()
if ((self.arrow_start != False and self.arrow_start is not None) or
(self.arrow_end != False and self.arrow_end is not None)):
defs = SVG("defs")
if self.arrow_start != False and self.arrow_start is not None:
if isinstance(self.arrow_start, SVG):
defs.append(self.arrow_start)
line.attr["marker-start"] = "url(#%s)" % self.arrow_start["id"]
elif isinstance(self.arrow_start, basestring):
defs.append(make_marker(self.arrow_start, "arrow_start"))
line.attr["marker-start"] = "url(#%s)" % self.arrow_start
else:
raise TypeError, "arrow_start must be False/None or an id string for the new marker"
if self.arrow_end != False and self.arrow_end is not None:
if isinstance(self.arrow_end, SVG):
defs.append(self.arrow_end)
line.attr["marker-end"] = "url(#%s)" % self.arrow_end["id"]
elif isinstance(self.arrow_end, basestring):
defs.append(make_marker(self.arrow_end, "arrow_end"))
line.attr["marker-end"] = "url(#%s)" % self.arrow_end
else:
raise TypeError, "arrow_end must be False/None or an id string for the new marker"
return SVG("g", defs, line)
return line
def Path(self, trans=None, local=False):
"""Apply the transformation "trans" and return a Path object in
global coordinates. If local=True, return a Path in local coordinates
(which must be transformed again)."""
self.f = lambda t: (self.x1 + t*(self.x2 - self.x1), self.y1 + t*(self.y2 - self.y1))
self.low = 0.
self.high = 1.
self.loop = False
if trans is None:
return Path([("M", self.x1, self.y1, not local), ("L", self.x2, self.y2, not local)], **self.attr)
else:
return Curve.Path(self, trans, local)
class LineGlobal:
"""Draws a line between two points, one or both of which is in
global coordinates.
Line(x1, y1, x2, y2, lcoal1, local2, arrow_start, arrow_end, attribute=value)
x1, y1 required the starting point
x2, y2 required the ending point
local1 default=False if True, interpret first point as a
local coordinate (apply transform)
local2 default=False if True, interpret second point as a
local coordinate (apply transform)
arrow_start default=None if an identifier string/Unicode,
draw a new arrow object at the
beginning of the line; if a marker,
draw that marker instead
arrow_end default=None same for the end of the line
attribute=value pairs keyword list SVG attributes
"""
defaults = {}
def __repr__(self):
local1, local2 = "", ""
if self.local1:
local1 = "L"
if self.local2:
local2 = "L"
return "<LineGlobal %s(%s, %s) to %s(%s, %s) %s>" % (
local1, str(self.x1), str(self.y1), local2, str(self.x2), str(self.y2), self.attr)
def __init__(self, x1, y1, x2, y2, local1=False, local2=False, arrow_start=None, arrow_end=None, **attr):
self.x1, self.y1, self.x2, self.y2 = x1, y1, x2, y2
self.local1, self.local2 = local1, local2
self.arrow_start, self.arrow_end = arrow_start, arrow_end
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
if isinstance(trans, basestring):
trans = totrans(trans)
X1, Y1, X2, Y2 = self.x1, self.y1, self.x2, self.y2
if self.local1:
X1, Y1 = trans(X1, Y1)
if self.local2:
X2, Y2 = trans(X2, Y2)
line = SVG("path", d="M%s %s L%s %s" % (X1, Y1, X2, Y2), **self.attr)
if ((self.arrow_start != False and self.arrow_start is not None) or
(self.arrow_end != False and self.arrow_end is not None)):
defs = SVG("defs")
if self.arrow_start != False and self.arrow_start is not None:
if isinstance(self.arrow_start, SVG):
defs.append(self.arrow_start)
line.attr["marker-start"] = "url(#%s)" % self.arrow_start["id"]
elif isinstance(self.arrow_start, basestring):
defs.append(make_marker(self.arrow_start, "arrow_start"))
line.attr["marker-start"] = "url(#%s)" % self.arrow_start
else:
raise TypeError, "arrow_start must be False/None or an id string for the new marker"
if self.arrow_end != False and self.arrow_end is not None:
if isinstance(self.arrow_end, SVG):
defs.append(self.arrow_end)
line.attr["marker-end"] = "url(#%s)" % self.arrow_end["id"]
elif isinstance(self.arrow_end, basestring):
defs.append(make_marker(self.arrow_end, "arrow_end"))
line.attr["marker-end"] = "url(#%s)" % self.arrow_end
else:
raise TypeError, "arrow_end must be False/None or an id string for the new marker"
return SVG("g", defs, line)
return line
class VLine(Line):
"""Draws a vertical line.
VLine(y1, y2, x, attribute=value)
y1, y2 required y range
x required x position
attribute=value pairs keyword list SVG attributes
"""
defaults = {}
def __repr__(self):
return "<VLine (%g, %g) at x=%s %s>" % (self.y1, self.y2, self.x, self.attr)
def __init__(self, y1, y2, x, **attr):
self.x = x
self.attr = dict(self.defaults)
self.attr.update(attr)
Line.__init__(self, x, y1, x, y2, **self.attr)
def Path(self, trans=None, local=False):
"""Apply the transformation "trans" and return a Path object in
global coordinates. If local=True, return a Path in local coordinates
(which must be transformed again)."""
self.x1 = self.x
self.x2 = self.x
return Line.Path(self, trans, local)
class HLine(Line):
"""Draws a horizontal line.
HLine(x1, x2, y, attribute=value)
x1, x2 required x range
y required y position
attribute=value pairs keyword list SVG attributes
"""
defaults = {}
def __repr__(self):
return "<HLine (%g, %g) at y=%s %s>" % (self.x1, self.x2, self.y, self.attr)
def __init__(self, x1, x2, y, **attr):
self.y = y
self.attr = dict(self.defaults)
self.attr.update(attr)
Line.__init__(self, x1, y, x2, y, **self.attr)
def Path(self, trans=None, local=False):
"""Apply the transformation "trans" and return a Path object in
global coordinates. If local=True, return a Path in local coordinates
(which must be transformed again)."""
self.y1 = self.y
self.y2 = self.y
return Line.Path(self, trans, local)
######################################################################
class Rect(Curve):
"""Draws a rectangle.
Rect(x1, y1, x2, y2, attribute=value)
x1, y1 required the starting point
x2, y2 required the ending point
attribute=value pairs keyword list SVG attributes
"""
defaults = {}
def __repr__(self):
return "<Rect (%g, %g), (%g, %g) %s>" % (
self.x1, self.y1, self.x2, self.y2, self.attr)
def __init__(self, x1, y1, x2, y2, **attr):
self.x1, self.y1, self.x2, self.y2 = x1, y1, x2, y2
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
return self.Path(trans).SVG()
def Path(self, trans=None, local=False):
"""Apply the transformation "trans" and return a Path object in
global coordinates. If local=True, return a Path in local coordinates
(which must be transformed again)."""
if trans is None:
return Path([("M", self.x1, self.y1, not local), ("L", self.x2, self.y1, not local), ("L", self.x2, self.y2, not local), ("L", self.x1, self.y2, not local), ("Z",)], **self.attr)
else:
self.low = 0.
self.high = 1.
self.loop = False
self.f = lambda t: (self.x1 + t*(self.x2 - self.x1), self.y1)
d1 = Curve.Path(self, trans, local).d
self.f = lambda t: (self.x2, self.y1 + t*(self.y2 - self.y1))
d2 = Curve.Path(self, trans, local).d
del d2[0]
self.f = lambda t: (self.x2 + t*(self.x1 - self.x2), self.y2)
d3 = Curve.Path(self, trans, local).d
del d3[0]
self.f = lambda t: (self.x1, self.y2 + t*(self.y1 - self.y2))
d4 = Curve.Path(self, trans, local).d
del d4[0]
return Path(d=(d1 + d2 + d3 + d4 + [("Z",)]), **self.attr)
######################################################################
class Ellipse(Curve):
"""Draws an ellipse from a semimajor vector (ax,ay) and a semiminor
length (b).
Ellipse(x, y, ax, ay, b, attribute=value)
x, y required the center of the ellipse/circle
ax, ay required a vector indicating the length
and direction of the semimajor axis
b required the length of the semiminor axis.
If equal to sqrt(ax2 + ay2), the
ellipse is a circle
attribute=value pairs keyword list SVG attributes
(If sqrt(ax**2 + ay**2) is less than b, then (ax,ay) is actually the
semiminor axis.)
"""
defaults = {}
def __repr__(self):
return "<Ellipse (%g, %g) a=(%g, %g), b=%g %s>" % (
self.x, self.y, self.ax, self.ay, self.b, self.attr)
def __init__(self, x, y, ax, ay, b, **attr):
self.x, self.y, self.ax, self.ay, self.b = x, y, ax, ay, b
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
return self.Path(trans).SVG()
def Path(self, trans=None, local=False):
"""Apply the transformation "trans" and return a Path object in
global coordinates. If local=True, return a Path in local coordinates
(which must be transformed again)."""
angle = math.atan2(self.ay, self.ax) + math.pi/2.
bx = self.b * math.cos(angle)
by = self.b * math.sin(angle)
self.f = lambda t: (self.x + self.ax*math.cos(t) + bx*math.sin(t), self.y + self.ay*math.cos(t) + by*math.sin(t))
self.low = -math.pi
self.high = math.pi
self.loop = True
return Curve.Path(self, trans, local)
######################################################################
def unumber(x):
"""Converts numbers to a Unicode string, taking advantage of special
Unicode characters to make nice minus signs and scientific notation.
"""
output = u"%g" % x
if output[0] == u"-":
output = u"\u2013" + output[1:]
index = output.find(u"e")
if index != -1:
uniout = unicode(output[:index]) + u"\u00d710"
saw_nonzero = False
for n in output[index+1:]:
if n == u"+":
pass # uniout += u"\u207a"
elif n == u"-":
uniout += u"\u207b"
elif n == u"0":
if saw_nonzero:
uniout += u"\u2070"
elif n == u"1":
saw_nonzero = True
uniout += u"\u00b9"
elif n == u"2":
saw_nonzero = True
uniout += u"\u00b2"
elif n == u"3":
saw_nonzero = True
uniout += u"\u00b3"
elif u"4" <= n <= u"9":
saw_nonzero = True
if saw_nonzero:
uniout += eval("u\"\\u%x\"" % (0x2070 + ord(n) - ord(u"0")))
else:
uniout += n
if uniout[:2] == u"1\u00d7":
uniout = uniout[2:]
return uniout
return output
class Ticks:
"""Superclass for all graphics primitives that draw ticks,
miniticks, and tick labels. This class only draws the ticks.
Ticks(f, low, high, ticks, miniticks, labels, logbase, arrow_start,
arrow_end, text_attr, attribute=value)
f required parametric function along which ticks
will be drawn; has the same format as
the function used in Curve
low, high required range of the independent variable
ticks default=-10 request ticks according to the standard
tick specification (see below)
miniticks default=True request miniticks according to the
standard minitick specification (below)
labels True request tick labels according to the
standard tick label specification (below)
logbase default=None if a number, the axis is logarithmic with
ticks at the given base (usually 10)
arrow_start default=None if a new string identifier, draw an arrow
at the low-end of the axis, referenced by
that identifier; if an SVG marker object,
use that marker
arrow_end default=None if a new string identifier, draw an arrow
at the high-end of the axis, referenced by
that identifier; if an SVG marker object,
use that marker
text_attr default={} SVG attributes for the text labels
attribute=value pairs keyword list SVG attributes for the tick marks
Standard tick specification:
* True: same as -10 (below).
* Positive number N: draw exactly N ticks, including the endpoints. To
subdivide an axis into 10 equal-sized segments, ask for 11 ticks.
* Negative number -N: draw at least N ticks. Ticks will be chosen with
"natural" values, multiples of 2 or 5.
* List of values: draw a tick mark at each value.
* Dict of value, label pairs: draw a tick mark at each value, labeling
it with the given string. This lets you say things like {3.14159: "pi"}.
* False or None: no ticks.
Standard minitick specification:
* True: draw miniticks with "natural" values, more closely spaced than
the ticks.
* Positive number N: draw exactly N miniticks, including the endpoints.
To subdivide an axis into 100 equal-sized segments, ask for 101 miniticks.
* Negative number -N: draw at least N miniticks.
* List of values: draw a minitick mark at each value.
* False or None: no miniticks.
Standard tick label specification:
* True: use the unumber function (described below)
* Format string: standard format strings, e.g. "%5.2f" for 12.34
* Python callable: function that converts numbers to strings
* False or None: no labels
"""
defaults = {"stroke-width": "0.25pt", }
text_defaults = {"stroke": "none", "fill": "black", "font-size": 5, }
tick_start = -1.5
tick_end = 1.5
minitick_start = -0.75
minitick_end = 0.75
text_start = 2.5
text_angle = 0.
def __repr__(self):
return "<Ticks %s from %s to %s ticks=%s labels=%s %s>" % (
self.f, self.low, self.high, str(self.ticks), str(self.labels), self.attr)
def __init__(self, f, low, high, ticks=-10, miniticks=True, labels=True, logbase=None,
arrow_start=None, arrow_end=None, text_attr={}, **attr):
self.f = f
self.low = low
self.high = high
self.ticks = ticks
self.miniticks = miniticks
self.labels = labels
self.logbase = logbase
self.arrow_start = arrow_start
self.arrow_end = arrow_end
self.attr = dict(self.defaults)
self.attr.update(attr)
self.text_attr = dict(self.text_defaults)
self.text_attr.update(text_attr)
def orient_tickmark(self, t, trans=None):
"""Return the position, normalized local x vector, normalized
local y vector, and angle of a tick at position t.
Normally only used internally.
"""
if isinstance(trans, basestring):
trans = totrans(trans)
if trans is None:
f = self.f
else:
f = lambda t: trans(*self.f(t))
eps = _epsilon * abs(self.high - self.low)
X, Y = f(t)
Xprime, Yprime = f(t + eps)
xhatx, xhaty = (Xprime - X)/eps, (Yprime - Y)/eps
norm = math.sqrt(xhatx**2 + xhaty**2)
if norm != 0:
xhatx, xhaty = xhatx/norm, xhaty/norm
else:
xhatx, xhaty = 1., 0.
angle = math.atan2(xhaty, xhatx) + math.pi/2.
yhatx, yhaty = math.cos(angle), math.sin(angle)
return (X, Y), (xhatx, xhaty), (yhatx, yhaty), angle
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
if isinstance(trans, basestring):
trans = totrans(trans)
self.last_ticks, self.last_miniticks = self.interpret()
tickmarks = Path([], **self.attr)
minitickmarks = Path([], **self.attr)
output = SVG("g")
if ((self.arrow_start != False and self.arrow_start is not None) or
(self.arrow_end != False and self.arrow_end is not None)):
defs = SVG("defs")
if self.arrow_start != False and self.arrow_start is not None:
if isinstance(self.arrow_start, SVG):
defs.append(self.arrow_start)
elif isinstance(self.arrow_start, basestring):
defs.append(make_marker(self.arrow_start, "arrow_start"))
else:
raise TypeError, "arrow_start must be False/None or an id string for the new marker"
if self.arrow_end != False and self.arrow_end is not None:
if isinstance(self.arrow_end, SVG):
defs.append(self.arrow_end)
elif isinstance(self.arrow_end, basestring):
defs.append(make_marker(self.arrow_end, "arrow_end"))
else:
raise TypeError, "arrow_end must be False/None or an id string for the new marker"
output.append(defs)
eps = _epsilon * (self.high - self.low)
for t, label in self.last_ticks.items():
(X, Y), (xhatx, xhaty), (yhatx, yhaty), angle = self.orient_tickmark(t, trans)
if ((not self.arrow_start or abs(t - self.low) > eps) and
(not self.arrow_end or abs(t - self.high) > eps)):
tickmarks.d.append(("M", X - yhatx*self.tick_start, Y - yhaty*self.tick_start, True))
tickmarks.d.append(("L", X - yhatx*self.tick_end, Y - yhaty*self.tick_end, True))
angle = (angle - math.pi/2.)*180./math.pi + self.text_angle
########### a HACK! ############ (to be removed when Inkscape handles baselines)
if _hacks["inkscape-text-vertical-shift"]:
if self.text_start > 0:
X += math.cos(angle*math.pi/180. + math.pi/2.) * 2.
Y += math.sin(angle*math.pi/180. + math.pi/2.) * 2.
else:
X += math.cos(angle*math.pi/180. + math.pi/2.) * 2. * 2.5
Y += math.sin(angle*math.pi/180. + math.pi/2.) * 2. * 2.5
########### end hack ###########
if label != "":
output.append(SVG("text", label, transform="translate(%g, %g) rotate(%g)" %
(X - yhatx*self.text_start, Y - yhaty*self.text_start, angle), **self.text_attr))
for t in self.last_miniticks:
skip = False
for tt in self.last_ticks.keys():
if abs(t - tt) < eps:
skip = True
break
if not skip:
(X, Y), (xhatx, xhaty), (yhatx, yhaty), angle = self.orient_tickmark(t, trans)
if ((not self.arrow_start or abs(t - self.low) > eps) and
(not self.arrow_end or abs(t - self.high) > eps)):
minitickmarks.d.append(("M", X - yhatx*self.minitick_start, Y - yhaty*self.minitick_start, True))
minitickmarks.d.append(("L", X - yhatx*self.minitick_end, Y - yhaty*self.minitick_end, True))
output.prepend(tickmarks.SVG(trans))
output.prepend(minitickmarks.SVG(trans))
return output
def interpret(self):
"""Evaluate and return optimal ticks and miniticks according to
the standard minitick specification.
Normally only used internally.
"""
if self.labels is None or self.labels == False:
format = lambda x: ""
elif self.labels == True:
format = unumber
elif isinstance(self.labels, basestring):
format = lambda x: (self.labels % x)
elif callable(self.labels):
format = self.labels
else:
raise TypeError, "labels must be None/False, True, a format string, or a number->string function"
# Now for the ticks
ticks = self.ticks
# Case 1: ticks is None/False
if ticks is None or ticks == False:
return {}, []
# Case 2: ticks is the number of desired ticks
elif isinstance(ticks, (int, long)):
if ticks == True:
ticks = -10
if self.logbase is None:
ticks = self.compute_ticks(ticks, format)
else:
ticks = self.compute_logticks(self.logbase, ticks, format)
# Now for the miniticks
if self.miniticks == True:
if self.logbase is None:
return ticks, self.compute_miniticks(ticks)
else:
return ticks, self.compute_logminiticks(self.logbase)
elif isinstance(self.miniticks, (int, long)):
return ticks, self.regular_miniticks(self.miniticks)
elif getattr(self.miniticks, "__iter__", False):
return ticks, self.miniticks
elif self.miniticks == False or self.miniticks is None:
return ticks, []
else:
raise TypeError, "miniticks must be None/False, True, a number of desired miniticks, or a list of numbers"
# Cases 3 & 4: ticks is iterable
elif getattr(ticks, "__iter__", False):
# Case 3: ticks is some kind of list
if not isinstance(ticks, dict):
output = {}
eps = _epsilon * (self.high - self.low)
for x in ticks:
if format == unumber and abs(x) < eps:
output[x] = u"0"
else:
output[x] = format(x)
ticks = output
# Case 4: ticks is a dict
else:
pass
# Now for the miniticks
if self.miniticks == True:
if self.logbase is None:
return ticks, self.compute_miniticks(ticks)
else:
return ticks, self.compute_logminiticks(self.logbase)
elif isinstance(self.miniticks, (int, long)):
return ticks, self.regular_miniticks(self.miniticks)
elif getattr(self.miniticks, "__iter__", False):
return ticks, self.miniticks
elif self.miniticks == False or self.miniticks is None:
return ticks, []
else:
raise TypeError, "miniticks must be None/False, True, a number of desired miniticks, or a list of numbers"
else:
raise TypeError, "ticks must be None/False, a number of desired ticks, a list of numbers, or a dictionary of explicit markers"
def compute_ticks(self, N, format):
"""Return less than -N or exactly N optimal linear ticks.
Normally only used internally.
"""
if self.low >= self.high:
raise ValueError, "low must be less than high"
if N == 1:
raise ValueError, "N can be 0 or >1 to specify the exact number of ticks or negative to specify a maximum"
eps = _epsilon * (self.high - self.low)
if N >= 0:
output = {}
x = self.low
for i in xrange(N):
if format == unumber and abs(x) < eps:
label = u"0"
else:
label = format(x)
output[x] = label
x += (self.high - self.low)/(N-1.)
return output
N = -N
counter = 0
granularity = 10**math.ceil(math.log10(max(abs(self.low), abs(self.high))))
lowN = math.ceil(1.*self.low / granularity)
highN = math.floor(1.*self.high / granularity)
while lowN > highN:
countermod3 = counter % 3
if countermod3 == 0:
granularity *= 0.5
elif countermod3 == 1:
granularity *= 0.4
else:
granularity *= 0.5
counter += 1
lowN = math.ceil(1.*self.low / granularity)
highN = math.floor(1.*self.high / granularity)
last_granularity = granularity
last_trial = None
while True:
trial = {}
for n in range(int(lowN), int(highN)+1):
x = n * granularity
if format == unumber and abs(x) < eps:
label = u"0"
else:
label = format(x)
trial[x] = label
if int(highN)+1 - int(lowN) >= N:
if last_trial is None:
v1, v2 = self.low, self.high
return {v1: format(v1), v2: format(v2)}
else:
low_in_ticks, high_in_ticks = False, False
for t in last_trial.keys():
if 1.*abs(t - self.low)/last_granularity < _epsilon:
low_in_ticks = True
if 1.*abs(t - self.high)/last_granularity < _epsilon:
high_in_ticks = True
lowN = 1.*self.low / last_granularity
highN = 1.*self.high / last_granularity
if abs(lowN - round(lowN)) < _epsilon and not low_in_ticks:
last_trial[self.low] = format(self.low)
if abs(highN - round(highN)) < _epsilon and not high_in_ticks:
last_trial[self.high] = format(self.high)
return last_trial
last_granularity = granularity
last_trial = trial
countermod3 = counter % 3
if countermod3 == 0:
granularity *= 0.5
elif countermod3 == 1:
granularity *= 0.4
else:
granularity *= 0.5
counter += 1
lowN = math.ceil(1.*self.low / granularity)
highN = math.floor(1.*self.high / granularity)
def regular_miniticks(self, N):
"""Return exactly N linear ticks.
Normally only used internally.
"""
output = []
x = self.low
for i in xrange(N):
output.append(x)
x += (self.high - self.low)/(N-1.)
return output
def compute_miniticks(self, original_ticks):
"""Return optimal linear miniticks, given a set of ticks.
Normally only used internally.
"""
if len(original_ticks) < 2:
original_ticks = ticks(self.low, self.high) # XXX ticks is undefined!
original_ticks = original_ticks.keys()
original_ticks.sort()
if self.low > original_ticks[0] + _epsilon or self.high < original_ticks[-1] - _epsilon:
raise ValueError, "original_ticks {%g...%g} extend beyond [%g, %g]" % (original_ticks[0], original_ticks[-1], self.low, self.high)
granularities = []
for i in range(len(original_ticks)-1):
granularities.append(original_ticks[i+1] - original_ticks[i])
spacing = 10**(math.ceil(math.log10(min(granularities)) - 1))
output = []
x = original_ticks[0] - math.ceil(1.*(original_ticks[0] - self.low) / spacing) * spacing
while x <= self.high:
if x >= self.low:
already_in_ticks = False
for t in original_ticks:
if abs(x-t) < _epsilon * (self.high - self.low):
already_in_ticks = True
if not already_in_ticks:
output.append(x)
x += spacing
return output
def compute_logticks(self, base, N, format):
"""Return less than -N or exactly N optimal logarithmic ticks.
Normally only used internally.
"""
if self.low >= self.high:
raise ValueError, "low must be less than high"
if N == 1:
raise ValueError, "N can be 0 or >1 to specify the exact number of ticks or negative to specify a maximum"
eps = _epsilon * (self.high - self.low)
if N >= 0:
output = {}
x = self.low
for i in xrange(N):
if format == unumber and abs(x) < eps:
label = u"0"
else:
label = format(x)
output[x] = label
x += (self.high - self.low)/(N-1.)
return output
N = -N
lowN = math.floor(math.log(self.low, base))
highN = math.ceil(math.log(self.high, base))
output = {}
for n in range(int(lowN), int(highN)+1):
x = base**n
label = format(x)
if self.low <= x <= self.high:
output[x] = label
for i in range(1, len(output)):
keys = output.keys()
keys.sort()
keys = keys[::i]
values = map(lambda k: output[k], keys)
if len(values) <= N:
for k in output.keys():
if k not in keys:
output[k] = ""
break
if len(output) <= 2:
output2 = self.compute_ticks(N=-int(math.ceil(N/2.)), format=format)
lowest = min(output2)
for k in output:
if k < lowest:
output2[k] = output[k]
output = output2
return output
def compute_logminiticks(self, base):
"""Return optimal logarithmic miniticks, given a set of ticks.
Normally only used internally.
"""
if self.low >= self.high:
raise ValueError, "low must be less than high"
lowN = math.floor(math.log(self.low, base))
highN = math.ceil(math.log(self.high, base))
output = []
num_ticks = 0
for n in range(int(lowN), int(highN)+1):
x = base**n
if self.low <= x <= self.high:
num_ticks += 1
for m in range(2, int(math.ceil(base))):
minix = m * x
if self.low <= minix <= self.high:
output.append(minix)
if num_ticks <= 2:
return []
else:
return output
######################################################################
class CurveAxis(Curve, Ticks):
"""Draw an axis with tick marks along a parametric curve.
CurveAxis(f, low, high, ticks, miniticks, labels, logbase, arrow_start, arrow_end,
text_attr, attribute=value)
f required a Python callable or string in
the form "f(t), g(t)", just like Curve
low, high required left and right endpoints
ticks default=-10 request ticks according to the standard
tick specification (see help(Ticks))
miniticks default=True request miniticks according to the
standard minitick specification
labels True request tick labels according to the
standard tick label specification
logbase default=None if a number, the x axis is logarithmic
with ticks at the given base (10 being
the most common)
arrow_start default=None if a new string identifier, draw an
arrow at the low-end of the axis,
referenced by that identifier; if an
SVG marker object, use that marker
arrow_end default=None if a new string identifier, draw an
arrow at the high-end of the axis,
referenced by that identifier; if an
SVG marker object, use that marker
text_attr default={} SVG attributes for the text labels
attribute=value pairs keyword list SVG attributes
"""
defaults = {"stroke-width": "0.25pt", }
text_defaults = {"stroke": "none", "fill": "black", "font-size": 5, }
def __repr__(self):
return "<CurveAxis %s [%s, %s] ticks=%s labels=%s %s>" % (
self.f, self.low, self.high, str(self.ticks), str(self.labels), self.attr)
def __init__(self, f, low, high, ticks=-10, miniticks=True, labels=True, logbase=None,
arrow_start=None, arrow_end=None, text_attr={}, **attr):
tattr = dict(self.text_defaults)
tattr.update(text_attr)
Curve.__init__(self, f, low, high)
Ticks.__init__(self, f, low, high, ticks, miniticks, labels, logbase, arrow_start, arrow_end, tattr, **attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
func = Curve.SVG(self, trans)
ticks = Ticks.SVG(self, trans) # returns a <g />
if self.arrow_start != False and self.arrow_start is not None:
if isinstance(self.arrow_start, basestring):
func.attr["marker-start"] = "url(#%s)" % self.arrow_start
else:
func.attr["marker-start"] = "url(#%s)" % self.arrow_start.id
if self.arrow_end != False and self.arrow_end is not None:
if isinstance(self.arrow_end, basestring):
func.attr["marker-end"] = "url(#%s)" % self.arrow_end
else:
func.attr["marker-end"] = "url(#%s)" % self.arrow_end.id
ticks.append(func)
return ticks
class LineAxis(Line, Ticks):
"""Draws an axis with tick marks along a line.
LineAxis(x1, y1, x2, y2, start, end, ticks, miniticks, labels, logbase,
arrow_start, arrow_end, text_attr, attribute=value)
x1, y1 required starting point
x2, y2 required ending point
start, end default=0, 1 values to start and end labeling
ticks default=-10 request ticks according to the standard
tick specification (see help(Ticks))
miniticks default=True request miniticks according to the
standard minitick specification
labels True request tick labels according to the
standard tick label specification
logbase default=None if a number, the x axis is logarithmic
with ticks at the given base (usually 10)
arrow_start default=None if a new string identifier, draw an arrow
at the low-end of the axis, referenced by
that identifier; if an SVG marker object,
use that marker
arrow_end default=None if a new string identifier, draw an arrow
at the high-end of the axis, referenced by
that identifier; if an SVG marker object,
use that marker
text_attr default={} SVG attributes for the text labels
attribute=value pairs keyword list SVG attributes
"""
defaults = {"stroke-width": "0.25pt", }
text_defaults = {"stroke": "none", "fill": "black", "font-size": 5, }
def __repr__(self):
return "<LineAxis (%g, %g) to (%g, %g) ticks=%s labels=%s %s>" % (
self.x1, self.y1, self.x2, self.y2, str(self.ticks), str(self.labels), self.attr)
def __init__(self, x1, y1, x2, y2, start=0., end=1., ticks=-10, miniticks=True, labels=True,
logbase=None, arrow_start=None, arrow_end=None, exclude=None, text_attr={}, **attr):
self.start = start
self.end = end
self.exclude = exclude
tattr = dict(self.text_defaults)
tattr.update(text_attr)
Line.__init__(self, x1, y1, x2, y2, **attr)
Ticks.__init__(self, None, None, None, ticks, miniticks, labels, logbase, arrow_start, arrow_end, tattr, **attr)
def interpret(self):
if self.exclude is not None and not (isinstance(self.exclude, (tuple, list)) and len(self.exclude) == 2 and
isinstance(self.exclude[0], (int, long, float)) and isinstance(self.exclude[1], (int, long, float))):
raise TypeError, "exclude must either be None or (low, high)"
ticks, miniticks = Ticks.interpret(self)
if self.exclude is None:
return ticks, miniticks
ticks2 = {}
for loc, label in ticks.items():
if self.exclude[0] <= loc <= self.exclude[1]:
ticks2[loc] = ""
else:
ticks2[loc] = label
return ticks2, miniticks
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
line = Line.SVG(self, trans) # must be evaluated first, to set self.f, self.low, self.high
f01 = self.f
self.f = lambda t: f01(1. * (t - self.start) / (self.end - self.start))
self.low = self.start
self.high = self.end
if self.arrow_start != False and self.arrow_start is not None:
if isinstance(self.arrow_start, basestring):
line.attr["marker-start"] = "url(#%s)" % self.arrow_start
else:
line.attr["marker-start"] = "url(#%s)" % self.arrow_start.id
if self.arrow_end != False and self.arrow_end is not None:
if isinstance(self.arrow_end, basestring):
line.attr["marker-end"] = "url(#%s)" % self.arrow_end
else:
line.attr["marker-end"] = "url(#%s)" % self.arrow_end.id
ticks = Ticks.SVG(self, trans) # returns a <g />
ticks.append(line)
return ticks
class XAxis(LineAxis):
"""Draws an x axis with tick marks.
XAxis(xmin, xmax, aty, ticks, miniticks, labels, logbase, arrow_start, arrow_end,
exclude, text_attr, attribute=value)
xmin, xmax required the x range
aty default=0 y position to draw the axis
ticks default=-10 request ticks according to the standard
tick specification (see help(Ticks))
miniticks default=True request miniticks according to the
standard minitick specification
labels True request tick labels according to the
standard tick label specification
logbase default=None if a number, the x axis is logarithmic
with ticks at the given base (usually 10)
arrow_start default=None if a new string identifier, draw an arrow
at the low-end of the axis, referenced by
that identifier; if an SVG marker object,
use that marker
arrow_end default=None if a new string identifier, draw an arrow
at the high-end of the axis, referenced by
that identifier; if an SVG marker object,
use that marker
exclude default=None if a (low, high) pair, don't draw text
labels within this range
text_attr default={} SVG attributes for the text labels
attribute=value pairs keyword list SVG attributes for all lines
The exclude option is provided for Axes to keep text from overlapping
where the axes cross. Normal users are not likely to need it.
"""
defaults = {"stroke-width": "0.25pt", }
text_defaults = {"stroke": "none", "fill": "black", "font-size": 5, "dominant-baseline": "text-before-edge", }
text_start = -1.
text_angle = 0.
def __repr__(self):
return "<XAxis (%g, %g) at y=%g ticks=%s labels=%s %s>" % (
self.xmin, self.xmax, self.aty, str(self.ticks), str(self.labels), self.attr) # XXX self.xmin/xmax undefd!
def __init__(self, xmin, xmax, aty=0, ticks=-10, miniticks=True, labels=True, logbase=None,
arrow_start=None, arrow_end=None, exclude=None, text_attr={}, **attr):
self.aty = aty
tattr = dict(self.text_defaults)
tattr.update(text_attr)
LineAxis.__init__(self, xmin, aty, xmax, aty, xmin, xmax, ticks, miniticks, labels, logbase, arrow_start, arrow_end, exclude, tattr, **attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
self.y1 = self.aty
self.y2 = self.aty
return LineAxis.SVG(self, trans)
class YAxis(LineAxis):
"""Draws a y axis with tick marks.
YAxis(ymin, ymax, atx, ticks, miniticks, labels, logbase, arrow_start, arrow_end,
exclude, text_attr, attribute=value)
ymin, ymax required the y range
atx default=0 x position to draw the axis
ticks default=-10 request ticks according to the standard
tick specification (see help(Ticks))
miniticks default=True request miniticks according to the
standard minitick specification
labels True request tick labels according to the
standard tick label specification
logbase default=None if a number, the y axis is logarithmic
with ticks at the given base (usually 10)
arrow_start default=None if a new string identifier, draw an arrow
at the low-end of the axis, referenced by
that identifier; if an SVG marker object,
use that marker
arrow_end default=None if a new string identifier, draw an arrow
at the high-end of the axis, referenced by
that identifier; if an SVG marker object,
use that marker
exclude default=None if a (low, high) pair, don't draw text
labels within this range
text_attr default={} SVG attributes for the text labels
attribute=value pairs keyword list SVG attributes for all lines
The exclude option is provided for Axes to keep text from overlapping
where the axes cross. Normal users are not likely to need it.
"""
defaults = {"stroke-width": "0.25pt", }
text_defaults = {"stroke": "none", "fill": "black", "font-size": 5, "text-anchor": "end", "dominant-baseline": "middle", }
text_start = 2.5
text_angle = 90.
def __repr__(self):
return "<YAxis (%g, %g) at x=%g ticks=%s labels=%s %s>" % (
self.ymin, self.ymax, self.atx, str(self.ticks), str(self.labels), self.attr) # XXX self.ymin/ymax undefd!
def __init__(self, ymin, ymax, atx=0, ticks=-10, miniticks=True, labels=True, logbase=None,
arrow_start=None, arrow_end=None, exclude=None, text_attr={}, **attr):
self.atx = atx
tattr = dict(self.text_defaults)
tattr.update(text_attr)
LineAxis.__init__(self, atx, ymin, atx, ymax, ymin, ymax, ticks, miniticks, labels, logbase, arrow_start, arrow_end, exclude, tattr, **attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
self.x1 = self.atx
self.x2 = self.atx
return LineAxis.SVG(self, trans)
class Axes:
"""Draw a pair of intersecting x-y axes.
Axes(xmin, xmax, ymin, ymax, atx, aty, xticks, xminiticks, xlabels, xlogbase,
yticks, yminiticks, ylabels, ylogbase, arrows, text_attr, attribute=value)
xmin, xmax required the x range
ymin, ymax required the y range
atx, aty default=0, 0 point where the axes try to cross;
if outside the range, the axes will
cross at the closest corner
xticks default=-10 request ticks according to the standard
tick specification (see help(Ticks))
xminiticks default=True request miniticks according to the
standard minitick specification
xlabels True request tick labels according to the
standard tick label specification
xlogbase default=None if a number, the x axis is logarithmic
with ticks at the given base (usually 10)
yticks default=-10 request ticks according to the standard
tick specification
yminiticks default=True request miniticks according to the
standard minitick specification
ylabels True request tick labels according to the
standard tick label specification
ylogbase default=None if a number, the y axis is logarithmic
with ticks at the given base (usually 10)
arrows default=None if a new string identifier, draw arrows
referenced by that identifier
text_attr default={} SVG attributes for the text labels
attribute=value pairs keyword list SVG attributes for all lines
"""
defaults = {"stroke-width": "0.25pt", }
text_defaults = {"stroke": "none", "fill": "black", "font-size": 5, }
def __repr__(self):
return "<Axes x=(%g, %g) y=(%g, %g) at (%g, %g) %s>" % (
self.xmin, self.xmax, self.ymin, self.ymax, self.atx, self.aty, self.attr)
def __init__(self, xmin, xmax, ymin, ymax, atx=0, aty=0,
xticks=-10, xminiticks=True, xlabels=True, xlogbase=None,
yticks=-10, yminiticks=True, ylabels=True, ylogbase=None,
arrows=None, text_attr={}, **attr):
self.xmin, self.xmax = xmin, xmax
self.ymin, self.ymax = ymin, ymax
self.atx, self.aty = atx, aty
self.xticks, self.xminiticks, self.xlabels, self.xlogbase = xticks, xminiticks, xlabels, xlogbase
self.yticks, self.yminiticks, self.ylabels, self.ylogbase = yticks, yminiticks, ylabels, ylogbase
self.arrows = arrows
self.text_attr = dict(self.text_defaults)
self.text_attr.update(text_attr)
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
atx, aty = self.atx, self.aty
if atx < self.xmin:
atx = self.xmin
if atx > self.xmax:
atx = self.xmax
if aty < self.ymin:
aty = self.ymin
if aty > self.ymax:
aty = self.ymax
xmargin = 0.1 * abs(self.ymin - self.ymax)
xexclude = atx - xmargin, atx + xmargin
ymargin = 0.1 * abs(self.xmin - self.xmax)
yexclude = aty - ymargin, aty + ymargin
if self.arrows is not None and self.arrows != False:
xarrow_start = self.arrows + ".xstart"
xarrow_end = self.arrows + ".xend"
yarrow_start = self.arrows + ".ystart"
yarrow_end = self.arrows + ".yend"
else:
xarrow_start = xarrow_end = yarrow_start = yarrow_end = None
xaxis = XAxis(self.xmin, self.xmax, aty, self.xticks, self.xminiticks, self.xlabels, self.xlogbase, xarrow_start, xarrow_end, exclude=xexclude, text_attr=self.text_attr, **self.attr).SVG(trans)
yaxis = YAxis(self.ymin, self.ymax, atx, self.yticks, self.yminiticks, self.ylabels, self.ylogbase, yarrow_start, yarrow_end, exclude=yexclude, text_attr=self.text_attr, **self.attr).SVG(trans)
return SVG("g", *(xaxis.sub + yaxis.sub))
######################################################################
class HGrid(Ticks):
"""Draws the horizontal lines of a grid over a specified region
using the standard tick specification (see help(Ticks)) to place the
grid lines.
HGrid(xmin, xmax, low, high, ticks, miniticks, logbase, mini_attr, attribute=value)
xmin, xmax required the x range
low, high required the y range
ticks default=-10 request ticks according to the standard
tick specification (see help(Ticks))
miniticks default=False request miniticks according to the
standard minitick specification
logbase default=None if a number, the axis is logarithmic
with ticks at the given base (usually 10)
mini_attr default={} SVG attributes for the minitick-lines
(if miniticks != False)
attribute=value pairs keyword list SVG attributes for the major tick lines
"""
defaults = {"stroke-width": "0.25pt", "stroke": "gray", }
mini_defaults = {"stroke-width": "0.25pt", "stroke": "lightgray", "stroke-dasharray": "1,1", }
def __repr__(self):
return "<HGrid x=(%g, %g) %g <= y <= %g ticks=%s miniticks=%s %s>" % (
self.xmin, self.xmax, self.low, self.high, str(self.ticks), str(self.miniticks), self.attr)
def __init__(self, xmin, xmax, low, high, ticks=-10, miniticks=False, logbase=None, mini_attr={}, **attr):
self.xmin, self.xmax = xmin, xmax
self.mini_attr = dict(self.mini_defaults)
self.mini_attr.update(mini_attr)
Ticks.__init__(self, None, low, high, ticks, miniticks, None, logbase)
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
self.last_ticks, self.last_miniticks = Ticks.interpret(self)
ticksd = []
for t in self.last_ticks.keys():
ticksd += Line(self.xmin, t, self.xmax, t).Path(trans).d
miniticksd = []
for t in self.last_miniticks:
miniticksd += Line(self.xmin, t, self.xmax, t).Path(trans).d
return SVG("g", Path(d=ticksd, **self.attr).SVG(), Path(d=miniticksd, **self.mini_attr).SVG())
class VGrid(Ticks):
"""Draws the vertical lines of a grid over a specified region
using the standard tick specification (see help(Ticks)) to place the
grid lines.
HGrid(ymin, ymax, low, high, ticks, miniticks, logbase, mini_attr, attribute=value)
ymin, ymax required the y range
low, high required the x range
ticks default=-10 request ticks according to the standard
tick specification (see help(Ticks))
miniticks default=False request miniticks according to the
standard minitick specification
logbase default=None if a number, the axis is logarithmic
with ticks at the given base (usually 10)
mini_attr default={} SVG attributes for the minitick-lines
(if miniticks != False)
attribute=value pairs keyword list SVG attributes for the major tick lines
"""
defaults = {"stroke-width": "0.25pt", "stroke": "gray", }
mini_defaults = {"stroke-width": "0.25pt", "stroke": "lightgray", "stroke-dasharray": "1,1", }
def __repr__(self):
return "<VGrid y=(%g, %g) %g <= x <= %g ticks=%s miniticks=%s %s>" % (
self.ymin, self.ymax, self.low, self.high, str(self.ticks), str(self.miniticks), self.attr)
def __init__(self, ymin, ymax, low, high, ticks=-10, miniticks=False, logbase=None, mini_attr={}, **attr):
self.ymin, self.ymax = ymin, ymax
self.mini_attr = dict(self.mini_defaults)
self.mini_attr.update(mini_attr)
Ticks.__init__(self, None, low, high, ticks, miniticks, None, logbase)
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
self.last_ticks, self.last_miniticks = Ticks.interpret(self)
ticksd = []
for t in self.last_ticks.keys():
ticksd += Line(t, self.ymin, t, self.ymax).Path(trans).d
miniticksd = []
for t in self.last_miniticks:
miniticksd += Line(t, self.ymin, t, self.ymax).Path(trans).d
return SVG("g", Path(d=ticksd, **self.attr).SVG(), Path(d=miniticksd, **self.mini_attr).SVG())
class Grid(Ticks):
"""Draws a grid over a specified region using the standard tick
specification (see help(Ticks)) to place the grid lines.
Grid(xmin, xmax, ymin, ymax, ticks, miniticks, logbase, mini_attr, attribute=value)
xmin, xmax required the x range
ymin, ymax required the y range
ticks default=-10 request ticks according to the standard
tick specification (see help(Ticks))
miniticks default=False request miniticks according to the
standard minitick specification
logbase default=None if a number, the axis is logarithmic
with ticks at the given base (usually 10)
mini_attr default={} SVG attributes for the minitick-lines
(if miniticks != False)
attribute=value pairs keyword list SVG attributes for the major tick lines
"""
defaults = {"stroke-width": "0.25pt", "stroke": "gray", }
mini_defaults = {"stroke-width": "0.25pt", "stroke": "lightgray", "stroke-dasharray": "1,1", }
def __repr__(self):
return "<Grid x=(%g, %g) y=(%g, %g) ticks=%s miniticks=%s %s>" % (
self.xmin, self.xmax, self.ymin, self.ymax, str(self.ticks), str(self.miniticks), self.attr)
def __init__(self, xmin, xmax, ymin, ymax, ticks=-10, miniticks=False, logbase=None, mini_attr={}, **attr):
self.xmin, self.xmax = xmin, xmax
self.ymin, self.ymax = ymin, ymax
self.mini_attr = dict(self.mini_defaults)
self.mini_attr.update(mini_attr)
Ticks.__init__(self, None, None, None, ticks, miniticks, None, logbase)
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
self.low, self.high = self.xmin, self.xmax
self.last_xticks, self.last_xminiticks = Ticks.interpret(self)
self.low, self.high = self.ymin, self.ymax
self.last_yticks, self.last_yminiticks = Ticks.interpret(self)
ticksd = []
for t in self.last_xticks.keys():
ticksd += Line(t, self.ymin, t, self.ymax).Path(trans).d
for t in self.last_yticks.keys():
ticksd += Line(self.xmin, t, self.xmax, t).Path(trans).d
miniticksd = []
for t in self.last_xminiticks:
miniticksd += Line(t, self.ymin, t, self.ymax).Path(trans).d
for t in self.last_yminiticks:
miniticksd += Line(self.xmin, t, self.xmax, t).Path(trans).d
return SVG("g", Path(d=ticksd, **self.attr).SVG(), Path(d=miniticksd, **self.mini_attr).SVG())
######################################################################
class XErrorBars:
"""Draws x error bars at a set of points. This is usually used
before (under) a set of Dots at the same points.
XErrorBars(d, attribute=value)
d required list of (x,y,xerr...) points
attribute=value pairs keyword list SVG attributes
If points in d have
* 3 elements, the third is the symmetric error bar
* 4 elements, the third and fourth are the asymmetric lower and
upper error bar. The third element should be negative,
e.g. (5, 5, -1, 2) is a bar from 4 to 7.
* more than 4, a tick mark is placed at each value. This lets
you nest errors from different sources, correlated and
uncorrelated, statistical and systematic, etc.
"""
defaults = {"stroke-width": "0.25pt", }
def __repr__(self):
return "<XErrorBars (%d nodes)>" % len(self.d)
def __init__(self, d=[], **attr):
self.d = list(d)
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
if isinstance(trans, basestring):
trans = totrans(trans) # only once
output = SVG("g")
for p in self.d:
x, y = p[0], p[1]
if len(p) == 3:
bars = [x - p[2], x + p[2]]
else:
bars = [x + pi for pi in p[2:]]
start, end = min(bars), max(bars)
output.append(LineAxis(start, y, end, y, start, end, bars, False, False, **self.attr).SVG(trans))
return output
class YErrorBars:
"""Draws y error bars at a set of points. This is usually used
before (under) a set of Dots at the same points.
YErrorBars(d, attribute=value)
d required list of (x,y,yerr...) points
attribute=value pairs keyword list SVG attributes
If points in d have
* 3 elements, the third is the symmetric error bar
* 4 elements, the third and fourth are the asymmetric lower and
upper error bar. The third element should be negative,
e.g. (5, 5, -1, 2) is a bar from 4 to 7.
* more than 4, a tick mark is placed at each value. This lets
you nest errors from different sources, correlated and
uncorrelated, statistical and systematic, etc.
"""
defaults = {"stroke-width": "0.25pt", }
def __repr__(self):
return "<YErrorBars (%d nodes)>" % len(self.d)
def __init__(self, d=[], **attr):
self.d = list(d)
self.attr = dict(self.defaults)
self.attr.update(attr)
def SVG(self, trans=None):
"""Apply the transformation "trans" and return an SVG object."""
if isinstance(trans, basestring):
trans = totrans(trans) # only once
output = SVG("g")
for p in self.d:
x, y = p[0], p[1]
if len(p) == 3:
bars = [y - p[2], y + p[2]]
else:
bars = [y + pi for pi in p[2:]]
start, end = min(bars), max(bars)
output.append(LineAxis(x, start, x, end, start, end, bars, False, False, **self.attr).SVG(trans))
return output
Reference in New Issue View Git Blame Copy Permalink