Эксперимент: динамический график

#!/usr/bin/python
# -*- coding: utf-8 -*-

from __future__ import division
import wx

class DynGraph:
    def __init__(self, data, realSettings, realKoeffs):
        self.grid = Grid(data, realSettings, realKoeffs)
        self.lines = Lines(data, self.grid.GetXSampleWidth())
       
    def Draw(self, dc):
        drawer = Drawer(dc, self.grid.GetSampleSettings())
        self.grid.Draw(drawer)
        self.lines.Draw(drawer)

class Drawer:
    def __init__(self, dc, sampleSettings):
        self.dc = dc
        w, h = dc.GetSizeTuple()
        self.rect = [20, 20, w - 40, h - 40]
       
        self.kMtoP = self.rect[3] / (sampleSettings.ySampleMax - sampleSettings.ySampleMin)
        self.kStoP = self.rect[2] / (sampleSettings.xSampleWidth)
        self.ypix0 = self.rect[1] + self.kMtoP*sampleSettings.ySampleMax
       
        self.dc.SetBackground(wx.Brush(wx.LIGHT_GREY))
        self.dc.Clear()
        self.dc.DrawRectangleRect(self.rect)
        self.font = wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL)
               
    def DrawStepLine(self, line, step, color):
        xFin = self.rect[0] + self.rect[2]
        self.dc.SetPen(wx.Pen(color, 2))
        dots = [(xFin -  self.kStoP*i, self.ypix0 - y*self.kMtoP) for i, y in enumerate(reversed(line))]#self.kStoP * i
        self.dc.DrawLines(dots)
        self.dc.SetPen(wx.NullPen)

class SampleSettings:
    def __init__(self, ySampleMin, ySampleMax, xSampleWidth):
        self.ySampleMin, self.ySampleMax, self.xSampleWidth = (
        ySampleMin, ySampleMax, xSampleWidth)
       

class Grid:
    def __init__(self, data, realSettings, realKoeffs):
        self.realSettings = realSettings
        self.realKoeffs = realKoeffs
        self.xSampleWidth = int(realSettings.xRealWidth / realKoeffs.kStoT) # yes, exception possible
        self.ySampleMin = int(realSettings.yRealMin / realKoeffs.kMtoR)
        self.ySampleMax = int(realSettings.yRealMax / realKoeffs.kMtoR)
       
    def GetXSampleWidth(self):
        return self.xSampleWidth
       
    def GetSampleSettings(self):
        return SampleSettings(self.ySampleMin, self.ySampleMax, self.xSampleWidth)
       
    def Draw(self, drawer):
        pass

class Lines:
    def __init__(self, data, xSampleWidth):
        self.data = data
        self.xSampleWidth = xSampleWidth
   
    def Draw(self, drawer):
        beg, end = [len(self.data.mass[0]) - self.xSampleWidth, self.data.index]
        if beg < 0: beg = 0
        if end > len(self.data.mass[0]): end = -1
        for lineNcolor in zip(self.data.mass, [(0xFF, 0x33, 0x33), (0x33, 0xFF, 0x33), (0x33, 0x33, 0xFF)]):
            mass = lineNcolor[0][beg:end]
            drawer.DrawStepLine(mass, 3, lineNcolor[1])
       
class RealSettings:
    def __init__(self, yRealMax = 0, yRealMin = 0, xRealWidth = 0, xRealStep = 0, yRealStep = 0):
        self.yRealMax = yRealMax
        self.yRealMin = yRealMin
        self.xRealWidth = xRealWidth
        self.xRealStep = xRealStep
        self.yRealStep = yRealStep
   
class RealKoeffs:
    def __init__(self, kStoT = 1.0, kMtoR = 1.0):
        self.kStoT = kStoT
        self.kMtoR = kMtoR
   
class RegData:
    def __init__(self, mass = [], index = -1):
        self.mass = mass
        self.index = index

