# plotlib.py, svg plot generator by Reinier Heeres <reinier@heeres.eu>
#
# 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 St, Fifth Floor, Boston, MA 02110-1301 USA
#
# Change log:
# 2007-09-04: rwh, first version
import types
import logging
_logger = logging.getLogger('PlotLib')
class PlotLib:
"""Class to generate an svg plot for a function.
Evaluation of values is done using the EqnParser class."""
def __init__(self, parser):
self.parser = parser
self.svg_data = ""
self.set_size(0, 0)
def set_size(self, width, height):
self.width = width
self.height = height
def get_svg(self):
return self.svg_data
def parse_range(self, range):
p1 = range.split('=')
if len(p1) != 2:
return None
p2 = p1[1].split('..')
if len(p2) != 2:
return None
return (p1[0], (float(p2[0]), float(p2[1])))
def evaluate(self, eqn, var, range, n=100):
x_old = self.parser.get_var(var)
res = []
d = float((range[1] - range[0])) / (n - 1)
x = range[0]
while n > 0:
self.parser.set_var(var, x)
v = float(self.parser.parse(eqn))
res.append((x, v))
x += d
n -= 1
self.parser.set_var(var, x_old)
return res
def create_image(self):
self.svg_data = '<?xml version="1.0" standalone="no"?>\n'
self.svg_data += '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n'
self.svg_data += '<svg width="%d" height="%d" version="1.1" xmlns="http://www.w3.org/2000/svg">\n' % (self.width, self.height)
def finish_image(self):
self.svg_data += '</svg>'
def plot_line(self, c0, c1, col):
c0 = self.rcoords_to_coords(c0)
c1 = self.rcoords_to_coords(c1)
self.svg_data += '<line style="stroke:%s;stroke-width:1" x1="%f" y1="%f" x2="%f" y2="%f" />\n' % (col, c0[0], c0[1], c1[0], c1[1])
def plot_polyline(self, coords, col):
self.svg_data += '<polyline style="fill:none;stroke:%s;stroke-width:1" points="' % (col)
for c in coords:
c = self.rcoords_to_coords(c)
self.svg_data += '%f,%f ' % (c[0], c[1])
self.svg_data += '" />\n'
def add_text(self, c, text, rotate=0):
if type(text) is types.UnicodeType:
text = text.encode('utf-8')
c = self.rcoords_to_coords(c)
self.svg_data += '<text x="%f" y="%f"' % (c[0], c[1])
if rotate != 0:
self.svg_data += ' transform="rotate(%d)"' % (rotate)
self.svg_data += '>%s</text>\n' % (text)
def determine_bounds(self, vals):
self.minx = self.miny = 1e99
self.maxx = self.maxy = -1e99
for (x, y) in vals:
self.minx = min(float(x), self.minx)
self.miny = min(float(y), self.miny)
self.maxx = max(float(x), self.maxx)
self.maxy = max(float(y), self.maxy)
x_space = 0.02 * (self.maxx - self.minx)
self.minx -= x_space
self.maxx += x_space
y_space = 0.02 * (self.maxy - self.miny)
self.miny -= y_space
self.maxy += y_space
def rcoords_to_coords(self, pair):
"""Convert fractional coordinates to image coordinates"""
return (pair[0] * self.width, pair[1] * self.height)
def vals_to_rcoords(self, pair):
"""Convert values to fractional coordinates"""
ret = (0.1 + (pair[0] - self.minx) / (self.maxx - self.minx) * 0.8, \
0.9 - (pair[1] - self.miny) / (self.maxy - self.miny) * 0.8)
return ret
def add_curve(self, vals):
self.determine_bounds(vals)
c = []
for v in vals:
c.append(self.vals_to_rcoords(v))
# print 'coords: %r' % c
self.plot_polyline(c, "blue")
def get_label_vals(self, startx, endx, n, opts=()):
"""Return label values"""
range = endx - startx
logrange = log(range)
haszero = (startx < 0 & endx < 0)
def draw_axes(self, labelx, labely):
self.plot_line((0.08, 0.92), (0.92, 0.92), "black")
self.add_text((0.50, 0.98), labelx)
self.plot_line((0.08, 0.08), (0.08, 0.92), "black")
self.add_text((-0.50, 0.065), labely, rotate=-90)
def export_plot(self, fn):
f = open(fn, "w")
f.write(self.svg_data)
f.close()
def plot(self, eqn, range_spec):
_logger.debug('plot(): %r, %r', eqn, range_spec)
(var, range) = self.parse_range(range_spec)
if range is None:
_logger.error('Unable to parse range')
return False
_logger.info('Plot range for var %s: %r', var, range)
self.set_size(250, 250)
self.create_image()
self.draw_axes(var, eqn)
vals = self.evaluate(eqn, var, range)
# print 'vals: %r' % vals
self.add_curve(vals)
self.finish_image()
# self.export_plot("/tmp/calculate_graph.svg")
svg = self.get_svg()
if type(svg) is types.UnicodeType:
return svg.encode('utf-8')
else:
return svg