Changeset 109

Timestamp:

10/27/08 16:49:58 (4 years ago)

Author:

lgs

Message:

Some refactoring and support for negative values in line and bar charts. Inspired by Nicolas patch

Location:

trunk

Files:

• chavier/app.py (modified) (3 diffs)
• chavier/dialogs.py (modified) (1 diff)
• chavier/gui.py (modified) (8 diffs)
• src/bar.py (modified) (10 diffs)
• src/chart.py (modified) (11 diffs)
• src/line.py (modified) (3 diffs)
• src/pie.py (modified) (3 diffs)
• src/scatter.py (modified) (3 diffs)
• tests/bar.py (modified) (5 diffs)
• tests/chart.py (modified) (4 diffs)
• tests/line.py (modified) (2 diffs)

trunk/chavier/app.py

@@ -65 +65 @@
                 tickCount=int,
                 tickPrecision=int,
+                interval=int,
                 range=list,
                 rotate=float,
@@ -103 +104 @@
         shouldFill=bool,
         barWidthFillFraction=float,
-        xOriginIsZero=bool,
-        yOriginIsZero=bool,
         pieRadius=float,
         colorScheme=str,
@@ -127 +126 @@
         chart.addDataset(datasets)
         chart.render()
-        return surface
+        return chart
 
 if __name__ == '__main__':

trunk/chavier/dialogs.py

@@ -133 +133 @@
                                                0, 1, 5, 1, 1000, 10)
         self.min = self._create_spin_button('Minimum y value',
-                                            2, 0.5, 1, 0, 1000, 0)
+                                            2, 0.5, 1, -1000, 1000, 0)
         self.max = self._create_spin_button('Maximum y value',
                                             2, 0.5, 1, 0, 1000, 10)

trunk/chavier/gui.py

@@ -22 +22 @@
 from chavier.dialogs import (
     TextInputDialog, PointDialog, OptionDialog, RandomGeneratorDialog,
-    AboutDialog,
+    AboutDialog, warning
     )
 
@@ -29 +29 @@
         self.app = app
 
+        self.chart = None
         self.surface = None
 
@@ -123 +124 @@
                  '<ctrl>g', 'Generate random points',
                  self.generate_random_points),
+                ('dump-chart-state', gtk.STOCK_CONVERT, '_Dump chart state',
+                 '<ctrl>d', 'Dump internal chart variables',
+                 self.dump_chart_state),
                 ('help', None, '_Help', None, 'Help', None),
                 ('about', gtk.STOCK_ABOUT, None, None, 'About this program',
@@ -168 +172 @@
     <menu action="tools">
       <menuitem action="random-points"/>
+      <menuitem action="dump-chart-state"/>
     </menu>
     <menu action="help">
@@ -357 +362 @@
 
     def drawing_area_expose_event(self, widget, event, data=None):
-        if self.surface is None:
+        if self.chart is None:
             return
 
@@ -364 +369 @@
                      event.area.width, event.area.height)
         cr.clip()
-        cr.set_source_surface(self.surface, 0, 0)
+        cr.set_source_surface(self.chart.surface, 0, 0)
         cr.paint()
 
     def drawing_area_size_allocate_event(self, widget, event, data=None):
-        if self.surface is not None:
+        if self.chart is not None:
             self.refresh()
 
     def on_chart_type_change(self, action, current, data=None):
-        if self.surface is not None:
+        if self.chart is not None:
             self.refresh()
 
@@ -478 +483 @@
             chart_type = self._get_chart_type()
             alloc = self.drawing_area.get_allocation()
-            self.surface = self.app.get_chart(datasets, options, chart_type,
-                                              alloc.width, alloc.height)
+            self.chart = self.app.get_chart(datasets, options, chart_type,
+                                            alloc.width, alloc.height)
             self.drawing_area.queue_draw()
         else:
-            self.surface = None
+            self.chart = None
 
     def generate_random_points(self, action=None):
@@ -500 +505 @@
         dialog.destroy()
 
+    def dump_chart_state(self, action=None):
+        if self.chart is None:
+            return
+
+        alloc = self.drawing_area.get_allocation()
+
+        print 'CHART STATE'
+        print '-' * 70
+        print 'surface: %d x %d' % (alloc.width, alloc.height)
+        print 'area   :', self.chart.area
+        print
+        print 'minxval:', self.chart.minxval
+        print 'maxxval:', self.chart.maxxval
+        print 'xrange :', self.chart.xrange
+        print
+        print 'minyval:', self.chart.minyval
+        print 'maxyval:', self.chart.maxyval
+        print 'yrange :', self.chart.yrange
+
     def about(self, action=None):
         dialog = AboutDialog(self.main_window)

trunk/src/bar.py

@@ -17 +17 @@
 
 from pycha.chart import Chart, uniqueIndices
-from pycha.color import hex2rgb, clamp
+from pycha.color import hex2rgb
 
 class BarChart(Chart):
