def main():
# bar chart
if(c.charttype==2):
svgport = svg.svg(viewbox='0 0 1000 2%d50' % 3*(c.magnitudelegend==True))
if c.magnitudelegend:
chart1 = svg.g()
else:
chart1 = svg.g()
chart1.add(makebarsvert(c.magnitudebenefit,c.saliencebenefit,c.magnitudecost,c.saliencecost))
svgport.add(chart1)
# salience legend for bar
if(c.saliencelegend):
sal = svg.g(p='transform="rotate(90 1000 50) translate(%s 0)"' % (550+c.textradius))
sal.add(makesaliencelegend())
svgport.add(sal)
else:
# amoeba chart
if(c.charttype==0):
svgport = svg.svg(viewbox='0 0 2%d50 1%d00' % (3*(c.magnitudelegend==True), 1*(c.saliencelegend==True)))
chart1 = svg.g()
chart1.add(makecircle(c.magnitudebenefit,c.saliencebenefit,benefit=1))
chart2 = svg.g(p='transform="translate(1050)"')
chart2.add(makecircle(c.magnitudecost,c.saliencecost,benefit=0))
svgport.add(chart1)
svgport.add(chart2)
if (c.magnitudelegend):
mag = svg.g(p='transform="translate(2050)"')
mag.add(makemagnitudelegend())
svgport.add(mag)
# column chart (default)
else:
svgport = svg.svg(viewbox='0 0 2%d50 1%d00' % (3*(c.magnitudelegend==True), 1*(c.saliencelegend==True)))
if c.magnitudelegend:
chart1 = svg.g()
else:
chart1 = svg.g(p='transform="translate(-200)"')
chart1.add(makebars(c.magnitudebenefit,c.saliencebenefit,c.magnitudecost,c.saliencecost))
svgport.add(chart1)
# salience legend for amoeba and column
if(c.saliencelegend):
sal = svg.g(p='transform="translate(0 %s)"' % (550+c.textradius))
sal.add(makesaliencelegend())
svgport.add(sal)
svg.gen(svgport, c.savename)
def tosvg(path, filename, width=500, border=80, color="white", bgcolor="black", linewidth=1):
points, kinds = path
points = points / points.max() * width + border/2
kinds = ['M' if k == lsys.MOVE else 'L' for k in kinds]
img = svg(points[:,0].max() + border/2, points[:,1].max() + border/2, bgcolor)
img.path(points, kinds, stroke=color, strokewidth=linewidth)
img.save(filename)
def makesaliencelegend():
out = svg.svg(width=2000, height=100, viewbox='0 0 2000 100')
if c.swapsaliencemagnitude:
te = 'Magnitude:'
else:
te = 'Salience:'
out.add(svg.text(te, 70, 50, fontsize=c.font))
for i in range(0,2):
if i==0:
red,green,blue = c.colorsbenefit[0]
elif c.colorsbenefit[0]==c.colorscost[0]:
return out
else:
red,green,blue = c.colorscost[0]
for j in range(0,3+c.includezerosalience):
out.add(svg.text(j + (1-c.includezerosalience), (i*950+290+j*(200-60*c.includezerosalience)), 50, fontsize=c.font))
if(c.saliencebycolor):
s = ((j+1)**c.saliencebycolor)/((3.0+c.includezerosalience)**c.saliencebycolor)
else:
s = 1
if(c.saliencebywidth):
out.add(svg.rect((i*950+320+j*(200-60*c.includezerosalience)),11,80,50, stroke='black', fill='none'))
if(c.saliencebywidth>1):
w = 80.0/(c.saliencebywidth**3)*(c.saliencebywidth**(j+1-c.includezerosalience))
else:
w = 80.0/(3+c.includezerosalience)*(j+1)
out.add(svg.rect((i*950+360+j*(200-60*c.includezerosalience)-(w/2)),11,w,50, stroke='none', fill='rgb(%s,%s,%s)' % (red,green,blue), p='fill-opacity="%s"' % s))
else:
out.add(svg.rect((i*950+320+j*(200-60*c.includezerosalience)),11,80,50, stroke='none', fill='rgb(%s,%s,%s)' % (red,green,blue), p='fill-opacity="%s"' % s))
return out
def draw_rna(sequence, secstruct, colors, filename="secstruct", line=False):
r = render_rna.RNARenderer()
pairmap = render_rna.get_pairmap_from_secstruct(secstruct)
pairs = []
for i in range(len(pairmap)):
if pairmap[i] > i:
pairs.append({
"from": i,
"to": pairmap[i],
"p": 1.0,
"color": COLORS["e"]
})
r.setup_tree(secstruct, NODE_R, PRIMARY_SPACE, PAIR_SPACE)
size = r.get_size()
cell_size = max(size) + CELL_PADDING * 2
# if colors are numeric, create color scale
try:
colors = [float(x) for x in colors.split()]
gist_earth = cm.get_cmap('gist_earth_r')
min_ = min(colors)
range_ = max(colors) - min_
colors = [gist_earth((x - min_) / range_)[:-1] for x in colors]
colors = [[c * 256 for c in color] for color in colors]
# otherwise, colors are indexes to COLORS dict
except:
colors = [COLORS[x] for x in list(colors)]
svgobj = svg.svg("%s.svg" % filename, cell_size, cell_size)
r.draw(svgobj, CELL_PADDING, CELL_PADDING, colors, pairs, sequence,
RENDER_IN_LETTERS, line)
def svg_double_dragon(iterations, filename, stepsize=5, border=80, color1="#4479ff", color2="#5cc455", bgcolor=None):
points = track(doubledragon(iterations)) * stepsize + border/2
points1 = points[:points.shape[0]/2]
points2 = points[points.shape[0]/2:]
width = points[:,0].max() + border/2
height = points[:,1].max() + border/2
img = svg(width, height, bgcolor)
img.path(points1, stroke=color1)
img.path(points2, stroke=color2)
img.save(filename)
def draw_rna(sequence,
secstruct,
colors,
filename="secstruct",
line=False,
cmap_name='gist_heat_r',
ext_color_file=False,
chemical_mapping_mode=False):
r = render_rna.RNARenderer()
pairmap = render_rna.get_pairmap_from_secstruct(secstruct)
pairs = []
for i in range(len(pairmap)):
if pairmap[i] > i:
pairs.append({
"from": i,
"to": pairmap[i],
"p": 1.0,
"color": COLORS["e"]
})
r.setup_tree(secstruct, NODE_R, PRIMARY_SPACE, PAIR_SPACE)
size = r.get_size()
cell_size = max(size) + CELL_PADDING * 2
# if colors are numeric, create color scale
if ext_color_file:
if chemical_mapping_mode:
vmax = 3
else:
vmax = np.max(colors)
colormap = plt.get_cmap(cmap_name)
cNorm = mcolors.Normalize(vmin=0, vmax=3)
scalarMap = cm.ScalarMappable(norm=cNorm, cmap=colormap)
colors = [scalarMap.to_rgba(val)[:-1] for val in colors]
colors = [[x * 256 for x in y] for y in colors]
else:
# try:
# print('Interpreting color string as integer values')
# colors = [float(x) for x in colors.split()]
# colormap = plt.get_cmap(cmap_name)
# cNorm = mcolors.Normalize(vmin=0, vmax=3)
# scalarMap = cm.ScalarMappable(norm=cNorm, cmap=colormap)
# colors = [scalarMap.to_rgba(val)[:-1] for val in colors]
# colors = [[x*256 for x in y] for y in colors]
# # otherwise, colors are indexes to COLORS dict
# except:
colors = [COLORS[x] for x in list(colors)]
svgobj = svg.svg("%s.svg" % filename, cell_size, cell_size)
r.draw(svgobj, CELL_PADDING, CELL_PADDING, colors, pairs, sequence,
RENDER_IN_LETTERS, line)
def draw_rna(sequence, secstruct, colors, filename="secstruct"):
r = render_rna.RNARenderer()
pairmap = render_rna.get_pairmap_from_secstruct(secstruct)
pairs = []
for i in range(len(pairmap)):
if pairmap[i] > i:
pairs.append({
"from": i,
"to": pairmap[i],
"p": 1.0,
"color": COLORS["e"]
})
r.setup_tree(secstruct, NODE_R, PRIMARY_SPACE, PAIR_SPACE)
size = r.get_size()
cell_size = max(size) + CELL_PADDING * 2
colors = [COLORS[x] for x in list(colors)]
svgobj = svg.svg("%s.svg" % filename, cell_size, cell_size)
r.draw(svgobj, CELL_PADDING, CELL_PADDING, colors, pairs, sequence,
RENDER_IN_LETTERS)
def makemagnitudelegend():
angles = [-math.pi / 2, math.pi / 2]
wedgeangle = math.pi * 2 / 21
out = svg.svg(width=250, height=1000, viewbox='0 0 250 1000')
x = (500 + math.cos(angles[0]) * c.textradius)
y = (500 + math.sin(angles[0]) * c.textradius)
if c.swapsaliencemagnitude:
te = 'Salience:'
else:
te = 'Magnitude:'
out.add(
svg.text(te,
125,
25,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'))
for angle in angles:
x1 = (125 + math.cos(angle + wedgeangle / 2) * c.centerradius)
y1 = (500 + math.sin(angle + wedgeangle / 2) * c.centerradius)
x2 = (125 + math.cos(angle + wedgeangle / 2) * c.textradius)
y2 = (500 + math.sin(angle + wedgeangle / 2) * c.textradius)
x3 = (125 + math.cos(angle - wedgeangle / 2) * c.textradius)
y3 = (500 + math.sin(angle - wedgeangle / 2) * c.textradius)
x4 = (125 + math.cos(angle - wedgeangle / 2) * c.centerradius)
y4 = (500 + math.sin(angle - wedgeangle / 2) * c.centerradius)
out.add(svg.line(x1, y1, x2, y2, 'black', 2))
out.add(svg.line(x3, y3, x4, y4, 'black', 2))
if (c.drawsaliencedividers):
x1 = (125 + math.cos(angle) * c.centerradius)
y1 = (500 + math.sin(angle) * c.centerradius)
x2 = (125 + math.cos(angle) * c.edgeradius)
y2 = (500 + math.sin(angle) * c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
for j in range(1 - c.includezerosalience, 3):
if (c.saliencebywidth > 1):
wedgewidth = wedgeangle / 2 / (c.saliencebywidth**
3) * (c.saliencebywidth**j)
else:
wedgewidth = wedgeangle / 2 / (
3 + c.includezerosalience) * (j +
c.includezerosalience)
x1 = (125 + math.cos(angle - wedgewidth) * c.centerradius)
y1 = (500 + math.sin(angle - wedgewidth) * c.centerradius)
x2 = (125 + math.cos(angle - wedgewidth) * c.edgeradius)
y2 = (500 + math.sin(angle - wedgewidth) * c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
x1 = (125 + math.cos(angle + wedgewidth) * c.centerradius)
y1 = (500 + math.sin(angle + wedgewidth) * c.centerradius)
x2 = (125 + math.cos(angle + wedgewidth) * c.edgeradius)
y2 = (500 + math.sin(angle + wedgewidth) * c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
for i in range(0, c.maxvalue + c.includezeromagnitude + 1):
if (i == c.includezeromagnitude):
w = 5
else:
w = 1
r = ringradii(i)
x1 = (125 + math.cos(angle + wedgeangle / 1.5) * r)
y1 = (500 + math.sin(angle + wedgeangle / 1.5) * r)
x2 = (125 + math.cos(angle - wedgeangle / 1.5) * r)
y2 = (500 + math.sin(angle - wedgeangle / 1.5) * r)
d = 'M %s,%s A %s,%s 0 0,0 %s,%s' % (x1, y1, r, r, x2, y2)
out.add(svg.path(d, stroke='black', strokewidth=w))
y = y1
if (i % 2 == 0):
x = x2 + 10 * angle
else:
x = x1 - 10 * angle
if (i - c.includezeromagnitude >= 0):
out.add(
svg.text(
i - c.includezeromagnitude,
x,
y,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'
))
return out
print
import urllib
from svg import svg
import lsys
import cgi
arguments = cgi.FieldStorage()
angle = float(arguments['angle'].value)
iterations = int(arguments['iterations'].value)
constants = set(list(str(arguments['constants'].value).decode("hex")))
axiom = str(arguments['axiom'].value).decode("hex")
rules = str(arguments['rules'].value).decode("hex").split("\n")
rotate = float(arguments['rotate'].value)
thickness = str(arguments['thickness'].value)
border = 100
width = 820
bgcolor = "#404040"
subject = lsys.subject(axiom)
result = subject.replace([lsys.rule(rule) for rule in rules], iterations)
points, kinds = result.track(angle, constants, start_rotation=rotate)
points = points / points[:,0].max() * (width - border) + border/2
height = points[:,1].max() + border/2
image = svg(width, height, bg=bgcolor)
image.path(points, kinds, strokewidth=thickness)
print image
def makebarsvert(magnitudebenefit,saliencebenefit,magnitudecost,saliencecost):
if c.swapsaliencemagnitude:
tm = saliencebenefit[:]
saliencebenefit = magnitudebenefit[:]
magnitudebenefit = tm
tm = saliencecost[:]
saliencecost = magnitudecost[:]
magnitudecost = tm
#general variables
t = 0
if c.centerlabel is not None:
t = 50
out = svg.svg(width = 1000, height = 2250+t, viewbox='0 0 1000 2150')
barwidth = 2050/(21+c.spacebars*2)
chart = svg.g('transform="translate(0 %s)"' % t)
out.add(chart)
for cb in range(0,2):
if c.centerlabel is not None:
out.add(svg.text(c.centerlabel[1-cb], 250+(cb)*500, 25, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
if(cb==1):
colors=c.colorsbenefit
magnitude=magnitudebenefit
salience=saliencebenefit
else:
magnitude=magnitudecost
salience=saliencecost
colors=c.colorscost
#draw bars
for i in range(0,21):
h = barheight(magnitude[i]+c.includezeromagnitude)
if(c.saliencebywidth==1):
w = barwidth/(3+c.includezerosalience)*(salience[i]+c.includezerosalience)
elif(c.saliencebywidth>1):
w = barwidth/(c.saliencebywidth**3)*(c.saliencebywidth**salience[i])
else:
w = barwidth
if(c.saliencebycolor):
s = ((salience[i]+c.includezerosalience)**c.saliencebycolor)/((3.0+c.includezerosalience)**c.saliencebycolor)
else:
s = 1
red,green,blue = colors[i//7]
if(salience[i]>0 or c.includezerosalience):
barlinecolor=(int(red*c.barlineshade),int(green*c.barlineshade),int(blue*c.barlineshade))
chart.add(svg.rect(500+(cb-1)*h,(i+(i//7)*c.spacebars)*barwidth+(barwidth-w)/2,h,w, fill='rgb(%s,%s,%s)' % (red,green,blue), stroke='rgb(%s,%s,%s)' % (barlinecolor[0],barlinecolor[1],barlinecolor[2]), strokewidth=c.barline, p='fill-opacity="%s"' % s))
#invisible link and tooltip box
newrect = svg.rect(500+(cb-1)*c.textradius,(i+(i//7)*c.spacebars)*barwidth,c.textradius,barwidth, fill='white', p='fill-opacity="0.0"')
newrect.add(svg.title(' %s: %s\n Magnitude %s\tSalience %s' % (c.indicatornames[i], c.indicatorfullnames[i], magnitude[i], salience[i])))
chart.add(newrect)
#draw ygrid
for i in range(0,c.maxvalue+c.includezeromagnitude+1):
if(i==c.includezeromagnitude):
w=5
else:
w=1
if (c.ygrid or i==0):
x2 = 0
else:
x2 = 2050-c.ticksize
chart.add(svg.line(500+barheight(i)*(cb-.5)*2,2050+c.ticksize,500+barheight(i)*(cb-.5)*2,x2,'black',w))
#draw xgrid dividers
chart.add(svg.line(500-c.edgeradius,2050,500+c.edgeradius,2050,'black',5))
for i in range(0,21+c.spacebars*2):
if (c.xgrid or (c.saliencebywidth and c.drawsaliencedividers)):
chart.add(svg.line(500-c.edgeradius,barwidth*i,500+c.edgeradius,barwidth*i, 'black', 1))
elif(ticksize):
chart.add(svg.line(500-c.ticksize,barwidth*i,500+c.ticksize,barwidth*i, 'black', 1))
#draw salience dividers and column headings
for i in range(0,21):
if(c.saliencebywidth and c.drawsaliencedividers):
for j in range(1-c.includezerosalience,3):
if(c.saliencebywidth>1):
w = barwidth/2/(c.saliencebywidth**3)*(c.saliencebywidth**j)
else:
w = barwidth/2/(3+c.includezerosalience)*(j+c.includezerosalience)
for k in [1,-1]:
chart.add(svg.line(500-c.edgeradius,barwidth*(i+(i//7)+.5)+k*w,500+c.edgeradius,barwidth*(i+(i//7)+.5)+k*w, 'black', .5))
x = (500 - c.textradius)
y = ((i+(i//7)*c.spacebars+.5)*barwidth)
chart.add(svg.text(c.indicatornames[i], x, y, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
#draw magnitude legend
if c.magnitudelegend:
if c.swapsaliencemagnitude:
te = 'Salience'
else:
te = 'Magnitude'
mag=svg.g(p='transform="translate(0 2050)"')
mag.add(svg.text(te, 500, 100, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
lastnumber=1
for i in range(0,c.maxvalue+c.includezeromagnitude+1):
if (i-c.includezeromagnitude==0):
mag.add(svg.text(i-c.includezeromagnitude,502-barheight(i),40, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
if (barheight(i)*2>c.font):
mag.add(svg.text(i-c.includezeromagnitude,502+barheight(i), 40, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
elif (i-c.includezeromagnitude>0):
# alternate top and bottom if axis lables too close
mag.add(svg.text(i-c.includezeromagnitude, 502+barheight(i)*lastnumber,40, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
if (barheight(i)-barheight(i-1)>c.font):
mag.add(svg.text(i-c.includezeromagnitude, 502-barheight(i)*lastnumber,40, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
else:
lastnumber = lastnumber * -1
chart.add(mag)
return out
def makemagnitudelegend():
angles = [-math.pi/2,math.pi/2]
wedgeangle = math.pi*2/21
out = svg.svg(width=250, height=1000, viewbox='0 0 250 1000')
x = (500 + math.cos(angles[0])*c.textradius)
y = (500 + math.sin(angles[0])*c.textradius)
if c.swapsaliencemagnitude:
te = 'Salience:'
else:
te = 'Magnitude:'
out.add(svg.text(te, 125, 25, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
for angle in angles:
x1 = (125 + math.cos(angle+wedgeangle/2)*c.centerradius)
y1 = (500 + math.sin(angle+wedgeangle/2)*c.centerradius)
x2 = (125 + math.cos(angle+wedgeangle/2)*c.textradius)
y2 = (500 + math.sin(angle+wedgeangle/2)*c.textradius)
x3 = (125 + math.cos(angle-wedgeangle/2)*c.textradius)
y3 = (500 + math.sin(angle-wedgeangle/2)*c.textradius)
x4 = (125 + math.cos(angle-wedgeangle/2)*c.centerradius)
y4 = (500 + math.sin(angle-wedgeangle/2)*c.centerradius)
out.add(svg.line(x1, y1, x2, y2, 'black', 2))
out.add(svg.line(x3, y3, x4, y4, 'black', 2))
if(c.drawsaliencedividers):
x1 = (125 + math.cos(angle)*c.centerradius)
y1 = (500 + math.sin(angle)*c.centerradius)
x2 = (125 + math.cos(angle)*c.edgeradius)
y2 = (500 + math.sin(angle)*c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
for j in range(1-c.includezerosalience,3):
if(c.saliencebywidth>1):
wedgewidth = wedgeangle/2/(c.saliencebywidth**3)*(c.saliencebywidth**j)
else:
wedgewidth = wedgeangle/2/(3+c.includezerosalience)*(j+c.includezerosalience)
x1 = (125 + math.cos(angle-wedgewidth)*c.centerradius)
y1 = (500 + math.sin(angle-wedgewidth)*c.centerradius)
x2 = (125 + math.cos(angle-wedgewidth)*c.edgeradius)
y2 = (500 + math.sin(angle-wedgewidth)*c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
x1 = (125 + math.cos(angle+wedgewidth)*c.centerradius)
y1 = (500 + math.sin(angle+wedgewidth)*c.centerradius)
x2 = (125 + math.cos(angle+wedgewidth)*c.edgeradius)
y2 = (500 + math.sin(angle+wedgewidth)*c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
for i in range(0,c.maxvalue+c.includezeromagnitude+1):
if(i==c.includezeromagnitude):
w=5
else:
w=1
r=ringradii(i)
x1 = (125 + math.cos(angle+wedgeangle/1.5)*r)
y1 = (500 + math.sin(angle+wedgeangle/1.5)*r)
x2 = (125 + math.cos(angle-wedgeangle/1.5)*r)
y2 = (500 + math.sin(angle-wedgeangle/1.5)*r)
d = 'M %s,%s A %s,%s 0 0,0 %s,%s' % (x1,y1,r,r,x2,y2)
out.add(svg.path(d, stroke='black', strokewidth=w))
y = y1
if(i%2==0):
x = x2 + 10*angle
else:
x = x1 - 10*angle
if(i-c.includezeromagnitude>=0):
out.add(svg.text(i-c.includezeromagnitude, x, y, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
return out
def makecircle(magnitude, salience, benefit=1):
if c.swapsaliencemagnitude:
tm = salience[:]
salience = magnitude[:]
magnitude = tm
#general variables
indicatorseparatorangles = [-math.pi*2/21*i + math.pi/21 for i in range(0,22)]
indicatorcenterangles = [-math.pi*2/21*i for i in range(0,21)]
wedgeangle = math.pi*2/21
out = svg.svg(width=1000, height=1000+100*c.saliencelegend, viewbox='0 0 1000 1%d00' % (1*c.saliencelegend==True))
if(benefit):
colors=c.colorsbenefit
else:
colors=c.colorscost
if c.centerlabel is not None:
out.add(svg.text(c.centerlabel[1-benefit], 500, 500, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
#draw wedges
for i in range(0,21):
r = ringradii(magnitude[i]+c.includezeromagnitude)
if(c.saliencebywidth==1):
wedgewidth = wedgeangle/2/(3+c.includezerosalience)*(salience[i]+c.includezerosalience)
elif(c.saliencebywidth>1):
wedgewidth = wedgeangle/2/(saliencebywidth**3)*(c.saliencebywidth**salience[i])
else:
wedgewidth = wedgeangle/2
x1 = (500 + math.cos(indicatorcenterangles[i]+wedgewidth)*c.centerradius)
y1 = (500 + math.sin(indicatorcenterangles[i]+wedgewidth)*c.centerradius)
x2 = (500 + math.cos(indicatorcenterangles[i]+wedgewidth)*r)
y2 = (500 + math.sin(indicatorcenterangles[i]+wedgewidth)*r)
x3 = (500 + math.cos(indicatorcenterangles[i]-wedgewidth)*r)
y3 = (500 + math.sin(indicatorcenterangles[i]-wedgewidth)*r)
x4 = (500 + math.cos(indicatorcenterangles[i]-wedgewidth)*c.centerradius)
y4 = (500 + math.sin(indicatorcenterangles[i]-wedgewidth)*c.centerradius)
if(c.saliencebycolor):
s = ((salience[i]+c.includezerosalience)**c.saliencebycolor)/((3.0+c.includezerosalience)**c.saliencebycolor)
else:
s = 1
red,green,blue = colors[i//7]
d = 'M %s,%s L %s,%s A %s,%s 0 0,0 %s,%s L %s,%s A %s,%s 0 0,1 %s,%s' % (x1,y1,x2,y2,r,r,x3,y3,x4,y4,c.centerradius,c.centerradius,x1,y1)
if(salience[i]>0 or c.includezerosalience):
out.add(svg.path(d, fill='rgb(%s,%s,%s)' % (red,green,blue), p='fill-opacity="%s"' % s))
#draw dividers and text
for i in range(0,21):
if(c.saliencebywidth and c.drawsaliencedividers):
x1 = (500 + math.cos(indicatorcenterangles[i])*c.centerradius)
y1 = (500 + math.sin(indicatorcenterangles[i])*c.centerradius)
x2 = (500 + math.cos(indicatorcenterangles[i])*c.edgeradius)
y2 = (500 + math.sin(indicatorcenterangles[i])*c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
for j in range(1-c.includezerosalience,3):
if(c.saliencebywidth>1):
wedgewidth = wedgeangle/2/(c.saliencebywidth**3)*(c.saliencebywidth**j)
else:
wedgewidth = wedgeangle/2/(3+c.includezerosalience)*(j+c.includezerosalience)
for k in [1,-1]:
x1 = (500 + math.cos(indicatorcenterangles[i]+wedgewidth*k)*c.centerradius)
y1 = (500 + math.sin(indicatorcenterangles[i]+wedgewidth*k)*c.centerradius)
x2 = (500 + math.cos(indicatorcenterangles[i]+wedgewidth*k)*c.edgeradius)
y2 = (500 + math.sin(indicatorcenterangles[i]+wedgewidth*k)*c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
#invisible link and tooltip box
x1 = (500 + math.cos(indicatorcenterangles[i]+wedgeangle/2)*c.centerradius)
y1 = (500 + math.sin(indicatorcenterangles[i]+wedgeangle/2)*c.centerradius)
x2 = (500 + math.cos(indicatorcenterangles[i]+wedgeangle/2)*c.textradius+25)
y2 = (500 + math.sin(indicatorcenterangles[i]+wedgeangle/2)*c.textradius+25)
x3 = (500 + math.cos(indicatorcenterangles[i]-wedgeangle/2)*c.textradius+25)
y3 = (500 + math.sin(indicatorcenterangles[i]-wedgeangle/2)*c.textradius+25)
x4 = (500 + math.cos(indicatorcenterangles[i]-wedgeangle/2)*c.centerradius)
y4 = (500 + math.sin(indicatorcenterangles[i]-wedgeangle/2)*c.centerradius)
d = 'M %s,%s L %s,%s L %s,%s L %s,%s z' % (x1,y1,x2,y2,x3,y3,x4,y4)
newpath = svg.path(d, fill='white', p='fill-opacity="0.0"')
newpath.add(svg.title(' %s: %s\n Magnitude %s\tSalience %s' % (c.indicatornames[i], c.indicatorfullnames[i], magnitude[i], salience[i])))
out.add(newpath)
x = (500 + math.cos(indicatorcenterangles[i])*c.textradius)
y = (500 + math.sin(indicatorcenterangles[i])*c.textradius)
out.add(svg.text(c.indicatornames[i], x, y, fontsize=c.font, p='style="text-anchor: middle; dominant-baseline: middle"'))
# draw dividers
x1 = 500 + math.cos(indicatorseparatorangles[i])*c.centerradius
y1 = 500 + math.sin(indicatorseparatorangles[i])*c.centerradius
if(i % 7 == 0):
x2 = 500 + math.cos(indicatorseparatorangles[i])*(c.textradius+25)
y2 = 500 + math.sin(indicatorseparatorangles[i])*(c.textradius+25)
out.add(svg.line(x1, y1, x2, y2, 'black', 10))
elif (c.xgrid or (c.saliencebywidth and c.drawsaliencedividers)):
x2 = 500 + math.cos(indicatorseparatorangles[i])*(c.textradius)
y2 = 500 + math.sin(indicatorseparatorangles[i])*(c.textradius)
out.add(svg.line(x1, y1, x2, y2, 'black', 2))
#draw rings
for i in range(0,c.maxvalue+c.includezeromagnitude+1):
if(i==c.includezeromagnitude):
w=5
out.add(svg.circle('500','500',ringradii(i),'black',w,'none'))
elif (c.ygrid or i==0):
w=1
out.add(svg.circle('500','500',ringradii(i),'black',w,'none'))
return out
renderer.setup_tree(puzzle[agent]["secstruct"], NODE_R,PRIMARY_SPACE, PAIR_SPACE)
size = renderer.get_size()
puzzle[agent]["renderer"] = renderer
if(size[0] > cell_max_w):
cell_max_w = size[0]
if(size[0] > cell_max_h):
cell_max_h = size[1]
cell_size = max(cell_max_w,cell_max_h) + CELL_PADDING * 2
svg_w = cell_size * len(puzzle_nids)
svg_h = cell_size * len(agents)
svgobj = svg.svg("secstruct_table.svg", svg_w, svg_h)
puzzle_index = 0
for puzzle_nid in puzzle_nids:
puzname = str(puzzle_nid)
if puzname in puzzles:
puzzle = puzzles[puzname]
agent_index = 0
for agent in agents:
if agent in puzzle:
colors = None
pairs = None
if 'pairs' in puzzle[agent]:
pairs = puzzle[agent]['pairs']
agents = []
for ii in range(0, len(AGENTS)):
agents.append(AGENTS[ii])
for ii in range(1, puzround + 1):
agents.append("Players_%d" % ii)
for agent in agents:
scores = puzzle[agent]
if len(scores) > 0:
WIDTH += BAR_WIDTH
WIDTH += PUZZLE_MARGIN
plot = svg.svg("progress_plot.svg", WIDTH + 30, HEIGHT + 30)
xaxis_y = HEIGHT - (SCORE_LOWER_BOUND) * POINT_H + H_MARGIN
xaxis_y_max = H_MARGIN - POINT_H * 2
plot.line(W_MARGIN, xaxis_y, WIDTH, xaxis_y, "#000000")
plot.line(W_MARGIN, xaxis_y_max, WIDTH, xaxis_y_max, "#000000")
plot.line(W_MARGIN, xaxis_y, W_MARGIN, xaxis_y_max, "#000000")
plot.line(WIDTH, xaxis_y, WIDTH, xaxis_y_max, "#000000")
for step in range(SCORE_LOWER_BOUND, 100, SCORE_STEP):
score = step + SCORE_STEP
plot.line(W_MARGIN, HEIGHT - score * POINT_H + H_MARGIN, WIDTH,
HEIGHT - score * POINT_H + H_MARGIN, "#949494", 1)
plot.text(W_MARGIN - 11, HEIGHT - score * POINT_H + H_MARGIN, 14,
"#949494", "end", "%d" % score)
def makesaliencelegend():
out = svg.svg(width=2000, height=100, viewbox='0 0 2000 100')
if c.swapsaliencemagnitude:
te = 'Magnitude:'
else:
te = 'Salience:'
out.add(svg.text(te, 70, 50, fontsize=c.font))
for i in range(0, 2):
if i == 0:
red, green, blue = c.colorsbenefit[0]
elif c.colorsbenefit[0] == c.colorscost[0]:
return out
else:
red, green, blue = c.colorscost[0]
for j in range(0, 3 + c.includezerosalience):
out.add(
svg.text(j + (1 - c.includezerosalience),
(i * 950 + 290 + j *
(200 - 60 * c.includezerosalience)),
50,
fontsize=c.font))
if (c.saliencebycolor):
s = ((j + 1)**c.saliencebycolor) / (
(3.0 + c.includezerosalience)**c.saliencebycolor)
else:
s = 1
if (c.saliencebywidth):
out.add(
svg.rect((i * 950 + 320 + j *
(200 - 60 * c.includezerosalience)),
11,
80,
50,
stroke='black',
fill='none'))
if (c.saliencebywidth > 1):
w = 80.0 / (c.saliencebywidth**3) * (c.saliencebywidth**(
j + 1 - c.includezerosalience))
else:
w = 80.0 / (3 + c.includezerosalience) * (j + 1)
out.add(
svg.rect((i * 950 + 360 + j *
(200 - 60 * c.includezerosalience) - (w / 2)),
11,
w,
50,
stroke='none',
fill='rgb(%s,%s,%s)' % (red, green, blue),
p='fill-opacity="%s"' % s))
else:
out.add(
svg.rect((i * 950 + 320 + j *
(200 - 60 * c.includezerosalience)),
11,
80,
50,
stroke='none',
fill='rgb(%s,%s,%s)' % (red, green, blue),
p='fill-opacity="%s"' % s))
return out
def plot(series,
bins=40,
smoothing=1,
range_x=(0, 1),
range_y=(0, 1),
major=(0.1, 0.1),
minor=(2, 2),
title=None,
subtitle=None,
label_x=None,
label_y=None,
legend={},
colors={}):
resolution = 20 * bins
kernel_width = smoothing / bins
display = 800, 400
margin_x = 120, 120
margin_y = 80, 50 + 10 * (subtitle is not None) + 20 * (title is not None)
area = display[0] - sum(margin_x), sum(margin_y) - display[1]
offset = margin_x[0], display[1] - margin_y[0]
start, end = range_x
low, high = range_y
# epsilon deals with floating point error
cells = int((end - start) / major[0] * minor[0] +
1e-5), int((high - low) / major[1] * minor[1] + 1e-5)
grid_minor = []
grid_major = []
ticks = []
labels = []
for i in range(cells[0] + 1):
x = i * major[0] / (minor[0] * (end - start))
v = i * major[0] / minor[0] + start
m = i % minor[0] == 0
screen = tuple(
tuple(map(round, transform(x, area, offset)))
for x in ((x, 0), (x, 1)))
length = 12 if m else 6
(grid_major if m else grid_minor).append(
svg.path(
(transform(screen[0], (1, 1),
(0.5, 0)), transform(screen[1], (1, 1), (0.5, -1))),
classes=('grid', 'grid-major' if m else 'grid-minor')))
ticks.append(
svg.path((transform(screen[0], (1, 1), (0.5, 8)),
transform(screen[0], (1, 1), (0.5, 8 + length))),
classes=('tick', )))
if m:
labels.append(
svg.text(str(round(v, 3)),
position=transform(screen[0], (1, 1),
(0, 16 + length)),
classes=('label-numeric', 'label-x')))
for i in range(cells[1] + 1):
y = i * major[1] / (minor[1] * (high - low))
v = i * major[1] / minor[1] + low
m = i % minor[1] == 0
screen = tuple(
tuple(map(round, transform(y, area, offset)))
for y in ((0, y), (1, y)))
length = 12 if m else 6
(grid_major if m else grid_minor).append(
svg.path(
(transform(screen[0], (1, 1),
(0, -0.5)), transform(screen[1], (1, 1),
(1, -0.5))),
classes=('grid', 'grid-major' if m else 'grid-minor')))
ticks.append(
svg.path((transform(screen[0], (1, 1), (-8, -0.5)),
transform(screen[0], (1, 1), (-8 - length, -0.5))),
classes=('tick', )))
if m:
labels.append(
svg.text(str(round(v, 3)),
position=transform(screen[0], (1, 1),
(-16 - length, 0)),
classes=('label-numeric', 'label-y')))
paths = []
# emit using the same ordering as `colors`
for name, *_ in colors:
scale = 1 / (bins * len(series[name]))
curve = tuple((x / resolution, (sum(
kernel(x / resolution, (point - start) /
(end - start), kernel_width)
for point in series[name]) * scale - low) / (high - low))
for x in range(resolution + 1))
paths.append(
svg.path(map(lambda x: transform(x, area, offset), curve),
classes=(name, 'density-curve')))
for i, (name, label) in enumerate(legend):
base = tuple(map(round, transform((1, 1), area, offset)))
dy = 20 * i
paths.append(
svg.path((transform(base, (1, 1),
(10, dy)), transform(base, (1, 1), (25, dy))),
classes=(name, 'density-curve')))
labels.append(
svg.text(label,
position=transform(base, (1, 1), (32, dy)),
classes=('label-legend', )))
if type(title) is str:
screen = tuple(map(round, transform((0.5, 1), area, offset)))
labels.append(
svg.text(title,
position=transform(screen, (1, 1), (0, -40)),
classes=('title', )))
if type(subtitle) is str:
screen = tuple(map(round, transform((0.5, 1), area, offset)))
labels.append(
svg.text(subtitle,
position=transform(screen, (1, 1), (0, -20)),
classes=('subtitle', )))
if type(label_x) is str:
screen = tuple(map(round, transform((0.5, 0), area, offset)))
labels.append(
svg.text(label_x,
position=transform(screen, (1, 1), (0, 50)),
classes=('label-axis', 'label-x')))
if type(label_y) is str:
screen = tuple(map(round, transform((0, 0.5), area, offset)))
labels.append(
svg.text(label_y,
position=transform(screen, (1, 1), (-80, 0)),
classes=('label-axis', 'label-y', 'label-vertical')))
def linestyle(color, line):
properties = [('stroke', color)]
if line == 'dashed':
properties.append(('stroke-dasharray', '6 3'))
return '\n'.join(' {0}: {1};'.format(property, value)
for property, value in properties)
style = '''
rect.background
{
fill: white;
}
path.grid
{
stroke-width: 1px;
fill: none;
}
path.grid-major
{
stroke: #eeeeeeff;
}
path.grid-minor
{
stroke: #f5f5f5ff;
}
path.tick
{
stroke-width: 1px;
stroke: #333333ff;
fill: none;
}
text
{
fill: #333333ff;
font-family: 'SF Mono';
}
text.label-numeric
{
font-size: 12px;
}
text.label-x
{
text-anchor: middle;
dominant-baseline: hanging;
}
text.label-y
{
text-anchor: end;
dominant-baseline: middle;
}
text.label-legend
{
font-size: 12px;
text-anchor: begin;
dominant-baseline: middle;
}
text.label-axis
{
font-size: 14px;
font-weight: 700;
}
text.label-vertical.label-y
{
text-anchor: middle;
transform-box: fill-box;
transform-origin: center;
transform: rotate(-90deg);
}
text.title, text.subtitle
{
text-anchor: middle;
}
text.title
{
font-size: 20px;
}
text.subtitle
{
font-size: 12px;
}
path.density-curve
{
stroke-linejoin: round;
stroke-width: 2px;
fill: none;
}
''' + ''.join('''
path.{0}
{{
{1}
}}
'''.format(name, linestyle(color, line)) for name, color, line in colors)
return svg.svg(display, style,
grid_minor + grid_major + ticks + paths + labels)
def makecircle(magnitude, salience, benefit=1):
if c.swapsaliencemagnitude:
tm = salience[:]
salience = magnitude[:]
magnitude = tm
#general variables
indicatorseparatorangles = [
-math.pi * 2 / 21 * i + math.pi / 21 for i in range(0, 22)
]
indicatorcenterangles = [-math.pi * 2 / 21 * i for i in range(0, 21)]
wedgeangle = math.pi * 2 / 21
out = svg.svg(width=1000,
height=1000 + 100 * c.saliencelegend,
viewbox='0 0 1000 1%d00' % (1 * c.saliencelegend == True))
if (benefit):
colors = c.colorsbenefit
else:
colors = c.colorscost
if c.centerlabel is not None:
out.add(
svg.text(
c.centerlabel[1 - benefit],
500,
500,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'))
#draw wedges
for i in range(0, 21):
r = ringradii(magnitude[i] + c.includezeromagnitude)
if (c.saliencebywidth == 1):
wedgewidth = wedgeangle / 2 / (3 + c.includezerosalience) * (
salience[i] + c.includezerosalience)
elif (c.saliencebywidth > 1):
wedgewidth = wedgeangle / 2 / (saliencebywidth**3) * (
c.saliencebywidth**salience[i])
else:
wedgewidth = wedgeangle / 2
x1 = (500 +
math.cos(indicatorcenterangles[i] + wedgewidth) * c.centerradius)
y1 = (500 +
math.sin(indicatorcenterangles[i] + wedgewidth) * c.centerradius)
x2 = (500 + math.cos(indicatorcenterangles[i] + wedgewidth) * r)
y2 = (500 + math.sin(indicatorcenterangles[i] + wedgewidth) * r)
x3 = (500 + math.cos(indicatorcenterangles[i] - wedgewidth) * r)
y3 = (500 + math.sin(indicatorcenterangles[i] - wedgewidth) * r)
x4 = (500 +
math.cos(indicatorcenterangles[i] - wedgewidth) * c.centerradius)
y4 = (500 +
math.sin(indicatorcenterangles[i] - wedgewidth) * c.centerradius)
if (c.saliencebycolor):
s = ((salience[i] + c.includezerosalience)**c.saliencebycolor) / (
(3.0 + c.includezerosalience)**c.saliencebycolor)
else:
s = 1
red, green, blue = colors[i // 7]
d = 'M %s,%s L %s,%s A %s,%s 0 0,0 %s,%s L %s,%s A %s,%s 0 0,1 %s,%s' % (
x1, y1, x2, y2, r, r, x3, y3, x4, y4, c.centerradius,
c.centerradius, x1, y1)
if (salience[i] > 0 or c.includezerosalience):
out.add(
svg.path(d,
fill='rgb(%s,%s,%s)' % (red, green, blue),
p='fill-opacity="%s"' % s))
#draw dividers and text
for i in range(0, 21):
if (c.saliencebywidth and c.drawsaliencedividers):
x1 = (500 + math.cos(indicatorcenterangles[i]) * c.centerradius)
y1 = (500 + math.sin(indicatorcenterangles[i]) * c.centerradius)
x2 = (500 + math.cos(indicatorcenterangles[i]) * c.edgeradius)
y2 = (500 + math.sin(indicatorcenterangles[i]) * c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
for j in range(1 - c.includezerosalience, 3):
if (c.saliencebywidth > 1):
wedgewidth = wedgeangle / 2 / (c.saliencebywidth**
3) * (c.saliencebywidth**j)
else:
wedgewidth = wedgeangle / 2 / (
3 + c.includezerosalience) * (j +
c.includezerosalience)
for k in [1, -1]:
x1 = (500 +
math.cos(indicatorcenterangles[i] + wedgewidth * k) *
c.centerradius)
y1 = (500 +
math.sin(indicatorcenterangles[i] + wedgewidth * k) *
c.centerradius)
x2 = (500 +
math.cos(indicatorcenterangles[i] + wedgewidth * k) *
c.edgeradius)
y2 = (500 +
math.sin(indicatorcenterangles[i] + wedgewidth * k) *
c.edgeradius)
out.add(svg.line(x1, y1, x2, y2, 'black', .5))
#invisible link and tooltip box
x1 = (500 + math.cos(indicatorcenterangles[i] + wedgeangle / 2) *
c.centerradius)
y1 = (500 + math.sin(indicatorcenterangles[i] + wedgeangle / 2) *
c.centerradius)
x2 = (500 + math.cos(indicatorcenterangles[i] + wedgeangle / 2) *
c.textradius + 25)
y2 = (500 + math.sin(indicatorcenterangles[i] + wedgeangle / 2) *
c.textradius + 25)
x3 = (500 + math.cos(indicatorcenterangles[i] - wedgeangle / 2) *
c.textradius + 25)
y3 = (500 + math.sin(indicatorcenterangles[i] - wedgeangle / 2) *
c.textradius + 25)
x4 = (500 + math.cos(indicatorcenterangles[i] - wedgeangle / 2) *
c.centerradius)
y4 = (500 + math.sin(indicatorcenterangles[i] - wedgeangle / 2) *
c.centerradius)
d = 'M %s,%s L %s,%s L %s,%s L %s,%s z' % (x1, y1, x2, y2, x3, y3, x4,
y4)
newpath = svg.path(d, fill='white', p='fill-opacity="0.0"')
newpath.add(
svg.title(' %s: %s\n Magnitude %s\tSalience %s' %
(c.indicatornames[i], c.indicatorfullnames[i],
magnitude[i], salience[i])))
out.add(newpath)
x = (500 + math.cos(indicatorcenterangles[i]) * c.textradius)
y = (500 + math.sin(indicatorcenterangles[i]) * c.textradius)
out.add(
svg.text(
c.indicatornames[i],
x,
y,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'))
# draw dividers
x1 = 500 + math.cos(indicatorseparatorangles[i]) * c.centerradius
y1 = 500 + math.sin(indicatorseparatorangles[i]) * c.centerradius
if (i % 7 == 0):
x2 = 500 + math.cos(
indicatorseparatorangles[i]) * (c.textradius + 25)
y2 = 500 + math.sin(
indicatorseparatorangles[i]) * (c.textradius + 25)
out.add(svg.line(x1, y1, x2, y2, 'black', 10))
elif (c.xgrid or (c.saliencebywidth and c.drawsaliencedividers)):
x2 = 500 + math.cos(indicatorseparatorangles[i]) * (c.textradius)
y2 = 500 + math.sin(indicatorseparatorangles[i]) * (c.textradius)
out.add(svg.line(x1, y1, x2, y2, 'black', 2))
#draw rings
for i in range(0, c.maxvalue + c.includezeromagnitude + 1):
if (i == c.includezeromagnitude):
w = 5
out.add(svg.circle('500', '500', ringradii(i), 'black', w, 'none'))
elif (c.ygrid or i == 0):
w = 1
out.add(svg.circle('500', '500', ringradii(i), 'black', w, 'none'))
return out
def main():
# bar chart
if (c.charttype == 2):
svgport = svg.svg(viewbox='0 0 1000 2%d50' % 3 *
(c.magnitudelegend == True))
if c.magnitudelegend:
chart1 = svg.g()
else:
chart1 = svg.g()
chart1.add(
makebarsvert(c.magnitudebenefit, c.saliencebenefit,
c.magnitudecost, c.saliencecost))
svgport.add(chart1)
# salience legend for bar
if (c.saliencelegend):
sal = svg.g(p='transform="rotate(90 1000 50) translate(%s 0)"' %
(550 + c.textradius))
sal.add(makesaliencelegend())
svgport.add(sal)
else:
# amoeba chart
if (c.charttype == 0):
svgport = svg.svg(viewbox='0 0 2%d50 1%d00' %
(3 * (c.magnitudelegend == True), 1 *
(c.saliencelegend == True)))
chart1 = svg.g()
chart1.add(
makecircle(c.magnitudebenefit, c.saliencebenefit, benefit=1))
chart2 = svg.g(p='transform="translate(1050)"')
chart2.add(makecircle(c.magnitudecost, c.saliencecost, benefit=0))
svgport.add(chart1)
svgport.add(chart2)
if (c.magnitudelegend):
mag = svg.g(p='transform="translate(2050)"')
mag.add(makemagnitudelegend())
svgport.add(mag)
# column chart (default)
else:
svgport = svg.svg(viewbox='0 0 2%d50 1%d00' %
(3 * (c.magnitudelegend == True), 1 *
(c.saliencelegend == True)))
if c.magnitudelegend:
chart1 = svg.g()
else:
chart1 = svg.g(p='transform="translate(-200)"')
chart1.add(
makebars(c.magnitudebenefit, c.saliencebenefit,
c.magnitudecost, c.saliencecost))
svgport.add(chart1)
# salience legend for amoeba and column
if (c.saliencelegend):
sal = svg.g(p='transform="translate(0 %s)"' % (550 + c.textradius))
sal.add(makesaliencelegend())
svgport.add(sal)
svg.gen(svgport, c.savename)
def plot(ratios,
range_x = (0, 2),
major = 1.0,
minor = 5,
title = None,
subtitle = None,
colors = {}):
display = 800, 680
margin_x = 60, 60
margin_y = 20, 80 + 10 * (subtitle is not None) + 20 * (title is not None)
area = display[0] - sum(margin_x), sum(margin_y) - display[1]
offset = margin_x[0], display[1] - margin_y[0]
# draw grid lines
start, end = range_x
# epsilon to deal with rounding errors
cells = int((end - start) / major * minor + 1e-5)
grid_minor = []
grid_major = []
ticks = []
labels = []
for i in range(cells + 1):
x = i * major / (minor * (end - start))
v = i * major / minor
m = i % minor == 0
screen = tuple(tuple(map(round, transform(x, area, offset))) for x in ((x, 0), (x, 1)))
length = 12 if m else 6
(grid_major if m else grid_minor).append(
svg.path( (transform(screen[0], (1, 1), (0.5, 0)),
transform(screen[1], (1, 1), (0.5, -1))),
classes = ('grid', 'grid-major' if m else 'grid-minor')))
ticks.append(
svg.path( (transform(screen[1], (1, 1), (0.5, -8)),
transform(screen[1], (1, 1), (0.5, -8 - length))),
classes = ('tick',)))
if m:
labels.append(svg.text(str(round(v, 3)),
position = transform(screen[1], (1, 1), (0, -16 - length)),
classes = ('label-numeric', 'label-x') + (('unity',) if v == 1 else ())))
# title and subtitle
if type(title) is str:
screen = tuple(map(round, transform((0.5, 1), area, offset)))
labels.append(svg.text(title,
position = transform(screen, (1, 1), (0, -70)),
classes = ('title',)))
if type(subtitle) is str:
screen = tuple(map(round, transform((0.5, 1), area, offset)))
labels.append(svg.text(subtitle,
position = transform(screen, (1, 1), (0, -50)),
classes = ('subtitle',)))
# plot data
rows = tuple((name, ratio, (
margin_x[0] + area[0] * (ratio - range_x[0]) / (range_x[1] - range_x[0]),
margin_y[1] + (i + 0.5) * 20))
for i, (name, ratio) in enumerate(sorted(ratios.items(), key = lambda k: k[1])))
# pixel coordinate of the y axis
zero = margin_x[0] + area[0] * (1.0 - range_x[0]) / (range_x[1] - range_x[0])
legend = tuple(svg.text(name,
(zero + 16 * (1 if ratio <= 1 else -1), screen[1]),
classes = ('label-legend', 'better' if ratio <= 1 else 'worse'))
for name, ratio, screen in rows)
percents = tuple(svg.text('{:+.2f} %'.format((ratio - 1) * 100),
(screen[0] - 16 * (1 if ratio <= 1 else -1), screen[1]),
classes = ('label-percent', 'better' if ratio <= 1 else 'worse'))
for name, ratio, screen in rows)
stems = tuple(svg.path((
(zero, screen[1]),
(screen[0] + 4 * (1 if ratio <= 1 else -1), screen[1])),
classes = ('stem', 'better' if ratio <= 1 else 'worse'))
for name, ratio, screen in rows
if abs(screen[0] - zero) > 4)
dots = tuple(svg.circle(screen, radius = 4,
classes = ('dot', 'better' if ratio <= 1 else 'worse'))
for name, ratio, screen in rows)
style = '''
rect.background
{
fill: white;
}
path.grid
{
stroke-width: 1px;
fill: none;
}
path.grid-major
{
stroke: #eeeeeeff;
}
path.grid-minor
{
stroke: #f5f5f5ff;
}
path.tick
{
stroke-width: 1px;
stroke: #333333ff;
fill: none;
}
path.stem
{
stroke-width: 1px;
stroke-dasharray: 3 3;
}
circle.dot
{
stroke-width: 2px;
stroke: #666;
fill: none;
}
text
{
fill: #333333ff;
font-family: 'SF Mono';
}
text.label-numeric
{
font-size: 12px;
}
text.label-numeric.unity
{
font-weight: 700;
}
text.label-x
{
text-anchor: middle;
dominant-baseline: text-top;
}
text.label-legend, text.label-percent
{
font-size: 12px;
dominant-baseline: middle;
}
text.label-percent
{
font-weight: 700;
}
text.label-legend.better, text.label-percent.worse
{
text-anchor: begin;
}
text.label-legend.worse, text.label-percent.better
{
text-anchor: end;
}
text.title, text.subtitle
{
text-anchor: middle;
}
text.title
{
font-size: 20px;
}
text.subtitle
{
font-size: 12px;
}
''' + '''
circle.better, path.stem.better
{{
stroke: {color_fill_better}
}}
circle.worse, path.stem.worse
{{
stroke: {color_fill_worse}
}}
text.label-percent.better
{{
fill: {color_better}
}}
text.label-percent.worse
{{
fill: {color_worse}
}}
'''.format( ** colors )
return svg.svg(display, style,
tuple(grid_minor + grid_major + ticks + labels) + legend + percents + stems + dots)
__author__ = 'majik'
import svg
if __name__ == "__main__":
# try:
# svg.svg('assets', 'out1', '-c --ccss --cs')
# svg.svg('assets/example-1.svg', 'out2', '-c --ccss --cs')
# svg.svg(['assets/example-2.svg', 'assets/example-1.svg', 'assets/example-1.png'], 'out3', '-c --ccss --cs')
# svg.svg('123', 'out4', '-c --ccss --cs')
# except svg.SvgException as svgexception:
# print svgexception.details
# svgtransformer.svgform('1.svg')
svg.svg('assets')
svg.svg('assets/example-1.svg')
def makebarsvert(magnitudebenefit, saliencebenefit, magnitudecost,
saliencecost):
if c.swapsaliencemagnitude:
tm = saliencebenefit[:]
saliencebenefit = magnitudebenefit[:]
magnitudebenefit = tm
tm = saliencecost[:]
saliencecost = magnitudecost[:]
magnitudecost = tm
#general variables
t = 0
if c.centerlabel is not None:
t = 50
out = svg.svg(width=1000, height=2250 + t, viewbox='0 0 1000 2150')
barwidth = 2050 / (21 + c.spacebars * 2)
chart = svg.g('transform="translate(0 %s)"' % t)
out.add(chart)
for cb in range(0, 2):
if c.centerlabel is not None:
out.add(
svg.text(
c.centerlabel[1 - cb],
250 + (cb) * 500,
25,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"')
)
if (cb == 1):
colors = c.colorsbenefit
magnitude = magnitudebenefit
salience = saliencebenefit
else:
magnitude = magnitudecost
salience = saliencecost
colors = c.colorscost
#draw bars
for i in range(0, 21):
h = barheight(magnitude[i] + c.includezeromagnitude)
if (c.saliencebywidth == 1):
w = barwidth / (3 + c.includezerosalience) * (
salience[i] + c.includezerosalience)
elif (c.saliencebywidth > 1):
w = barwidth / (c.saliencebywidth**3) * (c.saliencebywidth**
salience[i])
else:
w = barwidth
if (c.saliencebycolor):
s = ((salience[i] + c.includezerosalience)**
c.saliencebycolor) / (
(3.0 + c.includezerosalience)**c.saliencebycolor)
else:
s = 1
red, green, blue = colors[i // 7]
if (salience[i] > 0 or c.includezerosalience):
barlinecolor = (int(red * c.barlineshade),
int(green * c.barlineshade),
int(blue * c.barlineshade))
chart.add(
svg.rect(
500 + (cb - 1) * h,
(i + (i // 7) * c.spacebars) * barwidth +
(barwidth - w) / 2,
h,
w,
fill='rgb(%s,%s,%s)' % (red, green, blue),
stroke='rgb(%s,%s,%s)' %
(barlinecolor[0], barlinecolor[1], barlinecolor[2]),
strokewidth=c.barline,
p='fill-opacity="%s"' % s))
#invisible link and tooltip box
newrect = svg.rect(500 + (cb - 1) * c.textradius,
(i + (i // 7) * c.spacebars) * barwidth,
c.textradius,
barwidth,
fill='white',
p='fill-opacity="0.0"')
newrect.add(
svg.title(' %s: %s\n Magnitude %s\tSalience %s' %
(c.indicatornames[i], c.indicatorfullnames[i],
magnitude[i], salience[i])))
chart.add(newrect)
#draw ygrid
for i in range(0, c.maxvalue + c.includezeromagnitude + 1):
if (i == c.includezeromagnitude):
w = 5
else:
w = 1
if (c.ygrid or i == 0):
x2 = 0
else:
x2 = 2050 - c.ticksize
chart.add(
svg.line(500 + barheight(i) * (cb - .5) * 2, 2050 + c.ticksize,
500 + barheight(i) * (cb - .5) * 2, x2, 'black', w))
#draw xgrid dividers
chart.add(
svg.line(500 - c.edgeradius, 2050, 500 + c.edgeradius, 2050, 'black',
5))
for i in range(0, 21 + c.spacebars * 2):
if (c.xgrid or (c.saliencebywidth and c.drawsaliencedividers)):
chart.add(
svg.line(500 - c.edgeradius, barwidth * i, 500 + c.edgeradius,
barwidth * i, 'black', 1))
elif (ticksize):
chart.add(
svg.line(500 - c.ticksize, barwidth * i, 500 + c.ticksize,
barwidth * i, 'black', 1))
#draw salience dividers and column headings
for i in range(0, 21):
if (c.saliencebywidth and c.drawsaliencedividers):
for j in range(1 - c.includezerosalience, 3):
if (c.saliencebywidth > 1):
w = barwidth / 2 / (c.saliencebywidth**
3) * (c.saliencebywidth**j)
else:
w = barwidth / 2 / (3 + c.includezerosalience) * (
j + c.includezerosalience)
for k in [1, -1]:
chart.add(
svg.line(500 - c.edgeradius,
barwidth * (i + (i // 7) + .5) + k * w,
500 + c.edgeradius,
barwidth * (i + (i // 7) + .5) + k * w,
'black', .5))
x = (500 - c.textradius)
y = ((i + (i // 7) * c.spacebars + .5) * barwidth)
chart.add(
svg.text(
c.indicatornames[i],
x,
y,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'))
#draw magnitude legend
if c.magnitudelegend:
if c.swapsaliencemagnitude:
te = 'Salience'
else:
te = 'Magnitude'
mag = svg.g(p='transform="translate(0 2050)"')
mag.add(
svg.text(
te,
500,
100,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'))
lastnumber = 1
for i in range(0, c.maxvalue + c.includezeromagnitude + 1):
if (i - c.includezeromagnitude == 0):
mag.add(
svg.text(
i - c.includezeromagnitude,
502 - barheight(i),
40,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'
))
if (barheight(i) * 2 > c.font):
mag.add(
svg.text(
i - c.includezeromagnitude,
502 + barheight(i),
40,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'
))
elif (i - c.includezeromagnitude > 0):
# alternate top and bottom if axis lables too close
mag.add(
svg.text(
i - c.includezeromagnitude,
502 + barheight(i) * lastnumber,
40,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'
))
if (barheight(i) - barheight(i - 1) > c.font):
mag.add(
svg.text(
i - c.includezeromagnitude,
502 - barheight(i) * lastnumber,
40,
fontsize=c.font,
p='style="text-anchor: middle; dominant-baseline: middle"'
))
else:
lastnumber = lastnumber * -1
chart.add(mag)
return out
