def _drawLabels(self, Title, xAxis, yAxis):
self.graphCenterX = self.width/2
self.graphCenterY = self.height/2
Label_Xaxis = Label()
Label_Xaxis.fontSize = 7
Label_Xaxis.angle = 0
Label_Xaxis.dx = self.graphCenterX - 50
Label_Xaxis.dy = 0
Label_Xaxis.boxAnchor = 's'
Label_Xaxis.setText(xAxis)
self.drawing.add(Label_Xaxis)
Label_Yaxis = Label()
Label_Yaxis.fontSize = 7
Label_Yaxis.angle = 90
Label_Yaxis.boxAnchor = 'n'
Label_Yaxis.dx = -5
Label_Yaxis.dy = self.graphCenterY
Label_Yaxis.setText(yAxis)
self.drawing.add(Label_Yaxis)
Label_Graph = Label()
Label_Graph.fontSize = 10
Label_Graph.angle = 0
Label_Graph.boxAnchor = 'n'
Label_Graph.dx = self.graphCenterX - 50
Label_Graph.dy = self.height
Label_Graph.setText(Title)
self.drawing.add(Label_Graph)
def draw(self):
# general widget bits
w = float(self.length)
h = float(self.height)
g = shapes.Group()
body = shapes.Polygon(
[self.x-0.5*w, self.y-0.5*w,
self.x-0.5*w, self.y+0.5*w,
self.x+0.5*w, self.y],
fillColor=self.fillColor,
strokeColor=self.strokeColor,
strokeWidth=self.strokeWidth)
g.add(body)
if self.label:
b = g.getBounds()
s = Label()
s.setText(self.label)
s.setOrigin(self.x+0.5*w, self.y-h/2+b[3]-b[1]+4)
s.boxAnchor = self.boxAnchor
s.textAnchor = self.textAnchor
s.fontName = 'Helvetica'
s.fontSize = self.fontSize
s.angle = self.labelAngle
g.add(s)
return g
def getHumPlot():
drawing = Drawing(400, 200)
humedad = [getHumedad()]
lp = LinePlot()
lp.x = 50
lp.y = 50
lp.height = 125
lp.width = 300
lp.data = humedad
ydlabel = Label()
ydlabel.setText("Humedad (%)")
ydlabel.angle = 90
ydlabel.setOrigin(20, 120)
lp.joinedLines = 2
lp.lines[0].symbol = makeMarker('Circle')
lp.lines[0].strokeColor = colors.blue
lp.xValueAxis.valueMin = 0
lp.xValueAxis.valueMax = 30
lp.yValueAxis.valueMin = 0
lp.yValueAxis.valueMax = 100
#lp.xValueAxis.visible=False
#lp.yValueAxis.visible=False #Hide 2nd plot its Yaxis
drawing.add(lp)
drawing.add(ydlabel)
drawing.add(String(130, 200, "Gráfico de humedad", fontSize=16))
return drawing
def graphout_stackedBar(data, labels, X, Y):
drawing = Drawing(X*inch, Y*inch)
bar = VerticalBarChart()
bar.x = 50
bar.y = 50
bar.width = (X-2)*inch
bar.height = (Y-1)*inch
bar.data = data
bar.bars.strokeWidth = 0
bar.categoryAxis.style='stacked'
bar.categoryAxis.labels.boxAnchor = 'ne'
bar.categoryAxis.labels.dx = -2
bar.categoryAxis.labels.dy = -2
bar.categoryAxis.labels.angle = 45
bar.categoryAxis.categoryNames = labels
# ensure bar chart and legend coloring matches
for i in range(len(data)):
bar.bars[i].fillColor = colorList[i]
# Create a title for the y-axis
yLabel = Label()
yLabel.setOrigin(0, 50) # for reference, the graph origin is (50, 50)
yLabel.boxAnchor = 'c'
yLabel.angle = 90
yLabel.setText('Data Storage [GB]')
yLabel.fontSize=16
yLabel.dy = 1.25*inch
drawing.add(yLabel)
drawing.add(bar)
return drawing
def draw_travels(self):
for p in self.world.packets:
if self.detailed:
txt = p.command()
else:
txt = "(%d) %s" % (p.number, p.description)
last_action = (0,0)
for ts in p.trip:
action = self.packet_actions[ts.action]
if ts.actor not in self.verticals:
self.verticals[ts.actor] = self.verticals[ts.actor.node]
x2,y2 = self.verticals[ts.actor], -ts.time*self.yzoom
if action.sprite:
self.sequence_diagram.add(shapes.Circle(x2, y2,
action.size, fillColor=action.color, strokeWidth=1 ))
if action.travel:
if action.travel_desc:
# self.sequence_diagram.add(shapes.String((last_action[0] + x)/2,(last_action[1]+y)/2, label, fill=colors.black, textAnchor = 'middle'))
x1, y1 = last_action[0], last_action[1]
l = Label()
l.setText(txt)
l.angle = atan2((y2-y1)/2, (x2-x1))*360.0/pi
l.dy = 10
l.setOrigin((x1 + x2)/2,(y1+y2)/2)
self.sequence_diagram.add(l)
#anchor = Paragraph('<a name="diagram%d"/>' %p.number, styles['Normal'])
self.sequence_diagram.add(shapes.Line(last_action[0],last_action[1],x2,y2, strokeColor=colors.black, strokeWidth=1))
self.max_y = min(y2, self.max_y, last_action[1])
last_action = (x2,y2)
def draw(self):
# general widget bits
w = float(self.length)
h = float(self.height)
# print self.label,w,h
# Set minimum size
if abs(w)<self.wmin:
xmid = self.x+0.5*w
w = w/abs(w) * self.wmin
self.x = xmid-0.5*w
g = shapes.Group()
if abs(w)>self.wNoTail:
# arrow specific bits
body = shapes.Rect(x=self.x, y=self.y-self.aspectRatio*h/2,
width=2*(w/3),
height=self.aspectRatio*h,
fillColor=self.fillColor,
strokeColor=self.strokeColor,
strokeWidth=self.strokeWidth)
g.add(body)
head = shapes.Polygon(
points=[self.x+w, self.y,
self.x+2*(w/3), self.y+h/2,
self.x+2*(w/3), self.y-h/2,
self.x+w, self.y],
fillColor=self.fillColor,
strokeColor=self.strokeColor,
strokeWidth=self.strokeWidth)
g.add(head)
else:
head = shapes.Polygon(
points=[self.x+w, self.y,
self.x, self.y+h/2,
self.x, self.y-h/2,
self.x+w, self.y],
fillColor=self.fillColor,
strokeColor=self.strokeColor,
strokeWidth=self.strokeWidth)
g.add(head)
if self.label:
b = g.getBounds()
s = Label()
s.setText(self.label)
s.setOrigin(self.x+0.5*w+self.labeldx, self.y-h/2+b[3]-b[1]+self.labeldy)
s.boxAnchor = self.boxAnchor
s.textAnchor = self.textAnchor
s.fontName = 'Helvetica'
s.fontSize = self.fontSize
s.angle = self.labelAngle
g.add(s)
return g
def addLabel(drawing, x, y, text, fontName='Helvetica', fontSize=11, dy=0,
angle=0, boxAnchor='sw', textAnchor='start'):
"""Add a label to the drawing.
This interface here is inconsistent in that it requires pixel coords. FIX
This just sets convenient defaults for Label."""
label = Label()
label.setText(text)
label.setOrigin(x, y)
label.fontName = fontName
label.fontSize = fontSize
label.boxAnchor = boxAnchor
label.textAnchor = textAnchor
label.dy = dy
label.angle = angle
drawing.add(label)
def draw(self):
ascent = getFont(self.xValueAxis.labels.fontName).face.ascent
if ascent == 0:
ascent = 0.718 # default (from helvetica)
ascent = ascent * self.xValueAxis.labels.fontSize # normalize
# basic LinePlot - does the Axes, Ticks etc
lp = LinePlot.draw(self)
xLabel = self.xLabel
if xLabel: # Overall label for the X-axis
xl = Label()
xl.x = (self.x + self.width) / 2.0
xl.y = 0
xl.fontName = self.xValueAxis.labels.fontName
xl.fontSize = self.xValueAxis.labels.fontSize
xl.setText(xLabel)
lp.add(xl)
yLabel = self.yLabel
if yLabel: # Overall label for the Y-axis
yl = Label()
yl.angle = 90
yl.x = 0
yl.y = self.y + self.height / 2.0
yl.fontName = self.yValueAxis.labels.fontName
yl.fontSize = self.yValueAxis.labels.fontSize
yl.setText(yLabel)
lp.add(yl)
# do a bounding box - in the same style as the axes
if self.outerBorderOn:
lp.add(
Rect(
self.x,
self.y,
self.width,
self.height,
strokeColor=self.outerBorderColor,
strokeWidth=self.yValueAxis.strokeWidth,
fillColor=None,
)
)
lp.shift(self.leftPadding, self.bottomPadding)
return lp
def draw(self):
ascent = getFont(self.xValueAxis.labels.fontName).face.ascent
if ascent == 0:
ascent = 0.718 # default (from helvetica)
ascent = ascent * self.xValueAxis.labels.fontSize # normalize
#basic LinePlot - does the Axes, Ticks etc
lp = LinePlot.draw(self)
xLabel = self.xLabel
if xLabel: #Overall label for the X-axis
xl = Label()
xl.x = (self.x + self.width) / 2.0
xl.y = 0
xl.fontName = self.xValueAxis.labels.fontName
xl.fontSize = self.xValueAxis.labels.fontSize
xl.setText(xLabel)
lp.add(xl)
yLabel = self.yLabel
if yLabel: #Overall label for the Y-axis
yl = Label()
yl.angle = 90
yl.x = 0
yl.y = (self.y + self.height / 2.0)
yl.fontName = self.yValueAxis.labels.fontName
yl.fontSize = self.yValueAxis.labels.fontSize
yl.setText(yLabel)
lp.add(yl)
# do a bounding box - in the same style as the axes
if self.outerBorderOn:
lp.add(
Rect(self.x,
self.y,
self.width,
self.height,
strokeColor=self.outerBorderColor,
strokeWidth=self.yValueAxis.strokeWidth,
fillColor=None))
lp.shift(self.leftPadding, self.bottomPadding)
return lp
def addAxis(drawing, xmap, y, strokeWidth=1, minorStrokeWidth=0.5,
tickDir='down', autoTicks=False, nTicks=20, tickLen=5, fontSize=10, nMinorTicks=80,
minorTickLen=2, angle=0, dx=0, dy=-2, textAnchor='middle', boxAnchor=None,
scale=1.0, format='%i'):
"""Add a horizontal axis to the drawing.
To do: Round tick positions
"""
line = Line(xmap.x0, y, xmap.x1, y, strokeWidth=strokeWidth)
drawing.add(line)
if not boxAnchor:
if tickDir=='down':
boxAnchor = 'n'
else:
boxAnchor = 's'
signum = {'up': -1, 'down': 1}[tickDir]
if nTicks>0:
ticks = tick_generator(xmap.start, xmap.end, n=nTicks, convert=int)
for p in ticks:
x = xmap(p)
line = Line(x, y, x, y-signum*tickLen, strokeWidth=strokeWidth)
drawing.add(line)
s = Label()
s.setOrigin(x, y-signum*tickLen)
s.setText(format % (p/scale))
s.dx = dx
s.dy = signum*dy
s.fontName = 'Helvetica'
s.fontSize = fontSize
s.textAnchor = textAnchor
s.boxAnchor = boxAnchor
s.angle = angle
drawing.add(s)
minorticks = tick_generator(xmap.start, xmap.end, n=nMinorTicks, convert=int)
for p in minorticks:
x = xmap(p)
line = Line(x, y, x, y-signum*minorTickLen, strokeWidth=minorStrokeWidth)
drawing.add(line)
def simple_label():
drawing = shapes.Drawing(width=400, height=200)
drawing.add(shapes.Rect(200, 100, 10, 10, fillColor=colors.red))
x = 50
angle = 0
for item in range(3):
label = Label()
label.setOrigin(200, 100)
label.boxAnchor = 'se'
label.angle = angle
#label.boxStrokeColor = colors.black
label.setText('ReportLab label')
drawing.add(label)
x += 25
angle += 45
renderPDF.drawToFile(drawing, 'simple_label.pdf')
def addLabels(self,drawing,title=None,xlabel=None,ylabel=None):
from reportlab.graphics.charts.textlabels import Label
if not title is None:
Title = Label()
Title.fontName = 'Helvetica-Bold'
Title.fontSize = 7
Title.x = drawing.width/2
Title.y = drawing.height-25
Title._text = title
Title.maxWidth = 180
Title.height = 20
Title.textAnchor ='middle'
drawing.add(Title)
if not xlabel is None:
XLabel = Label()
XLabel.fontName = 'Helvetica'
XLabel.fontSize = 7
XLabel.x = drawing.width/2
XLabel.y = 10
XLabel.textAnchor ='middle'
XLabel.maxWidth = 100
XLabel.height = 20
XLabel._text = xlabel
drawing.add(XLabel)
if not ylabel is None:
YLabel = Label()
YLabel.fontName = 'Helvetica'
YLabel.fontSize = 7
YLabel.x = 12
YLabel.y = drawing.height/2
YLabel.angle = 90
YLabel.textAnchor ='middle'
YLabel.maxWidth = 100
YLabel.height = 20
YLabel._text = ylabel
drawing.add(YLabel)
def border():
draw = Drawing(1, 1)
rect = Polygon(points=[
-12, cm / 6, (PAGE_WIDTH - (RIGHT_MARGIN + LEFT_MARGIN)), cm / 6,
PAGE_WIDTH - (RIGHT_MARGIN + LEFT_MARGIN),
-1 * (PAGE_HEIGHT - (TOP_MARGIN + BOTTOM_MARGIN + cm / 2)), -12,
-1 * (PAGE_HEIGHT - (TOP_MARGIN + BOTTOM_MARGIN + cm / 2))
],
strokeColor=Color(*charts.BG_COLOR))
rect.fillColor = Color(*charts.BG_COLOR, 0.1)
draw.add(rect)
draw.add(Circle(100, 90, 5, fillColor=colors.green))
lab = Label()
lab.setOrigin(350, -50)
lab.boxAnchor = 'ne'
lab.fillColor = Color(*charts.BG_COLOR, 0.15)
lab.fontSize = 72
lab.angle = 60
lab.dx = 0
lab.dy = 0
lab.setText('Wisdom Tests')
draw.add(lab)
return draw
def setAxesLabels(self):
xlabel = Label()
xlabel.fontName = 'Helvetica'
xlabel.fontSize = 12
xlabel.x = 450
xlabel.y = 40
xlabel._text = self._data_dict.get('xlabel', '')
xlabel.maxWidth = 180
xlabel.height = 20
xlabel.textAnchor ='middle'
self.add(xlabel, name='xlabel')
ylabel = Label()
ylabel.fontName = 'Helvetica'
ylabel.fontSize = 12
ylabel.x = 20
ylabel.y = 210
ylabel.angle = 90
ylabel._text = self._data_dict.get('ylabel', '')
ylabel.maxWidth = 180
ylabel.height = 20
ylabel.textAnchor ='middle'
self.add(ylabel, name='ylabel')
def _rawDraw(self, x, y):
from reportlab.lib import colors
from reportlab.graphics.shapes import Drawing, Line, String, STATE_DEFAULTS
from reportlab.graphics.charts.axes import XCategoryAxis,YValueAxis
from reportlab.graphics.charts.textlabels import Label
from reportlab.graphics.charts.barcharts import VerticalBarChart
self.originX = x
self.originY = y
self._setScale([self.dataBar])
(x1, y1, Width, Height) = self._getGraphRegion(x, y)
#Build the graph
self.drawing = Drawing(self.width, self.height)
#Size of the Axis
SizeXaxis = 14
countSteps = int(self.valueMax / self.valueStep)
SizeYaxis = 0.0
for n in range(countSteps + 1):
eachValue = self.valueMin + n * self.valueStep
textString = self._customSecondsLabelFormat( eachValue )
SizeYaxis = max(SizeYaxis, self._stringWidth(textString, STATE_DEFAULTS['fontName'], STATE_DEFAULTS['fontSize']) )
bc = VerticalBarChart()
SizeYaxis += bc.valueAxis.tickLeft
bc.x = x1 - x + SizeYaxis
bc.y = y1 - y + SizeXaxis
bc.height = Height - SizeXaxis
bc.width = Width - SizeYaxis
self.graphCenterX = bc.x + bc.width/2
self.graphCenterY = bc.y + bc.height/2
if self.validData:
# add valid data to chart
bc.data = self.dataBar
bc.categoryAxis.categoryNames = self.dataNames
# axis values
bc.valueAxis.valueMin = self.valueMin
bc.valueAxis.valueMax = self.valueMax
bc.valueAxis.valueStep = self.valueStep
# add value labels above bars
bc.barLabelFormat = self._customSecondsLabelFormat
bc.barLabels.dy = 0.08*inch
bc.barLabels.fontSize = 6
else:
# no valid data
bc.data = [ (0, ), ]
bc.categoryAxis.categoryNames = [ '' ]
bc.valueAxis.valueMin = 0
bc.valueAxis.valueMax = 1
bc.valueAxis.valueStep = 1
Nodata = Label()
Nodata.fontSize = 12
Nodata.angle = 0
Nodata.boxAnchor = 'c'
Nodata.dx = self.graphCenterX
Nodata.dy = self.graphCenterY
Nodata.setText("NO VALID DATA")
self.drawing.add(Nodata)
# chart formatting
(R,G,B) = VeriwaveYellow
bc.bars[0].fillColor = colors.Color(R,G,B)
bc.valueAxis.labelTextFormat = self._customSecondsLabelFormat
# axis labels
bc.categoryAxis.labels.boxAnchor = 'c'
bc.categoryAxis.labels.dx = 0
bc.categoryAxis.labels.dy = -10
bc.categoryAxis.labels.angle = 0
bc.categoryAxis.labels.fontSize = 8
# add chart
self.drawing.add(bc)
#Adjust the labels to be the center of the graph
self._drawLabels(self.title, "", "")
# Add Legend in upper right corner
legendHeight = 9
legendX = bc.x + 5
legendY = bc.y + bc.height - 12
self.drawing.add(Line(legendX, legendY + 3 , legendX + 20, legendY + 3, strokeColor=bc.bars[0].fillColor, strokeWidth=3 ))
self.drawing.add(String(legendX + 22, legendY, 'MIN', fontName='Helvetica', fontSize=8))
legendY -= legendHeight
self.drawing.add(Line(legendX, legendY + 3 , legendX + 20, legendY + 3, strokeColor=bc.bars[1].fillColor, strokeWidth=3 ))
self.drawing.add(String(legendX + 22, legendY, 'MAX', fontName='Helvetica', fontSize=8))
legendY -= legendHeight
self.drawing.add(Line(legendX, legendY + 3 , legendX + 20, legendY + 3, strokeColor=bc.bars[2].fillColor, strokeWidth=3 ))
self.drawing.add(String(legendX + 22, legendY, 'AVG', fontName='Helvetica', fontSize=8))
legendY -= legendHeight
def getTempPlot():
drawing = Drawing(400, 200)
temps = [getTemps()]
bc = LinePlot()
bc.x = 50
bc.y = 50
bc.height = 125
bc.width = 300
bc.data = temps
bc.lines[0].symbol = makeMarker('Circle')
#labels
yilabel = Label()
yilabel.setText("Temperatura (°C)")
yilabel.angle = 90
yilabel.setOrigin(20, 120)
xlabel = Label()
xlabel.setText("Días")
xlabel.setOrigin(200, 20)
#labelT = Label()
#labelT.setText("Temperatura")
#labelT.setOrigin(210,185)
#labelH = Label()
#labelH.setText("Humedad")
#labelH.setOrigin(285,185)
label55 = Label()
label55.setText("55°")
label55.setOrigin(325, 185)
bc.xValueAxis.valueMin = 0
bc.xValueAxis.valueMax = 30
bc.xValueAxis.valueSteps = [x for x in range(0, bc.xValueAxis.valueMax, 5)]
#bc.xValueAxis.labelTextFormat = '%2.1f'
bc.yValueAxis.valueMin = 0
bc.yValueAxis.valueMax = 80
bc.yValueAxis.valueSteps = [0, 10, 20, 30, 40, 50, 60, 70, 80]
drawing.add(bc)
drawing.add(yilabel)
drawing.add(xlabel)
#drawing.add(Line(170,185,185,185, strokeColor=colors.red))
#drawing.add(Line(250,185,265,185, strokeColor=colors.blue))
drawing.add(
Line(300,
185,
315,
185,
strokeColor=colors.black,
strokeDashArray=[2, 2]))
drawing.add(
Line(50,
135,
350,
135,
strokeColor=colors.black,
strokeDashArray=[2, 2]))
#drawing.add(labelT)
#drawing.add(labelH)
drawing.add(label55)
#drawing.add(Grid())
drawing.add(String(130, 200, "Gráfico de temperaturas", fontSize=16))
return drawing
def bar_chart(data, labels, **kw):
"""
:param data: contains a two dimentional array of values, e.g. [[d11, d21, x1], [d12, d22, x2]]
:type data: list[list[numbers],...]
:param labels: can contain, but must not ["xlabel", "ylabel", ["data label0", ...]]
third item can also be an interger stating the iteration start as label
:type lables: ???
:param ylim: limit the y axis to these values, e.g. (0, 100)
:type ylim: ???
:param bars: list of colors we should use for the bars, refer to PDF_CHART_COLORS as an example
:type bars: ???
:param size: size in pixels, e.g. (8 * cm, 4 * cm) or pixels, e.g. (400, 200)
:type size: ???
:param title: title of bar chart
:type title: string
:param stacked: weather to do a stacked bar plot or std column plot
:type stacked: ???
"""
title = kw.pop('title', None)
stacked = kw.pop('stacked', False)
bars = kw.pop('bars', PDF_CHART_COLORS)
size = kw.pop('plotSize', (18 * cm, 9 * cm))
ylim = kw.pop('ylim', None)
# Create the drawing
drawing = Drawing(size[0], size[1])
# Create the Chart
chart = VerticalBarChart()
for key, val in list(kw.items()):
setattr(chart, key, val)
if title is not None:
drawing.add(String(20, size[1] - 20, title), name='title')
chart.y -= 10
chart.width = drawing.width - 20
chart.height = drawing.height - 40
chart.data = data
max_y = 0
min_y = maxsize
for i in range(len(data)):
chart.bars[i].fillColor = HexColor(bars[i % len(bars)])
max_y = max(data[i] + [max_y])
min_y = min(data[i] + [min_y])
chart.valueAxis.valueMax = max_y * 1.1
chart.valueAxis.valueMin = min_y * 0.9
if ylim is not None:
chart.valueAxis.valueMin = ylim[0]
chart.valueAxis.valueMax = ylim[1]
if len(data) > 1:
chart.barSpacing = 2
if labels is not None:
if len(labels) > 0:
xlabel = Label()
xlabel._text = labels[0] # pylint: disable=W0212
xlabel.textAnchor = 'middle'
xlabel.x = drawing.width / 2
xlabel.y = 0
chart.y += 15
drawing.add(xlabel, name="xlabel")
if len(labels) > 1:
ylabel = Label()
ylabel._text = labels[1] # pylint: disable=W0212
xlabel.textAnchor = 'middle'
ylabel.angle = 90
ylabel.x = 0
ylabel.y = drawing.height / 2
chart.x += 10
drawing.add(ylabel, name="ylabel")
if len(labels) > 2:
if len(labels[2]) == max([len(x) for x in data]):
chart.categoryAxis.categoryNames = labels[2]
chart.categoryAxis.labels.angle = 30
elif type(labels[2]) == int:
chart.categoryAxis.categoryNames = range(labels[2], max([len(x) for x in data]) + labels[2])
if stacked:
chart.categoryAxis.style = 'stacked'
drawing.add(chart, name='chart')
return drawing
def balance_statistics_chart(self, control_vars, match_vars, var_names):
"""
Specify layout of the balance statistics chart and generate
flowable object that can be added to the pdf
"""
drawing = Drawing()
vbc = VerticalBarChart()
# Chart position in document
vbc.x = self.chart_offset_x
vbc.y = self.chart_offset_y
vbc.height = self.chart_height
vbc.width = self.chart_width
# Specify data
# [[control_var1, control_var2], [match_var1, match_var2]]
vbc.data = [control_vars, match_vars]
#Set Y-Axis ranges
#axis_range = self._calculate_y_axis(vbc.data)
#vbc.valueAxis.valueMin = axis_range['min']
#vbc.valueAxis.valueMax = axis_range['max']
#vbc.valueAxis.valueStep = axis_range['step']
#Grid formatting
vbc.valueAxis.visibleGrid = 1
vbc.valueAxis.gridStrokeColor = colors.lightgrey
#Bar formatting
vbc.bars[0].fillColor = colors.blue
vbc.bars[1].fillColor = colors.yellow
vbc.bars.strokeColor = None
vbc.groupSpacing = 1
vbc.barWidth = 5
# Callout label formatting (numbers above bar)
#vbc.barLabels.fontName = "Arial"
vbc.barLabels.fontSize = 8
vbc.barLabels.fillColor = colors.black
vbc.barLabelFormat = '%.2f'
vbc.barLabels.nudge = 5
# Central axis
vbc.categoryAxis.visibleTicks = 1
# X-axis labels
#vbc.categoryAxis.labels.dy = -60
vbc.valueAxis.labels.fontName = 'Helvetica'
vbc.categoryAxis.categoryNames = var_names
lab = Label()
lab.setOrigin(10, 155)
lab.boxAnchor = 'ne'
lab.angle = 90
lab.dx = 0
lab.dy = -15
#lab.boxStrokeColor = colors.green
lab.setText('Percent Bias')
drawing.add(lab)
drawing.add(vbc)
self.elements.append(drawing)
def get_pdf_results(task_id):
# Flask response
response = Response()
response.status_code = 200
task = data.get_task_result(task_id)
#Saving file to a in-memory file
output_file = StringIO.StringIO()
def header_footer(canvas, doc):
canvas.saveState()
background = 'static/img/pdf_bg.png'
canvas.drawImage(background,
1 * inch,
5.75 * inch,
width=8 * inch,
height=6 * inch,
mask='auto')
# Header
logo = Image('static/img/logo/logo.png')
logo.drawHeight = 0.5 * inch
logo.drawWidth = 1.75 * inch
date = datetime.now().strftime("%y-%m-%d %H:%M")
headerData = [[logo, '', date]]
headerTable = Table(headerData,
colWidths=[2 * inch, 3.58 * inch, 1.2 * inch],
style=[('LINEBELOW', (0, 0), (2, 0), 1,
colors.HexColor(0xcccccc)),
('TEXTCOLOR', (0, 0), (2, 0),
colors.HexColor(0x807F83)),
('VALIGN', (1, 0), (1, 0), 'MIDDLE'),
('VALIGN', (2, 0), (2, 0), 'MIDDLE')])
headerTable.wrapOn(canvas, doc.width, doc.topMargin)
headerTable.drawOn(canvas, doc.leftMargin, doc.height + doc.topMargin)
pageNum = "Page %d" % doc.page
footerData = [[
'KAPSARC Building Energy Assessment Tool (BEAT)', pageNum
]]
footerTable = Table(footerData,
colWidths=[5.76 * inch, 1 * inch],
style=[('LINEABOVE', (0, 0), (1, 0), 2,
colors.HexColor(0xcccccc)),
('TEXTCOLOR', (0, 0), (1, 0),
colors.HexColor(0x807F83)),
('ALIGN', (1, 0), (1, 0), 'RIGHT')])
footerTable.wrapOn(canvas, doc.width, doc.bottomMargin)
footerTable.drawOn(canvas, doc.leftMargin, 0.5 * inch)
canvas.restoreState()
pdfmetrics.registerFont(TTFont('Vera', 'Vera.ttf'))
pdfmetrics.registerFont(TTFont('VeraBd', 'VeraBd.ttf'))
pdfmetrics.registerFont(TTFont('VeraIt', 'VeraIt.ttf'))
pdfmetrics.registerFont(TTFont('VeraBI', 'VeraBI.ttf'))
styles = getSampleStyleSheet()
# Title
styles.add(
ParagraphStyle(name='styleTitle',
alignment=TA_CENTER,
fontSize=16,
fontName='Vera',
textColor=colors.HexColor(0x61a659),
leading=30,
spaceBefore=35,
spaceAfter=10))
# Headings
styles.add(
ParagraphStyle(name='styleHeading',
parent=styles['Heading2'],
fontSize=14,
textColor=colors.HexColor(0x807F83),
leading=20,
spaceBefore=10,
underlineProportion=1.1,
spaceAfter=10))
styles.add(
ParagraphStyle(name='styleHeading2',
parent=styles['Heading2'],
fontSize=14,
textColor=colors.HexColor(0x61a659),
leading=20,
spaceBefore=20,
underlineProportion=1.1,
spaceAfter=20))
styles.add(
ParagraphStyle(
name='styleHeading3',
#alignment= TA_CENTER,
fontSize=12,
fontName='Vera',
textColor=colors.HexColor(0x61a659),
leading=20,
spaceBefore=10,
spaceAfter=5))
# Body text
styles.add(
ParagraphStyle(name='styleBodyText',
parent=styles['Normal'],
fontSize=9,
textColor=colors.HexColor(0x666666),
spaceBefore=5,
spaceAfter=15))
styleTitle = styles['styleTitle']
styleHeading = styles['styleHeading']
styleHeading2 = styles['styleHeading2']
styleHeading3 = styles['styleHeading3']
styleBodyText = styles['styleBodyText']
pdf_chart_colors = [
"#3D6531",
"#61a24f",
"#89B97B",
"#B0D1A7",
"#cde5c7",
"#7e7f82",
"#9E9FA1",
"#BFBFC1",
"#DFDFE0",
"#ffd200",
"#FFE360",
"#FFEE9F",
]
Elements = []
doc = BaseDocTemplate(output_file,
showBoundary=0,
pagesize=A4,
title='KASPSARC BEAT Report',
author="KAPSARC",
leftMargin=0.75 * inch,
rightMargin=0.75 * inch,
topMargin=inch,
bottomMargin=inch)
frame = Frame(doc.leftMargin,
doc.topMargin,
doc.width,
doc.height,
topPadding=0.3 * inch,
showBoundary=0)
template = PageTemplate(id='template',
frames=[frame],
onPage=header_footer)
doc.addPageTemplates([template])
## PAGE 1
#add some flowables
Elements.append(
Paragraph("KAPSARC Building Energy Assessment Tool (BEAT)",
styleTitle))
Elements.append(Paragraph("Your Building Description", styleHeading))
rowHeights = 0.3 * inch
calibrationData = task['calibrationData']
Elements.append(Paragraph("General Information:", styleHeading3))
infoTableData = [
[
Paragraph('<b>- Name: </b>' + calibrationData['txtBldgName'],
styleBodyText),
Paragraph('<b>- Address: </b>' + calibrationData['txtBldgAddress'],
styleBodyText),
Paragraph('<b>- Type: </b>' + calibrationData['cmbBldgType'],
styleBodyText)
],
[
Paragraph(
'<b>- Location: </b>' + calibrationData['cmbBldgLocation'],
styleBodyText),
Paragraph('<b>- Shape: </b>' + calibrationData['cmbBldgShape'],
styleBodyText),
Paragraph(
'<b>- Floor Area (m' + u"\u00b2" + '): </b>' +
str(calibrationData['txtFloorArea']), styleBodyText)
]
]
infoTable = Table(infoTableData,
colWidths=[160, 165, 150],
rowHeights=rowHeights)
Elements.append(infoTable)
Elements.append(Paragraph('<br />', styleBodyText))
Elements.append(Paragraph("Envelope Construction Details:", styleHeading3))
envTableData = [
[
Paragraph(
'<b>- South Wall: </b>' + calibrationData['cmbSouthWall'],
styleBodyText),
Paragraph('<b>- West Wall: </b>' + calibrationData['cmbWestWall'],
styleBodyText)
],
[
Paragraph(
'<b>- North Wall: </b>' + calibrationData['cmbNorthWall'],
styleBodyText),
Paragraph('<b>- East Wall: </b>' + calibrationData['cmbEastWall'],
styleBodyText)
],
[
Paragraph('<b>- Roof: </b>' + calibrationData['cmbRoof'],
styleBodyText),
Paragraph(
'<b>- Floor: </b>' + calibrationData['cmbFirstFloorContact'],
styleBodyText)
],
[
Paragraph('<b>- Windows Type: </b>' + calibrationData['glasstype'],
styleBodyText),
Paragraph(
'<b>- Overhang Depth (m): </b>' +
str(calibrationData['txtWinSouthOverhang']), styleBodyText)
]
]
envTable = Table(envTableData, colWidths=[240, 235], rowHeights=rowHeights)
Elements.append(envTable)
Elements.append(Paragraph('<br />', styleBodyText))
Elements.append(Paragraph("Air Conditioning Systems", styleHeading3))
hvacTableData = [[
Paragraph(
'<b>- HVAC System Type: </b>' + calibrationData['cmbBldgSystem'],
styleBodyText),
Paragraph(
'<b>- Cooling Temperature Setting (' + u"\u00b0" + 'C): </b>' +
str(calibrationData['txtCoolSetTemp']), styleBodyText)
],
[
Paragraph(
'<b>- Energy Efficiency Ratio (EER): </b>' +
str(calibrationData['eir']), styleBodyText),
Paragraph(
'<b>- Heating Temperature Setting (' + u"\u00b0" +
'C): </b>' +
str(calibrationData['txtHeatSetTemp']),
styleBodyText)
]]
hvacTable = Table(hvacTableData,
colWidths=[240, 235],
rowHeights=rowHeights)
Elements.append(hvacTable)
Elements.append(Paragraph('<br />', styleBodyText))
Elements.append(Paragraph("Overall Assessment", styleHeading))
Elements.append(
Paragraph(
"Based on your description and current SASO requirements, the tool provides the following assessments:",
styleBodyText))
if task['compliant']:
compliant = "<strong><font color=green>meets</font></strong>"
else:
compliant = "<strong><font color=red>does not meet</font></strong>"
if (task['ngEnergyDiff'] < 0):
energyDiff = "<strong><font color=green>" + str(
task['energyDiff']) + " kWh/year, less</font></strong>"
else:
energyDiff = "<strong><font color=red>" + str(
task['energyDiff']) + " kWh/year, more</font></strong>"
Elements.append(
Paragraph(
"- Your building " + compliant +
" SASO requirements for all building envelope", styleBodyText))
Elements.append(
Paragraph(
"- Your building consumed " + energyDiff +
" than the SASO Baseline", styleBodyText))
if task['compliant']:
Elements.append(
Paragraph(
"- You may reduce even more your energy consumption in your building by using LED lamps and high efficient appliances and air conditioning system",
styleBodyText))
else:
Elements.append(
Paragraph(
" - You need to add more insulation to the walls and/or roof, or use more efficient window glazing to comply with SASO requirements",
styleBodyText))
if not task['compliant'] and (task['ngEnergyDiff'] >= 0):
Elements.append(
Paragraph(
" - You may also consider using LED lamps and energy efficient appliances and air conditioning system",
styleBodyText))
Elements.append(PageBreak())
Elements.append(
Paragraph("How electricity is used in your building?", styleHeading3))
Elements.append(
Paragraph(
"Your building needs electricity to operate several types of equipment including: air-conditioning, lighting, appliances and domestic hot water.",
styleBodyText))
#add image
Elements.append(
Image('static/img/results-intro.png',
width=4 * inch,
height=1.2 * inch))
#add text
Elements.append(
Paragraph(
"Based on the description you provided as well as typical lighting and appliances used in households, here how your building consumes electricity on annual basis:",
styleBodyText))
bepuPieData = task['bepuPieData']
bepuTableData = [[0 for i in xrange(len(bepuPieData[0]))]
for i in xrange(len(bepuPieData) + 1)]
bepuChartLabel = [0 for i in xrange(len(bepuPieData))]
bepuChartData = [0 for i in xrange(len(bepuPieData))]
bepuTableData[0][0] = 'End-Use'
bepuTableData[0][1] = 'Annual Electricity Use'
for i, result in enumerate(bepuPieData):
# write body cells
bepuTableData[i + 1][0] = str(result['label'])
bepuTableData[i + 1][1] = int(result['value'])
bepuChartLabel[i] = str(result['label'])
bepuChartData[i] = result['value']
#add chart
bepuChart = Drawing(400, 200)
pc = Pie()
pc.data = bepuChartData
labelc = [0 for i in xrange(len(bepuChartData))]
for i, r in enumerate(bepuChartData):
labelc[i] = str(round(r / sum(bepuChartData) * 100, 1)) + "%"
pc.labels = labelc
pc._seriesCount = len(bepuChartLabel)
pc.slices.strokeColor = colors.HexColor(0xffffff)
pc.slices.strokeWidth = 0.5
bepu_chart_colors = ['#FFC43E', '#A4A4A4', '#F67A40', '#5894D0', '#98cd99']
for i, r in enumerate(bepuChartLabel):
pc.slices[i].fillColor = colors.HexColor(bepu_chart_colors[i])
pc.width = pc.height = 120
pc.x = 40
pc.y = 30
# add_legend(d, pc)
legend = Legend()
legend.alignment = 'right'
legend.x = pc.width + pc.x + 80
legend.y = pc.height - 10
legend.dx = 8
legend.dy = 8
legend.fontName = 'Helvetica'
legend.fillColor = colors.HexColor(0x807F83)
legend.fontSize = 10
legend.boxAnchor = 'nw'
legend.columnMaximum = 8
legend.strokeWidth = 0.5
legend.strokeColor = colors.HexColor(0xffffff)
legend.deltax = 75
legend.deltay = 10
legend.autoXPadding = 10
legend.yGap = 0
legend.dxTextSpace = 5
legend.dividerLines = 1 | 2 | 4
legend.dividerOffsY = 6
legend.subCols.rpad = 70
legend.dividerColor = colors.HexColor(0xdedede)
legend.colorNamePairs = [(pc.slices[i].fillColor,
(bepuChartLabel[i][0:20],
' %s ' % "{:,}".format(int(pc.data[i]))))
for i in xrange(len(pc.data))]
legendHeader = Legend()
legendHeader.colorNamePairs = [
('', ('End-Use', 'Annual Electricity Use\n(kWh/year)'))
]
legendHeader.alignment = 'right'
legendHeader.x = legend.x - 20
legendHeader.y = legend.y + 30
legendHeader.fontName = 'Helvetica'
legendHeader.fillColor = colors.HexColor(0x807F83)
legendHeader.fontSize = 10
legendHeader.boxAnchor = 'nw'
legendHeader.subCols.rpad = 80
legendFooter = Legend()
legendFooter.colorNamePairs = [
('', ('Total', str("{:,}".format(int(sum(bepuChartData)))) + ''))
]
legendFooter.alignment = 'right'
legendFooter.x = legendHeader.x + 5
legendFooter.y = legend.y - (len(bepuChartLabel) + 1) * 10
legendFooter.fontName = 'Helvetica-Bold'
legendFooter.fillColor = colors.HexColor(0x807F83)
legendFooter.fontSize = 10
legendFooter.boxAnchor = 'nw'
legendFooter.subCols.rpad = 145
bepuChart.add(legend)
bepuChart.add(legendHeader)
bepuChart.add(legendFooter)
pc.slices.fontColor = colors.HexColor(0x807F83)
n = len(pc.data)
bepuChart.add(pc, '')
Elements.append(bepuChart)
## PAGE 2
Elements.append(
Paragraph("When electricity is consumed in your building?",
styleHeading3))
Elements.append(
Paragraph(
"Based on the weather of your location as well as typical lighting and appliances used in households, your building consumes electricity as noted in the following monthly profile:",
styleBodyText))
#add chart
pseBarData = task['pseBarData']
pseTableData = [[0 for i in xrange(len(pseBarData[0]['values']) + 1)]
for i in xrange(len(pseBarData) + 1)]
pseChartData = [[0 for i in xrange(len(pseBarData[0]['values']))]
for i in xrange(len(pseBarData))]
pseChartLegend = [0 for i in xrange(len(pseBarData))]
pseTableData[0][0] = 'Key'
month = [
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct',
'Nov', 'Dec'
]
for i, m in enumerate(month):
pseTableData[0][i + 1] = str(month[i])
for i, result in enumerate(pseBarData):
# write body cells
pseTableData[i + 1][0] = str(result['key'])
pseChartLegend[i] = str(result['key'])
for j, value in enumerate(result['values']):
pseTableData[i + 1][j + 1] = int(result['values'][j]['y'])
pseChartData[i][j] = int(result['values'][j]['y'])
pseChart = Drawing(400, 200)
bc = VerticalBarChart()
bc.x = 70
bc.y = 0
bc.height = 200
bc.width = 300
bc.data = pseChartData
bc.strokeColor = colors.black
bc.valueAxis.valueMin = 0
bc.strokeWidth = 0
bc.valueAxis.valueMin = 0
bc.categoryAxis.style = 'stacked'
bc.categoryAxis.labels.boxAnchor = 'ne'
bc.categoryAxis.labels.dx = 10
bc.categoryAxis.labels.dy = -2
bc.valueAxis.labels.fontName = 'Helvetica'
bc.valueAxis.labels.fontSize = 10
bc.valueAxis.strokeWidth = 0.5
bc.valueAxis.strokeColor = colors.HexColor(0x807F83)
bc.categoryAxis.strokeWidth = 0.5
bc.categoryAxis.strokeColor = colors.HexColor(0x807F83)
bc.valueAxis.labels.fillColor = colors.HexColor(0x807F83)
bc.categoryAxis.labels.fontName = 'Helvetica'
bc.categoryAxis.labels.fontSize = 10
bc.categoryAxis.labels.fillColor = colors.HexColor(0x807F83)
bc.categoryAxis.categoryNames = month
# create a list and add the elements of our document (image, paragraphs, table, chart) to it
#add our barchart and legend
bc.barWidth = .3 * inch
bc.groupSpacing = .2 * inch
bc.bars.strokeColor = colors.HexColor(0xffffff)
bc.bars.strokeWidth = 0.
pse_chart_colors = ['#FFC43E', '#A4A4A4', '#F67A40', '#5894D0']
for i, r in enumerate(pseChartLegend):
bc.bars[i].fillColor = colors.HexColor(pse_chart_colors[i])
# = colors.blue
legend = Legend()
legend.alignment = 'right'
legend.x = bc.width + bc.x + 5
legend.y = bc.height + bc.y
legend.deltax = 40
legend.dxTextSpace = 5
legend.dx = 8
legend.dy = 8
legend.fontName = 'Helvetica'
legend.fillColor = colors.HexColor(0x807F83)
legend.fontSize = 10
legend.boxAnchor = 'nw'
legend.columnMaximum = (len(bc.data) + 1) / 2
legend.strokeWidth = 0.5
legend.strokeColor = colors.HexColor(0xffffff)
legend.deltax = 75
legend.deltay = 12
legend.dividerColor = colors.HexColor(0xdedede)
legend.columnMaximum = len(pseChartLegend)
legend.colorNamePairs = [(bc.bars[i].fillColor, pseChartLegend[i])
for i in xrange(len(bc.data))]
#pseChart.hAlign = 'RIGHT'
label = Label()
label.setOrigin(10, bc.height / 2)
#label.boxAnchor = 'sw'
label.angle = 90
label.fillColor = colors.HexColor(0x807F83)
label.setText('Electricity Consumption (kWh)')
label.fontName = 'Helvetica'
pseChart.add(legend, 'legend')
pseChart.add(bc)
pseChart.add(label)
Elements.append(pseChart)
Elements.append(PageBreak())
## PAGE 3
Elements.append(
Paragraph(
"Does your building meet SASO Thermal Performance Requirements?",
styleHeading3))
Elements.append(
Paragraph(
"Based on your description, the thermal transmittance properties of the walls, roof and glazing are calculated, and compared with SASO thermal building performance requirements:",
styleBodyText))
#add chart
lvdData = task['lvdData']
lvdChartData = [[0 for i in xrange(len(lvdData[0]['values']))]
for i in xrange(len(lvdData))]
lvdChartCategoryNames = [0 for i in xrange(len(lvdData[0]['values']))]
lvdComparedObjKey = [0 for i in xrange(len(lvdData))]
for i, result in enumerate(lvdData):
# write body cells
lvdComparedObjKey[i] = str(lvdData[i]['key'])
for j, value in enumerate(result['values']):
lvdChartCategoryNames[j] = value['label']
lvdChartData[i][j] = value['value']
lvdChart = Drawing(400, 200)
bc = VerticalBarChart()
bc.x = 70
bc.y = 0
bc.height = 200
bc.width = 300
bc.data = lvdChartData
bc.strokeColor = colors.black
# bc.fillColor=colors.blue
bc.valueAxis.valueMin = 0
bc.strokeWidth = 0
bc.valueAxis.valueMin = 0
bc.categoryAxis.labels.boxAnchor = 'n'
bc.categoryAxis.labels.dx = 0
bc.categoryAxis.labels.dy = -2
# bc.categoryAxis.labels.angle = 20
bc.valueAxis.labels.fontName = 'Helvetica'
bc.valueAxis.labels.fontSize = 10
bc.valueAxis.strokeWidth = 0.5
bc.valueAxis.strokeColor = colors.HexColor(0x807F83)
bc.categoryAxis.strokeWidth = 0.5
bc.categoryAxis.strokeColor = colors.HexColor(0x807F83)
bc.valueAxis.labels.fillColor = colors.HexColor(0x807F83)
bc.categoryAxis.labels.fontName = 'Helvetica'
bc.categoryAxis.labels.fontSize = 8
bc.categoryAxis.labels.fillColor = colors.HexColor(0x807F83)
bc.categoryAxis.categoryNames = lvdChartCategoryNames
bc.categoryAxis.labels.angle = 0
# create a list and add the elements of our document (image, paragraphs, table, chart) to it
#add our barchart and legend
bc.barWidth = .3 * inch
bc.groupSpacing = .2 * inch
bc.bars.strokeColor = colors.HexColor(0xffffff)
bc.bars.strokeWidth = 0.5
lvd_chart_colors = ['#5894D0', '#F67A40']
for i, r in enumerate(lvdComparedObjKey):
bc.bars[i].fillColor = colors.HexColor(lvd_chart_colors[i])
# = colors.blue
legend = Legend()
legend.alignment = 'right'
legend.x = bc.width + bc.x + 5
legend.y = bc.height + bc.y
legend.deltax = 40
legend.dxTextSpace = 5
legend.dx = 8
legend.dy = 8
legend.fontName = 'Helvetica'
legend.fillColor = colors.HexColor(0x807F83)
legend.fontSize = 10
legend.boxAnchor = 'nw'
legend.columnMaximum = (len(bc.data) + 1) / 2
legend.strokeWidth = 0.5
legend.strokeColor = colors.HexColor(0xffffff)
legend.deltax = 75
legend.deltay = 12
legend.dividerColor = colors.HexColor(0xdedede)
legend.columnMaximum = len(lvdComparedObjKey)
legend.colorNamePairs = [(bc.bars[i].fillColor, lvdComparedObjKey[i])
for i in xrange(len(bc.data))]
#pseChart.hAlign = 'RIGHT'
label = Label()
label.setOrigin(10, bc.height / 2)
#label.boxAnchor = 'sw'
label.angle = 90
label.fillColor = colors.HexColor(0x807F83)
label.setText('Envelope U-value (W/m' + u'\u00b2' + '.k)')
label.fontName = 'Helvetica'
lvdChart.add(label)
lvdChart.add(legend, 'legend')
lvdChart.add(bc)
Elements.append(lvdChart)
#Elements.append(PageBreak())
Elements.append(Paragraph('<br /><br />', styleBodyText))
## PAGE 4
Elements.append(
Paragraph("How energy efficient is your building?", styleHeading3))
Elements.append(
Paragraph(
"Using your input specifications, the annual electricity consumption is calculated and compared with a similar building that meets SASO requirements:",
styleBodyText))
#add chart
bepuComparisonData = task['bepuComparisonData']
bepuComparisonChartData = [[
0 for i in xrange(len(bepuComparisonData[0]['values']))
] for i in xrange(len(bepuComparisonData))]
bepuChartCategoryNames = [
0 for i in xrange(len(bepuComparisonData[0]['values']))
]
bepuComparedObjKey = [0 for i in xrange(len(bepuComparisonData))]
for i, result in enumerate(bepuComparisonData):
# write body cells
bepuComparedObjKey[i] = str(bepuComparisonData[i]['key'])
for j, value in enumerate(result['values']):
bepuChartCategoryNames[j] = value['label']
bepuComparisonChartData[i][j] = value['value']
bepuComparisonChart = Drawing(400, 200)
bc = VerticalBarChart()
bc.x = 70
bc.y = 0
bc.height = 200
bc.width = 300
bc.data = bepuComparisonChartData
bc.strokeColor = colors.black
# bc.fillColor=colors.blue
bc.valueAxis.valueMin = 0
bc.strokeWidth = 0
bc.valueAxis.valueMin = 0
bc.categoryAxis.labels.boxAnchor = 'ne'
bc.categoryAxis.labels.dx = 10
bc.categoryAxis.labels.dy = -2
# bc.categoryAxis.labels.angle = 20
bc.valueAxis.labels.fontName = 'Helvetica'
bc.valueAxis.labels.fontSize = 10
bc.valueAxis.strokeWidth = 0.5
bc.valueAxis.strokeColor = colors.HexColor(0x807F83)
bc.categoryAxis.strokeWidth = 0.5
bc.categoryAxis.strokeColor = colors.HexColor(0x807F83)
bc.valueAxis.labels.fillColor = colors.HexColor(0x807F83)
bc.categoryAxis.labels.fontName = 'Helvetica'
bc.categoryAxis.labels.fontSize = 10
bc.categoryAxis.labels.fillColor = colors.HexColor(0x807F83)
bc.categoryAxis.categoryNames = bepuChartCategoryNames
bc.categoryAxis.labels.angle = 30
# create a list and add the elements of our document (image, paragraphs, table, chart) to it
#add our barchart and legend
bc.barWidth = .3 * inch
bc.groupSpacing = .2 * inch
bc.bars.strokeColor = colors.HexColor(0xffffff)
bc.bars.strokeWidth = 0.5
bepu_chart_colors = ['#5894D0', '#F67A40']
for i, r in enumerate(bepuComparedObjKey):
bc.bars[i].fillColor = colors.HexColor(bepu_chart_colors[i])
# = colors.blue
# bc.bars[1].fillColor = colors.lightblue
legend = Legend()
legend.alignment = 'right'
legend.x = bc.width + bc.x + 5
legend.y = bc.height + bc.y
legend.deltax = 40
legend.dxTextSpace = 5
legend.dx = 8
legend.dy = 8
legend.fontName = 'Helvetica'
legend.fillColor = colors.HexColor(0x807F83)
legend.fontSize = 10
legend.boxAnchor = 'nw'
legend.columnMaximum = (len(bc.data) + 1) / 2
legend.strokeWidth = 0.5
legend.strokeColor = colors.HexColor(0xffffff)
legend.deltax = 75
legend.deltay = 12
legend.dividerColor = colors.HexColor(0xdedede)
legend.columnMaximum = len(bepuComparedObjKey)
legend.colorNamePairs = [(bc.bars[i].fillColor, bepuComparedObjKey[i])
for i in xrange(len(bc.data))]
#pseChart.hAlign = 'RIGHT'
label = Label()
label.setOrigin(10, bc.height / 2)
#label.boxAnchor = 'sw'
label.angle = 90
label.fillColor = colors.HexColor(0x807F83)
label.setText('Annual Energy Use (kWh/year)')
label.fontName = 'Helvetica'
bepuComparisonChart.add(label)
bepuComparisonChart.add(legend, 'legend')
bepuComparisonChart.add(bc)
Elements.append(bepuComparisonChart)
Elements.append(PageBreak())
doc.build(Elements)
output_file.seek(0)
# Set filname and mimetype
file_name = 'K-BEAT_export_{}.pdf'.format(
datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
#Returning the file from memory
return send_file(output_file,
attachment_filename=file_name,
as_attachment=True)
def getPlot():
drawing = Drawing(400, 200)
#temps = [((0.5,7), (1.5,1), (2.5,2), (3.5,1), (4.5,3), (5.5,5), (6.5, 10), (7.5,6))]
temps = [getTemps()]
bc = LinePlot()
bc.x = 50
bc.y = 50
bc.height = 125
bc.width = 300
bc.data = temps
#labels
yilabel = Label()
yilabel.setText("Temperatura (°C)")
yilabel.angle = 90
yilabel.setOrigin(20,120)
xlabel = Label()
xlabel.setText("Días")
xlabel.setOrigin(200,20)
labelT = Label()
labelT.setText("Temperatura")
labelT.setOrigin(210,185)
labelH = Label()
labelH.setText("Humedad")
labelH.setOrigin(285,185)
bc.xValueAxis.valueMin = 0
bc.xValueAxis.valueMax = 20
bc.xValueAxis.valueSteps = [x for x in range(1,bc.xValueAxis.valueMax)]
#bc.xValueAxis.labelTextFormat = '%2.1f'
bc.yValueAxis.valueMin = 0
bc.yValueAxis.valueMax = 60
bc.yValueAxis.valueSteps = [0, 10, 20, 30, 40, 50, 60]
drawing.add(bc)
drawing.add(yilabel)
drawing.add(xlabel)
drawing.add(Line(170,185,185,185, strokeColor=colors.red))
drawing.add(Line(250,185,265,185, strokeColor=colors.blue))
drawing.add(labelT)
drawing.add(labelH)
#humedad=[[(0.5, 4), (1.5, 3), (2.5, 4), (3.5, 6), (4.5, 4), (5.5, 2), (6.5, 5), (7.5, 6)]]
humedad = [getHumedad()]
lp = LinePlot()
lp.x = bc.x
lp.y = bc.y
lp.height = bc.height
lp.width = bc.width
lp.data = humedad
ydlabel = Label()
ydlabel.setText("Humedad (%)")
ydlabel.angle = -90
ydlabel.setOrigin(lp.x+lp.width+30,lp.y+70)
lp.joinedLines = 1
lp.lines[0].symbol = makeMarker('Circle')
lp.lines[0].strokeColor=colors.blue
lp.lineLabelFormat = '%2.0f'
lp.xValueAxis.valueMin = 0
lp.xValueAxis.valueMax = bc.xValueAxis.valueMax
lp.yValueAxis.valueMin = 0
lp.yValueAxis.valueMax = 100
lp.xValueAxis.visible=False
lp.yValueAxis.visible=False #Hide 2nd plot its Yaxis
drawing.add(lp)
drawing.add(ydlabel)
y2Axis = YValueAxis()#Replicate 2nd plot Yaxis in the right
y2Axis.setProperties(lp.yValueAxis.getProperties())
y2Axis.setPosition(lp.x+lp.width,lp.y,lp.height)
y2Axis.tickRight=5
y2Axis.tickLeft=0
y2Axis.labels.dx = 20
y2Axis.configure(humedad)
y2Axis.visible=True
drawing.add(y2Axis)
return drawing
def makeSummary(self, stype):
logger.debug('StartQT4::makeSummary(%s)' % stype)
pinfo = self.imageViews[-1].getSummaryDemographics()
if pinfo is None:
return
reportname = self.imageViews[-1].getReportName()+'.pdf'
filename = QtGui.QFileDialog.getSaveFileName(self, directory=reportname, filter='PDF Files *.pdf(*.pdf);;All Files *(*)')
#filename = QtGui.QFileDialog.getSaveFileName(self, filter='PDF Files *.pdf(*.pdf);;All Files *(*)')
if len(filename) == 0:
return
doc = SimpleDocTemplate(str(filename), pagesize=A4, rightMargin=1.5*cm, leftMargin=2*cm, topMargin=2*cm, bottomMargin=3*cm)
elements = []
#data = pinfo.items()
for iv in self.imageViews:
vt = iv.getVelocityText()
if stype == 'BOTH' or stype == iv.getViewShortName():
pinfo.append(vt)
t=Table(pinfo, rowHeights=12)
t.setStyle(TableStyle([('BACKGROUND',(1,1),(-2,-2),colors.green),
('TEXTCOLOR',(0,0),(1,-1),colors.black),
('ALIGNMENT', (0,0),(0,-1), 'RIGHT')]))
elements.append(t)
for iv in self.imageViews:
if stype == 'BOTH' or stype == iv.getViewShortName():
drawing = Drawing(400, 280)
cd = iv.getDataPointer()
vt = iv.getVelocityText()
pinfo.append(vt)
#ydata = cd.getCOMYScaled(False, 'mm').tolist()
ydata = cd.getCOMYScaled(True, 'mm').tolist()
xPlaneFit = cd.getYPlaneFit(units='mm', bothAxes=True).tolist()
vdata = cd.getVelocitySlopeScaled(units='mm', bothAxes=True)
gdata = [ydata, xPlaneFit]
if vdata is not None:
gdata.append(vdata.tolist())
title = Label()
title.setOrigin(150, 240)
title.setText(iv.getViewName())
ylabel = Label()
ylabel.setOrigin(0, 100)
ylabel.angle = 90
ylabel.setText("Millimeters")
xlabel = Label()
xlabel.setOrigin(70, 0)
xlabel.setText("Seconds")
lp = LinePlot()
lp.height = 230
lp.width = 400
lp.data = gdata
lp.lines[0].strokeColor = colors.blue
lp.lines[1].strokeColor = colors.red
lp.lines[2].strokeColor = colors.green
#lp.xValueAxis.xLabel = "Seconds"
drawing.add(title)
drawing.add(ylabel)
drawing.add(xlabel)
drawing.add(lp)
elements.append(drawing)
doc.build(elements, onFirstPage=self.pdfHeaderFooter, onLaterPages=self.pdfHeaderFooter)
def draw(self):
g = Group()
#box
g.add(Rect(self.x,self.y,len(self.xlabels)*self.gridDivWidth,len(self.ylabels)*self.gridDivWidth,
strokeColor=self.gridColor,
strokeWidth=self.strokeWidth,
fillColor=None))
#internal gridding
for f in range (1,len(self.ylabels)):
#horizontal
g.add(Line(strokeColor=self.gridColor,
strokeWidth=self.strokeWidth,
x1 = self.x,
y1 = self.y+f*self.gridDivWidth,
x2 = self.x+len(self.xlabels)*self.gridDivWidth,
y2 = self.y+f*self.gridDivWidth))
for f in range (1,len(self.xlabels)):
#vertical
g.add(Line(strokeColor=self.gridColor,
strokeWidth=self.strokeWidth,
x1 = self.x+f*self.gridDivWidth,
y1 = self.y,
x2 = self.x+f*self.gridDivWidth,
y2 = self.y+len(self.ylabels)*self.gridDivWidth))
# draw the 'dot'
g.add(Circle(strokeColor=self.gridColor,
strokeWidth=self.strokeWidth,
fillColor=self.dotColor,
cx = self.x+(self.dotXPosition*self.gridDivWidth),
cy = self.y+(self.dotYPosition*self.gridDivWidth),
r = self.dotDiameter/2.0))
#used for centering y-labels (below)
ascent=getFont(self.labelFontName).face.ascent
if ascent==0:
ascent=0.718 # default (from helvetica)
ascent=ascent*self.labelFontSize # normalize
#do y-labels
if self.ylabels != None:
for f in range (len(self.ylabels)-1,-1,-1):
if self.ylabels[f]!= None:
g.add(String(strokeColor=self.gridColor,
text = self.ylabels[f],
fontName = self.labelFontName,
fontSize = self.labelFontSize,
fillColor=_PCMYK_black,
x = self.x-self.labelOffset,
y = self.y+(f*self.gridDivWidth+(self.gridDivWidth-ascent)/2.0),
textAnchor = 'end'))
#do x-labels
if self.xlabels != None:
for f in range (0,len(self.xlabels)):
if self.xlabels[f]!= None:
l=Label()
l.x=self.x+(f*self.gridDivWidth)+(self.gridDivWidth+ascent)/2.0
l.y=self.y+(len(self.ylabels)*self.gridDivWidth)+self.labelOffset
l.angle=90
l.textAnchor='start'
l.fontName = self.labelFontName
l.fontSize = self.labelFontSize
l.fillColor = _PCMYK_black
l.setText(self.xlabels[f])
l.boxAnchor = 'sw'
l.draw()
g.add(l)
return g
def line_chart(data, labels, **kw):
"""
:param data: contains a three dimensional array of values (list of lists of points)
or just a list of datapoint lists (it will be auto-transposed to start at 0)
:type data: list
:param labels: can contain, but must not ["xlabel", "ylabel", ["data label0", ...]]
third item can also be an interger stating the iteration start as label
when of same size as data, then a legend is added instead
:type lables: ???
:param xlim: limit the x axis to these values, e.g. (0, 100)
:type xlim: Tuple(Number, Number)
:param ylim: limit the y axis to these values, e.g. (0, 50)
:type ylim: Tuple(Number, Number)
:param size: size in pixels, e.g. (18*cm, 9*cm)
:type size: Tuple(Number, Number)
:param title: title of bar chart
:type title: string
:param lines: list of colors we should use to paint lines
:type lines: list[???]
:param markers: list of markers we should use to draw markers
:type markers: list[`PDF_LINE_MARKERS`,...]
:param scatter: weather to do a scatter plot or line chart
:type scatter: boolean
"""
# Get all arguments from the keywordargs
title = kw.pop('title', None)
scatter = kw.pop('scatter', False)
size = kw.pop('plotSize', (18 * cm, 9 * cm))
lines = kw.pop('lines', PDF_CHART_COLORS)
markers = kw.pop('markers', PDF_LINE_MARKERS)
xlim = kw.pop('xlim', None)
ylim = kw.pop('ylim', None)
drawing = Drawing(size[0], size[1])
chart = None
if(scatter):
chart = ScatterPlot()
else:
chart = LinePlot()
for key, val in list(kw.items()):
setattr(chart, key, val)
if title is not None:
drawing.add(String(20, size[1] - 10, title), name='title')
chart.y -= 10
chart.width = drawing.width - 20
chart.height = drawing.height - 40
chart.x = 10
chart.y = 10
chart.data = data if type(data[0][0]) in (tuple, list) else [list(zip(list(range(len(i))), i)) for i in data]
max_y = 0
min_y = maxsize
for i in range(len(data)):
chart.lines[i].strokeColor = HexColor(lines[i % len(lines)])
if markers is not None:
chart.lines[i].symbol = makeMarker(markers[i % len(markers)])
chart.lines[i].symbol.size = 3
max_y = max([k[1] for k in chart.data[i]] + [max_y])
min_y = min([k[1] for k in chart.data[i]] + [min_y])
chart.yValueAxis.valueMax = max_y * 1.1
chart.yValueAxis.valueMin = min_y * 0.9
chart.xValueAxis.visibleGrid = True
chart.yValueAxis.visibleGrid = True
if xlim is not None:
chart.xValueAxis.valueMin = xlim[0]
chart.xValueAxis.valueMax = xlim[1]
if ylim is not None:
chart.yValueAxis.valueMin = ylim[0]
chart.yValueAxis.valueMax = ylim[1]
if scatter:
chart.xLabel = ''
chart.yLabel = ''
chart.y -= 10
chart.lineLabelFormat = None
if labels is not None:
if len(labels) > 0:
xlabel = Label()
xlabel._text = labels[0] # pylint: disable=W0212
xlabel.textAnchor = 'middle'
xlabel.x = drawing.width / 2
xlabel.y = 5
chart.y += 15
drawing.add(xlabel, name="xlabel")
if len(labels) > 1:
ylabel = Label()
ylabel._text = labels[1] # pylint: disable=W0212
xlabel.textAnchor = 'middle'
ylabel.angle = 90
ylabel.x = 0
ylabel.y = drawing.height / 2
chart.x += 12
drawing.add(ylabel, name="ylabel")
if len(labels) > 2:
# when labels are of same size as max nr of data point, use as x axis labels
if len(labels[2]) == max([len(x) for x in data]):
chart.categoryAxis.categoryNames = labels[2] # pylint: disable=E1101
chart.xValueAxis.labels.angle = 30 # pylint: disable=E1101
# otherwise when integer use the counter
elif type(labels[2]) == int:
temp = range(labels[2], max([len(x) for x in data]) + labels[2])
chart.categoryAxis.categoryNames = temp # pylint: disable=E1101
# or we could add a legend when of same size as data
elif len(labels[2]) == len(data):
legend = Legend()
chart.height -= 8
chart.y += 8
xlabel.y += 8
legend.boxAnchor = 'sw'
legend.x = chart.x + 8
legend.y = -2
legend.columnMaximum = 1
legend.deltax = 50
legend.deltay = 0
legend.dx = 10
legend.dy = 1.5
legend.fontSize = 7
legend.alignment = 'right'
legend.dxTextSpace = 5
legend.colorNamePairs = [(HexColor(lines[i]), labels[2][i]) for i in range(len(chart.data))]
legend.strokeWidth = 0
drawing.add(legend, name='legend')
drawing.add(chart, name='chart')
return drawing
def create_bar(self,
data_list,
label_x_axis,
contain,
y_label=None,
x_label=None,
bar_width=520,
bar_height=100,
draw_width=520,
draw_height=200,
user_color=None,
fontName="Times-Roman",
fontSize=6,
x_angle=0,
bar_space=0):
d = Drawing(width=draw_width, height=draw_height)
bar = VerticalBarChart()
bar.width = bar_width
bar.height = bar_height
bar.y = bar.height - (bar_height / 4)
bar.strokeColor = colors.black
bar.barLabelFormat = '%s'
bar.barLabels.nudge = 7
bar.barLabels.fontSize = fontSize
################# X AXIS PROPERTIES #################
bar.categoryAxis.labels.dx = 0
bar.categoryAxis.labels.angle = x_angle
bar.categoryAxis.labels.boxAnchor = 'autox'
bar.categoryAxis.labels.fontSize = fontSize
bar.categoryAxis.labels.fontName = self.master_font
bar.categoryAxis.strokeWidth = 0.25
bar.categoryAxis.tickDown = -(bar.height)
bar.categoryAxis.categoryNames = label_x_axis
labX = Label()
labX.boxAnchor = 'ne'
labX.dx = bar.width * 2.15
labX.dy = bar.height
labX.fontName = fontName
labX.fontSize = fontSize
labX.setText(x_label)
d.add(labX)
#####################################################
################# Y AXIS PROPERTIES #################
bar.valueAxis.forceZero = 1
bar.valueAxis.labels.fontSize = fontSize
bar.valueAxis.labels.fontName = fontName
bar.valueAxis.rangeRound = 'both'
bar.valueAxis.valueMin = 0
bar.valueAxis.visibleGrid = 1
bar.valueAxis.visibleAxis = 1
bar.valueAxis.labels.dx = -10
labY = Label()
labY.boxAnchor = 'autox'
labY.dy = bar.y + (bar.height / 1.5)
labY.dx = bar.x - 30
labY.angle = 90
labY.fontName = fontName
labY.fontSize = fontSize
labY.setText(y_label)
d.add(labY)
#####################################################
bar.barSpacing = bar_space
# bar.groupSpacing = 3
bar.data = data_list
# print len(data_list)
# print len(contain)
if user_color != None:
usage_color = user_color
else:
random_range = [randint(0, 100) for i in range(len(contain))]
usage_color = map(
lambda item: PCMYKColor(randint(0, item), randint(0, item),
randint(0, item), randint(0, item)),
random_range)
for i in range(len(data_list)):
bar.bars[i].name = contain[i].upper()
bar.bars[i].fillColor = usage_color[i]
legend = Legend()
# legend.autoXPadding = 10
legend.alignment = 'right'
legend.boxAnchor = 'sw'
legend.dxTextSpace = 10
legend.fontSize = fontSize
legend.fontName = fontName
legend.subCols.minWidth = 55
legend.variColumn = 1
legend.deltay = 15
legend.x = bar.x
legend.colorNamePairs = Auto(obj=bar)
d.add(bar)
d.add(legend)
self.flowables.append(d)
def results_chart(self, control_mean, match_mean, treated_mean, att):
"""
Specify layout of the results chart and generate
flowable object that can be added to the pdf
"""
drawing = Drawing()
vbc = VerticalBarChart()
# Offset chart from border and text
vbc.x = self.chart_offset_x
vbc.y = self.chart_offset_y
# Set figure size
vbc.height = self.chart_height
vbc.width = self.chart_width
# Specify chart -- list of lists -- list of series with enteries
vbc.data = [[control_mean, match_mean, treated_mean, att]]
#Set Y-Axis ranges
#axis_range = self._calculate_y_axis(vbc.data)
#vbc.valueAxis.valueMin = axis_range['min']
#vbc.valueAxis.valueMax = axis_range['max']
#vbc.valueAxis.valueStep = axis_range['step']
#Grid formatting
vbc.valueAxis.visibleGrid = 1
vbc.valueAxis.gridStrokeColor = colors.lightgrey
# Set bar characteristics
vbc.bars[(0, 0)].fillColor = colors.blue
vbc.bars[(0, 1)].fillColor = colors.yellow
vbc.bars[(0, 2)].fillColor = colors.red
vbc.bars[(0, 3)].fillColor = colors.green
vbc.bars.strokeColor = None
vbc.barSpacing = 2
# Create callout labels
#vbc.barLabels.fontName = "Helvetica"
vbc.barLabels.fontSize = 8
vbc.barLabels.fillColor = colors.black
vbc.barLabelFormat = '%.2f'
vbc.barLabels.nudge = 5
# X-axis labels
#vbc.categoryAxis.labels.dy = -60
#vbc.valueAxis.labels.fontName = 'Helvetica'
vbc.categoryAxis.categoryNames = [
'Control Mean', 'Matched Control Mean', 'Treatment mean', 'ATT'
]
lab = Label()
lab.setOrigin(10, 155)
lab.boxAnchor = 'ne'
lab.angle = 90
lab.dx = 0
lab.dy = -15
#lab.boxStrokeColor = colors.green
lab.setText('Result Values')
drawing.add(lab)
drawing.add(vbc)
self.elements.append(drawing)
d.add(lab)
""")
from reportlab.graphics import shapes
from reportlab.graphics.charts.textlabels import Label
d = Drawing(200, 100)
# mark the origin of the label
d.add(Circle(100,90, 5, fillColor=colors.green))
lab = Label()
lab.setOrigin(100,90)
lab.boxAnchor = 'ne'
lab.angle = 45
lab.dx = 0
lab.dy = -20
lab.boxStrokeColor = colors.green
lab.setText('Some\nMulti-Line\nLabel')
d.add(lab)
draw(d, 'Label example')
disc("""
In the drawing above, the label is defined relative to the green blob.
The text box should have its north-east corner ten points down from
the origin, and be rotated by 45 degrees about that corner.
def makeSummary(self, stype):
logger.debug('StartQT4::makeSummary(%s)' % stype)
pinfo = self.imageViews[-1].getSummaryDemographics()
if pinfo is None:
return
reportname = self.imageViews[-1].getReportName() + '.pdf'
filename = QtGui.QFileDialog.getSaveFileName(
self,
directory=reportname,
filter='PDF Files *.pdf(*.pdf);;All Files *(*)')
#filename = QtGui.QFileDialog.getSaveFileName(self, filter='PDF Files *.pdf(*.pdf);;All Files *(*)')
if len(filename) == 0:
return
doc = SimpleDocTemplate(str(filename),
pagesize=A4,
rightMargin=1.5 * cm,
leftMargin=2 * cm,
topMargin=2 * cm,
bottomMargin=3 * cm)
elements = []
#data = pinfo.items()
for iv in self.imageViews:
vt = iv.getVelocityText()
if stype == 'BOTH' or stype == iv.getViewShortName():
pinfo.append(vt)
t = Table(pinfo, rowHeights=12)
t.setStyle(
TableStyle([('BACKGROUND', (1, 1), (-2, -2), colors.green),
('TEXTCOLOR', (0, 0), (1, -1), colors.black),
('ALIGNMENT', (0, 0), (0, -1), 'RIGHT')]))
elements.append(t)
for iv in self.imageViews:
if stype == 'BOTH' or stype == iv.getViewShortName():
drawing = Drawing(400, 280)
cd = iv.getDataPointer()
vt = iv.getVelocityText()
pinfo.append(vt)
#ydata = cd.getCOMYScaled(False, 'mm').tolist()
ydata = cd.getCOMYScaled(True, 'mm').tolist()
xPlaneFit = cd.getYPlaneFit(units='mm', bothAxes=True).tolist()
vdata = cd.getVelocitySlopeScaled(units='mm', bothAxes=True)
gdata = [ydata, xPlaneFit]
if vdata is not None:
gdata.append(vdata.tolist())
title = Label()
title.setOrigin(150, 240)
title.setText(iv.getViewName())
ylabel = Label()
ylabel.setOrigin(0, 100)
ylabel.angle = 90
ylabel.setText("Millimeters")
xlabel = Label()
xlabel.setOrigin(70, 0)
xlabel.setText("Seconds")
lp = LinePlot()
lp.height = 230
lp.width = 400
lp.data = gdata
lp.lines[0].strokeColor = colors.blue
lp.lines[1].strokeColor = colors.red
lp.lines[2].strokeColor = colors.green
#lp.xValueAxis.xLabel = "Seconds"
drawing.add(title)
drawing.add(ylabel)
drawing.add(xlabel)
drawing.add(lp)
elements.append(drawing)
doc.build(elements,
onFirstPage=self.pdfHeaderFooter,
onLaterPages=self.pdfHeaderFooter)
def draw(self):
g = Group()
#box
g.add(
Rect(self.x,
self.y,
len(self.xlabels) * self.gridDivWidth,
len(self.ylabels) * self.gridDivWidth,
strokeColor=self.gridColor,
strokeWidth=self.strokeWidth,
fillColor=None))
#internal gridding
for f in range(1, len(self.ylabels)):
#horizontal
g.add(
Line(strokeColor=self.gridColor,
strokeWidth=self.strokeWidth,
x1=self.x,
y1=self.y + f * self.gridDivWidth,
x2=self.x + len(self.xlabels) * self.gridDivWidth,
y2=self.y + f * self.gridDivWidth))
for f in range(1, len(self.xlabels)):
#vertical
g.add(
Line(strokeColor=self.gridColor,
strokeWidth=self.strokeWidth,
x1=self.x + f * self.gridDivWidth,
y1=self.y,
x2=self.x + f * self.gridDivWidth,
y2=self.y + len(self.ylabels) * self.gridDivWidth))
# draw the 'dot'
g.add(
Circle(strokeColor=self.gridColor,
strokeWidth=self.strokeWidth,
fillColor=self.dotColor,
cx=self.x + (self.dotXPosition * self.gridDivWidth),
cy=self.y + (self.dotYPosition * self.gridDivWidth),
r=self.dotDiameter / 2.0))
#used for centering y-labels (below)
ascent = getFont(self.labelFontName).face.ascent
if ascent == 0:
ascent = 0.718 # default (from helvetica)
ascent = ascent * self.labelFontSize # normalize
#do y-labels
if self.ylabels != None:
for f in range(len(self.ylabels) - 1, -1, -1):
if self.ylabels[f] != None:
g.add(
String(strokeColor=self.gridColor,
text=self.ylabels[f],
fontName=self.labelFontName,
fontSize=self.labelFontSize,
fillColor=_PCMYK_black,
x=self.x - self.labelOffset,
y=self.y + (f * self.gridDivWidth +
(self.gridDivWidth - ascent) / 2.0),
textAnchor='end'))
#do x-labels
if self.xlabels != None:
for f in range(0, len(self.xlabels)):
if self.xlabels[f] != None:
l = Label()
l.x = self.x + (f * self.gridDivWidth
) + (self.gridDivWidth + ascent) / 2.0
l.y = self.y + (len(self.ylabels) *
self.gridDivWidth) + self.labelOffset
l.angle = 90
l.textAnchor = 'start'
l.fontName = self.labelFontName
l.fontSize = self.labelFontSize
l.fillColor = _PCMYK_black
l.setText(self.xlabels[f])
l.boxAnchor = 'sw'
l.draw()
g.add(l)
return g