@@ -28 +28 @@
         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"""
@@ -36 +42 @@
         if len(uniqx) == 1:
             xdelta = 1.0
-            self.xscale = 1.0
-            self.minxval = uniqx[0]
             barWidth = 1.0 * self.options.barWidthFillFraction
             self.barWidthForSet = barWidth / len(stores)
@@ -44 +48 @@
             xdelta = min([abs(uniqx[j] - uniqx[j-1])
                           for j in range(1, len(uniqx))])
-            self.xscale = 1.0 / (self.xrange + 1)
             barWidth = xdelta * self.xscale * self.options.barWidthFillFraction
             self.barWidthForSet = barWidth / len(stores)
@@ -57 +60 @@
 
         def drawBar(bar):
-            cx.set_line_width(self.options.stroke.width)
+            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
@@ -74 +81 @@
                 cx.fill()
 
-            if self.options.shouldFill:
+            if self.options.shouldFill or (not self.options.stroke.hide):
                 cx.rectangle(x, y, w, h)
-                cx.set_source_rgb(*self.options.colorScheme[bar.name])
-                cx.fill_preserve()
 
-            if not self.options.stroke.hide:
-                cx.set_source_rgb(*hex2rgb(self.options.stroke.color))
-                cx.stroke()
+                if self.options.shouldFill:
+                    cx.set_source_rgb(*self.options.colorScheme[bar.name])
+                    cx.fill_preserve()
+    
+                if not self.options.stroke.hide:
+                    cx.set_source_rgb(*hex2rgb(self.options.stroke.color))
+                    cx.stroke()
 
         cx.save()
@@ -93 +102 @@
         """Evaluates measures for vertical bars"""
         super(VerticalBarChart, self)._updateChart()
-
         for i, (name, store) in enumerate(self.datasets):
             for item in store:
                 xval, yval = item
                 x = (((xval - self.minxval) * self.xscale)
-                    + (i * self.barWidthForSet) + self.barMargin)
+                    + self.barMargin + (i * self.barWidthForSet))
                 w = self.barWidthForSet
-                h = (yval - self.minyval) * self.yscale
-                y = 1.0 - h
+                h = abs(yval) * self.yscale
+                if yval > 0:
+                    y = (1.0 - h) - self.area.origin
+                else:
+                    y = 1 - self.area.origin
                 rect = Rect(x, y, w, h, xval, yval, name)
 
@@ -127 +138 @@
                 xval, yval = item
                 y = (((xval - self.minxval) * self.xscale)
-                     + (i * self.barWidthForSet) + self.barMargin)
-                x = 0.0
+                     + self.barMargin  + (i * self.barWidthForSet))
                 h = self.barWidthForSet
-                w = (yval - self.minyval) * self.yscale
+                w = abs(yval) * self.yscale
+                if yval > 0:
+                    x = self.area.origin
+                else:
+                    x = self.area.origin - w
                 rect = Rect(x, y, w, h, xval, yval, name)
 
@@ -153 +167 @@
         return (x, y-2, w+2, h+4)
 
+    def _renderXAxis(self, cx):
+        """Draws the horizontal line representing the X axis"""
+        cx.new_path()
+        cx.move_to(self.area.x, self.area.y + self.area.h)
+        cx.line_to(self.area.x + self.area.w, self.area.y + self.area.h)
+        cx.close_path()
+        cx.stroke()
+
+    def _renderYAxis(self, cx):
+        # draws the vertical line representing the Y axis
+        cx.new_path()
+        cx.move_to(self.area.x + self.area.origin * self.area.w,
+                   self.area.y)
+        cx.line_to(self.area.x + self.area.origin * self.area.w,
+                   self.area.y + self.area.h)
+        cx.close_path()
+        cx.stroke()
 
 class Rect(object):
@@ -161 +192 @@
 
     def __str__(self):
-        return "<pycha.bar.Rect@(%.2f, %.2f) %.2fx%.2f>" % (self.x, self.y,
-                                                            self.w, self.h)
+        return ("<pycha.bar.Rect@(%.2f, %.2f) %.2fx%.2f (%.2f, %.2f) %s>"
+                % (self.x, self.y, self.w, self.h, self.xval, self.yval,
+                   self.name))

trunk/src/chart.py

@@ -139 +139 @@
     def _updateXY(self):
         """Calculates all kinds of metrics for the x and y axis"""
-        stores = self._getDatasetsValues()
+        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 / 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 / self.yrange
 
         # calculate area data
@@ -146 +182 @@
         height = (self.surface.get_height()
                   - self.options.padding.top - self.options.padding.bottom)
+
+        if self.minyval * self.maxyval < 0: # different signs
+            origin = abs(self.minyval) * self.yscale
+        else:
+            origin = 0
+
         self.area = Area(self.options.padding.left,
                          self.options.padding.top,
-                         width, height)
-
-        # gather data for the x axis
-        if self.options.axis.x.range:
-            self.minxval, self.maxxval = self.options.axis.x.range
-            self.xscale = self.maxxval - self.minxval
-        else:
-            xdata = [pair[0] for pair in reduce(lambda a,b: a+b, stores)]
-            if self.options.xOriginIsZero:
-                self.minxval = 0.0
-            else:
-                self.minxval = float(min(xdata))
-            self.maxxval = float(max(xdata))
-
-        self.xrange = self.maxxval - self.minxval
-        if self.xrange == 0:
-            self.xscale = 1.0
-        else:
-            self.xscale = 1 / self.xrange
-
-        # gather data for the y axis
-        if self.options.axis.y.range:
-            self.minyval, self.maxyval = self.options.axis.y.range
-            self.yscale = self.maxyval - self.minyval
-        else:
-            ydata = [pair[1] for pair in reduce(lambda a,b: a+b, stores)]
-            if self.options.yOriginIsZero:
-                self.minyval = 0.0
-            else:
-                self.minyval = float(min(ydata))
-            self.maxyval = float(max(ydata))
-
-        self.yrange = self.maxyval - self.minyval
-        if self.yrange == 0:
-            self.yscale = 1.0
-        else:
-            self.yscale = 1 / self.yrange
+                         width, height, origin)
 
     def _updateChart(self):
@@ -215 +221 @@
             uniqx = range(len(uniqueIndices(stores)) + 1)
             roughSeparation = self.xrange / self.options.axis.x.tickCount
-
             i = j = 0
-            while i + 1 < len(uniqx) and j < self.options.axis.x.tickCount:
-                if (uniqx[i + 1] - self.minxval) >= (j * roughSeparation):
+            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 + 1]))
+                        self.xticks.append((pos, uniqx[i]))
                         j += 1
                 i += 1
@@ -239 +244 @@
                     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))
+            while 0.0 <= pos <= 1.0:
+                self.yticks.append((pos, label))
+                label += interval
+                pos = 1.0 - (self.yscale * (label - self.minyval))
+
         elif self.options.axis.y.tickCount > 0:
             prec = self.options.axis.y.tickPrecision
@@ -263 +277 @@
         if self.options.background.baseColor:
             cx.set_source_rgb(*hex2rgb(self.options.background.baseColor))
-            x, y, w, h = 0, 0, self.area.w, self.area.h
-            w += self.options.padding.left + self.options.padding.right
-            h += self.options.padding.top + self.options.padding.bottom
-            cx.rectangle(x, y, w, h)
-            cx.fill()
+            cx.paint()
 
         if self.options.background.chartColor:
@@ -424 +434 @@
         """Draws the horizontal line representing the X axis"""
         cx.new_path()
-        cx.move_to(self.area.x, self.area.y + self.area.h)
-        cx.line_to(self.area.x + self.area.w, self.area.y + self.area.h)
+        cx.move_to(self.area.x,
+                   self.area.y + self.area.h * (1.0 - self.area.origin))
+        cx.line_to(self.area.x + self.area.w,
+                   self.area.y + self.area.h * (1.0 - self.area.origin))
         cx.close_path()
         cx.stroke()
@@ -567 +579 @@
 class Area(object):
     """Simple rectangle to hold an area coordinates and dimensions"""
-    def __init__(self, x, y, w, h):
+    def __init__(self, x, y, w, h, origin=0.0):
         self.x, self.y, self.w, self.h = x, y, w, h
+        self.origin = origin
 
     def __str__(self):
-        return "<pycha.chart.Area@(%.2f, %.2f) %.2fx%.2f" % (self.x, self.y,
-                                                             self.w, self.h)
+        msg = "<pycha.chart.Area@(%.2f, %.2f) %.2f x %.2f Origin: %.2f>"
+        return  msg % (self.x, self.y, self.w, self.h, self.origin)
 
 class Option(dict):
@@ -594 +607 @@
     axis=Option(
         lineWidth=1.0,
-        lineColor='#000000',
+        lineColor='#0f0000',
         tickSize=3.0,
         labelColor='#666666',
@@ -614 +627 @@
             tickCount=10,
             tickPrecision=1,
+            interval=0,
             range=None,
             rotate=None,
@@ -635 +649 @@
         left=30,
         right=30,
-        top=15,
-        bottom=15,
+        top=30,
+        bottom=30,
     ),
     stroke=Option(
@@ -647 +661 @@
     shouldFill=True,
     barWidthFillFraction=0.75,
-    xOriginIsZero=True,
-    yOriginIsZero=True,
     pieRadius=0.4,
     colorScheme=DEFAULT_COLOR,

trunk/src/line.py

@@ -17 +17 @@
 
 from pycha.chart import Chart
-from pycha.color import hex2rgb, clamp
+from pycha.color import hex2rgb
 
 class LineChart(Chart):
@@ -47 +47 @@
             if self.options.shouldFill:
                 # Go to the (0,0) coordinate to start drawing the area
-                cx.move_to(self.area.x, self.area.y + self.area.h)
+                #cx.move_to(self.area.x, self.area.y + self.area.h)
+                cx.move_to(self.area.x,
+                           self.area.y + (1.0 - self.area.origin) * self.area.h)
 
             for point in self.points:
@@ -65 +67 @@
             if self.options.shouldFill:
                 # Close the path to the start point
-                cx.line_to(lastX * self.area.w + self.area.x,
-                           self.area.h + self.area.y)
-                cx.line_to(self.area.x, self.area.y + self.area.h)
+                y = (1.0 - self.area.origin) * self.area.h + self.area.y
+                cx.line_to(lastX * self.area.w + self.area.x, y)
+                cx.line_to(self.area.x, y)
                 cx.close_path()
             else:

trunk/src/pie.py

@@ -60 +60 @@
         self.xticks = []
         if self.options.axis.x.ticks:
-            lookup = dict([(slice.xval, slice) for slice in self.slices])
+#            lookup = dict([(slice.xval, slice) for slice in self.slices])
+            lookup = dict([(slice.name, slice) for slice in self.slices])
             for tick in self.options.axis.x.ticks:
                 if not isinstance(tick, Option):
@@ -71 +72 @@
         else:
             for slice in self.slices:
-                label = '%s (%.1f%%)' % (slice.xval, slice.fraction * 100)
-                self.xticks.append((slice.xval, label))
+#                label = '%s (%.1f%%)' % (slice.xval, slice.fraction * 100)
+#                self.xticks.append((slice.xval, label))
+                label = '%s (%.1f%%)' % (slice.name, slice.fraction * 100)
+                self.xticks.append((slice.name, label))
 
     def _renderBackground(self, cx):
@@ -130 +133 @@
 
         self.xlabels = []
-        lookup = dict([(slice.xval, slice) for slice in self.slices])
+#        lookup = dict([(slice.xval, slice) for slice in self.slices])
+        lookup = dict([(slice.name, slice) for slice in self.slices])
 
         cx.set_source_rgb(*hex2rgb(self.options.axis.labelColor))

trunk/src/scatter.py

@@ -16 +16 @@
 # along with PyCha.  If not, see <http://www.gnu.org/licenses/>.
 
-from pycha.chart import Chart
-from pycha.color import hex2rgb, clamp
-from pycha.line import Point, LineChart
+from pycha.line import LineChart
 
 class ScatterplotChart(LineChart):
@@ -24 +22 @@
     def _renderChart(self, cx):
         """Renders a scatterplot"""
-        def drawSymbol(point, size=2):
-            ox = point.x * self.area.w + self.area.x
-            oy = point.y * self.area.h + self.area.y
-            cx.move_to(ox-size, oy  )
-            cx.line_to(ox+size, oy  )
-            cx.move_to(ox     , oy-size)
-            cx.line_to(ox     , oy+size)
+        def drawSymbol(point, size=2):
+            ox = point.x * self.area.w + self.area.x
+            oy = point.y * self.area.h + self.area.y
+            cx.move_to(ox-size, oy  )
+            cx.line_to(ox+size, oy  )
+            cx.move_to(ox     , oy-size)
+            cx.line_to(ox     , oy+size)
 
         def preparePath(storeName, size=2):
@@ -42 +40 @@
 
         cx.set_line_width(self.options.stroke.width)
-        # TODO: self.options.stroke.shadow
-        for key in self._getDatasetsKeys():
-            cx.set_source_rgb(*self.options.colorScheme[key])
-            preparePath(key)
-            cx.stroke()
+        # TODO: self.options.stroke.shadow
+        for key in self._getDatasetsKeys():
+            cx.set_source_rgb(*self.options.colorScheme[key])
+            preparePath(key)
+            cx.stroke()
 
         cx.restore()
 
     def _renderLines(self, cx):
-        """We don't need lines in the background"""
-        pass
+        # We don't need lines in the background
+        pass

