feldmaus

class HistoFrame(wx.Frame):
    def __init__(self,starttime,endtime,timescale,zeitspanne,peaks_found, times_peaks_appeared, *args, **kwargs):
        wx.Frame.__init__(self, *args, **kwargs)
        # maximum samples to show in our analysis at once
        self.maxitems = 1000
        # the last sample we can watch in the analysis
        self.peaks_found = peaks_found
        self.times_peaks_appeared = times_peaks_appeared
        # which sample should be shown first ?
        self.min = min = 0
        self.timescale = timescale
        # Which is the current analysis ?
        self.currentanalysis =  None
        # 5% Divergence from 20ms of a raster but as count. 19.5ms to 20.5ms= 1ms/3e-6 --> 330
        self.maxrasterdiv = int(200)
        self.rastertime = 0.020
        self.zeitspanne = zeitspanne
        """We need to define self.plots2 and self.plots which will contain or graphical
        Elements and their xdata,ydata properties. That is needed for changing the Slider
        or Text input Element will result in a new Graph."""
        self.plots = []
        self.plots2 = []
        self.plots3 = []
        self.Bind(wx.EVT_MENU, self.onQuit, id=105)
        # Menu
        self.fileMenu = wx.Menu()
        self.analMenu = wx.Menu()

        quit = wx.MenuItem(self.fileMenu, 105, '&Quit\tCtrl+Q', 'Quit the Application')
        saveall = wx.MenuItem(self.fileMenu,106, '&SaveAllto --> ../../../peakgnuplot.dat\tCtrl+S',
                                       'Save all peaks and there values to an ascii file in'
                                       ' Gnuplot format.')
        self.Bind(wx.EVT_MENU, self.savetoGnuplot, id=106)
        self.transient = wx.MenuItem(self.analMenu,201,'&Transient Analyse',
                                        'Show the peak appearance depending on the time.',
                                        kind=wx.ITEM_RADIO)
        self.Bind(wx.EVT_MENU, self.changeAnalysis, self.transient)
        self.histogram = wx.MenuItem(self.analMenu,202,'& Histogram Analyse',
                                         'Show the amplitude appearance of the peaks depending on time in a 1/50Hz raster.',
                                         kind=wx.ITEM_RADIO)
        self.Bind(wx.EVT_MENU, self.changeAnalysis, self.histogram)

        self.fileMenu.AppendItem(quit)
        self.fileMenu.AppendItem(saveall)
        self.transmenuid = self.analMenu.AppendItem(self.transient)
        self.histmenuid = self.analMenu.AppendItem(self.histogram)

        menubar = wx.MenuBar()
        menubar.Append(self.fileMenu, '&File')
        menubar.Append(self.analMenu, '&Analysis')
        self.SetMenuBar(menubar)

        self.figure = Figure()
        self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
        self.canvas.mpl_connect('motion_notify_event', self.UpdateStatusBar)
        self.canvas.Bind(wx.EVT_ENTER_WINDOW, self.ChangeCursor)
        """Load the needed Data """
        f_dat = open('../../../peakswerteundzeit.dat','rb')
        self.daten = cPickle.load(f_dat)
        # Only the peaks should be computed to the max and min value
        criterium = np.asarray(self.daten[1]==np.int_(1),dtype=bool)
        self.peakvaluemax = np.amax(np.asarray(self.daten[3])[criterium])*1.01
        self.peakvaluemin = np.amin(np.asarray(self.daten[3])[criterium])*0.99
        #Set default Analysis
        self.histmenuid.Check(True)
        #Make some Slider
        self.slider_param_trans = Param(0, minimum=0, maximum=len(self.daten[0]))
        self.slider_param_histo = Param(int(self.maxrasterdiv/2), minimum=0, maximum=int(self.maxrasterdiv))
        self.sliderlabeltrans = 'Lfd. Nr. des linken Wertes:'
        self.sliderlabelhisto= 'Zeitraster(20ms default):'
        if self.transmenuid.IsChecked():
            self.frequencySliderGroup = SliderGroup(self, label=self.sliderlabeltrans,
                                                    param=slider_param_trans)
            self.slider_param_trans.attach(self)
        elif self.histmenuid.IsChecked():
            self.frequencySliderGroup = SliderGroup(self, label=self.sliderlabelhisto,
                                                    param=self.slider_param_histo)
            self.slider_param_histo.attach(self)
        self.statusBar = wx.StatusBar(self, -1)
        self.statusBar.SetFieldsCount(1)
        self.SetStatusBar(self.statusBar)
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
        sizer.Add(self.frequencySliderGroup.sizer, 0,
                  wx.EXPAND | wx.ALIGN_CENTER | wx.ALL, border=5)
        sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        self.SetSizer(sizer)
        self.Fit()
        self.toolbar.Show()

        if self.transmenuid.IsChecked():
            self.currentanalysis = self.transient.GetId()
            self.drawtransient(min,self.maxitems)
        elif self.histmenuid.IsChecked():
            self.currentanalysis = self.histogram.GetId()
            self.drawhistogram(min,self.maxitems)

    def changeAnalysis(self,event):
        id = event.GetId()
        if self.currentanalysis != id:
            self.figure.clear()
            if (id == self.transient.GetId()):
                self.currentanalysis = self.transient.GetId()
                self.drawtransient(self.min,self.maxitems)
                self.slider_param_trans.attach(self)
            elif (id==self.histogram.GetId()):
                self.currentanalysis = self.histogram.GetId()
                self.drawhistogram(self.min,self.maxitems)
                self.slider_param_histo.attach(self)
            self.changeSliderGroup(id)
        self.canvas.draw()

    def changeSliderGroup(self,id):
        if (id == self.transient.GetId()):
            self.frequencySliderGroup.setsetting(self.slider_param_trans,self.sliderlabeltrans)
        elif (id==self.histogram.GetId()):
            self.frequencySliderGroup.setsetting(self.slider_param_histo,self.sliderlabelhisto)

