pygal/svg/charts/line.py

#!python

# $Id$

from operator import itemgetter, add
from lxml import etree

from util import flatten, float_range
from svg.charts.graph import Graph

class Line(Graph):
	"""Line Graph"""

	"""Show a small circle on the graph where the line goes from one point to
	the next"""
	show_data_points = True
	show_data_values = True
	"""Accumulates each data set. (i.e. Each point increased by sum of all
	previous series at same point)."""
	stacked = False
	"Fill in the area under the plot"
	area_fill = False
	
	scale_divisions = None

	#override some defaults
	top_align = top_font = right_align = right_font = True
	
	stylesheet_names = Graph.stylesheet_names + ['plot.css']

	def max_value(self):
		data = map(itemgetter('data'), self.data)
		if self.stacked:
			data = self.get_cumulative_data()
		return max(flatten(data))

	def min_value(self):
		if self.min_scale_value:
			return self.min_scale_value
		data = map(itemgetter('data'), self.data)
		if self.stacked:
			data = self.get_cumulative_data()
		return min(flatten(data))

	def get_cumulative_data():
		"""Get the data as it will be charted.  The first set will be
		the actual first data set.  The second will be the sum of the
		first and the second, etc."""
		sets = map(itemgetter('data'), self.data)
		if not sets: return
		sum = sets.pop(0)
		yield sum
		while sets:
			sum = map(add, sets.pop(0))
			yield sum

	def get_x_labels(self):
		return self.fields

	def calculate_left_margin(self):
		super(self.__class__, self).calculate_left_margin()
		label_left = len(self.fields[0]) / 2 * self.font_size * 0.6
		self.border_left = max(label_left, self.border_left)

	def get_y_label_values(self):
		max_value = self.max_value()
		min_value = self.min_value()
		range = max_value - min_value
		top_pad = (range / 20.0) or 10
		scale_range = (max_value + top_pad) - min_value
		
		scale_division = self.scale_divisions or (scale_range / 10.0)
		
		if self.scale_integers:
		  scale_division = min(1, round(scale_division))
		
		if max_value % scale_division == 0: 
			max_value += scale_division
		labels = tuple(float_range(min_value, max_value, scale_division))
		return labels

	def get_y_labels(self):
		return map(str, self.get_y_label_values())

	def calc_coords(self, field, value, width = None, height = None):
		if width is None: width = self.field_width
		if height is None: height = self.field_height
		coords = dict(
			x = width * field,
			y = self.graph_height - value * height,
			)
		return coords

	def draw_data(self):
		min_value = self.min_value()
		field_height = self.graph_height - self.font_size*2*self.top_font

		y_label_values = self.get_y_label_values()
		y_label_span = max(y_label_values) - min(y_label_values)
		field_height /= float(y_label_span)
		
		field_width = self.field_width()
		#line = len(self.data)
		
		prev_sum = [0]*len(self.fields)
		cum_sum = [-min_value]*len(self.fields)

		coord_format = lambda c: '%(x)s %(y)s' % c
		
		for line_n, data in reversed(list(enumerate(self.data, 1))):
			apath = ''
			
			if not self.stacked: cum_sum = [-min_value]*len(self.fields)
		
			cum_sum = map(add, cum_sum, data['data'])
			get_coords = lambda (i, val): self.calc_coords(i,
														 val,
														 field_width,
														 field_height)
			coords = map(get_coords, enumerate(cum_sum))
			paths = map(coord_format, coords)
			line_path = ' '.join(paths)

			if self.area_fill:
				# to draw the area, we'll use the line above, followed by
				#  tracing the bottom from right to left
				if self.stacked:
					prev_sum_rev = list(enumerate(prev_sum)).reversed()
					coords = map(get_coords, prev_sum_rev)
					paths = map(coord_format, coords)
					area_path = ' '.join(paths)
					origin = paths[-1]
				else:
					area_path = "V%(graph_height)s" % vars(self)
					origin = coord_format(get_coords((0,0)))

				d = ' '.join((
					'M',
					origin,
					'L',
					line_path,
					area_path,
					'Z'
				))
				etree.SubElement(self.graph, 'path', {
					'class': 'fill%(line_n)s' % vars(),
					'd': d,
					})

			# now draw the line itself
			etree.SubElement(self.graph, 'path', {
				'd': 'M0 %s L%s' % (self.graph_height, line_path),
				'class': 'line%(line_n)s' % vars(),
				})
			
			if self.show_data_points or self.show_data_values:
				for i, value in enumerate(cum_sum):
					if self.show_data_points:
						circle = etree.SubElement(
							self.graph,
							'circle',
							{'class': 'dataPoint%(line_n)s' % vars()},
							cx = str(field_width*i),
							cy = str(self.graph_height - value*field_height),
							r = '2.5',
							)
					self.make_datapoint_text(
						field_width*i,
						self.graph_height - value*field_height - 6,
						value + min_value
						)

			prev_sum = list(cum_sum)