trunk/tests/bar.py

@@ -62 +62 @@
         surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
         dataset = (
-            ('dataset1', ([0, 3], [1, 4], [2, 2], [3,5], [4,3.5])),
-            ('dataset2', ([0, 2], [1, 3], [2, 1], [3,5], [4,2.5])),
+            ('dataset1', ([0, 3], [1, 4], [2, 2], [3, 5], [4, 3.5])),
+            ('dataset2', ([0, 2], [1, 3], [2, 1], [3, 5], [4, 2.5])),
             )
         ch = pycha.bar.VerticalBarChart(surface)
@@ -69 +69 @@
         ch._updateXY()
         ch._updateChart()
+        self.assertEqual(ch.minxval, 0)
+        self.assertEqual(ch.maxxval, 4)
         self.assertEqual(ch.xrange, 4)
-        self.assertAlmostEqual(ch.xscale, 0.2, 4)
-        self.assertAlmostEqual(ch.yscale, 0.2, 4)
+        self.assertAlmostEqual(ch.xscale, 0.20, 4)
+        self.assertEqual(ch.minyval, 0)
+        self.assertEqual(ch.maxyval, 5)
+        self.assertEqual(ch.yrange, 5)
+        self.assertAlmostEqual(ch.yscale, 0.20, 4)
         self.assertEqual(ch.minxdelta, 1)
         self.assertAlmostEqual(ch.barWidthForSet, 0.075, 4)
         self.assertAlmostEqual(ch.barMargin, 0.025, 4)
 
