From 3e0e4421c3097e00b43b5524c11358dce52f01f9 Mon Sep 17 00:00:00 2001 From: Walter Bender Date: Fri, 02 Aug 2013 14:47:24 +0000 Subject: add more user feedback --- diff --git a/ShareStats.py b/ShareStats.py index 2aebad2..3744112 100644 --- a/ShareStats.py +++ b/ShareStats.py @@ -13,33 +13,27 @@ from gi.repository import Gtk from gi.repository import Gdk -from gi.repository import GdkPixbuf -from gi.repository import GObject -import subprocess import os from sugar3 import profile -from sugar3 import env from sugar3.activity import activity from sugar3.activity.widgets import ActivityToolbarButton from sugar3.activity.widgets import StopButton from sugar3.graphics.toolbarbox import ToolbarBox -from sugar3.graphics.toolbarbox import ToolbarButton -from sugar3.graphics.alert import NotifyAlert, Alert -from sugar3.graphics.icon import Icon, CanvasIcon +from sugar3.graphics.alert import NotifyAlert +from sugar3.graphics.icon import CanvasIcon from sugar3.graphics import style from sugar3.graphics.xocolor import XoColor from sugar3.datastore import datastore -from jarabe.model import bundleregistry -from jarabe.model.session import get_session_manager - +from toolbar_utils import separator_factory from journalstats import JournalReader -from toolbar_utils import (button_factory, separator_factory) +import chart as charts + from gettext import gettext as _ import logging @@ -59,6 +53,35 @@ IFACE = SERVICE PATH = '/org/sugarlabs/ShareStats' +class ChartArea(Gtk.DrawingArea): + + def __init__(self, chart): + '''A class for Draw the chart''' + super(ChartArea, self).__init__() + self._chart = chart + self.add_events(Gdk.EventMask.EXPOSURE_MASK | + Gdk.EventMask.VISIBILITY_NOTIFY_MASK) + self.connect('draw', self._draw_cb) + + def _draw_cb(self, widget, context): + alloc = self.get_allocation() + + # White Background: + context.rectangle(0, 0, alloc.width, alloc.height) + context.set_source_rgb(255, 255, 255) + context.fill() + + # Paint the chart: + chart_width = self._chart.width + chart_height = self._chart.height + + cxpos = alloc.width / 2 - chart_width / 2 + cypos = alloc.height / 2 - chart_height / 2 + + context.set_source_surface(self._chart.surface, cxpos, cypos) + context.paint() + + class ShareStats(activity.Activity): ''' Share journal stats ''' @@ -75,6 +98,13 @@ class ShareStats(activity.Activity): self._setup_canvas() self._setup_presence_service() + # Start with the Neighborhood View icon in the center of the screen + self._icon = self._create_icon('#FFFFFF,#000000', + name='zoom-neighborhood') + self._icon.show() + self._vbox.pack_end(self._icon, True, True, 0) + self._vbox.show() + def _setup_canvas(self): ''' Create a canvas ''' sw = Gtk.ScrolledWindow() @@ -83,14 +113,31 @@ class ShareStats(activity.Activity): self.set_canvas(sw) - self.vbox = Gtk.VBox(False, 0) - self.vbox.set_size_request(Gdk.Screen.width(), - Gdk.Screen.height() - style.GRID_CELL_SIZE) - sw.add(self.vbox) - self.vbox.show() - - def _create_buddy_icon(self, color): - return CanvasIcon(icon_name='computer-xo', + self._vbox = Gtk.VBox(False, 0) + self._vbox.set_size_request(Gdk.Screen.width(), + Gdk.Screen.height() - style.GRID_CELL_SIZE) + sw.add(self._vbox) + self._vbox.show() + + def _create_chart(self, data): + chart = charts.Chart(charts.HORIZONTAL_BAR) + + eventbox = Gtk.EventBox() + self.charts_area = ChartArea(chart) + eventbox.modify_bg(Gtk.StateType.NORMAL, _WHITE) + eventbox.add(self.charts_area) + self._vbox.pack_end(eventbox, True, True, 0) + + chart_data = [] + for entry in data: + label = entry[0] + value = len(entry[1]) + chart_data.append((label, float(value))) + logging.debug(chart_data) + chart.data_set(chart_data) + + def _create_icon(self, color, name='computer-xo'): + return CanvasIcon(icon_name=name, xo_color=XoColor(color), pixel_size=style.STANDARD_ICON_SIZE) @@ -100,7 +147,7 @@ class ShareStats(activity.Activity): if self._buddy_count % 5 == 0: self._hboxes.append(Gtk.HBox(False, 0)) self._hboxes[-1].show() - self.vbox.pack_end(self._hboxes[-1], True, False, 0) + self._vbox.pack_end(self._hboxes[-1], True, False, 0) self._buddy_count += 1 @@ -190,7 +237,7 @@ class ShareStats(activity.Activity): self._notify_alert(title=_('Share Stats'), msg='%s %s' % (_('Received journal statistics from'), nick)) - icon = self._create_buddy_icon(colors) + icon = self._create_icon(colors) self._add_buddy_icon(icon, nick) def _setup_presence_service(self): @@ -223,11 +270,14 @@ class ShareStats(activity.Activity): 'NewTube', self._new_tube_cb) _logger.debug('This is my activity: making a tube...') - id = self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].OfferDBusTube( + self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].OfferDBusTube( SERVICE, {}) self._waiting_cursor() + if self._icon in self._vbox: + self._vbox.remove(self._icon) + self._notify_alert(title=_('Share Journal Statistics'), msg=_('Please wait as statistics come in.')) @@ -245,7 +295,7 @@ class ShareStats(activity.Activity): self.tubes_chan = self.shared_activity.telepathy_tubes_chan self.text_chan = self.shared_activity.telepathy_text_chan - self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal(\ + self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal( 'NewTube', self._new_tube_cb) _logger.debug('I am joining an activity: waiting for a tube...') @@ -256,6 +306,9 @@ class ShareStats(activity.Activity): self.waiting = True self._waiting_cursor() + if self._icon in self._vbox: + self._vbox.remove(self._icon) + self._notify_alert(title=_('Share Journal Statistics'), msg=_('Generating statistics... please wait.'), action=self._share_stats) @@ -272,20 +325,21 @@ class ShareStats(activity.Activity): def _new_tube_cb(self, id, initiator, type, service, params, state): ''' Create a new tube. ''' _logger.debug('New tube: ID=%d initator=%d type=%d service=%s ' - 'params=%r state=%d', id, initiator, type, service, - params, state) + 'params=%r state=%d', id, initiator, type, service, + params, state) if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE): if state == telepathy.TUBE_STATE_LOCAL_PENDING: - self.tubes_chan[ \ - telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(id) + self.tubes_chan[ + telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(id) - tube_conn = TubeConnection(self.conn, - self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES], id, \ + tube_conn = TubeConnection( + self.conn, + self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES], id, group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP]) - self.chattube = ChatTube(tube_conn, self.initiating, \ - self.event_received_cb) + self.chattube = ChatTube(tube_conn, self.initiating, + self.event_received_cb) def event_received_cb(self, text): ''' Data is passed as tuples: cmd:text ''' @@ -304,12 +358,13 @@ class ShareStats(activity.Activity): colors = profile.get_color().to_string() self._send_event('S:%s' % (json.dumps([nick, colors, stats]))) self._restore_cursor() + self._create_chart(stats) def _receive_stats(self, data=None): if self.initiating: data_array = json.loads(data) nick = data_array[0] - colors = data_array[1] + colors = data_array[1].encode('ascii', 'replace') stats = data_array[2] self._save_stats(stats, nick=nick, colors=colors) diff --git a/chart.py b/chart.py new file mode 100644 index 0000000..1abc313 --- /dev/null +++ b/chart.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# chart.py by: +# Agustin Zubiaga +# Gonzalo Odiard +# Manuel Quiñones + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +import sugarpycha.bar +import sugarpycha.line +import sugarpycha.pie + +import cairo +from gi.repository import GObject + +# Chart types +VERTICAL_BAR = 1 +HORIZONTAL_BAR = 2 +LINE = 3 +PIE = 4 + + +class Chart(GObject.GObject): + def __init__(self, type=VERTICAL_BAR, width=600, height=460): + GObject.GObject.__init__(self) + + self.dataSet = None + self.options = None + self.surface = None + + self.type = type + self.width = width + self.height = height + + def data_set(self, data): + '''Set chart data (dataSet)''' + + self.dataSet = ( + ('Dots', [(i, l[1]) for i, l in enumerate(data)]), + ) + + self.options = { + 'legend': {'hide': True}, + 'titleFontSize': 16, + 'axis': { + 'tickFontSize': 12, + 'labelFontSize': 14, + 'lineColor': '#b3b3b3', + 'x': { + 'ticks': [dict(v=i, label=l[0]) for i, + l in enumerate(data)], + 'label': 'X', + }, + 'y': { + 'tickCount': 5, + 'label': 'Y', + } + }, + 'stroke': { + 'width': 3 + }, + 'background': { + 'chartColor': '#FFFFFF', + 'lineColor': '#CCCCCC' + }, + 'colorScheme': { + 'name': 'gradient', + 'args': { + 'initialColor': 'blue', + }, + }, + } + + def set_color_scheme(self, color='blue'): + '''Set the chart color scheme''' + self.options['colorScheme']['args'] = {'initialColor': color} + + def set_line_color(self, color='#000000'): + '''Set the chart line color''' + self.options['stroke']['color'] = color + + def set_x_label(self, text='X'): + '''Set the X Label''' + self.options['axis']['x']['label'] = str(text) + + def set_y_label(self, text='Y'): + '''Set the Y Label''' + self.options['axis']['y']['label'] = str(text) + + def set_type(self, type=VERTICAL_BAR): + '''Set chart type (VERTICAL_BAR, HORIZONTAL_BAR, LINE, PIE)''' + self.type = type + + def set_title(self, title='Chart'): + '''Set the chart title''' + self.options['title'] = title + + def render(self, sg=None): + '''Draw the chart + Use the self.surface variable for show the chart''' + self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, + self.width, + self.height) + + if self.type == VERTICAL_BAR: + chart = sugarpycha.bar.VerticalBarChart(self.surface, self.options) + + elif self.type == HORIZONTAL_BAR: + chart = sugarpycha.bar.HorizontalBarChart(self.surface, + self.options) + + elif self.type == LINE: + chart = sugarpycha.line.LineChart(self.surface, self.options) + + elif self.type == PIE: + self.options['legend'] = {'hide': 'False'} + chart = sugarpycha.pie.PieChart(self.surface, self.options) + self.dataSet = [(data[0], + [[0, data[1]]]) for data in sg.chart_data] + + chart.addDataset(self.dataSet) + chart.render() + + def as_png(self, file): + '''Save the chart as png image''' + self.surface.write_to_png(file) diff --git a/sugarpycha/__init__.py b/sugarpycha/__init__.py new file mode 100644 index 0000000..35bba09 --- /dev/null +++ b/sugarpycha/__init__.py @@ -0,0 +1,18 @@ +# Copyright(c) 2007-2010 by Lorenzo Gil Sanchez +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +version = "0.6.1dev" diff --git a/sugarpycha/bar.py b/sugarpycha/bar.py new file mode 100644 index 0000000..fa3698d --- /dev/null +++ b/sugarpycha/bar.py @@ -0,0 +1,318 @@ +# Copyright(c) 2007-2010 by Lorenzo Gil Sanchez +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +from sugarpycha.chart import Chart, uniqueIndices +from sugarpycha.color import hex2rgb +from sugarpycha.utils import safe_unicode + + +class BarChart(Chart): + + def __init__(self, surface=None, options={}, debug=False): + super(BarChart, self).__init__(surface, options, debug) + self.bars = [] + self.minxdelta = 0.0 + self.barWidthForSet = 0.0 + self.barMargin = 0.0 + + def _updateXY(self): + super(BarChart, self)._updateXY() + # each dataset is centered around a line segment. that's why we + # need n + 1 divisions on the x axis + self.xscale = 1 / (self.xrange + 1.0) + + def _updateChart(self): + """Evaluates measures for vertical bars""" + stores = self._getDatasetsValues() + uniqx = uniqueIndices(stores) + + if len(uniqx) == 1: + self.minxdelta = 1.0 + else: + self.minxdelta = min([abs(uniqx[j] - uniqx[j - 1]) + for j in range(1, len(uniqx))]) + + k = self.minxdelta * self.xscale + barWidth = k * self.options.barWidthFillFraction + self.barWidthForSet = barWidth / len(stores) + self.barMargin = k * (1.0 - self.options.barWidthFillFraction) / 2 + + self.bars = [] + + def _renderChart(self, cx): + """Renders a horizontal/vertical bar chart""" + + def drawBar(bar): + stroke_width = self.options.stroke.width + ux, uy = cx.device_to_user_distance(stroke_width, stroke_width) + if ux < uy: + ux = uy + cx.set_line_width(ux) + + # gather bar proportions + x = self.layout.chart.x + self.layout.chart.w * bar.x + y = self.layout.chart.y + self.layout.chart.h * bar.y + w = self.layout.chart.w * bar.w + h = self.layout.chart.h * bar.h + + if (w < 1 or h < 1) and self.options.yvals.skipSmallValues: + return # don't draw when the bar is too small + + if self.options.stroke.shadow: + cx.set_source_rgba(0, 0, 0, 0.15) + rectangle = self._getShadowRectangle(x, y, w, h) + cx.rectangle(*rectangle) + cx.fill() + + if self.options.shouldFill or (not self.options.stroke.hide): + + if self.options.shouldFill: + cx.set_source_rgb(*self.colorScheme[bar.name]) + cx.rectangle(x, y, w, h) + cx.fill() + + if not self.options.stroke.hide: + cx.set_source_rgb(*hex2rgb(self.options.stroke.color)) + cx.rectangle(x, y, w, h) + cx.stroke() + + if bar.yerr: + self._renderError(cx, x, y, w, h, bar.yval, bar.yerr) + + # render yvals above/beside bars + if self.options.yvals.show: + cx.save() + cx.set_font_size(self.options.yvals.fontSize) + cx.set_source_rgb(*hex2rgb(self.options.yvals.fontColor)) + + if callable(self.options.yvals.renderer): + label = safe_unicode(self.options.yvals.renderer(bar), + self.options.encoding) + else: + label = safe_unicode(bar.yval, self.options.encoding) + extents = cx.text_extents(label) + labelW = extents[2] + labelH = extents[3] + + self._renderYVal(cx, label, labelW, labelH, x, y, w, h) + + cx.restore() + + cx.save() + for bar in self.bars: + drawBar(bar) + cx.restore() + + def _renderYVal(self, cx, label, width, height, x, y, w, h): + raise NotImplementedError + + +class VerticalBarChart(BarChart): + + def _updateChart(self): + """Evaluates measures for vertical bars""" + super(VerticalBarChart, self)._updateChart() + for i, (name, store) in enumerate(self.datasets): + for item in store: + if len(item) == 3: + xval, yval, yerr = item + else: + xval, yval = item + + x = (((xval - self.minxval) * self.xscale) + + self.barMargin + (i * self.barWidthForSet)) + w = self.barWidthForSet + h = abs(yval) * self.yscale + if yval > 0: + y = (1.0 - h) - self.origin + else: + y = 1 - self.origin + rect = Rect(x, y, w, h, xval, yval, name) + + if (0.0 <= rect.x <= 1.0) and (0.0 <= rect.y <= 1.0): + self.bars.append(rect) + + def _updateTicks(self): + """Evaluates bar ticks""" + super(BarChart, self)._updateTicks() + offset = (self.minxdelta * self.xscale) / 2 + self.xticks = [(tick[0] + offset, tick[1]) for tick in self.xticks] + + def _getShadowRectangle(self, x, y, w, h): + return (x - 2, y - 2, w + 4, h + 2) + + def _renderYVal(self, cx, label, labelW, labelH, barX, barY, barW, barH): + x = barX + (barW / 2.0) - (labelW / 2.0) + if self.options.yvals.snapToOrigin: + y = barY + barH - 0.5 * labelH + elif self.options.yvals.inside: + y = barY + (1.5 * labelH) + else: + y = barY - 0.5 * labelH + + # if the label doesn't fit below the bar, put it above the bar + if y > (barY + barH): + y = barY - 0.5 * labelH + + cx.move_to(x, y) + cx.show_text(label) + + def _renderError(self, cx, barX, barY, barW, barH, value, error): + center = barX + (barW / 2.0) + errorWidth = max(barW * 0.1, 5.0) + left = center - errorWidth + right = center + errorWidth + errorSize = barH * error / value + top = barY + errorSize + bottom = barY - errorSize + + cx.set_source_rgb(0, 0, 0) + cx.move_to(left, top) + cx.line_to(right, top) + cx.stroke() + cx.move_to(center, top) + cx.line_to(center, bottom) + cx.stroke() + cx.move_to(left, bottom) + cx.line_to(right, bottom) + cx.stroke() + + +class HorizontalBarChart(BarChart): + + def _updateChart(self): + """Evaluates measures for horizontal bars""" + super(HorizontalBarChart, self)._updateChart() + + for i, (name, store) in enumerate(self.datasets): + for item in store: + if len(item) == 3: + xval, yval, yerr = item + else: + xval, yval = item + yerr = 0.0 + + y = (((xval - self.minxval) * self.xscale) + + self.barMargin + (i * self.barWidthForSet)) + h = self.barWidthForSet + w = abs(yval) * self.yscale + if yval > 0: + x = self.origin + else: + x = self.origin - w + rect = Rect(x, y, w, h, xval, yval, name, yerr) + + if (0.0 <= rect.x <= 1.0) and (0.0 <= rect.y <= 1.0): + self.bars.append(rect) + + def _updateTicks(self): + """Evaluates bar ticks""" + super(BarChart, self)._updateTicks() + offset = (self.minxdelta * self.xscale) / 2 + tmp = self.xticks + self.xticks = [(1.0 - tick[0], tick[1]) for tick in self.yticks] + self.yticks = [(tick[0] + offset, tick[1]) for tick in tmp] + + def _renderLines(self, cx): + """Aux function for _renderBackground""" + if self.options.axis.y.showLines and self.yticks: + for tick in self.xticks: + self._renderLine(cx, tick, True) + if self.options.axis.x.showLines and self.xticks: + for tick in self.yticks: + self._renderLine(cx, tick, False) + + def _getShadowRectangle(self, x, y, w, h): + return (x, y - 2, w + 2, h + 4) + + def _renderXAxisLabel(self, cx, labelText): + labelText = self.options.axis.x.label + super(HorizontalBarChart, self)._renderYAxisLabel(cx, labelText) + + def _renderXAxis(self, cx): + """Draws the horizontal line representing the X axis""" + cx.new_path() + cx.move_to(self.layout.chart.x, + self.layout.chart.y + self.layout.chart.h) + cx.line_to(self.layout.chart.x + self.layout.chart.w, + self.layout.chart.y + self.layout.chart.h) + cx.close_path() + cx.stroke() + + def _renderYAxisLabel(self, cx, labelText): + labelText = self.options.axis.y.label + super(HorizontalBarChart, self)._renderXAxisLabel(cx, labelText) + + def _renderYAxis(self, cx): + # draws the vertical line representing the Y axis + cx.new_path() + cx.move_to(self.layout.chart.x + self.origin * self.layout.chart.w, + self.layout.chart.y) + cx.line_to(self.layout.chart.x + self.origin * self.layout.chart.w, + self.layout.chart.y + self.layout.chart.h) + cx.close_path() + cx.stroke() + + def _renderYVal(self, cx, label, labelW, labelH, barX, barY, barW, barH): + y = barY + (barH / 2.0) + (labelH / 2.0) + if self.options.yvals.snapToOrigin: + x = barX + 2 + elif self.options.yvals.inside: + x = barX + barW - (1.2 * labelW) + else: + x = barX + barW + 0.2 * labelW + + # if the label doesn't fit to the left of the bar, put it to the right + if x < barX: + x = barX + barW + 0.2 * labelW + + cx.move_to(x, y) + cx.show_text(label) + + def _renderError(self, cx, barX, barY, barW, barH, value, error): + center = barY + (barH / 2.0) + errorHeight = max(barH * 0.1, 5.0) + top = center + errorHeight + bottom = center - errorHeight + errorSize = barW * error / value + right = barX + barW + errorSize + left = barX + barW - errorSize + + cx.set_source_rgb(0, 0, 0) + cx.move_to(left, top) + cx.line_to(left, bottom) + cx.stroke() + cx.move_to(left, center) + cx.line_to(right, center) + cx.stroke() + cx.move_to(right, top) + cx.line_to(right, bottom) + cx.stroke() + + +class Rect(object): + + def __init__(self, x, y, w, h, xval, yval, name, yerr=0.0): + self.x, self.y, self.w, self.h = x, y, w, h + self.xval, self.yval, self.yerr = xval, yval, yerr + self.name = name + + def __str__(self): + return ("" + % (self.x, self.y, self.w, self.h, + self.xval, self.yval, self.yerr, + self.name)) diff --git a/sugarpycha/chart.py b/sugarpycha/chart.py new file mode 100644 index 0000000..828b9e8 --- /dev/null +++ b/sugarpycha/chart.py @@ -0,0 +1,886 @@ +# Copyright(c) 2007-2010 by Lorenzo Gil Sanchez +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +import copy +import inspect +import math + +import cairo + +from sugarpycha.color import ColorScheme, hex2rgb, DEFAULT_COLOR +from sugarpycha.utils import safe_unicode + + +class Chart(object): + + def __init__(self, surface, options={}, debug=False): + # this flag is useful to reuse this chart for drawing different data + # or use different options + self.resetFlag = False + + # initialize storage + self.datasets = [] + + # computed values used in several methods + self.layout = Layout() + self.minxval = None + self.maxxval = None + self.minyval = None + self.maxyval = None + self.xscale = 1.0 + self.yscale = 1.0 + self.xrange = None + self.yrange = None + self.origin = 0.0 + + self.xticks = [] + self.yticks = [] + + # set the default options + self.options = copy.deepcopy(DEFAULT_OPTIONS) + if options: + self.options.merge(options) + + # initialize the surface + self._initSurface(surface) + + self.colorScheme = None + + # debug mode to draw aditional hints + self.debug = debug + + def addDataset(self, dataset): + """Adds an object containing chart data to the storage hash""" + self.datasets += dataset + + def _getDatasetsKeys(self): + """Return the name of each data set""" + return [d[0] for d in self.datasets] + + def _getDatasetsValues(self): + """Return the data (value) of each data set""" + return [d[1] for d in self.datasets] + + def setOptions(self, options={}): + """Sets options of this chart""" + self.options.merge(options) + + def getSurfaceSize(self): + cx = cairo.Context(self.surface) + x, y, w, h = cx.clip_extents() + return w, h + + def reset(self): + """Resets options and datasets. + + In the next render the surface will be cleaned before any drawing. + """ + self.resetFlag = True + self.options = copy.deepcopy(DEFAULT_OPTIONS) + self.datasets = [] + + def render(self, surface=None, options={}): + """Renders the chart with the specified options. + + The optional parameters can be used to render a chart in a different + surface with new options. + """ + self._update(options) + if surface: + self._initSurface(surface) + + cx = cairo.Context(self.surface) + + # calculate area data + surface_width, surface_height = self.getSurfaceSize() + self.layout.update(cx, self.options, surface_width, surface_height, + self.xticks, self.yticks) + + self._renderBackground(cx) + if self.debug: + self.layout.render(cx) + self._renderChart(cx) + self._renderAxis(cx) + self._renderTitle(cx) + self._renderLegend(cx) + + def clean(self): + """Clears the surface with a white background.""" + cx = cairo.Context(self.surface) + cx.save() + cx.set_source_rgb(1, 1, 1) + cx.paint() + cx.restore() + + def _setColorscheme(self): + """Sets the colorScheme used for the chart using the + options.colorScheme option + """ + name = self.options.colorScheme.name + keys = self._getDatasetsKeys() + colorSchemeClass = ColorScheme.getColorScheme(name, None) + if colorSchemeClass is None: + raise ValueError('Color scheme "%s" is invalid!' % name) + + # Remove invalid args before calling the constructor + kwargs = dict(self.options.colorScheme.args) + validArgs = inspect.getargspec(colorSchemeClass.__init__)[0] + kwargs = dict([(k, v) for k, v in kwargs.items() if k in validArgs]) + self.colorScheme = colorSchemeClass(keys, **kwargs) + + def _initSurface(self, surface): + self.surface = surface + + if self.resetFlag: + self.resetFlag = False + self.clean() + + def _update(self, options={}): + """Update all the information needed to render the chart""" + self.setOptions(options) + self._setColorscheme() + self._updateXY() + self._updateChart() + self._updateTicks() + + def _updateXY(self): + """Calculates all kinds of metrics for the x and y axis""" + x_range_is_defined = self.options.axis.x.range is not None + y_range_is_defined = self.options.axis.y.range is not None + + if not x_range_is_defined or not y_range_is_defined: + stores = self._getDatasetsValues() + + # gather data for the x axis + if x_range_is_defined: + self.minxval, self.maxxval = self.options.axis.x.range + else: + xdata = [pair[0] for pair in reduce(lambda a, b: a + b, stores)] + self.minxval = float(min(xdata)) + self.maxxval = float(max(xdata)) + if self.minxval * self.maxxval > 0 and self.minxval > 0: + self.minxval = 0.0 + + self.xrange = self.maxxval - self.minxval + if self.xrange == 0: + self.xscale = 1.0 + else: + self.xscale = 1.0 / self.xrange + + # gather data for the y axis + if y_range_is_defined: + self.minyval, self.maxyval = self.options.axis.y.range + else: + ydata = [pair[1] for pair in reduce(lambda a, b: a + b, stores)] + self.minyval = float(min(ydata)) + self.maxyval = float(max(ydata)) + if self.minyval * self.maxyval > 0 and self.minyval > 0: + self.minyval = 0.0 + + self.yrange = self.maxyval - self.minyval + if self.yrange == 0: + self.yscale = 1.0 + else: + self.yscale = 1.0 / self.yrange + + if self.minyval * self.maxyval < 0: # different signs + self.origin = abs(self.minyval) * self.yscale + else: + self.origin = 0.0 + + def _updateChart(self): + raise NotImplementedError + + def _updateTicks(self): + """Evaluates ticks for x and y axis. + + You should call _updateXY before because that method computes the + values of xscale, minxval, yscale, and other attributes needed for + this method. + """ + stores = self._getDatasetsValues() + + # evaluate xTicks + self.xticks = [] + if self.options.axis.x.ticks: + for tick in self.options.axis.x.ticks: + if not isinstance(tick, Option): + tick = Option(tick) + if tick.label is None: + label = str(tick.v) + else: + label = tick.label + pos = self.xscale * (tick.v - self.minxval) + if 0.0 <= pos <= 1.0: + self.xticks.append((pos, label)) + + elif self.options.axis.x.interval > 0: + interval = self.options.axis.x.interval + label = (divmod(self.minxval, interval)[0] + 1) * interval + pos = self.xscale * (label - self.minxval) + prec = self.options.axis.x.tickPrecision + while 0.0 <= pos <= 1.0: + pretty_label = round(label, prec) + if prec == 0: + pretty_label = int(pretty_label) + self.xticks.append((pos, pretty_label)) + label += interval + pos = self.xscale * (label - self.minxval) + + elif self.options.axis.x.tickCount > 0: + uniqx = range(len(uniqueIndices(stores)) + 1) + roughSeparation = self.xrange / self.options.axis.x.tickCount + i = j = 0 + while i < len(uniqx) and j < self.options.axis.x.tickCount: + if (uniqx[i] - self.minxval) >= (j * roughSeparation): + pos = self.xscale * (uniqx[i] - self.minxval) + if 0.0 <= pos <= 1.0: + self.xticks.append((pos, uniqx[i])) + j += 1 + i += 1 + + # evaluate yTicks + self.yticks = [] + if self.options.axis.y.ticks: + for tick in self.options.axis.y.ticks: + if not isinstance(tick, Option): + tick = Option(tick) + if tick.label is None: + label = str(tick.v) + else: + label = tick.label + pos = 1.0 - (self.yscale * (tick.v - self.minyval)) + if 0.0 <= pos <= 1.0: + self.yticks.append((pos, label)) + + elif self.options.axis.y.interval > 0: + interval = self.options.axis.y.interval + label = (divmod(self.minyval, interval)[0] + 1) * interval + pos = 1.0 - (self.yscale * (label - self.minyval)) + prec = self.options.axis.y.tickPrecision + while 0.0 <= pos <= 1.0: + pretty_label = round(label, prec) + if prec == 0: + pretty_label = int(pretty_label) + self.yticks.append((pos, pretty_label)) + label += interval + pos = 1.0 - (self.yscale * (label - self.minyval)) + + elif self.options.axis.y.tickCount > 0: + prec = self.options.axis.y.tickPrecision + num = self.yrange / self.options.axis.y.tickCount + if (num < 1 and prec == 0): + roughSeparation = 1 + else: + roughSeparation = round(num, prec) + + for i in range(self.options.axis.y.tickCount + 1): + yval = self.minyval + (i * roughSeparation) + pos = 1.0 - ((yval - self.minyval) * self.yscale) + if 0.0 <= pos <= 1.0: + pretty_label = round(yval, prec) + if prec == 0: + pretty_label = int(pretty_label) + self.yticks.append((pos, pretty_label)) + + def _renderBackground(self, cx): + """Renders the background area of the chart""" + if self.options.background.hide: + return + + cx.save() + + if self.options.background.baseColor: + cx.set_source_rgb(*hex2rgb(self.options.background.baseColor)) + cx.paint() + + if self.options.background.chartColor: + cx.set_source_rgb(*hex2rgb(self.options.background.chartColor)) + surface_width, surface_height = self.getSurfaceSize() + cx.rectangle(self.options.padding.left, self.options.padding.top, + surface_width - (self.options.padding.left + + self.options.padding.right), + surface_height - (self.options.padding.top + + self.options.padding.bottom)) + cx.fill() + + if self.options.background.lineColor: + cx.set_source_rgb(*hex2rgb(self.options.background.lineColor)) + cx.set_line_width(self.options.axis.lineWidth) + self._renderLines(cx) + + cx.restore() + + def _renderLines(self, cx): + """Aux function for _renderBackground""" + if self.options.axis.y.showLines and self.yticks: + for tick in self.yticks: + self._renderLine(cx, tick, False) + if self.options.axis.x.showLines and self.xticks: + for tick in self.xticks: + self._renderLine(cx, tick, True) + + def _renderLine(self, cx, tick, horiz): + """Aux function for _renderLines""" + x1, x2, y1, y2 = (0, 0, 0, 0) + if horiz: + x1 = x2 = tick[0] * self.layout.chart.w + self.layout.chart.x + y1 = self.layout.chart.y + y2 = y1 + self.layout.chart.h + else: + x1 = self.layout.chart.x + x2 = x1 + self.layout.chart.w + y1 = y2 = tick[0] * self.layout.chart.h + self.layout.chart.y + + cx.new_path() + cx.move_to(x1, y1) + cx.line_to(x2, y2) + cx.close_path() + cx.stroke() + + def _renderChart(self, cx): + raise NotImplementedError + + def _renderTick(self, cx, tick, x, y, x2, y2, rotate, text_position): + """Aux method for _renderXTick and _renderYTick""" + if callable(tick): + return + + cx.new_path() + cx.move_to(x, y) + cx.line_to(x2, y2) + cx.close_path() + cx.stroke() + cx.set_source_rgb(*hex2rgb('#000000')) + cx.select_font_face(self.options.axis.tickFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_NORMAL) + cx.set_font_size(self.options.axis.tickFontSize) + + label = safe_unicode(tick[1], self.options.encoding) + xb, yb, width, height, xa, ya = cx.text_extents(label) + + x, y = text_position + + if rotate: + cx.save() + cx.translate(x, y) + cx.rotate(math.radians(rotate)) + x = -width / 2.0 + y = -height / 2.0 + cx.move_to(x - xb, y - yb) + cx.show_text(label) + cx.set_source_rgb(*hex2rgb(self.options.axis.lineColor)) + if self.debug: + cx.rectangle(x, y, width, height) + cx.stroke() + cx.restore() + else: + x -= width / 2.0 + y -= height / 2.0 + cx.move_to(x - xb, y - yb) + cx.show_text(label) + cx.set_source_rgb(*hex2rgb(self.options.axis.lineColor)) + if self.debug: + cx.rectangle(x, y, width, height) + cx.stroke() + + return label + + def _renderYTick(self, cx, tick): + """Aux method for _renderAxis""" + x = self.layout.y_ticks.x + self.layout.y_ticks.w + y = self.layout.y_ticks.y + tick[0] * self.layout.y_ticks.h + + text_position = ((self.layout.y_tick_labels.x + + self.layout.y_tick_labels.w / 2.0 - 5), y) + + return self._renderTick(cx, tick, + x, y, + x - self.options.axis.tickSize, y, + self.options.axis.y.rotate, + text_position) + + def _renderXTick(self, cx, tick): + """Aux method for _renderAxis""" + + x = self.layout.x_ticks.x + tick[0] * self.layout.x_ticks.w + y = self.layout.x_ticks.y + + text_position = (x, (self.layout.x_tick_labels.y + 5 + + self.layout.x_tick_labels.h / 2.0)) + + return self._renderTick(cx, tick, + x, y, + x, y + self.options.axis.tickSize, + self.options.axis.x.rotate, + text_position) + + def _renderAxisLabel(self, cx, label, x, y, vertical=False): + cx.save() + cx.select_font_face(self.options.axis.labelFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_BOLD) + cx.set_font_size(self.options.axis.labelFontSize) + cx.set_source_rgb(*hex2rgb(self.options.axis.labelColor)) + + xb, yb, width, height, xa, ya = cx.text_extents(label) + + if vertical: + y = y + width / 2.0 + cx.move_to(x - xb, y - yb) + cx.translate(x, y) + cx.rotate(-math.radians(90)) + cx.move_to(-xb, -yb) + cx.show_text(label) + if self.debug: + cx.rectangle(0, 0, width, height) + cx.stroke() + else: + x = x - width / 2.0 + cx.move_to(x - xb, y - yb) + cx.show_text(label) + if self.debug: + cx.rectangle(x, y, width, height) + cx.stroke() + cx.restore() + + def _renderYAxisLabel(self, cx, label_text): + label = safe_unicode(label_text, self.options.encoding) + x = self.layout.y_label.x - 10 # tweak to prevent collisions + y = self.layout.y_label.y + self.layout.y_label.h / 2.0 + self._renderAxisLabel(cx, label, x, y, True) + + def _renderYAxis(self, cx): + """Draws the vertical line represeting the Y axis""" + cx.new_path() + cx.move_to(self.layout.chart.x, self.layout.chart.y) + cx.line_to(self.layout.chart.x, + self.layout.chart.y + self.layout.chart.h) + cx.close_path() + cx.stroke() + + def _renderXAxisLabel(self, cx, label_text): + label = safe_unicode(label_text, self.options.encoding) + x = self.layout.x_label.x + self.layout.x_label.w / 2.0 + y = self.layout.x_label.y + 5 # tweak to prevent collisions + self._renderAxisLabel(cx, label, x, y, False) + + def _renderXAxis(self, cx): + """Draws the horizontal line representing the X axis""" + cx.new_path() + y = self.layout.chart.y + (1.0 - self.origin) * self.layout.chart.h + cx.move_to(self.layout.chart.x, y) + cx.line_to(self.layout.chart.x + self.layout.chart.w, y) + cx.close_path() + cx.stroke() + + def _renderAxis(self, cx): + """Renders axis""" + if self.options.axis.x.hide and self.options.axis.y.hide: + return + + cx.save() + cx.set_line_width(self.options.axis.lineWidth) + + if not self.options.axis.y.hide: + if self.yticks: + for tick in self.yticks: + self._renderYTick(cx, tick) + + if self.options.axis.y.label: + self._renderYAxisLabel(cx, self.options.axis.y.label) + + cx.set_source_rgb(*hex2rgb(self.options.axis.lineColor)) + self._renderYAxis(cx) + + if not self.options.axis.x.hide: + if self.xticks: + for tick in self.xticks: + self._renderXTick(cx, tick) + + if self.options.axis.x.label: + self._renderXAxisLabel(cx, self.options.axis.x.label) + + cx.set_source_rgb(*hex2rgb(self.options.axis.lineColor)) + self._renderXAxis(cx) + + cx.restore() + + def _renderTitle(self, cx): + if self.options.title: + cx.save() + cx.select_font_face(self.options.titleFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_BOLD) + cx.set_font_size(self.options.titleFontSize) + cx.set_source_rgb(*hex2rgb(self.options.titleColor)) + + title = safe_unicode(self.options.title, self.options.encoding) + extents = cx.text_extents(title) + title_width = extents[2] + + x = (self.layout.title.x + + self.layout.title.w / 2.0 + - title_width / 2.0) + y = self.layout.title.y - extents[1] - 10 + + cx.move_to(x, y) + cx.show_text(title) + + cx.restore() + + def _renderLegend(self, cx): + """This function adds a legend to the chart""" + if self.options.legend.hide: + return + + surface_width, surface_height = self.getSurfaceSize() + + # Compute legend dimensions + padding = 4 + bullet = 15 + width = 0 + height = padding + keys = self._getDatasetsKeys() + cx.select_font_face(self.options.legend.legendFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_NORMAL) + cx.set_font_size(self.options.legend.legendFontSize) + for key in keys: + key = safe_unicode(key, self.options.encoding) + extents = cx.text_extents(key) + width = max(extents[2], width) + height += max(extents[3], bullet) + padding + width = padding + bullet + padding + width + padding + + # Compute legend position + legend = self.options.legend + if legend.position.right is not None: + legend.position.left = (surface_width + - legend.position.right + - width) + if legend.position.bottom is not None: + legend.position.top = (surface_height + - legend.position.bottom + - height) + + # Draw the legend + cx.save() + cx.rectangle(self.options.legend.position.left, + self.options.legend.position.top, + width, height) + cx.set_source_rgba(1, 1, 1, self.options.legend.opacity) + cx.fill_preserve() + cx.set_line_width(self.options.legend.borderWidth) + cx.set_source_rgb(*hex2rgb(self.options.legend.borderColor)) + cx.stroke() + + def drawKey(key, x, y, text_height): + cx.rectangle(x, y, bullet, bullet) + cx.set_source_rgb(*self.colorScheme[key]) + cx.fill_preserve() + cx.set_source_rgb(0, 0, 0) + cx.stroke() + cx.move_to(x + bullet + padding, + y + bullet / 2.0 + text_height / 2.0) + cx.show_text(key) + + cx.set_line_width(1) + x = self.options.legend.position.left + padding + y = self.options.legend.position.top + padding + for key in keys: + extents = cx.text_extents(key) + drawKey(key, x, y, extents[3]) + y += max(extents[3], bullet) + padding + + cx.restore() + + +def uniqueIndices(arr): + """Return a list with the indexes of the biggest element of arr""" + return range(max([len(a) for a in arr])) + + +class Area(object): + """Simple rectangle to hold an area coordinates and dimensions""" + + def __init__(self, x=0.0, y=0.0, w=0.0, h=0.0): + self.x, self.y, self.w, self.h = x, y, w, h + + def __str__(self): + msg = "" + return msg % (self.x, self.y, self.w, self.h) + + +def get_text_extents(cx, text, font, font_size, encoding): + if text: + cx.save() + cx.select_font_face(font, + cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD) + cx.set_font_size(font_size) + safe_text = safe_unicode(text, encoding) + extents = cx.text_extents(safe_text) + cx.restore() + return extents[2:4] + return (0.0, 0.0) + + +class Layout(object): + """Set of chart areas""" + + def __init__(self): + self.title = Area() + self.x_label = Area() + self.y_label = Area() + self.x_tick_labels = Area() + self.y_tick_labels = Area() + self.x_ticks = Area() + self.y_ticks = Area() + self.chart = Area() + + self._areas = ( + (self.title, (1, 126 / 255.0, 0)), # orange + (self.y_label, (41 / 255.0, 91 / 255.0, 41 / 255.0)), # grey + (self.x_label, (41 / 255.0, 91 / 255.0, 41 / 255.0)), # grey + (self.y_tick_labels, (0, 115 / 255.0, 0)), # green + (self.x_tick_labels, (0, 115 / 255.0, 0)), # green + (self.y_ticks, (229 / 255.0, 241 / 255.0, 18 / 255.0)), # yellow + (self.x_ticks, (229 / 255.0, 241 / 255.0, 18 / 255.0)), # yellow + (self.chart, (75 / 255.0, 75 / 255.0, 1.0)), # blue + ) + + def update(self, cx, options, width, height, xticks, yticks): + self.title.x = options.padding.left + self.title.y = options.padding.top + self.title.w = width - (options.padding.left + options.padding.right) + self.title.h = get_text_extents(cx, + options.title, + options.titleFont, + options.titleFontSize, + options.encoding)[1] + x_axis_label_height = get_text_extents(cx, + options.axis.x.label, + options.axis.labelFont, + options.axis.labelFontSize, + options.encoding)[1] + y_axis_label_width = get_text_extents(cx, + options.axis.y.label, + options.axis.labelFont, + options.axis.labelFontSize, + options.encoding)[1] + + x_axis_tick_labels_height = self._getAxisTickLabelsSize(cx, options, + options.axis.x, + xticks)[1] + y_axis_tick_labels_width = self._getAxisTickLabelsSize(cx, options, + options.axis.y, + yticks)[0] + + self.y_label.x = options.padding.left + self.y_label.y = options.padding.top + self.title.h + self.y_label.w = y_axis_label_width + self.y_label.h = height - (options.padding.bottom + + options.padding.top + + x_axis_label_height + + x_axis_tick_labels_height + + options.axis.tickSize + + self.title.h) + self.x_label.x = (options.padding.left + + y_axis_label_width + + y_axis_tick_labels_width + + options.axis.tickSize) + self.x_label.y = height - (options.padding.bottom + + x_axis_label_height) + self.x_label.w = width - (options.padding.left + + options.padding.right + + options.axis.tickSize + + y_axis_label_width + + y_axis_tick_labels_width) + self.x_label.h = x_axis_label_height + + self.y_tick_labels.x = self.y_label.x + self.y_label.w + self.y_tick_labels.y = self.y_label.y + self.y_tick_labels.w = y_axis_tick_labels_width + self.y_tick_labels.h = self.y_label.h + + self.x_tick_labels.x = self.x_label.x + self.x_tick_labels.y = self.x_label.y - x_axis_tick_labels_height + self.x_tick_labels.w = self.x_label.w + self.x_tick_labels.h = x_axis_tick_labels_height + + self.y_ticks.x = self.y_tick_labels.x + self.y_tick_labels.w + self.y_ticks.y = self.y_tick_labels.y + self.y_ticks.w = options.axis.tickSize + self.y_ticks.h = self.y_label.h + + self.x_ticks.x = self.x_tick_labels.x + self.x_ticks.y = self.x_tick_labels.y - options.axis.tickSize + self.x_ticks.w = self.x_label.w + self.x_ticks.h = options.axis.tickSize + + self.chart.x = self.y_ticks.x + self.y_ticks.w + self.chart.y = self.title.y + self.title.h + self.chart.w = self.x_ticks.w + self.chart.h = self.y_ticks.h + + def render(self, cx): + + def draw_area(area, r, g, b): + cx.rectangle(area.x, area.y, area.w, area.h) + cx.set_source_rgba(r, g, b, 0.5) + cx.fill() + + cx.save() + for area, color in self._areas: + draw_area(area, *color) + cx.restore() + + def _getAxisTickLabelsSize(self, cx, options, axis, ticks): + cx.save() + cx.select_font_face(options.axis.tickFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_NORMAL) + cx.set_font_size(options.axis.tickFontSize) + + max_width = max_height = 0.0 + if not axis.hide: + extents = [cx.text_extents(safe_unicode( + tick[1], options.encoding, + ))[2:4] # get width and height as a tuple + for tick in ticks] + if extents: + widths, heights = zip(*extents) + max_width, max_height = max(widths), max(heights) + if axis.rotate: + radians = math.radians(axis.rotate) + sin = math.sin(radians) + cos = math.cos(radians) + max_width, max_height = ( + max_width * cos + max_height * sin, + max_width * sin + max_height * cos, + ) + cx.restore() + return max_width, max_height + + +class Option(dict): + """Useful dict that allow attribute-like access to its keys""" + + def __getattr__(self, name): + if name in self.keys(): + return self[name] + else: + raise AttributeError(name) + + def merge(self, other): + """Recursive merge with other Option or dict object""" + for key, value in other.items(): + if key in self: + if isinstance(self[key], Option): + self[key].merge(other[key]) + else: + self[key] = other[key] + + +DEFAULT_OPTIONS = Option( + axis=Option( + lineWidth=1.0, + lineColor='#0f0000', + tickSize=3.0, + labelColor='#666666', + labelFont='Tahoma', + labelFontSize=9, + tickFont='Tahoma', + tickFontSize=9, + x=Option( + hide=False, + ticks=None, + tickCount=10, + tickPrecision=1, + range=None, + rotate=None, + label=None, + interval=0, + showLines=False, + ), + y=Option( + hide=False, + ticks=None, + tickCount=10, + tickPrecision=1, + range=None, + rotate=None, + label=None, + interval=0, + showLines=True, + ), + ), + background=Option( + hide=False, + baseColor=None, + chartColor='#f5f5f5', + lineColor='#ffffff', + lineWidth=1.5, + ), + legend=Option( + opacity=0.8, + borderColor='#000000', + borderWidth=2, + hide=False, + legendFont='Tahoma', + legendFontSize=9, + position=Option(top=20, left=40, bottom=None, right=None), + ), + padding=Option( + left=10, + right=10, + top=10, + bottom=10, + ), + stroke=Option( + color='#000000', + hide=False, + shadow=True, + width=1 + ), + yvals=Option( + show=False, + inside=False, + fontSize=11, + fontColor='#000000', + skipSmallValues=True, + snapToOrigin=False, + renderer=None + ), + fillOpacity=1.0, + shouldFill=True, + barWidthFillFraction=0.75, + pieRadius=0.4, + colorScheme=Option( + name='gradient', + args=Option( + initialColor=DEFAULT_COLOR, + colors=None, + ), + ), + title=None, + titleColor='#000000', + titleFont='Tahoma', + titleFontSize=12, + encoding='utf-8', +) diff --git a/sugarpycha/color.py b/sugarpycha/color.py new file mode 100644 index 0000000..fcf0784 --- /dev/null +++ b/sugarpycha/color.py @@ -0,0 +1,204 @@ +# Copyright(c) 2007-2010 by Lorenzo Gil Sanchez +# 2009 by Yaco S.L. +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +import math + +from sugarpycha.utils import clamp + + +DEFAULT_COLOR = '#3c581a' + + +def hex2rgb(hexstring, digits=2): + """Converts a hexstring color to a rgb tuple. + + Example: #ff0000 -> (1.0, 0.0, 0.0) + + digits is an integer number telling how many characters should be + interpreted for each component in the hexstring. + """ + if isinstance(hexstring, (tuple, list)): + return hexstring + + top = float(int(digits * 'f', 16)) + r = int(hexstring[1:digits + 1], 16) + g = int(hexstring[digits + 1:digits * 2 + 1], 16) + b = int(hexstring[digits * 2 + 1:digits * 3 + 1], 16) + return r / top, g / top, b / top + + +def rgb2hsv(r, g, b): + """Converts a RGB color into a HSV one + + See http://en.wikipedia.org/wiki/HSV_color_space + """ + maximum = max(r, g, b) + minimum = min(r, g, b) + if maximum == minimum: + h = 0.0 + elif maximum == r: + h = 60.0 * ((g - b) / (maximum - minimum)) + 360.0 + if h >= 360.0: + h -= 360.0 + elif maximum == g: + h = 60.0 * ((b - r) / (maximum - minimum)) + 120.0 + elif maximum == b: + h = 60.0 * ((r - g) / (maximum - minimum)) + 240.0 + + if maximum == 0.0: + s = 0.0 + else: + s = 1.0 - (minimum / maximum) + + v = maximum + + return h, s, v + + +def hsv2rgb(h, s, v): + """Converts a HSV color into a RGB one + + See http://en.wikipedia.org/wiki/HSV_color_space + """ + hi = int(math.floor(h / 60.0)) % 6 + f = (h / 60.0) - hi + p = v * (1 - s) + q = v * (1 - f * s) + t = v * (1 - (1 - f) * s) + + if hi == 0: + r, g, b = v, t, p + elif hi == 1: + r, g, b = q, v, p + elif hi == 2: + r, g, b = p, v, t + elif hi == 3: + r, g, b = p, q, v + elif hi == 4: + r, g, b = t, p, v + elif hi == 5: + r, g, b = v, p, q + + return r, g, b + + +def lighten(r, g, b, amount): + """Return a lighter version of the color (r, g, b)""" + return (clamp(0.0, 1.0, r + amount), + clamp(0.0, 1.0, g + amount), + clamp(0.0, 1.0, b + amount)) + + +basicColors = dict( + red='#6d1d1d', + green=DEFAULT_COLOR, + blue='#224565', + grey='#444444', + black='#000000', + darkcyan='#305755', + ) + + +class ColorSchemeMetaclass(type): + """This metaclass is used to autoregister all ColorScheme classes""" + + def __new__(mcs, name, bases, dict): + klass = type.__new__(mcs, name, bases, dict) + klass.registerColorScheme() + return klass + + +class ColorScheme(dict): + """A color scheme is a dictionary where the keys match the keys + constructor argument and the values are colors""" + + __metaclass__ = ColorSchemeMetaclass + __registry__ = {} + + def __init__(self, keys): + super(ColorScheme, self).__init__() + + @classmethod + def registerColorScheme(cls): + key = cls.__name__.replace('ColorScheme', '').lower() + if key: + cls.__registry__[key] = cls + + @classmethod + def getColorScheme(cls, name, default=None): + return cls.__registry__.get(name, default) + + +class GradientColorScheme(ColorScheme): + """In this color scheme each color is a lighter version of initialColor. + + This difference is computed based on the number of keys. + + The initialColor is given in a hex string format. + """ + + def __init__(self, keys, initialColor=DEFAULT_COLOR): + super(GradientColorScheme, self).__init__(keys) + if initialColor in basicColors: + initialColor = basicColors[initialColor] + + r, g, b = hex2rgb(initialColor) + light = 1.0 / (len(keys) * 2) + + for i, key in enumerate(keys): + self[key] = lighten(r, g, b, light * i) + + +class FixedColorScheme(ColorScheme): + """In this color scheme fixed colors are used. + + These colors are provided as a list argument in the constructor. + """ + + def __init__(self, keys, colors=[]): + super(FixedColorScheme, self).__init__(keys) + + if len(keys) != len(colors): + raise ValueError("You must provide as many colors as datasets " + "for the fixed color scheme") + + for i, key in enumerate(keys): + self[key] = hex2rgb(colors[i]) + + +class RainbowColorScheme(ColorScheme): + """In this color scheme the rainbow is divided in N pieces + where N is the number of datasets. + + So each dataset gets a color of the rainbow. + """ + + def __init__(self, keys, initialColor=DEFAULT_COLOR): + super(RainbowColorScheme, self).__init__(keys) + if initialColor in basicColors: + initialColor = basicColors[initialColor] + + r, g, b = hex2rgb(initialColor) + h, s, v = rgb2hsv(r, g, b) + + angleDelta = 360.0 / (len(keys) + 1) + for key in keys: + self[key] = hsv2rgb(h, s, v) + h += angleDelta + if h >= 360.0: + h -= 360.0 diff --git a/sugarpycha/line.py b/sugarpycha/line.py new file mode 100644 index 0000000..07be5e6 --- /dev/null +++ b/sugarpycha/line.py @@ -0,0 +1,129 @@ +# Copyright(c) 2007-2010 by Lorenzo Gil Sanchez +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +from sugarpycha.chart import Chart +from sugarpycha.color import hex2rgb + + +class LineChart(Chart): + + def __init__(self, surface=None, options={}, debug=False): + super(LineChart, self).__init__(surface, options, debug) + self.points = [] + + def _updateChart(self): + """Evaluates measures for line charts""" + self.points = [] + + for i, (name, store) in enumerate(self.datasets): + for item in store: + xval, yval = item + x = (xval - self.minxval) * self.xscale + y = 1.0 - (yval - self.minyval) * self.yscale + point = Point(x, y, xval, yval, name) + + if 0.0 <= point.x <= 1.0 and 0.0 <= point.y <= 1.0: + self.points.append(point) + + def _renderChart(self, cx): + """Renders a line chart""" + + def preparePath(storeName): + cx.new_path() + firstPoint = True + lastX = None + if self.options.shouldFill: + # Go to the (0,0) coordinate to start drawing the area + #cx.move_to(self.layout.chart.x, + # self.layout.chart.y + self.layout.chart.h) + offset = (1.0 - self.origin) * self.layout.chart.h + cx.move_to(self.layout.chart.x, self.layout.chart.y + offset) + + for point in self.points: + if point.name == storeName: + if not self.options.shouldFill and firstPoint: + # starts the first point of the line + cx.move_to(point.x * self.layout.chart.w + + self.layout.chart.x, + point.y * self.layout.chart.h + + self.layout.chart.y) + firstPoint = False + continue + cx.line_to(point.x * self.layout.chart.w + + self.layout.chart.x, + point.y * self.layout.chart.h + + self.layout.chart.y) + # we remember the last X coordinate to close the area + # properly. See bug #4 + lastX = point.x + + if self.options.shouldFill: + # Close the path to the start point + y = ((1.0 - self.origin) * self.layout.chart.h + + self.layout.chart.y) + cx.line_to(lastX * self.layout.chart.w + + self.layout.chart.x, y) + cx.line_to(self.layout.chart.x, y) + cx.close_path() + else: + cx.set_source_rgb(*self.colorScheme[storeName]) + cx.stroke() + + cx.save() + cx.set_line_width(self.options.stroke.width) + if self.options.shouldFill: + + def drawLine(storeName): + if self.options.stroke.shadow: + # draw shadow + cx.save() + cx.set_source_rgba(0, 0, 0, 0.15) + cx.translate(2, -2) + preparePath(storeName) + cx.fill() + cx.restore() + + # fill the line + cx.set_source_rgb(*self.colorScheme[storeName]) + preparePath(storeName) + cx.fill() + + if not self.options.stroke.hide: + # draw stroke + cx.set_source_rgb(*hex2rgb(self.options.stroke.color)) + preparePath(storeName) + cx.stroke() + + # draw the lines + for key in self._getDatasetsKeys(): + drawLine(key) + else: + for key in self._getDatasetsKeys(): + preparePath(key) + + cx.restore() + + +class Point(object): + + def __init__(self, x, y, xval, yval, name): + self.x, self.y = x, y + self.xval, self.yval = xval, yval + self.name = name + + def __str__(self): + return "" % (self.x, self.y) diff --git a/sugarpycha/pie.py b/sugarpycha/pie.py new file mode 100644 index 0000000..12544dc --- /dev/null +++ b/sugarpycha/pie.py @@ -0,0 +1,352 @@ +# Copyright(c) 2007-2010 by Lorenzo Gil Sanchez +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +import math + +import cairo + +from sugarpycha.chart import Chart, Option, Layout, Area, get_text_extents +from sugarpycha.color import hex2rgb + + +class PieChart(Chart): + + def __init__(self, surface=None, options={}, debug=False): + super(PieChart, self).__init__(surface, options, debug) + self.slices = [] + self.centerx = 0 + self.centery = 0 + self.layout = PieLayout(self.slices) + + def _updateChart(self): + """Evaluates measures for pie charts""" + slices = [dict(name=key, + value=(i, value[0][1])) + for i, (key, value) in enumerate(self.datasets)] + + s = float(sum([slice['value'][1] for slice in slices])) + + fraction = angle = 0.0 + + del self.slices[:] + for slice in slices: + if slice['value'][1] > 0: + angle += fraction + fraction = slice['value'][1] / s + self.slices.append(Slice(slice['name'], fraction, + slice['value'][0], slice['value'][1], + angle)) + + def _updateTicks(self): + """Evaluates pie ticks""" + self.xticks = [] + if self.options.axis.x.ticks: + lookup = dict([(_slice.xval, _slice) for _slice in self.slices]) + for tick in self.options.axis.x.ticks: + if not isinstance(tick, Option): + tick = Option(tick) + _slice = lookup.get(tick.v, None) + label = tick.label or str(tick.v) + if _slice is not None: + label += ' (%.1f%%)' % (_slice.fraction * 100) + self.xticks.append((tick.v, label)) + else: + for _slice in self.slices: + label = '%s (%.1f%%)' % (_slice.name, _slice.fraction * 100) + self.xticks.append((_slice.xval, label)) + + def _renderLines(self, cx): + """Aux function for _renderBackground""" + # there are no lines in a Pie Chart + + def _renderChart(self, cx): + """Renders a pie chart""" + self.centerx = self.layout.chart.x + self.layout.chart.w * 0.5 + self.centery = self.layout.chart.y + self.layout.chart.h * 0.5 + + cx.set_line_join(cairo.LINE_JOIN_ROUND) + + if self.options.stroke.shadow and False: + cx.save() + cx.set_source_rgba(0, 0, 0, 0.15) + + cx.new_path() + cx.move_to(self.centerx, self.centery) + cx.arc(self.centerx + 1, self.centery + 2, + self.layout.radius + 1, 0, math.pi * 2) + cx.line_to(self.centerx, self.centery) + cx.close_path() + cx.fill() + cx.restore() + + cx.save() + for slice in self.slices: + if slice.isBigEnough(): + cx.set_source_rgb(*self.colorScheme[slice.name]) + if self.options.shouldFill: + slice.draw(cx, self.centerx, self.centery, + self.layout.radius) + cx.fill() + + if not self.options.stroke.hide: + slice.draw(cx, self.centerx, self.centery, + self.layout.radius) + cx.set_line_width(self.options.stroke.width) + cx.set_source_rgb(*hex2rgb(self.options.stroke.color)) + cx.stroke() + + cx.restore() + + if self.debug: + cx.set_source_rgba(1, 0, 0, 0.5) + px = max(cx.device_to_user_distance(1, 1)) + for x, y in self.layout._lines: + cx.arc(x, y, 5 * px, 0, 2 * math.pi) + cx.fill() + cx.new_path() + cx.move_to(self.centerx, self.centery) + cx.line_to(x, y) + cx.stroke() + + def _renderAxis(self, cx): + """Renders the axis for pie charts""" + if self.options.axis.x.hide or not self.xticks: + return + + self.xlabels = [] + + if self.debug: + px = max(cx.device_to_user_distance(1, 1)) + cx.set_source_rgba(0, 0, 1, 0.5) + for x, y, w, h in self.layout.ticks: + cx.rectangle(x, y, w, h) + cx.stroke() + cx.arc(x + w / 2.0, y + h / 2.0, 5 * px, 0, 2 * math.pi) + cx.fill() + cx.arc(x, y, 2 * px, 0, 2 * math.pi) + cx.fill() + + cx.select_font_face(self.options.axis.tickFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_NORMAL) + cx.set_font_size(self.options.axis.tickFontSize) + + cx.set_source_rgb(*hex2rgb(self.options.axis.labelColor)) + + for i, tick in enumerate(self.xticks): + label = tick[1] + x, y, w, h = self.layout.ticks[i] + + xb, yb, width, height, xa, ya = cx.text_extents(label) + + # draw label with text tick[1] + cx.move_to(x - xb, y - yb) + cx.show_text(label) + self.xlabels.append(label) + + +class Slice(object): + + def __init__(self, name, fraction, xval, yval, angle): + self.name = name + self.fraction = fraction + self.xval = xval + self.yval = yval + self.startAngle = 2 * angle * math.pi + self.endAngle = 2 * (angle + fraction) * math.pi + + def __str__(self): + return ("" % + (self.startAngle, self.endAngle, self.fraction)) + + def isBigEnough(self): + return abs(self.startAngle - self.endAngle) > 0.001 + + def draw(self, cx, centerx, centery, radius): + cx.new_path() + cx.move_to(centerx, centery) + cx.arc(centerx, centery, radius, -self.endAngle, -self.startAngle) + cx.close_path() + + def getNormalisedAngle(self): + normalisedAngle = (self.startAngle + self.endAngle) / 2 + + if normalisedAngle > math.pi * 2: + normalisedAngle -= math.pi * 2 + elif normalisedAngle < 0: + normalisedAngle += math.pi * 2 + + return normalisedAngle + + +class PieLayout(Layout): + """Set of chart areas for pie charts""" + + def __init__(self, slices): + self.slices = slices + + self.title = Area() + self.chart = Area() + + self.ticks = [] + self.radius = 0 + + self._areas = ( + (self.title, (1, 126 / 255.0, 0)), # orange + (self.chart, (75 / 255.0, 75 / 255.0, 1.0)), # blue + ) + + self._lines = [] + + def update(self, cx, options, width, height, xticks, yticks): + self.title.x = options.padding.left + self.title.y = options.padding.top + self.title.w = width - (options.padding.left + options.padding.right) + self.title.h = get_text_extents(cx, + options.title, + options.titleFont, + options.titleFontSize, + options.encoding)[1] + + lookup = dict([(slice.xval, slice) for slice in self.slices]) + + self.chart.x = self.title.x + self.chart.y = self.title.y + self.title.h + self.chart.w = self.title.w + self.chart.h = height - self.title.h - (options.padding.top + + options.padding.bottom) + + centerx = self.chart.x + self.chart.w * 0.5 + centery = self.chart.y + self.chart.h * 0.5 + + self.radius = min(self.chart.w / 2.0, self.chart.h / 2.0) + for tick in xticks: + _slice = lookup.get(tick[0], None) + width, height = get_text_extents(cx, tick[1], + options.axis.tickFont, + options.axis.tickFontSize, + options.encoding) + angle = _slice.getNormalisedAngle() + radius = self._get_min_radius(angle, centerx, centery, + width, height) + self.radius = min(self.radius, radius) + + # Now that we now the radius we move the ticks as close as we can + # to the circle + for i, tick in enumerate(xticks): + _slice = lookup.get(tick[0], None) + angle = _slice.getNormalisedAngle() + self.ticks[i] = self._get_tick_position(self.radius, angle, + self.ticks[i], + centerx, centery) + + def _get_min_radius(self, angle, centerx, centery, width, height): + min_radius = None + + # precompute some common values + tan = math.tan(angle) + half_width = width / 2.0 + half_height = height / 2.0 + offset_x = half_width * tan + offset_y = half_height / tan + + def intersect_horizontal_line(y): + return centerx + (centery - y) / tan + + def intersect_vertical_line(x): + return centery - tan * (x - centerx) + + # computes the intersection between the rect that has + # that angle with the X axis and the bounding chart box + if 0.25 * math.pi <= angle < 0.75 * math.pi: + # intersects with the top rect + y = self.chart.y + x = intersect_horizontal_line(y) + self._lines.append((x, y)) + + x1 = x - half_width - offset_y + self.ticks.append((x1, self.chart.y, width, height)) + + min_radius = abs((y + height) - centery) + elif 0.75 * math.pi <= angle < 1.25 * math.pi: + # intersects with the left rect + x = self.chart.x + y = intersect_vertical_line(x) + self._lines.append((x, y)) + + y1 = y - half_height - offset_x + self.ticks.append((x, y1, width, height)) + + min_radius = abs(centerx - (x + width)) + elif 1.25 * math.pi <= angle < 1.75 * math.pi: + # intersects with the bottom rect + y = self.chart.y + self.chart.h + x = intersect_horizontal_line(y) + self._lines.append((x, y)) + + x1 = x - half_width + offset_y + self.ticks.append((x1, y - height, width, height)) + + min_radius = abs((y - height) - centery) + else: + # intersects with the right rect + x = self.chart.x + self.chart.w + y = intersect_vertical_line(x) + self._lines.append((x, y)) + + y1 = y - half_height + offset_x + self.ticks.append((x - width, y1, width, height)) + + min_radius = abs((x - width) - centerx) + + return min_radius + + def _get_tick_position(self, radius, angle, tick, centerx, centery): + text_width, text_height = tick[2:4] + half_width = text_width / 2.0 + half_height = text_height / 2.0 + + if 0 <= angle < 0.5 * math.pi: + # first quadrant + k1 = j1 = k2 = 1 + j2 = -1 + elif 0.5 * math.pi <= angle < math.pi: + # second quadrant + k1 = k2 = -1 + j1 = j2 = 1 + elif math.pi <= angle < 1.5 * math.pi: + # third quadrant + k1 = j1 = k2 = -1 + j2 = 1 + elif 1.5 * math.pi <= angle < 2 * math.pi: + # fourth quadrant + k1 = k2 = 1 + j1 = j2 = -1 + + cx = radius * math.cos(angle) + k1 * half_width + cy = radius * math.sin(angle) + j1 * half_height + + radius2 = math.sqrt(cx * cx + cy * cy) + + tan = math.tan(angle) + x = math.sqrt((radius2 * radius2) / (1 + tan * tan)) + y = tan * x + + x = centerx + k2 * x + y = centery + j2 * y + + return x - half_width, y - half_height, text_width, text_height diff --git a/sugarpycha/polygonal.py b/sugarpycha/polygonal.py new file mode 100644 index 0000000..bb5ced6 --- /dev/null +++ b/sugarpycha/polygonal.py @@ -0,0 +1,372 @@ +# Copyright(c) 2011 by Roberto Garcia Carvajal +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +import math + +import cairo + +from sugarpycha.chart import Chart +from sugarpycha.line import Point +from sugarpycha.color import hex2rgb +from sugarpycha.utils import safe_unicode + + +class PolygonalChart(Chart): + + def __init__(self, surface=None, options={}): + super(PolygonalChart, self).__init__(surface, options) + self.points = [] + + def _updateChart(self): + """Evaluates measures for polygonal charts""" + self.points = [] + + for i, (name, store) in enumerate(self.datasets): + for item in store: + xval, yval = item + x = (xval - self.minxval) * self.xscale + y = 1.0 - (yval - self.minyval) * self.yscale + point = Point(x, y, xval, yval, name) + + if 0.0 <= point.x <= 1.0 and 0.0 <= point.y <= 1.0: + self.points.append(point) + + def _renderBackground(self, cx): + """Renders the background area of the chart""" + if self.options.background.hide: + return + + cx.save() + + if self.options.background.baseColor: + cx.set_source_rgb(*hex2rgb(self.options.background.baseColor)) + cx.paint() + + if self.options.background.chartColor: + cx.set_source_rgb(*hex2rgb(self.options.background.chartColor)) + cx.set_line_width(10.0) + cx.new_path() + init = None + count = len(self.xticks) + for index, tick in enumerate(self.xticks): + ang = math.pi / 2 - index * 2 * math.pi / count + x = (self.layout.chart.x + self.layout.chart.w / 2 + - math.cos(ang) + * min(self.layout.chart.w / 2, self.layout.chart.h / 2)) + y = (self.layout.chart.y + self.layout.chart.h / 2 + - math.sin(ang) + * min(self.layout.chart.w / 2, self.layout.chart.h / 2)) + if init is None: + cx.move_to(x, y) + init = (x, y) + else: + cx.line_to(x, y) + cx.line_to(init[0], init[1]) + cx.close_path() + cx.fill() + + if self.options.background.lineColor: + cx.set_source_rgb(*hex2rgb(self.options.background.lineColor)) + cx.set_line_width(self.options.axis.lineWidth) + self._renderLines(cx) + + cx.restore() + + def _renderLine(self, cx, tick, horiz): + """Aux function for _renderLines""" + + rad = (self.layout.chart.h / 2) * (1 - tick[0]) + cx.new_path() + init = None + count = len(self.xticks) + for index, tick in enumerate(self.xticks): + ang = math.pi / 2 - index * 2 * math.pi / count + x = (self.layout.chart.x + self.layout.chart.w / 2 + - math.cos(ang) * rad) + y = (self.layout.chart.y + self.layout.chart.h / 2 + - math.sin(ang) * rad) + if init is None: + cx.move_to(x, y) + init = (x, y) + else: + cx.line_to(x, y) + cx.line_to(init[0], init[1]) + cx.close_path() + cx.stroke() + + def _renderXAxis(self, cx): + """Draws the horizontal line representing the X axis""" + + count = len(self.xticks) + + centerx = self.layout.chart.x + self.layout.chart.w / 2 + centery = self.layout.chart.y + self.layout.chart.h / 2 + + for i in range(0, count): + offset1 = i * 2 * math.pi / count + offset = math.pi / 2 - offset1 + + rad = self.layout.chart.h / 2 + (r1, r2) = (0, rad + 5) + + x1 = centerx - math.cos(offset) * r1 + x2 = centerx - math.cos(offset) * r2 + y1 = centery - math.sin(offset) * r1 + y2 = centery - math.sin(offset) * r2 + + cx.new_path() + cx.move_to(x1, y1) + cx.line_to(x2, y2) + cx.close_path() + cx.stroke() + + def _renderYTick(self, cx, tick, center): + """Aux method for _renderAxis""" + + i = tick + tick = self.yticks[i] + + count = len(self.yticks) + + if callable(tick): + return + + x = center[0] + y = center[1] - i * (self.layout.chart.h / 2) / count + + cx.new_path() + cx.move_to(x, y) + cx.line_to(x - self.options.axis.tickSize, y) + cx.close_path() + cx.stroke() + + cx.select_font_face(self.options.axis.tickFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_NORMAL) + cx.set_font_size(self.options.axis.tickFontSize) + + label = safe_unicode(tick[1], self.options.encoding) + extents = cx.text_extents(label) + labelWidth = extents[2] + labelHeight = extents[3] + + if self.options.axis.y.rotate: + radians = math.radians(self.options.axis.y.rotate) + cx.move_to(x - self.options.axis.tickSize + - (labelWidth * math.cos(radians)) + - 4, + y + (labelWidth * math.sin(radians)) + + labelHeight / (2.0 / math.cos(radians))) + cx.rotate(-radians) + cx.show_text(label) + cx.rotate(radians) # this is probably faster than a save/restore + else: + cx.move_to(x - self.options.axis.tickSize - labelWidth - 4, + y + labelHeight / 2.0) + cx.rel_move_to(0.0, -labelHeight / 2.0) + cx.show_text(label) + + return label + + def _renderYAxis(self, cx): + """Draws the vertical line for the Y axis""" + + centerx = self.layout.chart.x + self.layout.chart.w / 2 + centery = self.layout.chart.y + self.layout.chart.h / 2 + + offset = math.pi / 2 + + r1 = self.layout.chart.h / 2 + + x1 = centerx - math.cos(offset) * r1 + y1 = centery - math.sin(offset) * r1 + + cx.new_path() + cx.move_to(centerx, centery) + cx.line_to(x1, y1) + cx.close_path() + cx.stroke() + + def _renderAxis(self, cx): + """Renders axis""" + if self.options.axis.x.hide and self.options.axis.y.hide: + return + + cx.save() + cx.set_source_rgb(*hex2rgb(self.options.axis.lineColor)) + cx.set_line_width(self.options.axis.lineWidth) + + centerx = self.layout.chart.x + self.layout.chart.w / 2 + centery = self.layout.chart.y + self.layout.chart.h / 2 + + if not self.options.axis.y.hide: + if self.yticks: + + count = len(self.yticks) + + for i in range(0, count): + self._renderYTick(cx, i, (centerx, centery)) + + if self.options.axis.y.label: + self._renderYAxisLabel(cx, self.options.axis.y.label) + + self._renderYAxis(cx) + + if not self.options.axis.x.hide: + fontAscent = cx.font_extents()[0] + if self.xticks: + + count = len(self.xticks) + + for i in range(0, count): + self._renderXTick(cx, i, fontAscent, (centerx, centery)) + + if self.options.axis.x.label: + self._renderXAxisLabel(cx, self.options.axis.x.label) + + self._renderXAxis(cx) + + cx.restore() + + def _renderXTick(self, cx, i, fontAscent, center): + tick = self.xticks[i] + if callable(tick): + return + + count = len(self.xticks) + cx.select_font_face(self.options.axis.tickFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_NORMAL) + cx.set_font_size(self.options.axis.tickFontSize) + + label = safe_unicode(tick[1], self.options.encoding) + extents = cx.text_extents(label) + labelWidth = extents[2] + labelHeight = extents[3] + + x, y = center + cx.move_to(x, y) + + if self.options.axis.x.rotate: + radians = math.radians(self.options.axis.x.rotate) + cx.move_to(x - (labelHeight * math.cos(radians)), + y + self.options.axis.tickSize + + (labelHeight * math.cos(radians)) + + 4.0) + cx.rotate(radians) + cx.show_text(label) + cx.rotate(-radians) + else: + offset1 = i * 2 * math.pi / count + offset = math.pi / 2 - offset1 + + rad = self.layout.chart.h / 2 + 10 + + x = center[0] - math.cos(offset) * rad + y = center[1] - math.sin(offset) * rad + + cx.move_to(x, y) + cx.rotate(offset - math.pi / 2) + + if math.sin(offset) < 0.0: + cx.rotate(math.pi) + cx.rel_move_to(0.0, 5.0) + + cx.rel_move_to(-labelWidth / 2.0, 0) + cx.show_text(label) + if math.sin(offset) < 0.0: + cx.rotate(-math.pi) + + cx.rotate(-(offset - math.pi / 2)) + return label + + def _renderChart(self, cx): + """Renders a polygonal chart""" + # draw the polygon. + def preparePath(storeName): + cx.new_path() + firstPoint = True + + count = len(self.points) / len(self.datasets) + centerx = self.layout.chart.x + self.layout.chart.w / 2 + centery = self.layout.chart.y + self.layout.chart.h / 2 + + firstPointCoord = None + + for index, point in enumerate(self.points): + if point.name == storeName: + offset1 = index * 2 * math.pi / count + offset = math.pi / 2 - offset1 + + rad = (self.layout.chart.h / 2) * (1 - point.y) + + x = centerx - math.cos(offset) * rad + y = centery - math.sin(offset) * rad + + if firstPointCoord is None: + firstPointCoord = (x, y) + + if not self.options.shouldFill and firstPoint: + # starts the first point of the line + cx.move_to(x, y) + firstPoint = False + continue + cx.line_to(x, y) + + if not firstPointCoord is None: + cx.line_to(firstPointCoord[0], firstPointCoord[1]) + + if self.options.shouldFill: + # Close the path to the start point + y = ((1.0 - self.origin) + * self.layout.chart.h + self.layout.chart.y) + else: + cx.set_source_rgb(*self.colorScheme[storeName]) + cx.stroke() + + cx.save() + cx.set_line_width(self.options.stroke.width) + if self.options.shouldFill: + + def drawLine(storeName): + if self.options.stroke.shadow: + # draw shadow + cx.save() + cx.set_source_rgba(0, 0, 0, 0.15) + cx.translate(2, -2) + preparePath(storeName) + cx.fill() + cx.restore() + + # fill the line + cx.set_source_rgb(*self.colorScheme[storeName]) + preparePath(storeName) + cx.fill() + + if not self.options.stroke.hide: + # draw stroke + cx.set_source_rgb(*hex2rgb(self.options.stroke.color)) + preparePath(storeName) + cx.stroke() + + # draw the lines + for key in self._getDatasetsKeys(): + drawLine(key) + else: + for key in self._getDatasetsKeys(): + preparePath(key) + cx.restore() diff --git a/sugarpycha/radial.py b/sugarpycha/radial.py new file mode 100644 index 0000000..8bbd1f9 --- /dev/null +++ b/sugarpycha/radial.py @@ -0,0 +1,346 @@ +# Copyright(c) 2011 by Roberto Garcia Carvajal +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +import math + +import cairo + +from sugarpycha.chart import Chart +from sugarpycha.line import Point +from sugarpycha.color import hex2rgb +from sugarpycha.utils import safe_unicode + + +class RadialChart(Chart): + + def __init__(self, surface=None, options={}): + super(RadialChart, self).__init__(surface, options) + self.points = [] + + def _updateChart(self): + """Evaluates measures for radial charts""" + self.points = [] + + for i, (name, store) in enumerate(self.datasets): + for item in store: + xval, yval = item + x = (xval - self.minxval) * self.xscale + y = 1.0 - (yval - self.minyval) * self.yscale + point = Point(x, y, xval, yval, name) + + if 0.0 <= point.x <= 1.0 and 0.0 <= point.y <= 1.0: + self.points.append(point) + + def _renderBackground(self, cx): + """Renders the background area of the chart""" + if self.options.background.hide: + return + + cx.save() + + if self.options.background.baseColor: + cx.set_source_rgb(*hex2rgb(self.options.background.baseColor)) + cx.paint() + + if self.options.background.chartColor: + cx.set_source_rgb(*hex2rgb(self.options.background.chartColor)) + cx.set_line_width(10.0) + cx.arc(self.layout.chart.x + self.layout.chart.w / 2, + self.layout.chart.y + self.layout.chart.h / 2, + min(self.layout.chart.w / 2, self.layout.chart.h / 2), + 0, 2 * math.pi) + cx.fill() + + if self.options.background.lineColor: + cx.set_source_rgb(*hex2rgb(self.options.background.lineColor)) + cx.set_line_width(self.options.axis.lineWidth) + self._renderLines(cx) + + cx.restore() + + def _renderLine(self, cx, tick, horiz): + """Aux function for _renderLines""" + + rad = (self.layout.chart.h / 2) * (1 - tick[0]) + cx.arc(self.layout.chart.x + self.layout.chart.w / 2, + self.layout.chart.y + self.layout.chart.h / 2, + rad, 0, 2 * math.pi) + cx.stroke() + + def _renderXAxis(self, cx): + """Draws the horizontal line representing the X axis""" + + count = len(self.xticks) + + centerx = self.layout.chart.x + self.layout.chart.w / 2 + centery = self.layout.chart.y + self.layout.chart.h / 2 + + for i in range(0, count): + offset1 = i * 2 * math.pi / count + offset = math.pi / 2 - offset1 + + rad = self.layout.chart.h / 2 + (r1, r2) = (0, rad + 5) + + x1 = centerx - math.cos(offset) * r1 + x2 = centerx - math.cos(offset) * r2 + y1 = centery - math.sin(offset) * r1 + y2 = centery - math.sin(offset) * r2 + + cx.new_path() + cx.move_to(x1, y1) + cx.line_to(x2, y2) + cx.close_path() + cx.stroke() + + def _renderYTick(self, cx, tick, center): + """Aux method for _renderAxis""" + + i = tick + tick = self.yticks[i] + + count = len(self.yticks) + + if callable(tick): + return + + x = center[0] + y = center[1] - i * (self.layout.chart.h / 2) / count + + cx.new_path() + cx.move_to(x, y) + cx.line_to(x - self.options.axis.tickSize, y) + cx.close_path() + cx.stroke() + + cx.select_font_face(self.options.axis.tickFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_NORMAL) + cx.set_font_size(self.options.axis.tickFontSize) + + label = safe_unicode(tick[1], self.options.encoding) + extents = cx.text_extents(label) + labelWidth = extents[2] + labelHeight = extents[3] + + if self.options.axis.y.rotate: + radians = math.radians(self.options.axis.y.rotate) + cx.move_to(x - self.options.axis.tickSize + - (labelWidth * math.cos(radians)) + - 4, + y + (labelWidth * math.sin(radians)) + + labelHeight / (2.0 / math.cos(radians))) + cx.rotate(-radians) + cx.show_text(label) + cx.rotate(radians) # this is probably faster than a save/restore + else: + cx.move_to(x - self.options.axis.tickSize - labelWidth - 4, + y + labelHeight / 2.0) + cx.rel_move_to(0.0, -labelHeight / 2.0) + cx.show_text(label) + + return label + + def _renderYAxis(self, cx): + """Draws the vertical line for the Y axis""" + + centerx = self.layout.chart.x + self.layout.chart.w / 2 + centery = self.layout.chart.y + self.layout.chart.h / 2 + + offset = math.pi / 2 + + r1 = self.layout.chart.h / 2 + + x1 = centerx - math.cos(offset) * r1 + y1 = centery - math.sin(offset) * r1 + + cx.new_path() + cx.move_to(centerx, centery) + cx.line_to(x1, y1) + cx.close_path() + cx.stroke() + + def _renderAxis(self, cx): + """Renders axis""" + if self.options.axis.x.hide and self.options.axis.y.hide: + return + + cx.save() + cx.set_source_rgb(*hex2rgb(self.options.axis.lineColor)) + cx.set_line_width(self.options.axis.lineWidth) + + centerx = self.layout.chart.x + self.layout.chart.w / 2 + centery = self.layout.chart.y + self.layout.chart.h / 2 + + if not self.options.axis.y.hide: + if self.yticks: + + count = len(self.yticks) + + for i in range(0, count): + self._renderYTick(cx, i, (centerx, centery)) + + if self.options.axis.y.label: + self._renderYAxisLabel(cx, self.options.axis.y.label) + + self._renderYAxis(cx) + + if not self.options.axis.x.hide: + fontAscent = cx.font_extents()[0] + if self.xticks: + + count = len(self.xticks) + + for i in range(0, count): + self._renderXTick(cx, i, fontAscent, (centerx, centery)) + + if self.options.axis.x.label: + self._renderXAxisLabel(cx, self.options.axis.x.label) + + self._renderXAxis(cx) + + cx.restore() + + def _renderXTick(self, cx, i, fontAscent, center): + tick = self.xticks[i] + if callable(tick): + return + + count = len(self.xticks) + cx.select_font_face(self.options.axis.tickFont, + cairo.FONT_SLANT_NORMAL, + cairo.FONT_WEIGHT_NORMAL) + cx.set_font_size(self.options.axis.tickFontSize) + + label = safe_unicode(tick[1], self.options.encoding) + extents = cx.text_extents(label) + labelWidth = extents[2] + labelHeight = extents[3] + + x, y = center + cx.move_to(x, y) + + if self.options.axis.x.rotate: + radians = math.radians(self.options.axis.x.rotate) + cx.move_to(x - (labelHeight * math.cos(radians)), + y + self.options.axis.tickSize + + (labelHeight * math.cos(radians)) + + 4.0) + cx.rotate(radians) + cx.show_text(label) + cx.rotate(-radians) + else: + offset1 = i * 2 * math.pi / count + offset = math.pi / 2 - offset1 + + rad = self.layout.chart.h / 2 + 10 + + x = center[0] - math.cos(offset) * rad + y = center[1] - math.sin(offset) * rad + + cx.move_to(x, y) + cx.rotate(offset - math.pi / 2) + + if math.sin(offset) < 0.0: + cx.rotate(math.pi) + cx.rel_move_to(0.0, 5.0) + + cx.rel_move_to(-labelWidth / 2.0, 0) + cx.show_text(label) + if math.sin(offset) < 0.0: + cx.rotate(-math.pi) + + cx.rotate(-(offset - math.pi / 2)) + return label + + def _renderChart(self, cx): + """Renders a line chart""" + + # draw the circle + def preparePath(storeName): + cx.new_path() + firstPoint = True + + count = len(self.points) / len(self.datasets) + centerx = self.layout.chart.x + self.layout.chart.w / 2 + centery = self.layout.chart.y + self.layout.chart.h / 2 + + firstPointCoord = None + + for index, point in enumerate(self.points): + if point.name == storeName: + offset1 = index * 2 * math.pi / count + offset = math.pi / 2 - offset1 + + rad = (self.layout.chart.h / 2) * (1 - point.y) + + x = centerx - math.cos(offset) * rad + y = centery - math.sin(offset) * rad + + if firstPointCoord is None: + firstPointCoord = (x, y) + + if not self.options.shouldFill and firstPoint: + # starts the first point of the line + cx.move_to(x, y) + firstPoint = False + continue + cx.line_to(x, y) + + if not firstPointCoord is None: + cx.line_to(firstPointCoord[0], firstPointCoord[1]) + + if self.options.shouldFill: + # Close the path to the start point + y = ((1.0 - self.origin) + * self.layout.chart.h + self.layout.chart.y) + else: + cx.set_source_rgb(*self.colorScheme[storeName]) + cx.stroke() + + cx.save() + cx.set_line_width(self.options.stroke.width) + if self.options.shouldFill: + + def drawLine(storeName): + if self.options.stroke.shadow: + # draw shadow + cx.save() + cx.set_source_rgba(0, 0, 0, 0.15) + cx.translate(2, -2) + preparePath(storeName) + cx.fill() + cx.restore() + + # fill the line + cx.set_source_rgb(*self.colorScheme[storeName]) + preparePath(storeName) + cx.fill() + + if not self.options.stroke.hide: + # draw stroke + cx.set_source_rgb(*hex2rgb(self.options.stroke.color)) + preparePath(storeName) + cx.stroke() + + # draw the lines + for key in self._getDatasetsKeys(): + drawLine(key) + else: + for key in self._getDatasetsKeys(): + preparePath(key) + cx.restore() diff --git a/sugarpycha/scatter.py b/sugarpycha/scatter.py new file mode 100644 index 0000000..001e786 --- /dev/null +++ b/sugarpycha/scatter.py @@ -0,0 +1,38 @@ +# Copyright(c) 2007-2010 by Lorenzo Gil Sanchez +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +import math + +from sugarpycha.line import LineChart + + +class ScatterplotChart(LineChart): + + def _renderChart(self, cx): + """Renders a scatterplot""" + + def drawSymbol(point, size): + ox = point.x * self.layout.chart.w + self.layout.chart.x + oy = point.y * self.layout.chart.h + self.layout.chart.y + cx.arc(ox, oy, size, 0.0, 2 * math.pi) + cx.fill() + + for key in self._getDatasetsKeys(): + cx.set_source_rgb(*self.colorScheme[key]) + for point in self.points: + if point.name == key: + drawSymbol(point, self.options.stroke.width) diff --git a/sugarpycha/stackedbar.py b/sugarpycha/stackedbar.py new file mode 100644 index 0000000..3daf6e3 --- /dev/null +++ b/sugarpycha/stackedbar.py @@ -0,0 +1,121 @@ +# Copyright(c) 2009 by Yaco S.L. +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + +from sugarpycha.bar import BarChart, VerticalBarChart, HorizontalBarChart, Rect +from sugarpycha.chart import uniqueIndices + + +class StackedBarChart(BarChart): + + def __init__(self, surface=None, options={}, debug=False): + super(StackedBarChart, self).__init__(surface, options, debug) + self.barWidth = 0.0 + + def _updateXY(self): + super(StackedBarChart, self)._updateXY() + # each dataset is centered around a line segment. that's why we + # need n + 1 divisions on the x axis + self.xscale = 1 / (self.xrange + 1.0) + + if self.options.axis.y.range is None: + # Fix the yscale as we accumulate the y values + stores = self._getDatasetsValues() + n_stores = len(stores) + flat_y = [pair[1] for pair in reduce(lambda a, b: a + b, stores)] + store_size = len(flat_y) / n_stores + accum = [sum(flat_y[j]for j in xrange(i, + i + store_size * n_stores, + store_size)) + for i in range(len(flat_y) / n_stores)] + self.yrange = float(max(accum)) + if self.yrange == 0: + self.yscale = 1.0 + else: + self.yscale = 1.0 / self.yrange + + def _updateChart(self): + """Evaluates measures for vertical bars""" + stores = self._getDatasetsValues() + uniqx = uniqueIndices(stores) + + if len(uniqx) == 1: + self.minxdelta = 1.0 + else: + self.minxdelta = min([abs(uniqx[j] - uniqx[j - 1]) + for j in range(1, len(uniqx))]) + + k = self.minxdelta * self.xscale + self.barWidth = k * self.options.barWidthFillFraction + self.barMargin = k * (1.0 - self.options.barWidthFillFraction) / 2 + + self.bars = [] + + +class StackedVerticalBarChart(StackedBarChart, VerticalBarChart): + + def _updateChart(self): + """Evaluates measures for vertical bars""" + super(StackedVerticalBarChart, self)._updateChart() + + accumulated_heights = {} + for i, (name, store) in enumerate(self.datasets): + for item in store: + xval, yval = item + x = ((xval - self.minxval) * self.xscale) + self.barMargin + w = self.barWidth + h = abs(yval) * self.yscale + if yval > 0: + y = (1.0 - h) - self.origin + else: + y = 1 - self.origin + + accumulated_height = accumulated_heights.setdefault(xval, 0) + y -= accumulated_height + accumulated_heights[xval] += h + + rect = Rect(x, y, w, h, xval, yval, name) + + if (0.0 <= rect.x <= 1.0) and (0.0 <= rect.y <= 1.0): + self.bars.append(rect) + + +class StackedHorizontalBarChart(StackedBarChart, HorizontalBarChart): + + def _updateChart(self): + """Evaluates measures for horizontal bars""" + super(StackedHorizontalBarChart, self)._updateChart() + + accumulated_widths = {} + for i, (name, store) in enumerate(self.datasets): + for item in store: + xval, yval = item + y = ((xval - self.minxval) * self.xscale) + self.barMargin + h = self.barWidth + w = abs(yval) * self.yscale + if yval > 0: + x = self.origin + else: + x = self.origin - w + + accumulated_width = accumulated_widths.setdefault(xval, 0) + x += accumulated_width + accumulated_widths[xval] += w + + rect = Rect(x, y, w, h, xval, yval, name) + + if (0.0 <= rect.x <= 1.0) and (0.0 <= rect.y <= 1.0): + self.bars.append(rect) diff --git a/sugarpycha/utils.py b/sugarpycha/utils.py new file mode 100644 index 0000000..9e1b692 --- /dev/null +++ b/sugarpycha/utils.py @@ -0,0 +1,40 @@ +# Copyright(c) 2007-2010 by Lorenzo Gil Sanchez +# 2009-2010 by Yaco S.L. +# +# This file is part of PyCha. +# +# PyCha is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# PyCha is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with PyCha. If not, see . + + +def clamp(minValue, maxValue, value): + """Make sure value is between minValue and maxValue""" + if value < minValue: + return minValue + if value > maxValue: + return maxValue + return value + + +def safe_unicode(obj, encoding=None): + """Return a unicode value from the argument""" + if isinstance(obj, unicode): + return obj + elif isinstance(obj, str): + if encoding is None: + return unicode(obj) + else: + return unicode(obj, encoding) + else: + # it may be an int or a float + return unicode(obj) -- cgit v0.9.1