class GraphWindow(wx.Window):
   
    def __init__(self, parent):
        wx.Window.__init__(self, parent)
       
        someList = [5, 8, 6, 9, 7, 4]*50
        funcs = [lambda x: 50 + x*10, lambda x: 150 + x*5, lambda x: 250 + x*3]
        self.regData = RegData([[f(x) for x in someList] for f in funcs])
        realSettings = RealSettings(yRealMax = 300, xRealWidth = 400, xRealStep = 50, yRealStep = 50)
        self.graph = DynGraph(self.regData, realSettings, RealKoeffs(2.0, 1.01))
       
        self.InitBuffer()
        self.Bind(wx.EVT_SIZE, self.OnSize)
        self.Bind(wx.EVT_PAINT, self.OnPaint)
       
    def OnSize(self, evt):
        # When the window size changes we need a new buffer.
        self.InitBuffer()
       
    def OnPaint(self, evt):
        dc = wx.BufferedPaintDC(self, self.buffer)
       
    def InitBuffer(self):
        w, h = self.GetClientSize()
        self.buffer = wx.EmptyBitmap(w, h)
        dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
        self.DrawGraph(dc)
       
    def GetData(self):
        return self.data
   
    def DrawGraph(self, dc):
        self.graph.Draw(dc)
   
class TestFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, title="Plot", size=(480,480))
        self.plot = GraphWindow(self)
       
def Main():
    app = wx.PySimpleApp()
    frm = TestFrame()
    frm.Show()
    app.MainLoop()
   

if __name__ == "__main__":
    Main()