+        R = pycha.bar.Rect
         bars = (
-            pycha.bar.Rect(0.025, 0.4, 0.075, 0.6, 0, 3, 'dataset1'),
-            pycha.bar.Rect(0.225, 0.2, 0.075, 0.8, 1, 4, 'dataset1'),
-            pycha.bar.Rect(0.425, 0.6, 0.075, 0.4, 2, 2, 'dataset1'),
-            pycha.bar.Rect(0.625, 0.0, 0.075, 1.0, 3, 5, 'dataset1'),
-            pycha.bar.Rect(0.825, 0.3, 0.075, 0.7, 4, 3.5, 'dataset1'),
-
-            pycha.bar.Rect(0.100, 0.6, 0.075, 0.4, 0, 2, 'dataset2'),
-            pycha.bar.Rect(0.300, 0.4, 0.075, 0.6, 1, 3, 'dataset2'),
-            pycha.bar.Rect(0.500, 0.8, 0.075, 0.2, 2, 1, 'dataset2'),
-            pycha.bar.Rect(0.700, 0.0, 0.075, 1.0, 3, 5, 'dataset2'),
-            pycha.bar.Rect(0.900, 0.5, 0.075, 0.5, 4, 2.5, 'dataset2'),
+            R(0.025, 0.400, 0.075, 0.600, 0, 3, 'dataset1'),
+            R(0.225, 0.200, 0.075, 0.800, 1, 4, 'dataset1'),
+            R(0.425, 0.600, 0.075, 0.400, 2, 2, 'dataset1'),
+            R(0.625, 0.000, 0.075, 1.000, 3, 5, 'dataset1'),
+            R(0.825, 0.300, 0.075, 0.700, 4, 3.5, 'dataset1'),
+
+            R(0.100, 0.600, 0.075, 0.400, 0, 2, 'dataset2'),
+            R(0.300, 0.400, 0.075, 0.600, 1, 3, 'dataset2'),
+            R(0.500, 0.800, 0.075, 0.200, 2, 1, 'dataset2'),
+            R(0.700, 0.000, 0.075, 1.000, 3, 5, 'dataset2'),
+            R(0.900, 0.500, 0.075, 0.500, 4, 2.5, 'dataset2'),
             )
 
