wxplotcanvas.py

Wxpython Implemented on Windows CE, Source code

"""
This is a port of Konrad Hinsen's tkPlotCanvas.py plotting module.
After thinking long and hard I came up with the name "wxPlotCanvas.py".

This file contains two parts; first the re-usable library stuff, then, after
a "if __name__=='__main__'" test, a simple frame and a few default plots
for testing.

Harm van der Heijden, feb 1999

Original comment follows below:
# This module defines a plot widget for Tk user interfaces.
# It supports only elementary line plots at the moment.
# See the example at the end for documentation...
#
# Written by Konrad Hinsen <[e-mail]>
# With contributions from RajGopal Srinivasan <[e-mail]>
# Last revision: 1998-7-28
#
"""
# 12/13/2003 - Jeff Grimmett ([e-mail])
#
# o Updated for V2.5 compatability
# o wx.SpinCtl has some issues that cause the control to
#   lock up. Noted in other places using it too, it's not this module
#   that's at fault.
# o Added deprecation warning.
# 

import  warnings
import  wx

warningmsg = r"""\

THIS MODULE IS NOW DEPRECATED

This module has been replaced by wxPyPlot, which in wxPython
can be found in wx.lib.plot.py.

"""

warnings.warn(warningmsg, DeprecationWarning, stacklevel=2)

# Not everybody will have Numeric, so let's be cool about it...
try:
    import Numeric
except:
    # bummer!
    msg = """This module requires the Numeric module, which could not be
imported.  It probably is not installed (it's not part of the standard
Python distribution). See the Python site (http://www.python.org) for
information on downloading source or binaries."""

    print msg
    if wx.Platform == '__WXMSW__' and wx.GetApp() is not None:
        d = wx.MessageDialog(None, msg, "Numeric not found")
        if d.ShowModal() == wx.ID_CANCEL:
            d = wx.MessageDialog(None, "I kid you not! Pressing Cancel won't help you!", "Not a joke", wx.OK)
            d.ShowModal()
    raise

#
# Plotting classes...
#
class PolyPoints:

    def __init__(self, points, attr):
        self.points = Numeric.array(points)
        self.scaled = self.points
        self.attributes = {}
        for name, value in self._attributes.items():
            try:
                value = attr[name]
            except KeyError: pass
            self.attributes[name] = value

    def boundingBox(self):
        return Numeric.minimum.reduce(self.points), \
               Numeric.maximum.reduce(self.points)

    def scaleAndShift(self, scale=1, shift=0):
        self.scaled = scale*self.points+shift


class PolyLine(PolyPoints):

    def __init__(self, points, **attr):
        PolyPoints.__init__(self, points, attr)

    _attributes = {'color': 'black',
                   'width': 1}

    def draw(self, dc):
        color = self.attributes['color']
        width = self.attributes['width']
        arguments = []
        dc.SetPen(wx.Pen(wx.NamedColour(color), width))
        dc.DrawLines(map(tuple,self.scaled))


