# -*- coding: ISO-8859-1 -*-
#
#
# Copyright (C) 2002-2004 Jrg Lehmann <joergl@users.sourceforge.net>
# Copyright (C) 2003-2004 Michael Schindler <m-schindler@users.sourceforge.net>
# Copyright (C) 2002-2006 Andr Wobst <wobsta@users.sourceforge.net>
#
# This file is part of PyX (http://pyx.sourceforge.net/).
#
# PyX 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.
#
# PyX 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 PyX; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
from __future__ import nested_scopes
import math, re, ConfigParser, struct, warnings
from pyx import text
from pyx.style import linestyle
from pyx.graph import style
try:
enumerate([])
except NameError:
# fallback implementation for Python 2.2 and below
def enumerate(list):
return zip(xrange(len(list)), list)
try:
dict()
except NameError:
# fallback implementation for Python 2.1
def dict(items):
result = {}
for key, value in items:
result[key] = value
return result
def splitatvalue(value, *splitpoints):
section = 0
while section < len(splitpoints) and splitpoints[section] < value:
section += 1
if len(splitpoints) > 1:
if section % 2:
section = None
else:
section >>= 1
return (section, value)
_mathglobals = {"neg": lambda x: -x,
"abs": lambda x: x < 0 and -x or x,
"sgn": lambda x: x < 0 and -1 or 1,
"sqrt": math.sqrt,
"exp": math.exp,
"log": math.log,
"sin": math.sin,
"cos": math.cos,
"tan": math.tan,
"asin": math.asin,
"acos": math.acos,
"atan": math.atan,
"sind": lambda x: math.sin(math.pi/180*x),
"cosd": lambda x: math.cos(math.pi/180*x),
"tand": lambda x: math.tan(math.pi/180*x),
"asind": lambda x: 180/math.pi*math.asin(x),
"acosd": lambda x: 180/math.pi*math.acos(x),
"atand": lambda x: 180/math.pi*math.atan(x),
"norm": lambda x, y: math.hypot(x, y),
"splitatvalue": splitatvalue,
"pi": math.pi,
"e": math.e}
class _data:
"""graph data interface
Graph data consists in columns, where each column might be identified by a
string or an integer. Each row in the resulting table refers to a data
point.
All methods except for the constructor should consider self and its
attributes to be readonly, since the data instance might be shared between
several graphs simultaniously.
The instance variable columns is a dictionary mapping column names to the
data of the column (i.e. to a list). Only static columns (known at
construction time) are contained in that dictionary. For data with numbered
columns the column data is also available via the list columndata.
Otherwise the columndata list should be missing and an access to a column
number will fail.
The names of all columns (static and dynamic) must be fixed at the constructor
and stated in the columnnames dictionary.
The instance variable title and defaultstyles contain the data title and
the default styles (a list of styles), respectively.
"""
def dynamiccolumns(self, graph):
"""create and return dynamic columns data
Returns dynamic data matching the given axes (the axes range and other
data might be used). The return value is a dictionary similar to the
columns instance variable.
"""
return {}
defaultsymbols = [style.symbol()]
defaultlines = [style.line()]
class values(_data):
defaultstyles = defaultsymbols
def __init__(self, title="user provided values", **columns):
for i, values in enumerate(columns.values()):
if i and len(values) != l:
raise ValueError("different number of values")
else:
l = len(values)
self.columns = columns
self.columnnames = columns.keys()
self.title = title
class points(_data):
"Graph data from a list of points"
defaultstyles = defaultsymbols
def __init__(self, points, title="user provided points", addlinenumbers=1, **columns):
if len(points):
l = len(points[0])
self.columndata = [[x] for x in points[0]]
for point in points[1:]:
if l != len(point):
raise ValueError("different number of columns per point")
for i, x in enumerate(point):
self.columndata[i].append(x)
for v in columns.values():
if abs(v) > l or (not addlinenumbers and abs(v) == l):
raise ValueError("column number bigger than number of columns")
if addlinenumbers:
self.columndata = [range(1, len(points) + 1)] + self.columndata
self.columns = dict([(key, self.columndata[i]) for key, i in columns.items()])
else:
self.columns = dict([(key, []) for key, i in columns])
self.columnnames = self.columns.keys()
self.title = title
def list(*args, **kwargs):
warnings.warn("graph.data.list is deprecated. Use graph.data.points instead.")
return points(*args, **kwargs)
class _notitle:
pass
_columnintref = re.compile(r"\$(-?\d+)", re.IGNORECASE)
class data(_data):
"creates a new data set out of an existing data set"
def __init__(self, data, title=_notitle, context={}, copy=1,
replacedollar=1, columncallback="__column__", **columns):
# build a nice title
if title is _notitle:
items = columns.items()
items.sort() # we want sorted items (otherwise they would be unpredictable scrambled)
self.title = "%s: %s" % (text.escapestring(data.title or "unkown source"),
", ".join(["%s=%s" % (text.escapestring(key),
text.escapestring(str(value)))
for key, value in items]))
else:
self.title = title
self.orgdata = data
self.defaultstyles = self.orgdata.defaultstyles
# analyse the **columns argument
self.columns = {}
for columnname, value in columns.items():
# search in the columns dictionary
try:
self.columns[columnname] = self.orgdata.columns[value]
except KeyError:
# search in the columndata list
try:
self.columns[columnname] = self.orgdata.columndata[value]
except (AttributeError, TypeError):
# value was not an valid column identifier
# i.e. take it as a mathematical expression
if replacedollar:
m = _columnintref.search(value)
while m:
value = "%s%s(%s)%s" % (value[:m.start()], columncallback, m.groups()[0], value[m.end():])
m = _columnintref.search(value)
value = value.replace("$", columncallback)
expression = compile(value.strip(), __file__, "eval")
context = context.copy()
context[columncallback] = self.columncallback
if self.orgdata.columns:
key, columndata = self.orgdata.columns.items()[0]
count = len(columndata)
elif self.orgdata.columndata:
count = len(self.orgdata.columndata[0])
else:
count = 0
newdata = []
for i in xrange(count):
self.columncallbackcount = i
for key, values in self.orgdata.columns.items():
context[key] = values[i]
try:
newdata.append(eval(expression, _mathglobals, context))
except (ArithmeticError, ValueError):
newdata.append(None)
self.columns[columnname] = newdata
if copy:
# copy other, non-conflicting column names
for columnname, columndata in self.orgdata.columns.items():
if not self.columns.has_key(columnname):
self.columns[columnname] = columndata
self.columnnames = self.columns.keys()
def columncallback(self, value):
try:
return self.orgdata.columndata[value][self.columncallbackcount]
except:
return self.orgdata.columns[value][self.columncallbackcount]
filecache = {}
class file(data):
defaultcommentpattern = re.compile(r"(#+|!+|%+)\s*")
defaultstringpattern = re.compile(r"\"(.*?)\"(\s+|$)")
defaultcolumnpattern = re.compile(r"(.*?)(\s+|$)")
def splitline(self, line, stringpattern, columnpattern, tofloat=1):
"""returns a tuple created out of the string line
- matches stringpattern and columnpattern, adds the first group of that
match to the result and and removes those matches until the line is empty
- when stringpattern matched, the result is always kept as a string
- when columnpattern matched and tofloat is true, a conversion to a float
is tried; when this conversion fails, the string is kept"""
result = []
# try to gain speed by skip matching regular expressions
if line.find('"')!=-1 or \
stringpattern is not self.defaultstringpattern or \
columnpattern is not self.defaultcolumnpattern:
while len(line):
match = stringpattern.match(line)
if match:
result.append(match.groups()[0])
line = line[match.end():]
else:
match = columnpattern.match(line)
if tofloat:
try:
result.append(float(match.groups()[0]))
except (TypeError, ValueError):
result.append(match.groups()[0])
else:
result.append(match.groups()[0])
line = line[match.end():]
else:
if tofloat:
try:
return map(float, line.split())
except (TypeError, ValueError):
result = []
for r in line.split():
try:
result.append(float(r))
except (TypeError, ValueError):
result.append(r)
else:
return line.split()
return result
def getcachekey(self, *args):
return ":".join([str(x) for x in args])
def __init__(self, filename,
commentpattern=defaultcommentpattern,
stringpattern=defaultstringpattern,
columnpattern=defaultcolumnpattern,
skiphead=0, skiptail=0, every=1,
**kwargs):
def readfile(file, title, self=self, commentpattern=commentpattern, stringpattern=stringpattern, columnpattern=columnpattern, skiphead=skiphead, skiptail=skiptail, every=every):
columns = []
columndata = []
linenumber = 0
maxcolumns = 0
for line in file.readlines():
line = line.strip()
match = commentpattern.match(line)
if match:
if not len(columndata):
columns = self.splitline(line[match.end():], stringpattern, columnpattern, tofloat=0)
else:
linedata = []
for value in self.splitline(line, stringpattern, columnpattern, tofloat=1):
linedata.append(value)
if len(linedata):
if linenumber >= skiphead and not ((linenumber - skiphead) % every):
linedata = [linenumber + 1] + linedata
if len(linedata) > maxcolumns:
maxcolumns = len(linedata)
columndata.append(linedata)
linenumber += 1
if skiptail >= every:
skip, x = divmod(skiptail, every)
del columndata[-skip:]
for i in xrange(len(columndata)):
if len(columndata[i]) != maxcolumns:
columndata[i].extend([None]*(maxcolumns-len(columndata[i])))
return points(columndata, title=title, addlinenumbers=0,
**dict([(column, i+1) for i, column in enumerate(columns[:maxcolumns-1])]))
try:
filename.readlines
except:
# not a file-like object -> open it
cachekey = self.getcachekey(filename, commentpattern, stringpattern, columnpattern, skiphead, skiptail, every)
if not filecache.has_key(cachekey):
filecache[cachekey] = readfile(open(filename), filename)
data.__init__(self, filecache[cachekey], **kwargs)
else:
data.__init__(self, readfile(filename, "user provided file-like object"), **kwargs)
conffilecache = {}
class conffile(data):
def __init__(self, filename, **kwargs):
"""read data from a config-like file
- filename is a string
- each row is defined by a section in the config-like file (see
config module description)
- the columns for each row are defined by lines in the section file;
the option entries identify and name the columns
- further keyword arguments are passed to the constructor of data,
keyword arguments data and titles excluded"""
def readfile(file, title):
config = ConfigParser.ConfigParser()
config.optionxform = str
config.readfp(file)
sections = config.sections()
sections.sort()
columndata = [None]*len(sections)
maxcolumns = 1
columns = {}
for i in xrange(len(sections)):
point = [sections[i]] + [None]*(maxcolumns-1)
for option in config.options(sections[i]):
value = config.get(sections[i], option)
try:
value = float(value)
except:
pass
try:
index = columns[option]
except KeyError:
columns[option] = maxcolumns
point.append(value)
maxcolumns += 1
else:
point[index] = value
columndata[i] = point
# wrap result into a data instance to remove column numbers
result = data(points(columndata, addlinenumbers=0, **columns), title=title)
# ... but reinsert sections as linenumbers
result.columndata = [[x[0] for x in columndata]]
return result
try:
filename.readlines
except:
# not a file-like object -> open it
if not filecache.has_key(filename):
filecache[filename] = readfile(open(filename), filename)
data.__init__(self, filecache[filename], **kwargs)
else:
data.__init__(self, readfile(filename, "user provided file-like object"), **kwargs)
cbdfilecache = {}
class cbdfile(data):
defaultstyles = defaultlines
def getcachekey(self, *args):
return ":".join([str(x) for x in args])
def __init__(self, filename, minrank=None, maxrank=None, **kwargs):
class cbdhead:
def __init__(self, file):
(self.magic,
self.dictaddr,
self.segcount,
self.segsize,
self.segmax,
self.fill) = struct.unpack("<5i20s", file.read(40))
if self.magic != 0x20770002:
raise ValueError("bad magic number")
class segdict:
def __init__(self, file, i):
self.index = i
(self.segid,
self.maxlat,
self.minlat,
self.maxlong,
self.minlong,
self.absaddr,
self.nbytes,
self.rank) = struct.unpack("<6i2h", file.read(28))
class segment:
def __init__(self, file, sd):
file.seek(sd.absaddr)
(self.orgx,
self.orgy,
self.id,
self.nstrokes,
self.dummy) = struct.unpack("<3i2h", file.read(16))
oln, olt = self.orgx, self.orgy
self.points = [(olt, oln)]
for i in range(self.nstrokes):
c1, c2 = struct.unpack("2c", file.read(2))
if ord(c2) & 0x40:
if c1 > "\177":
dy = ord(c1) - 256
else:
dy = ord(c1)
if c2 > "\177":
dx = ord(c2) - 256
else:
dx = ord(c2) - 64
else:
c3, c4, c5, c6, c7, c8 = struct.unpack("6c", file.read(6))
if c2 > "\177":
c2 = chr(ord(c2) | 0x40)
dx, dy = struct.unpack("<2i", c3+c4+c1+c2+c7+c8+c5+c6)
oln += dx
olt += dy
self.points.append((olt, oln))
sd.nstrokes = self.nstrokes
def readfile(file, title):
h = cbdhead(file)
file.seek(h.dictaddr)
sds = [segdict(file, i+1) for i in range(h.segcount)]
sbs = [segment(file, sd) for sd in sds]
# remove jumps at long +/- 180
for sd, sb in zip(sds, sbs):
if sd.minlong < -150*3600 and sd.maxlong > 150*3600:
for i, (lat, long) in enumerate(sb.points):
if long < 0:
sb.points[i] = lat, long + 360*3600
columndata = []
for sd, sb in zip(sds, sbs):
if ((minrank is None or sd.rank >= minrank) and
(maxrank is None or sd.rank <= maxrank)):
if columndata:
columndata.append((None, None))
columndata.extend([(long/3600.0, lat/3600.0)
for lat, long in sb.points])
result = points(columndata, title=title)
result.defaultstyles = self.defaultstyles
return result
try:
filename.readlines
except:
# not a file-like object -> open it
cachekey = self.getcachekey(filename, minrank, maxrank)
if not cbdfilecache.has_key(cachekey):
cbdfilecache[cachekey] = readfile(open(filename, "rb"), filename)
data.__init__(self, cbdfilecache[cachekey], **kwargs)
else:
data.__init__(self, readfile(filename, "user provided file-like object"), **kwargs)
class function(_data):
defaultstyles = defaultlines
assignmentpattern = re.compile(r"\s*([a-z_][a-z0-9_]*)\s*\(\s*([a-z_][a-z0-9_]*)\s*\)\s*=", re.IGNORECASE)
def __init__(self, expression, title=_notitle, min=None, max=None,
points=100, context={}):
if title is _notitle:
self.title = expression
else:
self.title = title
self.min = min
self.max = max
self.numberofpoints = points
self.context = context.copy() # be safe on late evaluations
m = self.assignmentpattern.match(expression)
if m:
self.yname, self.xname = m.groups()
expression = expression[m.end():]
else:
raise ValueError("y(x)=... or similar expected")
if context.has_key(self.xname):
raise ValueError("xname in context")
self.expression = compile(expression.strip(), __file__, "eval")
self.columns = {}
self.columnnames = [self.xname, self.yname]
def dynamiccolumns(self, graph):
dynamiccolumns = {self.xname: [], self.yname: []}
xaxis = graph.axes[self.xname]
from pyx.graph.axis import logarithmic
logaxis = isinstance(xaxis.axis, logarithmic)
if self.min is not None:
min = self.min
else:
min = xaxis.data.min
if self.max is not None:
max = self.max
else:
max = xaxis.data.max
if logaxis:
min = math.log(min)
max = math.log(max)
for i in range(self.numberofpoints):
x = min + (max-min)*i / (self.numberofpoints-1.0)
if logaxis:
x = math.exp(x)
dynamiccolumns[self.xname].append(x)
self.context[self.xname] = x
try:
y = eval(self.expression, _mathglobals, self.context)
except (ArithmeticError, ValueError):
y = None
dynamiccolumns[self.yname].append(y)
return dynamiccolumns
class functionxy(function):
def __init__(self, f, min=None, max=None, **kwargs):
function.__init__(self, "y(x)=f(x)", context={"f": f}, min=min, max=max, **kwargs)
class paramfunction(_data):
defaultstyles = defaultlines
def __init__(self, varname, min, max, expression, title=_notitle, points=100, context={}):
if context.has_key(varname):
raise ValueError("varname in context")
if title is _notitle:
self.title = expression
else:
self.title = title
varlist, expression = expression.split("=")
expression = compile(expression.strip(), __file__, "eval")
keys = [key.strip() for key in varlist.split(",")]
self.columns = dict([(key, []) for key in keys])
context = context.copy()
for i in range(points):
param = min + (max-min)*i / (points-1.0)
context[varname] = param
values = eval(expression, _mathglobals, context)
for key, value in zip(keys, values):
self.columns[key].append(value)
if len(keys) != len(values):
raise ValueError("unpack tuple of wrong size")
self.columnnames = self.columns.keys()
class paramfunctionxy(paramfunction):
def __init__(self, f, min, max, **kwargs):
paramfunction.__init__(self, "t", min, max, "x, y = f(t)", context={"f": f}, **kwargs)
|