@@ -100 +106 @@
             self.assertEqual(b1.name, b2.name)
 
-    def test_updateTicks(self):
-        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
-        dataset = (
-            ('dataset1', ([0, 1], [1, 1], [2, 3])),
-            ('dataset2', ([0, 2], [1, 0], [3, 4])),
+    def test_updateChartWithNegatives(self):
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
+        dataset = (
+            ('dataset1', ([0, -3], [1, -1], [2, 3], [3, 5])),
             )
         ch = pycha.bar.VerticalBarChart(surface)
@@ -110 +115 @@
         ch._updateXY()
         ch._updateChart()
-        ch._updateTicks()
-        xticks = [(0.125, 1), (0.375, 2), (0.625, 3)]
-        for i in range(len(xticks)):
-            self.assertAlmostEqual(ch.xticks[i][0], xticks[i][0], 4)
-            self.assertAlmostEqual(ch.xticks[i][1], xticks[i][1], 4)
-
-    def test_shadowRectangle(self):
-        ch = pycha.bar.VerticalBarChart(None)
-        shadow = ch._getShadowRectangle(10, 20, 400, 300)
-        self.assertEqual(shadow, (8, 18, 404, 302))
-
-class HorizontalBarTests(unittest.TestCase):
-
-    def test_updateChart(self):
-        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
-        dataset = (
-            ('dataset1', ([0, 1], [1, 1], [2, 3])),
-            ('dataset2', ([0, 2], [1, 0], [3, 4])),
-            )
-        ch = pycha.bar.HorizontalBarChart(surface)
-        ch.addDataset(dataset)
-        ch._updateXY()
-        ch._updateChart()
+        self.assertEqual(ch.minxval, 0)
+        self.assertEqual(ch.maxxval, 3)
         self.assertEqual(ch.xrange, 3)
         self.assertAlmostEqual(ch.xscale, 0.25, 4)
-        self.assertAlmostEqual(ch.yscale, 0.25, 4)
+        self.assertEqual(ch.minyval, -3)
+        self.assertEqual(ch.maxyval, 5)
+        self.assertEqual(ch.yrange, 8)
+        self.assertAlmostEqual(ch.yscale, 0.125, 4)
+        self.assertAlmostEqual(ch.area.origin, 0.375)
         self.assertEqual(ch.minxdelta, 1)
-        self.assertAlmostEqual(ch.barWidthForSet, 0.09375, 4)
+        self.assertAlmostEqual(ch.barWidthForSet, 0.1875, 4)
         self.assertAlmostEqual(ch.barMargin, 0.03125, 4)
 
+        R = pycha.bar.Rect
         bars = (
-            pycha.bar.Rect(0, 0.03125, 0.25, 0.09375, 0, 1, 'dataset1'),
-            pycha.bar.Rect(0, 0.28125, 0.25, 0.09375, 1, 1, 'dataset1'),
-            pycha.bar.Rect(0, 0.53125, 0.75, 0.09375, 2, 3, 'dataset1'),
-
-            pycha.bar.Rect(0, 0.125, 0.5, 0.09375, 0, 2, 'dataset2'),
-            pycha.bar.Rect(0, 0.375, 0.0, 0.09375, 1, 0, 'dataset2'),
-            pycha.bar.Rect(0, 0.875, 1.0, 0.09375, 3, 4, 'dataset2'),
+            R(0.03125, 0.625, 0.1875, 0.375, 0, -3, 'dataset1'),
+            R(0.28125, 0.625, 0.1875, 0.125, 1, -1, 'dataset1'),
+            R(0.53125, 0.250, 0.1875, 0.375, 2,  3, 'dataset1'),
+            R(0.78125, 0.000, 0.1875, 0.625, 3,  5, 'dataset1'),
             )
 
@@ -166 +152 @@
             ('dataset2', ([0, 2], [1, 0], [3, 4])),
             )