class Knob:
    """
    Knob - simple class with a "setKnob" method.
    A Knob instance is attached to a Param instance, e.g. param.attach(knob)
    Base class is for documentation purposes.
    """
    def setKnob(self, value):
        pass


class Param:
    """
    The idea of the "Param" class is that some parameter in the GUI may have
    several knobs that both control it and reflect the parameter's state, e.g.
    a slider, text, and dragging can all change the value of the frequency in
    the waveform of this example.
    The class allows a cleaner way to update/"feedback" to the other knobs when
    one is being changed.  Also, this class handles min/max constraints for all
    the knobs.
    Idea - knob list - in "set" method, knob object is passed as well
      - the other knobs in the knob list have a "set" method which gets
        called for the others.
    """
    def __init__(self, initialValue=None, minimum=0., maximum=1.):
        self.minimum = minimum
        self.maximum = maximum
        if initialValue != self.constrain(initialValue):
            raise ValueError('illegal initial value')
        self.value = initialValue
        self.knobs = []

    def attach(self, knob):
        self.knobs += [knob]

    def set(self, value, knob=None):
        self.value = value
        self.value = self.constrain(value)
        for feedbackKnob in self.knobs:
            if feedbackKnob != knob:
                feedbackKnob.setKnob(self.value)

        return self.value

    def constrain(self, value):
        if value <= self.minimum:
            value = self.minimum
        if value >= self.maximum:
            value = self.maximum
        return value


class SliderGroup(Knob):
    def __init__(self, parent, label, param):
        self.sliderLabel = wx.StaticText(parent, label=label)
        self.sliderText = wx.TextCtrl(parent, -1, style=wx.TE_PROCESS_ENTER)
        self.slider = wx.Slider(parent, -1)
        self.slider.SetMax(param.maximum*1000)
        self.setKnob(param.value)

        sizer = wx.BoxSizer(wx.HORIZONTAL)
        sizer.Add(self.sliderLabel, 0, wx.EXPAND | wx.ALIGN_CENTER | wx.ALL, border=2)
        sizer.Add(self.sliderText, 0, wx.EXPAND | wx.ALIGN_CENTER | wx.ALL, border=2)
        sizer.Add(self.slider, 1, wx.EXPAND)
        self.sizer = sizer

        self.slider.Bind(wx.EVT_SLIDER, self.sliderHandler)
        self.sliderText.Bind(wx.EVT_TEXT_ENTER, self.sliderTextHandler)

        self.param = param
        self.param.attach(self)

    def sliderHandler(self, evt):
        value = evt.GetInt() / 1000.
        self.param.set(int(value))

    def sliderTextHandler(self, evt):
        value = int(self.sliderText.GetValue())
        self.param.set(int(value))

    def setKnob(self, value):
        value = int(value)
        self.sliderText.SetValue('%g'%value)
        self.slider.SetValue(value*1000)

    def setsetting(self,param,label):
        self.sliderLabel.SetLabel(label)
        self.slider.SetMax(param.maximum*1000)
        self.setKnob(param.value)
        self.param = param
        self.param.attach(self)