source: SHX/trunk/sandbox/bc_example.py @ 394

# -*- coding: utf-8 -*-

import wx
import wx.lib.scrolledpanel as SP
import sys
from bufferedcanvas import *

from obspy.core import read

class TestCanvas(BufferedCanvas):
    def __init__(self, parent, ID=-1, pos=wx.DefaultPosition, size=wx.DefaultSize):
        try:
            fname = sys.argv[1]
        except IndexError:
            fname = "../SeismicHandler/tests/data/mseed/2010.284.GR.GRA1..BHN"
        self.trace = read(fname)[0]

        # demean
        self.trace.data = self.trace.data-self.trace.data.mean()

        min, max = self.trace.data.min(), self.trace.data.max()
        self.base = abs(self.trace.max())
        self.npts = self.trace.stats.npts

        self.overlay = wx.Overlay()

        BufferedCanvas.__init__(self, parent, ID, size=size)

        self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
        self.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
        self.Bind(wx.EVT_MOTION, self.OnMouseMove)

        try:
            parent.Bind(wx.EVT_SCROLLWIN_CHANGED, self.OnScrollDone)
        except:
            parent.Bind(wx.EVT_SCROLLWIN, self.OnScrollDone)

        parent.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)

    def OnMouseWheel(self, evt):
        if evt.ControlDown():
            print "wheel CTRL event"
        else:
            evt.Skip()

    def OnScrollDone(self, evt):
        print "scrolling finished"
#        self.overlay.Reset()
        dc = wx.ClientDC(self)
        odc = wx.DCOverlay(self.overlay, dc)
        odc.Clear()
        del odc
        evt.Skip()

    def OnRightDown(self, evt):
        # Capture the mouse and save the starting position for the
        # rubber-band
        self.CaptureMouse()
        self.startPos = (evt.GetPosition()[0], 10)

    def OnMouseMove(self, evt):
        if not evt.RightIsDown():
#            print "move to", evt.GetPosition()
            dc = wx.ClientDC(self)
            odc = wx.DCOverlay(self.overlay, dc)
            odc.Clear()
            dc.SetPen(wx.Pen("Blue", 1))
            dc.SetBrush(wx.TRANSPARENT_BRUSH)
            dc.DrawLine(evt.GetPosition()[0], 10, evt.GetPosition()[0], self.buffer.Height-10)
            del odc

        if evt.Dragging() and evt.RightIsDown():
            rect = wx.RectPP(self.startPos, (evt.GetPosition()[0], self.buffer.Height-10))

            # Draw the rubber-band rectangle using an overlay so it
            # will manage keeping the rectangle and the former window
            # contents separate.
            dc = wx.ClientDC(self)
            odc = wx.DCOverlay(self.overlay, dc)
            odc.Clear()

            dc.SetPen(wx.Pen("red", 2))
            if 'wxMac' in wx.PlatformInfo:
                dc.SetBrush(wx.Brush(wx.Colour(0xC0, 0xC0, 0xC0, 0x80)))
            else:
                dc.SetBrush(wx.TRANSPARENT_BRUSH)
            dc.DrawRectangleRect(rect)

            del odc # work around a bug in the Python wrappers to make
                    # sure the odc is destroyed before the dc is.

    def OnRightUp(self, evt):
        if self.HasCapture():
            self.ReleaseMouse()
        self.startPos = None

        # When the mouse is released we reset the overlay and it
        # restores the former content to the window.
        dc = wx.ClientDC(self)
        odc = wx.DCOverlay(self.overlay, dc)
        odc.Clear()
        del odc
        self.overlay.Reset()

    def draw(self, dc):
        self.overlay.Reset()

        w, h = self.buffer.Width-20, self.buffer.Height
        spp = self.npts // w
        tail = self.npts % w

        print "samples per pixel: %u remains: %u" % (spp, tail)

        # resample
        if spp > 2:
            pass

        zoomx = float(w)/self.npts
        zoomy = float(h)/self.base/2.1
        
        dc.SetBackground(wx.Brush("White"))
        dc.Clear()

        dc.SetPen(wx.Pen('Black', 1))

        lines = []
        offsetx, offsety = 10, int(h / 2.)
        print "x: %u y: %u zoom: x=%.2f y=%.2f offset: x=%i y=%i" % (w, h, zoomx, zoomy, offsetx, offsety)

        oldx, oldy = offsetx, offsety
        for n, i in enumerate(self.trace.data):
            newx = n*zoomx+offsetx
            newy = -i*zoomy+offsety
            lines.append([oldx, oldy, newx, newy])
            oldx, oldy = newx, newy

        dc.SetPen(wx.Pen('Grey', 1, wx.LONG_DASH))
        dc.DrawLine(offsetx, offsety, offsetx+w, offsety)
        dc.DrawLabel("TEST", (0, 100, offsetx, offsety))

        pen = wx.Pen((80,80,80), 1)
#        pen.SetJoin(wx.JOIN_ROUND)
#        pen.SetCap(wx.CAP_ROUND)
        dc.SetPen(pen)
        dc.DrawLineList(lines)

class TestFrame(wx.Frame):
    def __init__(self,
                 parent=None,
                 ID=-1,
                 title="BufferedCanvas Trace Test",
                 pos=wx.DefaultPosition,
                 size=wx.DefaultSize,
                 style=wx.DEFAULT_FRAME_STYLE | wx.FULL_REPAINT_ON_RESIZE):

        wx.Frame.__init__(self, parent, ID, title, pos, size, style)

        panel = SP.ScrolledPanel(
            parent=self,
            pos=pos,
            size=(1, 1),
            style=wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER,
            name="panel"
        )

        self.canvas = TestCanvas(panel, size=[500,200])

        sizer  = wx.BoxSizer()
        sizer.Add(self.canvas, proportion=2)

        panel.SetSizer(sizer)
        panel.SetupScrolling()

        self.Bind(wx.EVT_CLOSE, self.onClose)

    def onClose(self,event):
        self.Show(False)
        self.Destroy()

def main():
    app = wx.PySimpleApp()
    frame = TestFrame(size=[700,200])
    frame.Show(True)
    app.MainLoop()

if __name__ == '__main__':
    main()