+        ch = pycha.bar.VerticalBarChart(surface)
+        ch.addDataset(dataset)
+        ch._updateXY()
+        ch._updateChart()
+        ch._updateTicks()
+        xticks = [(0.125, 0), (0.375, 1), (0.625, 2)]
+        for i in range(len(xticks)):
+            self.assertAlmostEqual(ch.xticks[i][0], xticks[i][0], 4)
+            self.assertAlmostEqual(ch.xticks[i][1], xticks[i][1], 4)
+
+        yticks = [
+            (1.0, 0.0), (0.9, 0.4), (0.8, 0.8), (0.7, 1.2), (0.6, 1.6),
+            (0.5, 2.0), (0.4, 2.4), (0.3, 2.8), (0.2, 3.2), (0.1, 3.6),
+            (0.0, 4.0)
+            ]
+        for i in range(len(yticks)):
+            self.assertAlmostEqual(ch.yticks[i][0], yticks[i][0], 4)
+            self.assertAlmostEqual(ch.yticks[i][1], yticks[i][1], 4)
+            
+    def test_udpateTicksWithNegatives(self):
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
+        dataset = (
+            ('dataset1', ([0, -2], [1, 1], [2, 3])),
+            )
+        ch = pycha.bar.VerticalBarChart(surface)
+        ch.addDataset(dataset)
+        ch._updateXY()
+        ch._updateChart()
+        ch._updateTicks()
+        xticks = [(0.1667, 0), (0.5000, 1), (0.8333, 2)]
+        for i in range(len(xticks)):
+            self.assertAlmostEqual(ch.xticks[i][0], xticks[i][0], 4)
+            self.assertAlmostEqual(ch.xticks[i][1], xticks[i][1], 4)
+
+        yticks = [
+            (1.0, -2.0), (0.9, -1.5), (0.8, -1.0), (0.7, -0.5), (0.6, 0.0),
+            (0.5, 0.5), (0.4, 1.0), (0.3, 1.5), (0.2, 2.0), (0.1, 2.5),
+            (0.0, 3.0)
+            ]
+        for i in range(len(yticks)):
+            self.assertAlmostEqual(ch.yticks[i][0], yticks[i][0], 4)
+            self.assertAlmostEqual(ch.yticks[i][1], yticks[i][1], 4)
+
+    def test_shadowRectangle(self):
+        ch = pycha.bar.VerticalBarChart(None)
+        shadow = ch._getShadowRectangle(10, 20, 400, 300)
+        self.assertEqual(shadow, (8, 18, 404, 302))
+
+class HorizontalBarTests(unittest.TestCase):
+
+    def test_updateChart(self):
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
+        dataset = (
+            ('dataset1', ([0, 1], [1, 1], [2, 3])),
+            ('dataset2', ([0, 2], [1, 0], [3, 4])),
+            )
         ch = pycha.bar.HorizontalBarChart(surface)
         ch.addDataset(dataset)
         ch._updateXY()
         ch._updateChart()