class Drawer:
    def __init__(self, dc, sampleSettings):
        self.dc = dc
        w, h = dc.GetSizeTuple()
        self.rect = [self.rectLeft, self.rectUp, self.rectWidth,
         self.rectHeight] = [40, 40, w - 80, h - 80]
       
        self.kMtoP = self.rectHeight / (sampleSettings.ySampleMax - sampleSettings.ySampleMin)
        self.kStoP = self.rectWidth / (sampleSettings.xSampleWidth)
        self.ypix0 = self.rectUp + self.kMtoP*sampleSettings.ySampleMax
       
        self.dc.SetBackground(wx.Brush(wx.LIGHT_GREY))
        self.dc.Clear()
        self.dc.DrawRectangleRect(self.rect)
        self.font = wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL)
               
    def SetClipping(self):
        self.dc.SetClippingRect(self.rect)

    def DestroyClipping(self):
        self.dc.DestroyClippingRegion()
       
    def DrawStepLine(self, line, color):
        xFin = self.rectLeft + self.rectWidth
        self.dc.SetPen(wx.Pen(color, 2))
        dots = [(xFin -  self.kStoP*i, self.ypix0 - y*self.kMtoP) for i, y in enumerate(reversed(line))]
        self.dc.DrawLines(dots)
        self.dc.SetPen(wx.NullPen)
       
    def DrawXAxisText(self, text, x):
        xFin = self.rectLeft + self.rectWidth
        yForXAxis = self.rectUp + self.rectHeight + 5
        tw, th = self.dc.GetTextExtent(text)
        self.dc.DrawText(text, xFin - self.kStoP*x - tw // 2, yForXAxis)
       
    def DrawYAxisText(self, text, y):
        tw, th = self.dc.GetTextExtent(text)
        xForXAxis = self.rectLeft - tw - 5
        self.dc.DrawText(text, xForXAxis, self.ypix0 - self.kMtoP*y - (th // 2))

class Drawer:
    def __init__(self, dc, sampleSettings):
        self.dc = dc
        w, h = dc.GetSizeTuple()
        self.CalcDimensions(w, h, sampleSettings)
       
        self.dc.SetBackground(wx.Brush(wx.LIGHT_GREY))
        self.dc.Clear()
        self.dc.DrawRectangleRect(self.rect)
        self.font = wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL)
       
    def CalcDimensions(self, width, height, sampleSettings):
        self.rect = [self.rectLeft, self.rectUp, self.rectWidth,
            self.rectHeight] = [40, 40, width - 80, height - 80]
        try:
            self.kyStoP = self.rectHeight / (sampleSettings.ySampleMax - sampleSettings.ySampleMin)
            self.kxStoP = self.rectWidth / (sampleSettings.xSampleWidth)
        except ZeroDivisionError:
            self.kyStoP, self.kxStoP = 1.0, 1.0
        self.yPix0 = self.rectUp + self.kyStoP*sampleSettings.ySampleMax
       
               
    def SetClipping(self):
        self.dc.SetClippingRect(self.rect)

    def DestroyClipping(self):
        self.dc.DestroyClippingRegion()
       
    def DrawStepLine(self, line, color):
        xFin = self.rectLeft + self.rectWidth
        self.dc.SetPen(wx.Pen(color, 2))
        dots = [(xFin -  self.kxStoP*i, self.yPix0 - y*self.kyStoP) for i, y in enumerate(reversed(line))]
        self.dc.DrawLines(dots)
        self.dc.SetPen(wx.NullPen)
       
    def DrawXAxisText(self, text, x):
        xFin = self.rectLeft + self.rectWidth
        yForXAxis = self.rectUp + self.rectHeight + 5
        tw, th = self.dc.GetTextExtent(text)
        self.dc.DrawText(text, xFin - self.kxStoP*x - tw // 2, yForXAxis)
       
    def DrawXAxisNet(self, x):
        self.dc.SetPen(wx.Pen(wx.GREEN, 1, wx.DOT))
        xFin = self.rectLeft + self.rectWidth
        xPix = xFin - self.kxStoP*x
        self.dc.DrawLine(xPix, self.rectUp, xPix, self.rectUp + self.rectHeight)
        self.dc.SetPen(wx.NullPen)      
       
    def DrawYAxisNet(self, y):
        self.dc.SetPen(wx.Pen(wx.GREEN, 1, wx.DOT))
        yReal = self.yPix0 - y * self.kyStoP
        self.dc.DrawLine(self.rectLeft, yReal, self.rectLeft + self.rectWidth, yReal)        
        self.dc.SetPen(wx.NullPen)      
       
    def DrawYAxisText(self, text, y):
        tw, th = self.dc.GetTextExtent(text)
        xForXAxis = self.rectLeft - tw - 5
        self.dc.DrawText(text, xForXAxis, self.yPix0 - self.kyStoP*y - (th // 2))

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import unittest
from DynPlot import*

class EmptyDrawer(Drawer): # blemish detected!
    def __init__(self): pass

class TestDrawer(unittest.TestCase):

    def testDrawerCalcDimensions(self):
        sc = EmptyDrawer()
        sampleSettings = SampleSettings(-10, 50, 50)
        sc.CalcDimensions(200, 200, sampleSettings)
        #print sc.kxStoP, sc.kyStoP, sc.yPix0
        self.assertAlmostEqual(sc.kxStoP, 2.4, 5)
        self.assertAlmostEqual(sc.kyStoP, 2.0, 5)
        self.assertAlmostEqual(sc.yPix0, 140, 3)

    def testDrawerCalcDimensions2(self):
        sc = EmptyDrawer()
        sampleSettings = SampleSettings(11, 133, 89)
        sc.CalcDimensions(407, 814, sampleSettings)
        #print sc.kxStoP, sc.kyStoP, sc.yPix0
        self.assertAlmostEqual(sc.kxStoP, 3.674157, 5)
        self.assertAlmostEqual(sc.kyStoP, 6.016393, 5)
        self.assertAlmostEqual(sc.yPix0, 840.18032, 3) # Why yPix0 is not int?

if __name__ == "__main__":

    LoadCase = unittest.defaultTestLoader.loadTestsFromTestCase
    suite = LoadCase(TestDrawer)
    #suite.addTest(LoadCase(Test...))
    unittest.TextTestRunner(verbosity = 2).run(suite)

class Curve:
    def __init__(self, mass, color = (0, 0, 0), name = None):
        self.mass = mass
        self.color = color
        self.name = name

class Legends:
    def __init__(self, curves):
        self.curves = curves

    def Draw(self, drawer):
        for i, curve in enumerate(self.curves):
            text = curve.name + ": " + str(curve.mass[-1])
            drawer.DrawDownLegend(i, text, curve.color)

class Lines:
    def __init__(self, data, xSampleWidth):
        self.data = data
        self.xSampleWidth = xSampleWidth
        self.legends = None
        self.curves = []

    def LegendsVisible(self, flag = True):
        if flag:
            if not self.legends:
                self.legends = Legends(self.curves)
        else: self.legends = None

    def SetCurves(self, curves):
        self.curves = curves

    def Draw(self, drawer):
        drawer.SetClipping()
        beg, end = self.data.index - self.xSampleWidth, self.data.index
        if beg < 0: beg = 0
        if end > len(self.curves[0].mass): end = -1
        for curve in self.curves:
            mass = curve.mass[beg:end]
            drawer.DrawStepLine(mass, curve.color)
        drawer.DestroyClipping()

        if self.legends:
            self.legends.Draw(drawer)

    def GetLegendsOffset(self):
        if self.legends:
            return (len(self.curves), 0)
        else:
            return 0