Despite being on holiday, I had a spare hour to refactor the code (@mrshrbrmstr was joining the 1% in the hotel spa). It’s up on github and now sports a spiffy JSON-format config file. You now must execute the slopegraph.py script with a “—config FILENAME” argument. The configuration file lets you specify the “theme” as well as the input file and output format (you can only use PDF for the moment).
Here’s a sample config file included in the github push (there’s another one there too):
{
"font_family" : "Palatino",
"font_size" : "20",
"x_margin" : "20",
"y_margin" : "30",
"line_width" : "0.5",
"background_color" : "DEC299",
"label_color" : "687D64",
"value_color" : "949258",
"slope_color" : "61514C",
"value_format_string" : "%2d",
"input" : "television.csv",
"output" : "television",
"format" : "pdf"
}Included in the refactor is the ability to use a sprintf-like format string for the label value output to make the slopegraphs a tad prettier. Also included with the refactor is a new limitation of the CSV file requiring a
“LABEL, VALUE, VALUE”
format in preparation for support for multiple columns. As @jayjacobs said to me, it’s easy to reformat data into the CSV file format, and, he’s right (as usual).
Plans for the next revision include:
- Specifying a transparent background
- Specifying PDF|PS|SVG|PNG format output
- Allowing for an arbitrary number of columns for the slopegraph
- Optional column labels as well as slopepgraph title (with themeing)
- Line color change by slope up/same/down value (will most likely be pushed out, tho)
Here’s the whole source:
import csv
import cairo
import argparse
import json
def split(input, size):
return [input[start:start+size] for start in range(0, len(input), size)]
class Slopegraph:
SLOPEGRAPH_CANVAS_SIZE = 300
starts = {} # starting "points"
ends = {} # ending "points"
pairs = [] # base pair array for the final plotting
def readCSV(self, filename):
slopeReader = csv.reader(open(filename, 'rb'), delimiter=',', quotechar='"')
for row in slopeReader:
# add chosen values (need start/end for each CSV row) to the final plotting array.
lab = row[0] # label
beg = float(row[1]) # left vals
end = float(row[2]) # right vals
self.pairs.append( (float(beg), float(end)) )
# combine labels of common values into one string
if beg in self.starts:
self.starts[beg] = self.starts[beg] + "; " + lab
else:
self.starts[beg] = lab
if end in self.ends:
self.ends[end] = self.ends[end] + "; " + lab
else:
self.ends[end] = lab
def sortKeys(self):
# sort all the values (in the event the CSV wasn't) so
# we can determine the smallest increment we need to use
# when stacking the labels and plotting points
self.startSorted = [(k, self.starts[k]) for k in sorted(self.starts)]
self.endSorted = [(k, self.ends[k]) for k in sorted(self.ends)]
self.startKeys = sorted(self.starts.keys())
self.delta = max(self.startSorted)
for i in range(len(self.startKeys)):
if (i+1 <= len(self.startKeys)-1):
currDelta = float(self.startKeys[i+1]) - float(self.startKeys[i])
if (currDelta < self.delta):
self.delta = currDelta
self.endKeys = sorted(self.ends.keys())
for i in range(len(self.endKeys)):
if (i+1 <= len(self.endKeys)-1):
currDelta = float(self.endKeys[i+1]) - float(self.endKeys[i])
if (currDelta < self.delta):
self.delta = currDelta
def findExtremes(self):
# we also need to find the absolute min & max values
# so we know how to scale the plots
self.lowest = min(self.startKeys)
if (min(self.endKeys) < self.lowest) : self.lowest = min(self.endKeys)
self.highest = max(self.startKeys)
if (max(self.endKeys) > self.highest) : self.highest = max(self.endKeys)
self.delta = float(self.delta)
self.lowest = float(self.lowest)
self.highest = float(self.highest)
def calculateExtents(self, filename, format, valueFormatString):
surface = cairo.PDFSurface (filename, 8.5*72, 11*72)
cr = cairo.Context (surface)
cr.save()
cr.select_font_face(self.FONT_FAMILY, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
cr.set_font_size(self.FONT_SIZE)
cr.set_line_width(self.LINE_WIDTH)
# find the *real* maximum label width (not just based on number of chars)
maxLabelWidth = 0
maxNumWidth = 0
for k in sorted(self.startKeys):
s1 = self.starts[k]
xbearing, ybearing, self.sWidth, self.sHeight, xadvance, yadvance = (cr.text_extents(s1))
if (self.sWidth > maxLabelWidth) : maxLabelWidth = self.sWidth
xbearing, ybearing, self.startMaxLabelWidth, startMaxLabelHeight, xadvance, yadvance = (cr.text_extents(valueFormatString % (k)))
if (self.startMaxLabelWidth > maxNumWidth) : maxNumWidth = self.startMaxLabelWidth
self.sWidth = maxLabelWidth
self.startMaxLabelWidth = maxNumWidth
maxLabelWidth = 0
maxNumWidth = 0
for k in sorted(self.endKeys):
e1 = self.ends[k]
xbearing, ybearing, self.eWidth, eHeight, xadvance, yadvance = (cr.text_extents(e1))
if (self.eWidth > maxLabelWidth) : maxLabelWidth = self.eWidth
xbearing, ybearing, self.endMaxLabelWidth, endMaxLabelHeight, xadvance, yadvance = (cr.text_extents(valueFormatString % (k)))
if (self.endMaxLabelWidth > maxNumWidth) : maxNumWidth = self.endMaxLabelWidth
self.eWidth = maxLabelWidth
self.endMaxLabelWidth = maxNumWidth
cr.restore()
cr.show_page()
surface.finish()
self.width = self.X_MARGIN + self.sWidth + self.SPACE_WIDTH + self.startMaxLabelWidth + self.SPACE_WIDTH + self.SLOPEGRAPH_CANVAS_SIZE + self.SPACE_WIDTH + self.endMaxLabelWidth + self.SPACE_WIDTH + self.eWidth + self.X_MARGIN ;
self.height = (self.Y_MARGIN * 2) + (((self.highest - self.lowest) / self.delta) * self.LINE_HEIGHT)
def makeSlopegraph(self, filename, config):
(lab_r,lab_g,lab_b) = split(config["label_color"],2)
(val_r,val_g,val_b) = split(config["value_color"],2)
(line_r,line_g,line_b) = split(config["slope_color"],2)
(bg_r,bg_g,bg_b) = split(config["background_color"],2)
LAB_R = (int(lab_r, 16)/255.0)
LAB_G = (int(lab_g, 16)/255.0)
LAB_B = (int(lab_b, 16)/255.0)
VAL_R = (int(val_r, 16)/255.0)
VAL_G = (int(val_g, 16)/255.0)
VAL_B = (int(val_b, 16)/255.0)
LINE_R = (int(line_r, 16)/255.0)
LINE_G = (int(line_g, 16)/255.0)
LINE_B = (int(line_b, 16)/255.0)
BG_R = (int(bg_r, 16)/255.0)
BG_G = (int(bg_g, 16)/255.0)
BG_B = (int(bg_b, 16)/255.0)
surface = cairo.PDFSurface (filename, self.width, self.height)
cr = cairo.Context(surface)
cr.save()
cr.select_font_face(self.FONT_FAMILY, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
cr.set_font_size(self.FONT_SIZE)
cr.set_line_width(self.LINE_WIDTH)
cr.set_source_rgb(BG_R,BG_G,BG_B)
cr.rectangle(0,0,self.width,self.height)
cr.fill()
# draw start labels at the correct positions
valueFormatString = config["value_format_string"]
for k in sorted(self.startKeys):
val = float(k)
label = self.starts[k]
xbearing, ybearing, lWidth, lHeight, xadvance, yadvance = (cr.text_extents(label))
xbearing, ybearing, kWidth, kHeight, xadvance, yadvance = (cr.text_extents(valueFormatString % (val)))
cr.set_source_rgb(LAB_R,LAB_G,LAB_B)
cr.move_to(self.X_MARGIN + (self.sWidth - lWidth), self.Y_MARGIN + (self.highest - val) * self.LINE_HEIGHT * (1/self.delta))
cr.show_text(label)
cr.set_source_rgb(VAL_R,VAL_G,VAL_B)
cr.move_to(self.X_MARGIN + self.sWidth + self.SPACE_WIDTH + (self.startMaxLabelWidth - kWidth), self.Y_MARGIN + (self.highest - val) * self.LINE_HEIGHT * (1/self.delta))
cr.show_text(valueFormatString % (val))
cr.stroke()
# draw end labels at the correct positions
for k in sorted(self.endKeys):
val = float(k)
label = self.ends[k]
xbearing, ybearing, lWidth, lHeight, xadvance, yadvance = (cr.text_extents(label))
cr.set_source_rgb(VAL_R,VAL_G,VAL_B)
cr.move_to(self.width - self.X_MARGIN - self.SPACE_WIDTH - self.eWidth - self.SPACE_WIDTH - self.endMaxLabelWidth, self.Y_MARGIN + (self.highest - val) * self.LINE_HEIGHT * (1/self.delta))
cr.show_text(valueFormatString % (val))
cr.set_source_rgb(LAB_R,LAB_G,LAB_B)
cr.move_to(self.width - self.X_MARGIN - self.SPACE_WIDTH - self.eWidth, self.Y_MARGIN + (self.highest - val) * self.LINE_HEIGHT * (1/self.delta))
cr.show_text(label)
cr.stroke()
# do the actual plotting
cr.set_line_width(self.LINE_WIDTH)
cr.set_source_rgb(LINE_R, LINE_G, LINE_B)
for s1,e1 in self.pairs:
cr.move_to(self.X_MARGIN + self.sWidth + self.SPACE_WIDTH + self.startMaxLabelWidth + self.LINE_START_DELTA, self.Y_MARGIN + (self.highest - s1) * self.LINE_HEIGHT * (1/self.delta) - self.LINE_HEIGHT/4)
cr.line_to(self.width - self.X_MARGIN - self.eWidth - self.SPACE_WIDTH - self.endMaxLabelWidth - self.LINE_START_DELTA, self.Y_MARGIN + (self.highest - e1) * self.LINE_HEIGHT * (1/self.delta) - self.LINE_HEIGHT/4)
cr.stroke()
cr.restore()
cr.show_page()
surface.finish()
def __init__(self, config):
# a couple methods need these so make them local to the class
self.FONT_FAMILY = config["font_family"]
self.LINE_WIDTH = float(config["line_width"])
self.X_MARGIN = float(config["x_margin"])
self.Y_MARGIN = float(config["y_margin"])
self.FONT_SIZE = float(config["font_size"])
self.SPACE_WIDTH = self.FONT_SIZE / 2.0
self.LINE_HEIGHT = self.FONT_SIZE + (self.FONT_SIZE / 2.0)
self.LINE_START_DELTA = 1.5*self.SPACE_WIDTH
OUTPUT_FILE = config["output"] + "." + config["format"]
# process the values & make the slopegraph
self.readCSV(config["input"])
self.sortKeys()
self.findExtremes()
self.calculateExtents(OUTPUT_FILE, config["format"], config["value_format_string"])
self.makeSlopegraph(OUTPUT_FILE, config)
def main():
parser = argparse.ArgumentParser(description="Creates a slopegraph from a CSV source")
parser.add_argument("--config",required=True,
help="config file name to use for slopegraph creation",)
args = parser.parse_args()
if args.config:
json_data = open(args.config)
config = json.load(json_data)
json_data.close()
Slopegraph(config)
return(0)
if __name__ == "__main__":
main()
No comments yet.