+        self.assertEqual(ch.xrange, 3)
+        self.assertAlmostEqual(ch.xscale, 0.25, 4)
+        self.assertAlmostEqual(ch.yscale, 0.25, 4)
+        self.assertEqual(ch.minxdelta, 1)
+        self.assertAlmostEqual(ch.barWidthForSet, 0.09375, 4)
+        self.assertAlmostEqual(ch.barMargin, 0.03125, 4)
+
+        bars = (
+            pycha.bar.Rect(0, 0.03125, 0.25, 0.09375, 0, 1, 'dataset1'),
+            pycha.bar.Rect(0, 0.28125, 0.25, 0.09375, 1, 1, 'dataset1'),
+            pycha.bar.Rect(0, 0.53125, 0.75, 0.09375, 2, 3, 'dataset1'),
+
+            pycha.bar.Rect(0, 0.125, 0.5, 0.09375, 0, 2, 'dataset2'),
+            pycha.bar.Rect(0, 0.375, 0.0, 0.09375, 1, 0, 'dataset2'),
+            pycha.bar.Rect(0, 0.875, 1.0, 0.09375, 3, 4, 'dataset2'),
+            )
+
+        for i, bar in enumerate(bars):
+            b1, b2 = ch.bars[i], bar
+            self.assertAlmostEqual(b1.x, b2.x, 4)
+            self.assertAlmostEqual(b1.y, b2.y, 4)
+            self.assertAlmostEqual(b1.w, b2.w, 4)
+            self.assertAlmostEqual(b1.h, b2.h, 4)
+            self.assertEqual(b1.xval, b2.xval)
+            self.assertEqual(b1.yval, b2.yval)
+            self.assertEqual(b1.name, b2.name)
+
+    def test_updateChartWithNegatives(self):
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
+        dataset = (
+            ('dataset1', ([0, -3], [1, -1], [2, 3], [3, 5])),
+            )
+ 
+        ch = pycha.bar.HorizontalBarChart(surface)
+        ch.addDataset(dataset)
+        ch._updateXY()
+        ch._updateChart()
+        self.assertEqual(ch.minxval, 0)
+        self.assertEqual(ch.maxxval, 3)
+        self.assertEqual(ch.xrange, 3)
+        self.assertAlmostEqual(ch.xscale, 0.25, 4)
+        self.assertEqual(ch.minyval, -3)
+        self.assertEqual(ch.maxyval, 5)
+        self.assertEqual(ch.yrange, 8)
+        self.assertAlmostEqual(ch.yscale, 0.125, 4)
+        self.assertAlmostEqual(ch.area.origin, 0.375)
+        self.assertEqual(ch.minxdelta, 1)
+        self.assertAlmostEqual(ch.barWidthForSet, 0.1875, 4)
+        self.assertAlmostEqual(ch.barMargin, 0.03125, 4)
+
+        R = pycha.bar.Rect
+        bars = (
+            R(0.000, 0.03125, 0.375, 0.1875, 0, -3, 'dataset1'),
+            R(0.250, 0.28125, 0.125, 0.1875, 1, -1, 'dataset1'),
+            R(0.375, 0.53125, 0.375, 0.1875, 2, 3, 'dataset1'),
+            R(0.375, 0.78125, 0.625, 0.1875, 3, 5, 'dataset1'),
+            )
+
+        for i, bar in enumerate(bars):
+            b1, b2 = ch.bars[i], bar
+            self.assertAlmostEqual(b1.x, b2.x, 4)
+            self.assertAlmostEqual(b1.y, b2.y, 4)
+            self.assertAlmostEqual(b1.w, b2.w, 4)
+            self.assertAlmostEqual(b1.h, b2.h, 4)
+            self.assertEqual(b1.xval, b2.xval)
+            self.assertEqual(b1.yval, b2.yval)
+            self.assertEqual(b1.name, b2.name)
+
+    def test_updateTicks(self):
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
+        dataset = (
+            ('dataset1', ([0, 1], [1, 1], [2, 3])),
+            ('dataset2', ([0, 2], [1, 0], [3, 4])),
+            )
+        ch = pycha.bar.HorizontalBarChart(surface)
+        ch.addDataset(dataset)
+        ch._updateXY()
+        ch._updateChart()
         ch._updateTicks()
-        yticks = [(0.125, 1), (0.375, 2), (0.625, 3)]
+
+        xticks = [
+            (0.0, 0.0), (0.1, 0.4), (0.2, 0.8), (0.3, 1.2), (0.4, 1.6),
+            (0.5, 2.0), (0.6, 2.4), (0.7, 2.8), (0.8, 3.2), (0.9, 3.6),
+            (1.0, 4.0)
+            ]
+        for i in range(len(xticks)):
+            self.assertAlmostEqual(ch.xticks[i][0], xticks[i][0], 4)
+            self.assertAlmostEqual(ch.xticks[i][1], xticks[i][1], 4)
+
+        yticks = [(0.125, 0), (0.375, 1), (0.625, 2)]
+        for i in range(len(yticks)):
+            self.assertAlmostEqual(ch.yticks[i][0], yticks[i][0], 4)
+            self.assertAlmostEqual(ch.yticks[i][1], yticks[i][1], 4)
+
+    def test_udpateTicksWithNegatives(self):
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
+        dataset = (
+            ('dataset1', ([0, -2], [1, 1], [2, 3])),
+            )
+        ch = pycha.bar.HorizontalBarChart(surface)
+        ch.addDataset(dataset)
+        ch._updateXY()
+        ch._updateChart()
+        ch._updateTicks()
+        xticks = [
+            (0.0, -2.0), (0.1, -1.5), (0.2, -1.0), (0.3, -0.5), (0.4, 0.0),
+            (0.5, 0.5), (0.6, 1.0), (0.7, 1.5), (0.8, 2.0), (0.9, 2.5),
+            (1.0, 3.0)
+            ]
+        for i in range(len(xticks)):
+            self.assertAlmostEqual(ch.xticks[i][0], xticks[i][0], 4)
+            self.assertAlmostEqual(ch.xticks[i][1], xticks[i][1], 4)
+
+        yticks = [(0.1667, 0), (0.5000, 1), (0.8333, 2)]
         for i in range(len(yticks)):
             self.assertAlmostEqual(ch.yticks[i][0], yticks[i][0], 4)