class PolyMarker(PolyPoints):

    def __init__(self, points, **attr):

        PolyPoints.__init__(self, points, attr)

    _attributes = {'color': 'black',
                   'width': 1,
                   'fillcolor': None,
                   'size': 2,
                   'fillstyle': wx.SOLID,
                   'outline': 'black',
                   'marker': 'circle'}

    def draw(self, dc):
        color = self.attributes['color']
        width = self.attributes['width']
        size = self.attributes['size']
        fillcolor = self.attributes['fillcolor']
        fillstyle = self.attributes['fillstyle']
        marker = self.attributes['marker']

        dc.SetPen(wx.Pen(wx.NamedColour(color),width))
        if fillcolor:
            dc.SetBrush(wx.Brush(wx.NamedColour(fillcolor),fillstyle))
        else:
            dc.SetBrush(wx.Brush(wx.NamedColour('black'), wx.TRANSPARENT))

        self._drawmarkers(dc, self.scaled, marker, size)

    def _drawmarkers(self, dc, coords, marker,size=1):
        f = eval('self._' +marker)
        for xc, yc in coords:
            f(dc, xc, yc, size)

    def _circle(self, dc, xc, yc, size=1):
        dc.DrawEllipse(xc-2.5*size,yc-2.5*size, 5.*size,5.*size)

    def _dot(self, dc, xc, yc, size=1):
        dc.DrawPoint(xc,yc)

    def _square(self, dc, xc, yc, size=1):
        dc.DrawRectangle(xc-2.5*size,yc-2.5*size,5.*size,5.*size)

    def _triangle(self, dc, xc, yc, size=1):
        dc.DrawPolygon([(-0.5*size*5,0.2886751*size*5),
                       (0.5*size*5,0.2886751*size*5),
                       (0.0,-0.577350*size*5)],xc,yc)

    def _triangle_down(self, dc, xc, yc, size=1):
        dc.DrawPolygon([(-0.5*size*5,-0.2886751*size*5),
                       (0.5*size*5,-0.2886751*size*5),
                       (0.0,0.577350*size*5)],xc,yc)

    def _cross(self, dc, xc, yc, size=1):
        dc.DrawLine(xc-2.5*size, yc-2.5*size, xc+2.5*size,yc+2.5*size)
        dc.DrawLine(xc-2.5*size,yc+2.5*size, xc+2.5*size,yc-2.5*size)

    def _plus(self, dc, xc, yc, size=1):
        dc.DrawLine(xc-2.5*size,yc, xc+2.5*size,yc)
        dc.DrawLine(xc,yc-2.5*size,xc, yc+2.5*size)

class PlotGraphics:

    def __init__(self, objects):
        self.objects = objects

    def boundingBox(self):
        p1, p2 = self.objects[0].boundingBox()
        for o in self.objects[1:]:
            p1o, p2o = o.boundingBox()
            p1 = Numeric.minimum(p1, p1o)
            p2 = Numeric.maximum(p2, p2o)
        return p1, p2

    def scaleAndShift(self, scale=1, shift=0):
        for o in self.objects:
            o.scaleAndShift(scale, shift)

    def draw(self, canvas):
        for o in self.objects:
            o.draw(canvas)

    def __len__(self):
        return len(self.objects)

    def __getitem__(self, item):
        return self.objects[item]


class PlotCanvas(wx.Window):

    def __init__(self, parent, id=-1,
                 pos = wx.DefaultPosition, size = wx.DefaultSize,
                 style = 0, name = 'plotCanvas'):
        wx.Window.__init__(self, parent, id, pos, size, style, name)
        self.border = (1,1)
        self.SetClientSize((400,400))
        self.SetBackgroundColour("white")

        self.Bind(wx.EVT_SIZE,self.reconfigure)
        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self._setsize()
        self.last_draw = None
#       self.font = self._testFont(font)

    def OnPaint(self, event):
        pdc = wx.PaintDC(self)
        if self.last_draw is not None:
            apply(self.draw, self.last_draw + (pdc,))

    def reconfigure(self, event):
        (new_width,new_height) = self.GetClientSize()
        if new_width == self.width and new_height == self.height:
            return
        self._setsize()
        # self.redraw()

    def _testFont(self, font):
        if font is not None:
            bg = self.canvas.cget('background')
            try:
                item = CanvasText(self.canvas, 0, 0, anchor=NW,
                                  text='0', fill=bg, font=font)
                self.canvas.delete(item)
            except TclError:
                font = None
        return font

    def _setsize(self):
        (self.width,self.height) = self.GetClientSize();
        self.plotbox_size = 0.97*Numeric.array([self.width, -self.height])
        xo = 0.5*(self.width-self.plotbox_size[0])
        yo = self.height-0.5*(self.height+self.plotbox_size[1])
        self.plotbox_origin = Numeric.array([xo, yo])

    def draw(self, graphics, xaxis = None, yaxis = None, dc = None):
        if dc == None: dc = wx.ClientDC(self)
        dc.BeginDrawing()
        dc.Clear()
        self.last_draw = (graphics, xaxis, yaxis)
        p1, p2 = graphics.boundingBox()
        xaxis = self._axisInterval(xaxis, p1[0], p2[0])
        yaxis = self._axisInterval(yaxis, p1[1], p2[1])
        text_width = [0., 0.]