def draw(self, root_element, x_transform, y_transform, **kwargs):
N_STEPS = 400
interval_length = self.max_value - self.min_value
d_value = interval_length / N_STEPS
if self.orientation == 'vertical':
x1, x2 = x_transform(0), x_transform(1)
for i in range(N_STEPS):
min_value = self.min_value + i * d_value
max_value = min_value + d_value
color = self.gradient.get_css_color((min_value + max_value) / 2)
rect = ET.SubElement(root_element, 'rect')
rect.set('x', '%.2f' % x1)
rect.set('width', '%.2f' % (x2 - x1))
y1 = y_transform(min_value)
y2 = y_transform(max_value)
if y1 > y2:
y2, y1 = y1, y2
rect.set('y', '%.2f' % y1)
rect.set('height', '%.2f' % (y2 - y1))
rect.set('fill', color)
rect.set('stroke', color)
else:
y1, y2 = y_transform(0), y_transform(1)
for i in range(N_STEPS):
min_value = self.min_value + i * d_value
max_value = min_value + d_value
color = self.gradient.get_css_color((min_value + max_value) / 2)
rect = ET.SubElement(root_element, 'rect')
rect.set('y', '%.2f' % y2)
rect.set('height', '%.2f' % (y1 - y2))
x1 = x_transform(min_value)
x2 = x_transform(max_value)
if x1 > x2:
x2, x1 = x1, x2
rect.set('x', '%.2f' % x1)
rect.set('width', '%.2f' % (x2 - x1))
rect.set('fill', color)
rect.set('stroke', color)
def rdraw(self, root_element, x_transform, y_transform, svg_bbox):
width = svg_bbox[2] - svg_bbox[0]
height = svg_bbox[1] - svg_bbox[3]
assert width > 0
assert height > 0
im = Image.new('RGBA', (width, height), (255, 255, 255, 0))
imdraw = ImageDraw.Draw(im)
# above should be hidden (not re-implemented in each subclass)
if self.gradient and self.gradient_i is not None:
for i, datapoint in enumerate(izip(*self.datapoints)):
rgba_color = self.gradient.get_rgba_color(
datapoint[self.gradient_i])
for s in self.symbols:
s.rdraw(imdraw,
x_transform,
y_transform,
*datapoint,
rgba_color=rgba_color)
elif self.colors:
for i, datapoint in enumerate(izip(*self.datapoints)):
for s in self.symbols:
rgba_color = svg_color2rgba_color(self.colors[i])
s.rdraw(imdraw,
x_transform,
y_transform,
*datapoint,
rgba_color=rgba_color)
else:
for datapoint in izip(*self.datapoints):
rgba_color = svg_color2rgba_color(self.color)
for s in self.symbols:
s.rdraw(imdraw,
x_transform,
y_transform,
*datapoint,
rgba_color=rgba_color)
# below should be hidden (not re-implemented in each subclass)
tmp = StringIO.StringIO()
im.save(tmp, format='png')
encoded_png = 'data:image/png;base64,\n' + encodestring(tmp.getvalue())
img = ET.SubElement(root_element, 'image')
img.set('xlink:href', encoded_png)
img.set('x', '%.2f' % min(svg_bbox[0], svg_bbox[2]))
img.set('y', '%.2f' % min(svg_bbox[1], svg_bbox[3]))
img.set('width', '%.2f' % width)
img.set('height', '%.2f' % height)
img.set('preserveAspectRatio', 'none')
def draw(self, root_element, x_transform, y_transform):
'''Draw line plot.'''
pl = ET.SubElement(root_element, 'polyline')
pl.set('stroke', self.color)
pl.set('fill', 'none')
points = []
for x, y in zip(self.datapoints[0], self.datapoints[1]):
points.append("%.2f,%.2f" % (x_transform(x), y_transform(y)))
pl.set('points', ' '.join(points))
if self.line_pattern:
pl.set('style', 'stroke-dasharray: %s' % self.line_pattern)
if self.use_markers:
super(LinePlotter, self).draw(root_element, x_transform,
y_transform)
def draw_xy(self, root_element, x, y, *datapoint, **kwargs):
# only draw if the self.x and self.y lie within the data_bbox
W = 10
w = W / 2
H = 10
h = H / 2
d = ET.SubElement(root_element, 'rect')
d.set('x', '%.2f' % (x - w))
d.set('y', '%.2f' % (y - h))
d.set('width', '%.2f' % W)
d.set('height', '%.2f' % H)
d.set('fill', 'none')
d.set('stroke-width', '2')
if 'color' in kwargs:
d.set('stroke', kwargs['color'])
def draw(self, root_element, x_transform, y_transform):
# NOTE : the following is a crude way of detecting logarithmic
# transforms for the axes. Bit of a hack.
try:
x_transform(-1)
y_transform(-1)
except ValueError:
msg = 'RasterPlotterMixin does not support logarithmic axes.'
raise ValueError(msg)
x = x_transform(self.img_bbox[0])
y = y_transform(self.img_bbox[3])
width = x_transform(self.img_bbox[2]) - x
height = y_transform(self.img_bbox[1]) - y
img = ET.SubElement(root_element, 'image')
img.set('xlink:href', self.encoded_png)
img.set('x', '%.2f' % x)
img.set('y', '%.2f' % y)
img.set('width', '%.2f' % width)
img.set('height', '%.2f' % height)
img.set('preserveAspectRatio', 'none')
def draw(self, root_element, x_transform, y_transform):
'''Draw scatter plot.'''
if self.links:
L = self.links
else:
L = FakeList('')
if self.gradient and self.gradient_i is not None:
for i, datapoint in enumerate(izip(*self.datapoints)):
for s in self.symbols:
s.draw(root_element,
x_transform,
y_transform,
*datapoint,
color=self.gradient.get_css_color(
datapoint[self.gradient_i]),
link=L[i])
elif self.colors:
for i, datapoint in enumerate(izip(*self.datapoints)):
for s in self.symbols:
s.draw(root_element,
x_transform,
y_transform,
*datapoint,
color=self.colors[i],
link=L[i])
else:
root_element = ET.SubElement(root_element, 'g')
root_element.set('stroke', self.color)
root_element.set('fill', self.color)
for i, datapoint in enumerate(izip(*self.datapoints)):
for s in self.symbols:
s.draw(root_element,
x_transform,
y_transform,
*datapoint,
link=L[i])
def rdraw(self, root_element, x_transform, y_transform, svg_bbox):
width = svg_bbox[2] - svg_bbox[0]
height = svg_bbox[1] - svg_bbox[3]
assert width > 0
assert height > 0
im = Image.new('RGBA', (width, height), (255, 255, 255, 0))
imdraw = ImageDraw.Draw(im)
rgba_color = svg_color2rgba_color(self.color)
# above should be hidden (not re-implemented in each subclass)
if len(self.datapoints) > 1:
tmp = []
for datapoint in izip(*self.datapoints):
x = x_transform(datapoint[0])
y = y_transform(datapoint[1])
tmp.append(x)
tmp.append(y)
imdraw.line(tmp, fill=rgba_color, width=1)
# below should be hidden (not re-implemented in each subclass)
tmp = StringIO.StringIO()
im.save(tmp, format='png')
encoded_png = 'data:image/png;base64,\n' + encodestring(tmp.getvalue())
img = ET.SubElement(root_element, 'image')
img.set('xlink:href', encoded_png)
img.set('x', '%.2f' % min(svg_bbox[0], svg_bbox[2]))
img.set('y', '%.2f' % min(svg_bbox[1], svg_bbox[3]))
img.set('width', '%.2f' % width)
img.set('height', '%.2f' % height)
img.set('preserveAspectRatio', 'none')
if self.use_markers:
super(LinePlotter, self).rdraw(root_element, x_transform,
y_transform, svg_bbox)
def draw_right_axis(root_element, x_offset, y_offset, height, y_transform,
interval, use_log, **options):
'''
Draw right axis.
See the documentation for brp.svg.plotters.axes_procedural.draw_left_axis
'''
color = options.get('color', 'black')
axes_lines = ET.SubElement(root_element, 'g')
axes_lines.set('stroke', color)
axes_text = ET.SubElement(root_element, 'g')
axes_text.set('fill', color)
line = ET.SubElement(axes_lines, 'line')
line.set('x1', '%.2f' % (x_offset + AXIS_SIZE))
line.set('y1', '%.2f' % (y_offset + AXIS_SIZE))
line.set('x2', '%.2f' % (x_offset + AXIS_SIZE))
line.set('y2', '%.2f' % (y_offset + height - AXIS_SIZE))
hide_tickmarks = options.get('hide_tickmarks', False)
if not hide_tickmarks:
tickmarks = get_tickmarks(height, interval, use_log, **options)
hide_tickmarklabels = options.get('hide_tickmarklabels', False)
for y, size in tickmarks:
ny = y_transform(y)
tm = ET.SubElement(axes_lines, 'line')
tm.set('x1', '%.2f' % (x_offset + AXIS_SIZE))
tm.set('x2', '%.2f' % (x_offset + AXIS_SIZE - size * 0.7))
tm.set('y1', '%.2f' % (ny))
tm.set('y2', '%.2f' % (ny))
if hide_tickmarklabels:
continue
if size != 10:
continue
ticklabel = ET.SubElement(axes_text, 'text')
ticklabel.set('font-size', str(FONT_SIZE))
ticklabel.set('text-anchor', 'middle')
ticklabel.set(
'x', '%.2f' % (x_offset + AXIS_SIZE + TICKMARK_LABEL_SPACING +
0.5 * FONT_SIZE)),
ticklabel.set('y', '%.2f' % ny)
ticklabel.set(
'transform', 'rotate(%d %.2f %.2f)' %
(-90, x_offset + AXIS_SIZE + TICKMARK_LABEL_SPACING +
0.5 * FONT_SIZE, ny))
ticklabel.text = escape(str(y))
hide_label = options.get('hide_label', False)
label_link = options.get('label_link', None)
if not hide_label:
if label_link:
axes_text = ET.SubElement(axes_text, 'a')
axes_text.set('xlink:href', label_link)
lbl = ET.SubElement(axes_text, 'text')
lbl.set('font-size', str(FONT_SIZE))
lbl.set('text-anchor', 'middle')
lbl.set(
'x', '%.2f' %
(x_offset + AXIS_SIZE + TICKMARK_LABEL_SPACING + 2.5 * FONT_SIZE)),
lbl.set('y', '%.2f' % (y_offset + 0.5 * height))
lbl.set(
'transform', 'rotate(%d %.2f %.2f)' %
(-90, x_offset + AXIS_SIZE + TICKMARK_LABEL_SPACING +
2.5 * FONT_SIZE, y_offset + 0.5 * height))
label = options.get('label', 'Y LABEL')
lbl.text = escape(label)
def draw_left_axis(root_element, x_offset, y_offset, height, y_transform,
interval, use_log, **options):
'''
Draw left axis.
arguments:
`root_element` --- ElementTree Element instance, receives the drawing
commands.
`x_offset` --- The horizontal offset in SVG screen coordinates of the
axis.
`y_offset` --- The vertical offset in SVG screen coordinates of the
axis.
`y_transform` --- Transformation function that transforms y data
coordinates to y SVG screen coordinates.
`interval` --- Interval in y data coordinates that the axis covers.
`use_log` --- Boolean, True if axis is to be treated as logarithmic.
key word arguments:
`tickmarks` --- list of tickmarks. Tickmarks are tuples like:
(position, size) with position and size numbers.
`label` --- Text that labels this axis.
`hide_label` --- Boolean, True if label should be hidden.
`hide_tickmarks` --- Boolean, True if tickmarks should be hidden.
`hide_tickmarklabels` --- Boolean, True if tickmarks and labels for
this axis should be hidden.
'''
color = options.get('color', 'black')
axes_lines = ET.SubElement(root_element, 'g')
axes_lines.set('stroke', color)
axes_text = ET.SubElement(root_element, 'g')
axes_text.set('fill', color)
line = ET.SubElement(axes_lines, 'line')
line.set('x1', '%.2f' % (x_offset + AXIS_SIZE))
line.set('y1', '%.2f' % (y_offset + AXIS_SIZE))
line.set('x2', '%.2f' % (x_offset + AXIS_SIZE))
line.set('y2', '%.2f' % (y_offset + height - AXIS_SIZE))
hide_tickmarks = options.get('hide_tickmarks', False)
if not hide_tickmarks:
tickmarks = get_tickmarks(height, interval, use_log, **options)
hide_tickmarklabels = options.get('hide_tickmarklabels', False)
for y, size in tickmarks:
ny = y_transform(y)
tm = ET.SubElement(axes_lines, 'line')
tm.set('x1', '%.2f' % (x_offset + AXIS_SIZE))
tm.set('x2', '%.2f' % (x_offset + AXIS_SIZE + size * 0.7))
tm.set('y1', '%.2f' % (ny))
tm.set('y2', '%.2f' % (ny))
tm.set('stroke', color)
if hide_tickmarklabels:
continue
if size != 10:
continue
ticklabel = ET.SubElement(axes_text, 'text')
ticklabel.set('font-size', str(FONT_SIZE))
ticklabel.set('text-anchor', 'middle')
ticklabel.set(
'x', '%.2f' % (x_offset + AXIS_SIZE - TICKMARK_LABEL_SPACING)),
ticklabel.set('y', '%.2f' % ny)
ticklabel.set(
'transform', 'rotate(%d %.2f %.2f)' %
(-90, x_offset + AXIS_SIZE - TICKMARK_LABEL_SPACING, ny))
ticklabel.text = escape(str(y))
hide_label = options.get('hide_label', False)
label_link = options.get('label_link', None)
if not hide_label:
if label_link:
axes_text = ET.SubElement(axes_text, 'a')
axes_text.set('xlink:href', label_link)
lbl = ET.SubElement(axes_text, 'text')
lbl.set('font-size', str(FONT_SIZE))
lbl.set('text-anchor', 'middle')
lbl.set(
'x', '%.2f' %
(x_offset + AXIS_SIZE - TICKMARK_LABEL_SPACING - 2 * FONT_SIZE)),
lbl.set('y', '%.2f' % (y_offset + 0.5 * height))
lbl.set(
'transform', 'rotate(%d %.2f %.2f)' %
(-90, x_offset + AXIS_SIZE - TICKMARK_LABEL_SPACING -
2 * FONT_SIZE, y_offset + 0.5 * height))
label = options.get('label', 'Y LABEL')
lbl.text = escape(label)
def draw_top_axis(root_element, x_offset, y_offset, width, x_transform,
interval, use_log, **options):
'''
Draw top axis.
See the documentation for brp.svg.plotters.axes_procedural.draw_left_axis
'''
color = options.get('color', 'black')
axes_lines = ET.SubElement(root_element, 'g')
axes_lines.set('stroke', color)
axes_text = ET.SubElement(root_element, 'g')
axes_text.set('fill', color)
line = ET.SubElement(axes_lines, 'line')
line.set('x1', '%.2f' % (x_offset + AXIS_SIZE))
line.set('y1', '%.2f' % (y_offset + AXIS_SIZE))
line.set('x2', '%.2f' % (x_offset + width - AXIS_SIZE))
line.set('y2', '%.2f' % (y_offset + AXIS_SIZE))
hide_tickmarks = options.get('hide_tickmarks', False)
if not hide_tickmarks:
tickmarks = get_tickmarks(width, interval, use_log, **options)
hide_tickmarklabels = options.get('hide_tickmarklabels', False)
for x, size in tickmarks:
nx = x_transform(x)
tm = ET.SubElement(axes_lines, 'line')
tm.set('x1', '%.2f' % (nx))
tm.set('x2', '%.2f' % (nx))
tm.set('y1', '%.2f' % (y_offset + AXIS_SIZE))
tm.set('y2', '%.2f' % (y_offset + AXIS_SIZE + size * 0.7))
if hide_tickmarklabels:
continue
if size != 10:
continue
ticklabel = ET.SubElement(axes_text, 'text')
ticklabel.set('font-size', str(FONT_SIZE))
ticklabel.set('text-anchor', 'middle')
ticklabel.set(
'y', '%.2f' % (y_offset + AXIS_SIZE - TICKMARK_LABEL_SPACING)),
ticklabel.set('x', '%.2f' % nx)
ticklabel.text = escape(str(x))
hide_label = options.get('hide_label', False)
label_link = options.get('label_link', None)
if not hide_label:
if label_link:
axes_text = ET.SubElement(axes_text, 'a')
axes_text.set('xlink:href', label_link)
lbl = ET.SubElement(axes_text, 'text')
lbl.set('font-size', str(FONT_SIZE))
lbl.set('text-anchor', 'middle')
lbl.set(
'y', '%.2f' %
(y_offset + AXIS_SIZE - TICKMARK_LABEL_SPACING - 2 * FONT_SIZE)),
lbl.set('x', '%.2f' % (x_offset + 0.5 * width))
label = options.get('label', 'X LABEL')
lbl.text = escape(label)
def draw(self, root_element, x_transform, y_transform):
L = len(self.binned_data)
# Still needs the optimization for line segments that extend each other
# (those need to be merged).
points = []
for i in range(L):
if i == 0:
x1, x2, y = self.binned_data[0]
if self.orientation == 'horizontal':
points.append('%.2f,%.2f' % (x_transform(x1),
y_transform(y)))
else:
points.append('%.2f,%.2f' % (x_transform(y),
y_transform(x1)))
else:
x1, x2, y = self.binned_data[i]
previous_x1, previous_x2, previous_y = self.binned_data[i - 1]
if x1 == previous_x2:
if self.orientation == 'horizontal':
points.append('%.2f,%.2f' % (x_transform(x1),
y_transform(previous_y)))
if y != previous_y:
points.append('%.2f,%.2f' % (x_transform(x1),
y_transform(y)))
else:
points.append('%.2f,%.2f' % (x_transform(previous_y),
y_transform(x1)))
if y != previous_y:
points.append('%.2f,%.2f' % (x_transform(y),
y_transform(x1)))
else: # a 'break' in the histogram
if self.orientation == 'horizontal':
points.append('%.2f,%.2f' % (x_transform(previous_x2),
y_transform(previous_y)))
else:
points.append('%.2f,%.2f' % (x_transform(previous_y),
y_transform(previous_x2)))
pl = ET.SubElement(root_element, 'polyline')
pl.set('stroke', self.color)
pl.set('fill', 'none')
pl.set('points', ' '.join(points))
if self.line_pattern:
pl.set('style', 'stroke-dasharray:%s' %
self.line_pattern)
if self.orientation == 'horizontal':
points = ['%.2f,%.2f' % (x_transform(x1),
y_transform(y))]
else:
points = ['%.2f,%.2f' % (x_transform(y),
y_transform(x1))]
if i == L - 1:
x1, x2, y = self.binned_data[-1]
if self.orientation == 'horizontal':
points.append('%.2f,%.2f' % (x_transform(x2),
y_transform(y)))
else:
points.append('%.2f,%.2f' % (x_transform(y),
y_transform(x2)))
pl = ET.SubElement(root_element, 'polyline')
pl.set('stroke', self.color)
pl.set('fill', 'none')
pl.set('points', ' '.join(points))
if self.line_pattern:
pl.set('style', 'stroke-dasharray:%s' % self.line_pattern)