trunk/tests/chart.py

@@ -45 +45 @@
         self.assertEqual(area.w, 100)
         self.assertEqual(area.h, 300)
+        self.assertEqual(area.origin, 0.0)
+        msg = "<pycha.chart.Area@(10.00, 20.00) 100.00 x 300.00 Origin: 0.00>"
+        self.assertEqual(str(area), msg)
 
 class OptionTests(unittest.TestCase):
@@ -164 +167 @@
         self.assertEqual(ch.yscale, 1/4.0)
         
-        # TODO: test with different options (xOriginIsZero, axis.range, ...)
+        # TODO: test with different options (axis.range, ...)
 
     def test_updateTicks(self):
@@ -177 +180 @@
         ch._updateXY()
         ch._updateTicks()
-        xticks = [(0.0, 1), (1/3.0, 2), (2/3.0, 3)]
+        xticks = [(0.0, 0), (1/3.0, 1), (2/3.0, 2)]
         for i in range(len(xticks)):
             self.assertAlmostEqual(ch.xticks[i][0], xticks[i][0], 4)
@@ -189 +192 @@
             self.assertAlmostEqual(ch.yticks[i][1], yticks[i][1], 4)
 
-    def test_updateExplicitTicks(self):
+    def _test_updateExplicitTicks(self):
         """Test for bug #7"""
         surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)

trunk/tests/line.py

@@ -48 +48 @@
         ch._updateXY()
         ch._updateChart()
-                
+
+        self.assertEqual(ch.minxval, 0)
+        self.assertEqual(ch.maxxval, 3)
+        self.assertEqual(ch.xrange, 3)
+        self.assertAlmostEqual(ch.xscale, 1/3.0, 4)
+        self.assertEqual(ch.minyval, 0)
+        self.assertEqual(ch.maxyval, 4)
+        self.assertEqual(ch.yrange, 4)
+        self.assertAlmostEqual(ch.yscale, 0.25, 4)
+
         points = (
             pycha.line.Point(0, 0.75, 0, 1, 'dataset1'),
@@ -65 +74 @@
             self.assertEqual(p1.name, p2.name)
 
+    def test_updateChartWithNegatives(self):
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 500, 500)
+        dataset = (
+            ('dataset1', ([0, 1], [1, -2], [2, 3])),
+            ('dataset2', ([0, 2], [1, 0], [3, -4])),
+            )
+        ch = pycha.line.LineChart(surface)
+        ch.addDataset(dataset)
+        ch._updateXY()
+        ch._updateChart()
+        self.assertEqual(ch.minxval, 0)
+        self.assertEqual(ch.maxxval, 3)
+        self.assertEqual(ch.xrange, 3)
+        self.assertAlmostEqual(ch.xscale, 1/3.0, 4)
+        self.assertEqual(ch.minyval, -4)
+        self.assertEqual(ch.maxyval, 3)
+        self.assertEqual(ch.yrange, 7)
+        self.assertAlmostEqual(ch.yscale, 1/7.0, 4)
+
+        points = (
+            pycha.line.Point(0, 0.2857, 0, 1, 'dataset1'),
+            pycha.line.Point(1/3.0, 0.7143, 1, -2, 'dataset1'),
+            pycha.line.Point(2/3.0, 0.0, 2, 3, 'dataset1'),
+            pycha.line.Point(0, 0.1429, 0, 2, 'dataset2'),
+            pycha.line.Point(1/3.0, 0.4286, 1, 0, 'dataset2'),
+            pycha.line.Point(1, 1.0, 3, -4, 'dataset2'),
+        )
+        for i, point in enumerate(points):
+            p1, p2 = ch.points[i], point
+            self.assertAlmostEqual(p1.x, p2.x, 4)
+            self.assertAlmostEqual(p1.y, p2.y, 4)
+            self.assertAlmostEqual(p1.xval, p2.xval, 4)
+            self.assertAlmostEqual(p1.yval, p2.yval, 4)
+            self.assertEqual(p1.name, p2.name)
+
 def test_suite():
     return unittest.TestSuite((