Ejemplo n.º 1
0
class CanvasPanel(wx.Panel):
    """
    This panel holds the actual chart. It is recreated everytime with a new Chart as input.
    """
    def __init__(self, parent, chart):
        wx.Panel.__init__(self, parent)
        self.SetBackgroundColour(wx.NamedColour("WHITE"))
        if chart is not None:
            self.figure, self.axes = chart.fig, chart.ax
        else:
            self.figure = Figure(
            )  #WE NEED TO INITIALIZE OTHERWISE IT CAN BREAK
        self.canvas = FigureCanvas(self, -1, self.figure)
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
        self.add_toolbar()
        self.SetSizer(self.sizer)
        self.Fit()

    def add_toolbar(self):
        """Copied verbatim from embedding_wx2.py"""
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if IS_MAC:
            self.SetToolBar(self.toolbar)
        else:
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        self.toolbar.update()
Ejemplo n.º 2
0
class VolumePanel(wx.Panel):
    def __init__(self, parent):
        wx.Panel.__init__(self, parent)
        # initialize matplotlib stuff
        self.figure = Figure()
        self.canvas = FigureCanvas(self, -1, self.figure)
        self.ax = self.figure.add_subplot(111)

        #print "Top Applications ..."
        self.timeControlPanel = TimeControlPanel(self)

        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.timeControlPanel, 0, wx.LEFT | wx.TOP | wx.GROW)
        self.sizer.Add(self.canvas, 0, wx.LEFT | wx.TOP | wx.GROW)
        self.SetSizer(self.sizer)
        self.Fit()
        self.SetSize(panel_size)

        self.add_toolbar()  # comment this out for no toolbar

    def add_toolbar(self):
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if wx.Platform == '__WXMAC__':
            self.SetToolBar(self.toolbar)
        else:
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        # update the axes menu on the toolbar
        self.toolbar.update()
Ejemplo n.º 3
0
class CanvasFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1, 'CanvasFrame', size=(550, 350))
        self.SetBackgroundColour(wx.NamedColor('WHITE'))
        self.figure = Figure()
        self.axes = self.figure.add_subplot(111)
        t = arange(0.0, 3.0, 0.01)
        s = sin(2 * pi * t)
        self.axes.plot(t, s)
        self.canvas = FigureCanvas(self, -1, self.figure)
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
        self.SetSizerAndFit(self.sizer)
        self.add_toolbar()

    def add_toolbar(self):
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if wx.Platform == '__WXMAC__':
            self.SetToolBar(self.toolbar)
        else:
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        self.toolbar.update()

    def OnPaint(self, event):
        self.canvas.draw()
Ejemplo n.º 4
0
class PlotFigure(wxFrame):

    def __init__(self):
        wxFrame.__init__(self, None, -1, "Test embedded wxFigure")

        self.fig = Figure((5,4), 75)
        self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
        self.toolbar = Toolbar(self.canvas)
        self.toolbar.Realize()

        # On Windows, default frame size behaviour is incorrect
        # you don't need this under Linux
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(wxSize(fw, th))

        # Create a figure manager to manage things

        # Now put all into a sizer
        sizer = wxBoxSizer(wxVERTICAL)
        # This way of adding to sizer allows resizing
        sizer.Add(self.canvas, 1, wxLEFT|wxTOP|wxGROW)
        # Best to allow the toolbar to resize!
        sizer.Add(self.toolbar, 0, wxGROW)
        self.SetSizer(sizer)
        self.Fit()
        EVT_TIMER(self, TIMER_ID, self.onTimer)

    def init_plot_data(self):
        # jdh you can add a subplot directly from the fig rather than
        # the fig manager
        a = self.fig.add_subplot(111)
        self.x = numerix.arange(120.0)*2*numerix.pi/120.0
        self.x.resize((100,120))
        self.y = numerix.arange(100.0)*2*numerix.pi/100.0
        self.y.resize((120,100))
        self.y = numerix.transpose(self.y)
        z = numerix.sin(self.x) + numerix.cos(self.y)
        self.im = a.imshow( z, cmap=cm.jet)#, interpolation='nearest')



    def GetToolBar(self):
        # You will need to override GetToolBar if you are using an 
        # unmanaged toolbar in your frame
        return self.toolbar
		
    def onTimer(self, evt):
        self.x += numerix.pi/15
        self.y += numerix.pi/20
        z = numerix.sin(self.x) + numerix.cos(self.y)
        self.im.set_array(z)
        self.canvas.draw()
        #self.canvas.gui_repaint()  # jdh wxagg_draw calls this already
        
    def onEraseBackground(self, evt):
        # this is supposed to prevent redraw flicker on some X servers...
        pass
Ejemplo n.º 5
0
class CanvasFrame(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, parent, -1, 'CanvasFrame', size=(550, 350))

        #main_sizer = wx.BoxSizer(wx.VERTICAL)
        #self.conf_panel = ConfPanel(self)
        #main_sizer.Add(self.conf_panel, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL, 5)

        self.SetBackgroundColour(wx.NamedColour("WHITE"))
        self.figure = Figure()
        self.axes = self.figure.add_subplot(111)

        self.cmap = plt.cm.hot
        self.ndivs = (1000, 1000)

        self.canvas = FigureCanvas(self, -1, self.figure)

        self.sizer = sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)

        self.toolbar = MyNavigationToolbar(self)
        self.toolbar.Realize()

        # On Windows platform, default window size is incorrect, so set toolbar width to figure width.
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        # By adding toolbar in sizer, we are able to put it at the bottom
        # of the frame - so appearance is closer to GTK version.
        self.toolbar.SetSize(wx.Size(fw, th))
        sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)

        # Update the axes menu on the toolbar
        self.toolbar.update()

        self.SetSizerAndFit(sizer)

        # Compute fractal and show picture.
        self.imshow_fractal()

    def imshow_fractal(self, extent=None):
        xvals, yvals, data = mandelbrot(extent=extent, ndivs=self.ndivs)

        if extent is None:
            extent = (xvals[0], xvals[-1], yvals[0], yvals[-1])

        self.axes.imshow(np.log(data),
                         cmap=plt.cm.hot,
                         origin="lower",
                         extent=extent)

        # Save values
        self.xvals, self.yvals, self.data = xvals, yvals, data
Ejemplo n.º 6
0
class CanvasFrame(Frame):

   def __init__(self):
       Frame.__init__(self,None,-1,
                                       'CanvasFrame',size=(550,350))

       self.SetBackgroundColour(NamedColor("WHITE"))

       self.figure = Figure()
       
       self.canvas = FigureCanvas(self, -1, self.figure)
       self.ax = self.figure.add_subplot(111)

       self.sizer = BoxSizer(VERTICAL)
       self.sizer.Add(self.canvas, 1, LEFT | TOP | GROW)
       self.SetSizer(self.sizer)
       self.Fit()

       self.add_toolbar()  # comment this out for no toolbar
       
       self.plot_map()
       
   def add_toolbar(self):
       self.toolbar = NavigationToolbar2Wx(self.canvas)
       self.toolbar.Realize()
       if Platform == '__WXMAC__':
          # Mac platform (OSX 10.3, MacPython) does not seem to cope with
          # having a toolbar in a sizer. This work-around gets the buttons
          # back, but at the expense of having the toolbar at the top
          self.SetToolBar(self.toolbar)
       else:
          # On Windows platform, default window size is incorrect, so set
          # toolbar width to figure width.
          tw, th = self.toolbar.GetSizeTuple()
          fw, fh = self.canvas.GetSizeTuple()
          # By adding toolbar in sizer, we are able to put it at the bottom
          # of the frame - so appearance is closer to GTK version.
          # As noted above, doesn't work for Mac.
          self.toolbar.SetSize(Size(fw, th))
          self.sizer.Add(self.toolbar, 0, LEFT | EXPAND)
       # update the axes menu on the toolbar
       self.toolbar.update()
           
   def plot_map(self):
       map = Basemap(ax=self.ax)
       map.drawcoastlines()
       map.drawcountries()
       map.drawmapboundary()
       map.fillcontinents(color='coral', lake_color='aqua')
       map.drawmapboundary(fill_color='aqua')
       self.figure.canvas.draw()
Ejemplo n.º 7
0
class PlotFigure(Frame):
    def __init__(self):
        Frame.__init__(self, None, -1, "Dynamic Data Display - WX")

        self.fig = Figure((5, 4), 100)
        self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()

        # On Windows, default frame size behaviour is incorrect
        # you don't need this under Linux
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(Size(fw, th))

        # Create a figure manager to manage things

        # Now put all into a sizer
        sizer = BoxSizer(VERTICAL)
        # This way of adding to sizer allows resizing
        sizer.Add(self.canvas, 1, LEFT | TOP | GROW)
        # Best to allow the toolbar to resize!
        sizer.Add(self.toolbar, 0, GROW)
        self.SetSizer(sizer)
        self.Fit()
        EVT_TIMER(self, TIMER_ID, self.onTimer)

    def init_plot_data(self):

        self.ax1 = self.fig.add_axes([0.15, 0.15, 0.8, 0.8])
        self.ax1.grid(True)
        self.ax1.set_xlabel('Frame Number')
        self.ax1.set_ylabel('Cells detected')

    def GetToolBar(self):
        # You will need to override GetToolBar if you are using an
        # unmanaged toolbar in your frame
        return self.toolbar

    def onTimer(self, evt):

        data = np.loadtxt(options.filename, delimiter='\t')
        self.ax1.bar(data[:, 0], data[:, 1], width=0.7, bottom=0)
        self.ax1.set_xlim([data[0, 0] - 1, data[-1, 0] + 1])
        self.ax1.set_ylim([data[:, 1].min() * 0.9, data[:, 1].max() * 1.1])

        self.canvas.draw()

    def onEraseBackground(self, evt):
        # this is supposed to prevent redraw flicker on some X servers...
        pass
Ejemplo n.º 8
0
class Plots_Panel(wx.Panel):
    """

    Panel to hold matplotlib figure. There are three plots inside a grid, big one
    for temperature vs. deformation and smaller ones for time vs. deformation and
    time vs. temperature.

    """

    #--------------------------------------------------------------------------#
    def __init__(self, parent):

        wx.Panel.__init__(self, parent)

        self.init_plots()  #make figure
        self.PlotsCanvas = FigCanvas(self, wx.ID_ANY, self.fig)

        self.toolbar = NavigationToolbar(self.PlotsCanvas)
        self.toolbar.Realize()

        #correct toolbar size
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.PlotsCanvas.GetSizeTuple()

        # Sizers
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.PlotsCanvas, 1, wx.EXPAND | wx.GROW)
        sizer.Add(self.toolbar, 0, wx.BOTTOM | wx.GROW)
        self.toolbar.SetSize(wx.Size(fw, th))
        self.toolbar.update()
        self.SetSizerAndFit(sizer)

    #--------------------------------------------------------------------------#
    def init_plots(self):

        self.fig = Figure((-1, 7.5))
        self.fig.subplots_adjust(left=0.05, wspace=.3,
                                 hspace=3)  #sub plot spacing

        gs = matplotlib.gridspec.GridSpec(8, 3)
        self.ax1 = self.fig.add_subplot(gs[:, 0:2])
        self.ax2 = self.fig.add_subplot(gs[0:4, 2])
        self.ax3 = self.fig.add_subplot(gs[4:8, 2])

        self.ax1.set_xlabel(u'Temperatura ($^\circ$C)')
        self.ax1.set_ylabel(u'Deformación (mm)')
        self.ax2.set_xlabel(u'Tiempo (s)')
        self.ax2.set_ylabel(u'Deformación (mm)')
        self.ax3.set_xlabel(u'Tiempo (s)')
        self.ax3.set_ylabel(u'Temperatura ($^\circ$C)')
Ejemplo n.º 9
0
class CanvasFrame(wx.Frame):

    def __init__(self):
        wx.Frame.__init__(self,None,-1,
                         'CanvasFrame',size=(550,350))

        self.SetBackgroundColour(wx.NamedColor("WHITE"))

        self.figure = Figure(figsize=(5,4), dpi=100)
        self.axes = self.figure.add_subplot(111)
        t = arange(0.0,3.0,0.01)
        s = sin(2*pi*t)

        self.axes.plot(t,s)

        self.canvas = FigureCanvas(self, -1, self.figure)

        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.canvas, 1, wx.TOP | wx.LEFT | wx.EXPAND)
        # Capture the paint message
        wx.EVT_PAINT(self, self.OnPaint)

        self.toolbar = MyNavigationToolbar(self.canvas, True)
        self.toolbar.Realize()
        if wx.Platform == '__WXMAC__':
            # Mac platform (OSX 10.3, MacPython) does not seem to cope with
            # having a toolbar in a sizer. This work-around gets the buttons
            # back, but at the expense of having the toolbar at the top
            print "Using max workaround!"
            self.SetToolBar(self.toolbar)
        else:
            # On Windows platform, default window size is incorrect, so set
            # toolbar width to figure width.
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            # By adding toolbar in sizer, we are able to put it at the bottom
            # of the frame - so appearance is closer to GTK version.
            # As noted above, doesn't work for Mac.
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)

        # update the axes menu on the toolbar
        self.toolbar.update()
        self.SetSizer(self.sizer)
        self.Fit()


    def OnPaint(self, event):
        self.canvas.draw()
        event.Skip()
Ejemplo n.º 10
0
class PlotFigure(wxFrame):
    def __init__(self):
        wxFrame.__init__(self, None, -1, "Test embedded wxFigure")

        self.fig = Figure((9, 8), 75)
        self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
        self.toolbar = NavigationToolbar2WxAgg(self.canvas)
        self.toolbar.Realize()

        self.figmgr = FigureManager(self.canvas, 1, self)
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(wxSize(fw, th))
        sizer = wxBoxSizer(wxVERTICAL)

        # This way of adding to sizer allows resizing
        sizer.Add(self.canvas, 1, wxLEFT | wxTOP | wxGROW)
        sizer.Add(self.toolbar, 0, wxGROW)
        self.SetSizer(sizer)
        self.Fit()

        self.plot3d()

    def plot3d(self):
        # sample taken from http://www.scipy.org/Cookbook/Matplotlib/mplot3D
        ax3d = matplotlib.axes3d.Axes3D(self.fig)
        plt = self.fig.axes.append(ax3d)

        delta = nx.pi / 199.0
        u = nx.arange(0, 2 * nx.pi + (delta * 2), delta * 2)
        v = nx.arange(0, nx.pi + delta, delta)

        x = nx.outerproduct(nx.cos(u), nx.sin(v))
        y = nx.outerproduct(nx.sin(u), nx.sin(v))
        z = nx.outerproduct(nx.ones(nx.size(u)), nx.cos(v))
        print x.shape, y.shape, z.shape

        #ax3d.plot_wireframe(x,y,z)
        surf = ax3d.plot_surface(x, y, z)
        surf.set_array(matplotlib.mlab.linspace(0, 1.0, len(v)))

        ax3d.set_xlabel('X')
        ax3d.set_ylabel('Y')
        ax3d.set_zlabel('Z')
        self.fig.savefig('globe')
Ejemplo n.º 11
0
class PlotFigure(Frame):
    def __init__(self):
        Frame.__init__(self, None, -1, "Test embedded wxFigure")

        self.fig = Figure((9,8), 75)
        self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
        self.toolbar = NavigationToolbar2WxAgg(self.canvas)
        self.toolbar.Realize()

        self.figmgr = FigureManager(self.canvas, 1, self)
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(Size(fw, th))
        sizer = BoxSizer(VERTICAL)

        # This way of adding to sizer allows resizing
        sizer.Add(self.canvas, 1, LEFT|TOP|GROW)
        sizer.Add(self.toolbar, 0, GROW)
        self.SetSizer(sizer)
        self.Fit()

        self.plot3d()

    def plot3d(self):
        # sample taken from http://www.scipy.org/Cookbook/Matplotlib/mplot3D
        ax3d = matplotlib.axes3d.Axes3D(self.fig)
        plt = self.fig.axes.append(ax3d)

        delta = npy.pi / 199.0
        u = npy.arange(0, 2*npy.pi+(delta*2), delta*2)
        v = npy.arange(0, npy.pi+delta, delta)

        x = npy.cos(u)[:,npy.newaxis] * npy.sin(v)[npy.newaxis,:]
        y = npy.sin(u)[:,npy.newaxis] * npy.sin(v)[npy.newaxis,:]
        z = npy.ones_like(u)[:,npy.newaxis] * npy.cos(v)[npy.newaxis,:]
                # (there is probably a better way to calculate z)
        print x.shape, y.shape, z.shape

        #ax3d.plot_wireframe(x,y,z)
        surf = ax3d.plot_surface(x, y, z)
        surf.set_array(matplotlib.mlab.linspace(0, 1.0, len(v)))

        ax3d.set_xlabel('X')
        ax3d.set_ylabel('Y')
        ax3d.set_zlabel('Z')
Ejemplo n.º 12
0
class icCanvasPanel(wx.Panel):
    def __init__(self, parent, id=-1, pos=(-1, -1), size=(-1, -1)):
        wx.Panel.__init__(self, parent, id, pos, size)
        self.count = 0

        self.SetBackgroundColour(wx.NamedColor('WHITE'))
        self.figure = Figure()

        # ---
        dd = 10

        # --- Plot2
        matplotlib.rcParams['timezone'] = 'US/Pacific'
        tz = timezone('US/Pacific')

        date1 = datetime.datetime(2000, 3, 2, 10, tzinfo=tz)
        date2 = datetime.datetime(2000, 3, 2, 15, tzinfo=tz)
        delta = datetime.timedelta(minutes=5)
        dates = drange(date1, date2, delta)

        self.axes1 = self.figure.add_subplot(111)

        yy = pylab.arrayrange(len(dates) * 1.0)
        majorTick = HourLocator(range(0, 25, 1), tz=tz)

        ysq = [y * y / dd for y in yy]
        line = self.axes1.plot_date(dates, ysq, tz=tz)

        self.axes1.xaxis.set_major_locator(majorTick)
        self.axes1.set_xlabel('Time (s)')
        self.axes1.set_ylabel('Price 2 ($)')

        #
        self.canvas = FigureCanvas(self, -1, self.figure)
        self.canvas.mpl_connect('motion_notify_event', self.mouse_move)
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
        self.SetSizer(self.sizer)

        # --- Add Toolbar
        self.toolbar = Toolbar(self.canvas)
        self.toolbar.Realize()

        # On Windows, default frame size behaviour is incorrect
        # you don't need this under Linux
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(wx.Size(fw, th))

        # Create a figure manager to manage things
        self.figmgr = FigureManager(self.canvas, 1, self)

        self.sizer.Add(self.toolbar, 0, wx.EXPAND)
        self.toolbar.update()
        self.statusBar = wx.StatusBar(self, -1)
        self.statusBar.SetFieldsCount(1)
        self.sizer.Add(self.statusBar, 0, wx.EXPAND)

        self.Fit()

        # --- Обработчики событий
        self.Bind(wx.EVT_PAINT, self.OnPaint)

    def GetToolBar(self):
        """
        You will need to override GetToolBar if you are using an unmanaged toolbar in your frame.
        """
        return self.toolbar

    def mouse_move(self, event):
        self.draw_cursor(event)

    def add_toolbar(self):
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(wx.Size(fw, th))
        self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        # update the axes menu on the toolbar
        self.toolbar.update()

    def OnButton(self, evt):
        """
        """
        dd = 20
        t = arange(0.0, 3.0, 1.0 / dd)
        s = [10 + y * y / dd + self.count for y in xrange(0, 3 * dd)]
        self.count += 5
        self.axes.lines.pop(0)

        line, = self.axes.plot(t, s, 'r:d')
        line.set_markersize(5)
        self.Refresh()
        evt.Skip()

    def OnPaint(self, event):
        self.erase_cursor()
        try:
            del self.lastInfo
        except AttributeError:
            pass
        self.canvas.draw()
        event.Skip()

    def draw_cursor(self, event):
        """
        event is a MplEvent.  Draw a cursor over the axes.
        """
        if event.inaxes is None:
            self.erase_cursor()
            try:
                del self.lastInfo
            except AttributeError:
                pass
            return
        canvas = self.canvas
        figheight = canvas.figure.bbox.height()
        ax = event.inaxes
        left, bottom, width, height = ax.bbox.get_bounds()
        bottom = figheight - bottom
        top = bottom - height
        right = left + width
        x, y = event.x, event.y
        y = figheight - y

        dc = wx.ClientDC(canvas)
        dc.SetLogicalFunction(wx.XOR)
        wbrush = wx.Brush(wx.Colour(255, 255, 255), wx.TRANSPARENT)
        wpen = wx.Pen(wx.Colour(200, 200, 200), 1, wx.SOLID)
        dc.SetBrush(wbrush)
        dc.SetPen(wpen)

        dc.ResetBoundingBox()
        dc.BeginDrawing()

        x, y, left, right, bottom, top = [
            int(val) for val in x, y, left, right, bottom, top
        ]

        self.erase_cursor()
        line1 = (x, bottom, x, top)
        line2 = (left, y, right, y)
        self.lastInfo = line1, line2, ax, dc
        dc.DrawLine(*line1)  # draw new
        dc.DrawLine(*line2)  # draw new
        dc.EndDrawing()

        time, price = event.xdata, event.ydata
        self.statusBar.SetStatusText('Time=%f  Price=%f' % (time, price), 0)

    def erase_cursor(self):
        try:
            lastline1, lastline2, lastax, lastdc = self.lastInfo
        except AttributeError:
            pass
        else:
            lastdc.DrawLine(*lastline1)  # erase old
            lastdc.DrawLine(*lastline2)  # erase old
Ejemplo n.º 13
0
class MegaPlotWindow(PlotWindow):
    """Specialized four-panel PlotWindow for displaying
    A, B, and C scans of a three-dimensional dataset"""
    def __init__(self, parent, data_file):
        self.parent = parent
        self.data_file = data_file
        self.controller = MegaPlotWindowController(self, data_file)
        module_logger.info("Successfully initialized MegaPlotWindow.")
        self.load_data()

    @property
    def axes(self):
        """Returns a tuple of all the view's axes"""
        return (self.ascan_axes, self.hbscan_axes, self.vbscan_axes,
                self.cscan_axes)

    def init_ui(self):
        """Creates the PlotWindow UI"""
        parent_x, parent_y = self.parent.GetPositionTuple()
        parent_w, parent_h = self.parent.GetSize()
        self.SetPosition((parent_x + parent_w + ui_defaults.widget_margin,
                          ui_defaults.widget_margin))
        self.main_panel = wx.Panel(self)
        self.main_panel_sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer = wx.BoxSizer(wx.VERTICAL)

        # Controls for specifying (x,y,z) position in 3D dataset
        self.ctrl_panel = wx.Panel(self.main_panel)
        self.ctrl_sizer = wx.BoxSizer(wx.HORIZONTAL)
        info_lbl = wx.StaticText(self.ctrl_panel, wx.ID_ANY,
                                 u"Coordinates In Data:", wx.DefaultPosition,
                                 wx.DefaultSize)
        self.ctrl_sizer.Add(info_lbl, ui_defaults.lbl_pct,
                            ui_defaults.lblsizer_flags,
                            ui_defaults.widget_margin)
        xpos_lbl = wx.StaticText(self.ctrl_panel, wx.ID_ANY, u"X Position",
                                 wx.DefaultPosition, wx.DefaultSize)
        self.ctrl_sizer.Add(xpos_lbl, ui_defaults.lbl_pct,
                            ui_defaults.lblsizer_flags,
                            ui_defaults.widget_margin)
        self.xpos_sc = wx.SpinCtrl(self.ctrl_panel,
                                   wx.ID_ANY,
                                   value="",
                                   min=0,
                                   max=self.controller.data.shape[1] - 1)
        self.Bind(wx.EVT_SPINCTRL, self.controller.on_xy_change, self.xpos_sc)
        self.ctrl_sizer.Add(self.xpos_sc, ui_defaults.ctrl_pct,
                            ui_defaults.sizer_flags, ui_defaults.widget_margin)
        ypos_lbl = wx.StaticText(self.ctrl_panel, wx.ID_ANY, u"Y Position",
                                 wx.DefaultPosition, wx.DefaultSize)
        self.ctrl_sizer.Add(ypos_lbl, ui_defaults.lbl_pct,
                            ui_defaults.lblsizer_flags,
                            ui_defaults.widget_margin)
        self.ypos_sc = wx.SpinCtrl(self.ctrl_panel,
                                   wx.ID_ANY,
                                   value="",
                                   min=0,
                                   max=self.controller.data.shape[0] - 1)
        self.Bind(wx.EVT_SPINCTRL, self.controller.on_xy_change, self.ypos_sc)
        self.ctrl_sizer.Add(self.ypos_sc, ui_defaults.ctrl_pct,
                            ui_defaults.sizer_flags, ui_defaults.widget_margin)
        self.slice_cb = wx.CheckBox(self.ctrl_panel,
                                    wx.ID_ANY,
                                    "Plot Z Index As C Scan",
                                    style=wx.ALIGN_RIGHT)
        self.slice_cb.SetToolTipString(
            u"Use the specified index in Z as the C Scan plot data")
        self.slice_cb.SetValue(True)
        self.ctrl_sizer.Add(self.slice_cb, ui_defaults.lbl_pct,
                            ui_defaults.sizer_flags, ui_defaults.widget_margin)
        self.slice_sc = wx.SpinCtrl(self.ctrl_panel,
                                    wx.ID_ANY,
                                    value="",
                                    min=0,
                                    max=self.controller.data.shape[2] - 1)
        self.Bind(wx.EVT_SPINCTRL, self.controller.on_sliceidx_change,
                  self.slice_sc)
        slice_lbl = wx.StaticText(self.ctrl_panel, wx.ID_ANY, u"Slice Index",
                                  wx.DefaultPosition, wx.DefaultSize)
        self.ctrl_sizer.Add(slice_lbl, ui_defaults.lbl_pct,
                            ui_defaults.lblsizer_flags,
                            ui_defaults.widget_margin)
        self.ctrl_sizer.Add(self.slice_sc, ui_defaults.ctrl_pct,
                            ui_defaults.sizer_flags, ui_defaults.widget_margin)
        self.ctrl_panel.SetSizerAndFit(self.ctrl_sizer)
        self.main_panel_sizer.Add(self.ctrl_panel, ui_defaults.lbl_pct,
                                  ui_defaults.sizer_flags,
                                  ui_defaults.widget_margin)
        self.figure = Figure()
        self.canvas = FigureCanvas(self.main_panel, wx.ID_ANY, self.figure)
        self.ascan_axes = self.figure.add_subplot(221)
        self.vbscan_axes = self.figure.add_subplot(222)
        self.hbscan_axes = self.figure.add_subplot(223)
        self.cscan_axes = self.figure.add_subplot(224)
        self.cscan_cursor = Cursor(self.cscan_axes,
                                   useblit=True,
                                   color="#4F6581",
                                   alpha=0.5)
        self.figure.canvas.mpl_connect("button_press_event",
                                       self.controller.on_click)
        self.main_panel_sizer.Add(self.canvas, 1, ui_defaults.sizer_flags, 0)
        self.navtools_cb = wx.CheckBox(self.main_panel, wx.ID_ANY,
                                       "Use Plot Navigation Tools")
        self.navtools_cb.SetValue(self.controller.get_navtools_config())
        self.navtools_cb.SetToolTipString("Check to use pan/zoom tools")
        self.Bind(wx.EVT_CHECKBOX, self.controller.on_check_navtools,
                  self.navtools_cb)
        self.main_panel_sizer.Add(self.navtools_cb, ui_defaults.lbl_pct,
                                  ui_defaults.sizer_flags,
                                  ui_defaults.widget_margin)
        self.add_toolbar()
        self.SetIcon(self.parent.GetIcon())
        self.main_panel.SetSizerAndFit(self.main_panel_sizer)
        self.sizer.Add(self.main_panel, 1, ui_defaults.sizer_flags, 0)
        self.SetSizerAndFit(self.sizer)

    def add_toolbar(self):
        """Creates the matplotlib toolbar (zoom, pan/scroll, etc.)
        for the plot"""
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if wx.Platform == '__WXMAC__':
            self.SetToolBar(self.toolbar)
        else:
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(wx.Size(fw, th))
            self.main_panel_sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND, 0)
        self.toolbar.update()
        self.toggle_toolbar()

    def toggle_toolbar(self):
        """Enables / disables the navigation toolbar and sets
        cursors accordingly."""
        if self.navtools_enabled():
            self.canvas.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
        else:
            self.canvas.SetCursor(wx.StockCursor(wx.CURSOR_CROSS))
        self.toolbar.Enable(self.navtools_enabled())
        self.controller.set_navtools_config(self.navtools_enabled())

    def init_plot_menu(self):
        """Creates the Plot menu"""
        self.plot_mnu = wx.Menu()

        self.labels_mnu = wx.Menu()  # Titles and Labels
        plottitle_mnui = wx.MenuItem(self.labels_mnu,
                                     wx.ID_ANY,
                                     text="Set Plot Title",
                                     help="Set Plot Title")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_set_plottitle,
                  id=plottitle_mnui.GetId())
        self.labels_mnu.AppendItem(plottitle_mnui)
        xlbl_mnui = wx.MenuItem(self.labels_mnu,
                                wx.ID_ANY,
                                text="Set X Axis Label",
                                help="Set X Axis Label")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_set_xlabel,
                  id=xlbl_mnui.GetId())
        self.labels_mnu.AppendItem(xlbl_mnui)
        ylbl_mnui = wx.MenuItem(self.labels_mnu,
                                wx.ID_ANY,
                                text="Set Y Axis Label",
                                help="Set Y Axis Label")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_set_ylabel,
                  id=ylbl_mnui.GetId())
        self.labels_mnu.AppendItem(ylbl_mnui)
        cbarlbl_mnui = wx.MenuItem(self.labels_mnu,
                                   wx.ID_ANY,
                                   text='Set Colorbar Label',
                                   help='Set Colorbar Label')
        self.Bind(wx.EVT_MENU,
                  self.controller.on_set_cbarlbl,
                  id=cbarlbl_mnui.GetId())
        self.labels_mnu.AppendItem(cbarlbl_mnui)
        self.plot_mnu.AppendMenu(wx.ID_ANY, "Title And Labels",
                                 self.labels_mnu)

        self.colormaps_mnu = wx.Menu()  # Colormaps
        self.preview_cmaps_mnui = wx.MenuItem(
            self.colormaps_mnu,
            wx.ID_ANY,
            text='Preview Colormaps',
            help='Preview available colormaps')
        self.Bind(wx.EVT_MENU,
                  self.controller.on_preview_cmaps,
                  id=self.preview_cmaps_mnui.GetId())
        self.colormaps_mnu.AppendItem(self.preview_cmaps_mnui)
        self.select_cmap_mnui = wx.MenuItem(self.colormaps_mnu,
                                            wx.ID_ANY,
                                            text='Select Colormap...',
                                            help='Selects colormap')
        self.Bind(wx.EVT_MENU,
                  self.controller.on_select_cmap,
                  id=self.select_cmap_mnui.GetId())
        self.colormaps_mnu.AppendItem(self.select_cmap_mnui)
        self.create_cmap_mnui = wx.MenuItem(self.colormaps_mnu,
                                            wx.ID_ANY,
                                            text='Create Colormap...',
                                            help='Create or edit a colormap')
        self.colormaps_mnu.AppendItem(self.create_cmap_mnui)
        self.Bind(wx.EVT_MENU,
                  self.controller.on_create_cmap,
                  id=self.create_cmap_mnui.GetId())
        self.plot_mnu.AppendMenu(wx.ID_ANY, "Colormaps", self.colormaps_mnu)
        self.show_colorbar_mnui = wx.MenuItem(
            self.plot_mnu,
            wx.ID_ANY,
            text="Show Colorbar",
            help="Show color scale in image plot",
            kind=wx.ITEM_CHECK)
        self.Bind(wx.EVT_MENU,
                  self.controller.on_toggle_colorbar,
                  id=self.show_colorbar_mnui.GetId())
        self.plot_mnu.AppendItem(self.show_colorbar_mnui)
        self.show_colorbar_mnui.Check(self.controller.get_colorbar_config())
        self.plot_conventional_bscans_mnui = wx.MenuItem(
            self.plot_mnu,
            wx.ID_ANY,
            text="Plot Conventional B-scans",
            help="Plot conventional 2D B-scans",
            kind=wx.ITEM_CHECK)
        self.Bind(wx.EVT_MENU,
                  self.controller.on_change_bscans,
                  id=self.plot_conventional_bscans_mnui.GetId())
        self.plot_mnu.AppendItem(self.plot_conventional_bscans_mnui)
        self.plot_conventional_bscans_mnui.Check(
            self.controller.conventional_bscans)
        gridtoggle_mnui = wx.MenuItem(self.plot_mnu,
                                      wx.ID_ANY,
                                      text="Toggle Grid",
                                      help="Turns grid on or off")
        self.plot_mnu.AppendItem(gridtoggle_mnui)
        self.Bind(wx.EVT_MENU,
                  self.controller.on_toggle_grid,
                  id=gridtoggle_mnui.GetId())
        self.menubar.Append(self.plot_mnu, "&Plot")

    def init_specific_ops_menu(self):
        """Creates any plot-specific Operations menu items"""
        self.setcscan_mnui = wx.MenuItem(
            self.ops_mnu,
            wx.ID_ANY,
            text="Define C Scan",
            help="Specify function to generate C Scan")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_define_cscan,
                  id=self.setcscan_mnui.GetId())
        self.ops_mnu.AppendItem(self.setcscan_mnui)
        self.rect_mnu = wx.Menu()  # Rectification operations
        self.fullrect_mnui = wx.MenuItem(self.rect_mnu,
                                         wx.ID_ANY,
                                         text="Full",
                                         help="Full Rectification")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_rectify,
                  id=self.fullrect_mnui.GetId())
        self.rect_mnu.AppendItem(self.fullrect_mnui)
        self.ops_mnu.AppendMenu(wx.ID_ANY, 'Rectify', self.rect_mnu)
        self.gate_mnu = wx.Menu()  # Gates operations
        for gate in self.controller.gates:
            gate_name = self.controller.gates[gate][0]
            gate_desc = "Applies a {0} gate function to the data".format(
                gate_name)
            gate_mnui = wx.MenuItem(self.gate_mnu,
                                    id=gate,
                                    text=gate_name,
                                    help=gate_desc)
            self.gate_mnu.AppendItem(gate_mnui)
            self.Bind(wx.EVT_MENU,
                      self.controller.on_apply_gate,
                      id=gate_mnui.GetId())
        self.ops_mnu.AppendMenu(wx.ID_ANY, 'Gates', self.gate_mnu)

    def navtools_enabled(self):
        """Returns True if plot navigation bar is enabled"""
        return self.navtools_cb.IsChecked()

    @property
    def plot_conventional_bscans(self):
        """True if the Bscan plots should be conventional 2D imgplots vs. the original Megaplot 1D"""
        return self.plot_conventional_bscans_mnui.IsChecked()

    @plot_conventional_bscans.setter
    def plot_conventional_bscans(self, on=True):
        """Sets the use of conventional Bscans or the original 1D Megaplot Bscans"""
        self.plot_conventional_bscans_mnui.Check(on)

    @property
    def plot_linear_bscans(self):
        """True if the Bscan plots should be the original 1D Megaplot plots"""
        return not self.plot_conventional_bscans
Ejemplo n.º 14
0
class PlotWindow(wx.Frame):
    """Basic wxPython UI element for displaying matplotlib plots"""
    def __init__(self, parent, data_file):
        self.parent = parent
        self.data_file = data_file
        self.controller = PlotWindowController(self, data_file)
        module_logger.info("Successfully initialized PlotWindow.")
        self.load_data()

    def has_data(self):
        """Returns True if data is not None"""
        return self.controller.data is not None

    def load_data(self):
        """Loads the data set and plots"""
        exception_queue = Queue.Queue()
        data_thd = workerthread.WorkerThread(exception_queue=exception_queue,
                                             target=self.controller.load_data)
        data_thd.start()
        while True:
            data_thd.join(0.125)
            if not data_thd.is_alive():
                try:
                    exc_type, exc = exception_queue.get(block=False)
                    err_str = str(exc)
                    if len(err_str) == 0:
                        err_str = exc_type.__name__
                    module_logger.error(
                        "Unable to load data: {0}".format(err_str))
                    err_msg = "An error occurred while loading data:\n{0}".format(
                        err_str)
                    if len(err_msg) > 150:
                        # Truncate lengthy error messages
                        err_msg = ''.join([err_msg[:150], "\n(continued)"])
                    err_dlg = wx.MessageDialog(self.parent,
                                               message=err_msg,
                                               caption="Unable To Load Data",
                                               style=wx.ICON_ERROR)
                    err_dlg.ShowModal()
                except Queue.Empty:
                    pass
                break
            wx.GetApp().Yield(True)
        if self.has_data():
            self.title = 'Plot - {0}'.format(os.path.basename(self.data_file))
            wx.Frame.__init__(self,
                              id=wx.ID_ANY,
                              parent=self.parent,
                              title=self.title)
            self.init_menu()
            self.init_ui()
            self.controller.plot(self.controller.data)

    def init_ui(self):
        """Creates the PlotWindow UI"""
        parent_x, parent_y = self.parent.GetPositionTuple()
        parent_w, parent_h = self.parent.GetSize()
        self.SetPosition((parent_x + parent_w + ui_defaults.widget_margin,
                          ui_defaults.widget_margin))
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.figure = Figure(figsize=(5, 4))
        self.canvas = FigureCanvas(self, wx.ID_ANY, self.figure)
        self.axes = self.figure.add_subplot(111, picker=True)
        self.axes.grid(True)
        #self.cursor = Cursor(self.axes, useblit=True, color='green', alpha=0.5, linestyle='--',
        # linewidth=2)
        self.sizer.Add(self.canvas, 1, ui_defaults.sizer_flags, 0)
        self.add_toolbar()
        self.SetIcon(self.parent.GetIcon())
        self.SetSizerAndFit(self.sizer)

    def add_toolbar(self):
        """Creates the matplotlib toolbar (zoom, pan/scroll, etc.)
        for the plot"""
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if wx.Platform == '__WXMAC__':
            self.SetToolBar(self.toolbar)
        else:
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND, 0)
        self.toolbar.update()

    def init_menu(self):
        """Creates the main menu"""
        self.menubar = wx.MenuBar()
        self.init_file_menu()
        self.init_plot_menu()
        self.init_ops_menu()
        self.init_tools_menu()
        self.init_help_menu()
        self.SetMenuBar(self.menubar)

    def init_file_menu(self):
        """Creates the File menu"""
        self.file_mnu = wx.Menu()
        savedata_mnui = wx.MenuItem(self.file_mnu,
                                    wx.ID_ANY,
                                    text="Save Current Data",
                                    help="Save current data to disk")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_save_data,
                  id=savedata_mnui.GetId())
        self.file_mnu.AppendItem(savedata_mnui)
        close_mnui = wx.MenuItem(self.file_mnu,
                                 wx.ID_ANY,
                                 text="Close Window",
                                 help="Close the plot window")
        self.Bind(wx.EVT_MENU, self.controller.on_close, id=close_mnui.GetId())
        self.file_mnu.AppendItem(close_mnui)
        self.menubar.Append(self.file_mnu, "&File")

    def init_plot_menu(self):
        """Creates the Plot menu"""
        self.plot_mnu = wx.Menu()

        self.labels_mnu = wx.Menu()  # Titles and Labels
        plottitle_mnui = wx.MenuItem(self.labels_mnu,
                                     wx.ID_ANY,
                                     text="Set Plot Title",
                                     help="Set Plot Title")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_set_plottitle,
                  id=plottitle_mnui.GetId())
        self.labels_mnu.AppendItem(plottitle_mnui)
        xlbl_mnui = wx.MenuItem(self.labels_mnu,
                                wx.ID_ANY,
                                text="Set X Axis Label",
                                help="Set X Axis Label")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_set_xlabel,
                  id=xlbl_mnui.GetId())
        self.labels_mnu.AppendItem(xlbl_mnui)
        ylbl_mnui = wx.MenuItem(self.labels_mnu,
                                wx.ID_ANY,
                                text="Set Y Axis Label",
                                help="Set Y Axis Label")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_set_ylabel,
                  id=ylbl_mnui.GetId())
        self.labels_mnu.AppendItem(ylbl_mnui)
        self.plot_mnu.AppendMenu(wx.ID_ANY, 'Title And Labels',
                                 self.labels_mnu)

        gridtoggle_mnui = wx.MenuItem(self.plot_mnu,
                                      wx.ID_ANY,
                                      text="Toggle Grid",
                                      help="Turns grid on or off")
        self.plot_mnu.AppendItem(gridtoggle_mnui)
        self.Bind(wx.EVT_MENU,
                  self.controller.on_toggle_grid,
                  id=gridtoggle_mnui.GetId())
        self.menubar.Append(self.plot_mnu, "&Plot")

    def init_ops_menu(self):
        """Creates the Operations menu"""
        self.ops_mnu = wx.Menu()
        self.revert_mnui = wx.MenuItem(self.ops_mnu,
                                       wx.ID_ANY,
                                       text='Revert To Original',
                                       help='Revert to original data set')
        self.Bind(wx.EVT_MENU,
                  self.controller.on_revert,
                  id=self.revert_mnui.GetId())
        self.ops_mnu.AppendItem(self.revert_mnui)
        self.init_specific_ops_menu()
        self.menubar.Append(self.ops_mnu, '&Operations')

    def init_specific_ops_menu(self):
        """Creates any plot-specific Operations menu items"""
        self.rect_mnu = wx.Menu()  # Rectification operations
        self.fullrect_mnui = wx.MenuItem(self.rect_mnu,
                                         wx.ID_ANY,
                                         text="Full",
                                         help="Full Rectification")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_rectify,
                  id=self.fullrect_mnui.GetId())
        self.rect_mnu.AppendItem(self.fullrect_mnui)
        self.ops_mnu.AppendMenu(wx.ID_ANY, 'Rectify', self.rect_mnu)

        self.gate_mnu = wx.Menu()  # Gates operations
        for gate in self.controller.gates:
            gate_name = self.controller.gates[gate][0]
            gate_desc = "Applies a {0} gate function to the data".format(
                gate_name)
            gate_mnui = wx.MenuItem(self.gate_mnu,
                                    id=gate,
                                    text=gate_name,
                                    help=gate_desc)
            self.gate_mnu.AppendItem(gate_mnui)
            self.Bind(wx.EVT_MENU,
                      self.controller.on_apply_gate,
                      id=gate_mnui.GetId())
        self.ops_mnu.AppendMenu(wx.ID_ANY, 'Gates', self.gate_mnu)

    def init_tools_menu(self):
        """Initializes the Tools Menu (Plugins and external scripts)"""
        self.tools_mnu = wx.Menu()
        self.init_plugins_menu()
        self.menubar.Append(self.tools_mnu, '&Tools')

    def init_plugins_menu(self):
        """Initializes the Plugins menu"""
        # If the Plugins menu already exists,
        # delete and rebuild.  Used to refresh
        # list of available plugins after installing
        # a new one
        plugins_mnu_id = self.tools_mnu.FindItem("Plugins")
        if plugins_mnu_id != -1:
            self.tools_mnu.RemoveItem(
                self.tools_mnu.FindItemById(plugins_mnu_id))
        self.plugins_mnu = wx.Menu()
        plugins = self.controller.available_plugins
        for plugin_id, plugin in plugins.items():
            plugin_name = plugin[1].name
            plugin_description = plugin[1].description
            script_mnui = wx.MenuItem(self.tools_mnu,
                                      id=plugin_id,
                                      text=plugin_name,
                                      help=plugin_description)
            self.Bind(wx.EVT_MENU,
                      self.controller.on_run_toolkit,
                      id=script_mnui.GetId())
            self.plugins_mnu.AppendItem(script_mnui)
        self.plugins_mnu.AppendSeparator()
        install_plugin_mnui = wx.MenuItem(self.plugins_mnu,
                                          wx.ID_ANY,
                                          text="Install Plugin...",
                                          help="Install a local plugin")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_install_plugin,
                  id=install_plugin_mnui.GetId())
        self.plugins_mnu.AppendItem(install_plugin_mnui)
        download_plugin_mnui = wx.MenuItem(
            self.plugins_mnu,
            wx.ID_ANY,
            text="Download Plugin...",
            help="Download and install a new plugin")
        self.Bind(wx.EVT_MENU,
                  self.controller.on_download_plugin,
                  id=download_plugin_mnui.GetId())
        self.plugins_mnu.AppendItem(download_plugin_mnui)
        self.tools_mnu.AppendMenu(wx.ID_ANY, "Plugins", self.plugins_mnu)

    def init_help_menu(self):
        pass
Ejemplo n.º 15
0
class PlotFigure(Frame):
    def __init__(self):
        Frame.__init__(self, None, -1, "96 Well Plate - Dynamic Heat Map")

        self.fig = Figure((8, 6), 100)
        self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()

        # On Windows, default frame size behaviour is incorrect
        # you don't need this under Linux
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(Size(fw, th))

        # Create a figure manager to manage things

        # Now put all into a sizer
        sizer = BoxSizer(VERTICAL)
        # This way of adding to sizer allows resizing
        sizer.Add(self.canvas, 1, LEFT | TOP | GROW)
        # Best to allow the toolbar to resize!
        sizer.Add(self.toolbar, 0, GROW)
        self.SetSizer(sizer)
        self.Fit()
        EVT_TIMER(self, TIMER_ID, self.onTimer)

    def init_plot_data(self):

        # read in cell numbers
        self.Nr = int(options.rows)
        self.Nc = int(options.columns)

        print "Number of Wells: ", self.Nr * self.Nc

        # initialize data array and plot for the 1st time
        self.data = np.zeros([self.Nr * self.Nc])
        # create matrix which will contain the number of counted cells
        well96 = np.zeros([self.Nr, self.Nc])

        # labeling schemes
        LabelX = [
            '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12',
            '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23',
            '24'
        ]

        LabelY = [
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
            'N', 'O', 'P'
        ]

        labelx = LabelX[0:self.Nc]
        labely = LabelY[0:self.Nr]

        print "Label X: ", labelx
        print "Label Y: ", labely

        self.ax1 = self.fig.add_axes([0.075, 0.1, 0.75, 0.85])
        self.cax = self.fig.add_axes([0.85, 0.1, 0.075, 0.85])
        self.im = self.ax1.imshow(well96, cmap=cm.jet, interpolation='nearest')
        self.fig.colorbar(self.im, cax=self.cax, orientation='vertical')

        self.ax1.set_xticks(np.arange(0, self.Nc, 1))
        self.ax1.set_xticklabels(labelx)
        self.ax1.set_yticks(np.arange(0, self.Nr, 1))
        self.ax1.set_yticklabels(labely)
        self.ax1.set_title('Cell Count per Well')

        self.figure_saved = False

    def onTimer(self, evt):

        datain = np.loadtxt(options.filename, delimiter='\t')

        current_well = datain.shape[0]
        #print current_well

        self.data[0:len(datain[:, 1])] = datain[:, 1]
        welldata = self.data.reshape(self.Nr, self.Nc)
        #print welldata
        #self.im.set_array(welldata)
        self.im = self.ax1.imshow(welldata,
                                  vmin=datain[:, 1].min(),
                                  vmax=datain[:, 1].max(),
                                  cmap=cm.jet,
                                  interpolation='nearest')
        self.fig.colorbar(self.im, cax=self.cax, orientation='vertical')
        self.canvas.draw()

        # save plot only when done and only once
        if (current_well == self.Nr * self.Nc and self.figure_saved == False):
            self.fig.savefig(savename)
            self.figure_saved = True
Ejemplo n.º 16
0
class CanvasFrame(wxFrame):
    
    def __init__(self):
        wxFrame.__init__(self,None,-1,
                         'CanvasFrame',size=(550,350))

        self.SetBackgroundColour(wxNamedColor("WHITE"))

        self.figure = Figure()
        self.axes = self.figure.add_subplot(111)
        t = arange(0.0,3.0,0.01)
        s = sin(2*pi*t)
        
        self.axes.plot(t,s)
        self.axes.set_xlabel('Time (s)')
        self.axes.set_ylabel('Price ($)')                
        self.canvas = FigureCanvas(self, -1, self.figure)
        self.canvas.mpl_connect('motion_notify_event', self.mouse_move)
        self.sizer = wxBoxSizer(wxVERTICAL)
        self.sizer.Add(self.canvas, 1, wxLEFT | wxTOP | wxGROW)
        self.SetSizer(self.sizer)
        self.Fit()

        self.statusBar =         wxStatusBar(self, -1)
        self.statusBar.SetFieldsCount(1)
        self.SetStatusBar(self.statusBar)

        self.add_toolbar()  # comment this out for no toolbar

        EVT_PAINT(self, self.OnPaint)


    def mouse_move(self, event):
        self.draw_cursor(event)

    def add_toolbar(self):
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(wxSize(fw, th))
        self.sizer.Add(self.toolbar, 0, wxLEFT | wxEXPAND)
        # update the axes menu on the toolbar
        self.toolbar.update()  

    def OnPaint(self, event):
        self.erase_cursor()
        try: del self.lastInfo
        except AttributeError: pass
        self.canvas.draw()
        event.Skip()

    def draw_cursor(self, event):
        'event is a MplEvent.  Draw a cursor over the axes'
        if event.inaxes is None:
            self.erase_cursor()
            try: del self.lastInfo
            except AttributeError: pass
            return
        canvas = self.canvas
        figheight = canvas.figure.bbox.height()
        ax = event.inaxes
        left,bottom,width,height = ax.bbox.get_bounds()
        bottom = figheight-bottom
        top = bottom - height
        right = left + width
        x, y = event.x, event.y
        y = figheight-y

        dc = wxClientDC(canvas)
        dc.SetLogicalFunction(wxXOR)            
        wbrush = wxBrush(wxColour(255,255,255), wxTRANSPARENT)
        wpen = wxPen(wxColour(200, 200, 200), 1, wxSOLID)
        dc.SetBrush(wbrush)
        dc.SetPen(wpen)
            
        dc.ResetBoundingBox()
        dc.BeginDrawing()

        x, y, left, right, bottom, top = [int(val) for val in x, y, left, right, bottom, top]

        self.erase_cursor()
        line1 = (x, bottom, x, top)
        line2 = (left, y, right, y)
        self.lastInfo = line1, line2, ax, dc
        dc.DrawLine(*line1) # draw new
        dc.DrawLine(*line2) # draw new        
        dc.EndDrawing()

        time, price = event.xdata, event.ydata
        self.statusBar.SetStatusText("Time=%f  Price=%f"% (time, price), 0)

    def erase_cursor(self):
        try: lastline1, lastline2, lastax, lastdc = self.lastInfo
        except AttributeError: pass
        else:
            lastdc.DrawLine(*lastline1) # erase old
            lastdc.DrawLine(*lastline2) # erase old            
Ejemplo n.º 17
0
class UI(wx.Frame):
    """Basic wxPython user interface"""
    def __init__(self, *args, **kwargs):
        self.base_title = "Gocator Profile Plotter"
        wx.Frame.__init__(self,
                          parent=None,
                          title=self.base_title,
                          *args,
                          **kwargs)
        self.init_ui()
        self.data_fname = None

    def init_ui(self):
        """Creates the user interface"""
        self.init_menu()
        self.SetSize(wx.Size(640, 480))
        self.main_panel = wx.Panel(self)
        self.main_panel_sizer = wx.BoxSizer(wx.VERTICAL)
        self.figure = Figure()
        self.canvas = FigureCanvas(self.main_panel, wx.ID_ANY, self.figure)
        self.main_panel_sizer.Add(self.canvas, 1, sizer_flags, 0)
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if wx.Platform == '__WXMAC__':
            self.SetToolBar(self.toolbar)
        else:
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(wx.Size(fw, th))
            self.main_panel_sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND, 0)
        self.toolbar.update()
        self.main_panel.SetSizerAndFit(self.main_panel_sizer)

    def init_menu(self):
        """Creates the main menu"""
        self.menubar = wx.MenuBar()
        self.file_mnu = wx.Menu()
        self.plotdata_mnui = wx.MenuItem(
            self.file_mnu,
            wx.ID_ANY,
            text="Plot Data...\tCTRL+O",
            help="Reads and plots an XYZ CSV data file")
        self.Bind(wx.EVT_MENU,
                  self.on_plot_data,
                  id=self.plotdata_mnui.GetId())
        self.file_mnu.AppendItem(self.plotdata_mnui)
        plottype_mnu = wx.Menu()
        self.plot_pointcloud_mnui = wx.MenuItem(
            plottype_mnu,
            wx.ID_ANY,
            text="Point Cloud",
            help="Plots the laser profile as a point cloud",
            kind=wx.ITEM_RADIO)
        self.Bind(wx.EVT_MENU,
                  self.on_plot_type,
                  id=self.plot_pointcloud_mnui.GetId())
        plottype_mnu.AppendItem(self.plot_pointcloud_mnui)
        self.plot_surface_mnui = wx.MenuItem(
            plottype_mnu,
            wx.ID_ANY,
            text="Fitted Surface",
            help="Plots the laser profile as an interpolated surface",
            kind=wx.ITEM_RADIO)
        self.Bind(wx.EVT_MENU,
                  self.on_plot_type,
                  id=self.plot_surface_mnui.GetId())
        plottype_mnu.AppendItem(self.plot_surface_mnui)
        self.plot_wireframe_mnui = wx.MenuItem(
            plottype_mnu,
            wx.ID_ANY,
            text="Fitted Wireframe Surface",
            help="Plots the laser profile as an interpolated wireframe surface",
            kind=wx.ITEM_RADIO)
        plottype_mnu.AppendItem(self.plot_wireframe_mnui)
        self.Bind(wx.EVT_MENU,
                  self.on_plot_type,
                  id=self.plot_wireframe_mnui.GetId())
        self.file_mnu.AppendSubMenu(plottype_mnu, "Type Of Plot")
        self.plotrawdata = wx.MenuItem(self.file_mnu,
                                       wx.ID_ANY,
                                       text="Plot Raw Data",
                                       help="Plot raw vs. filtered data",
                                       kind=wx.ITEM_CHECK)
        self.Bind(wx.EVT_MENU,
                  self.on_filter_data,
                  id=self.plotrawdata.GetId())
        self.file_mnu.AppendItem(self.plotrawdata)
        self.setzlim_mnui = wx.MenuItem(self.file_mnu,
                                        wx.ID_ANY,
                                        text="Set Z Axis Limits...\tCTRL+Z",
                                        help="Sets the limits of the Z Axis")
        self.Bind(wx.EVT_MENU, self.on_setzlim, id=self.setzlim_mnui.GetId())
        self.file_mnu.AppendItem(self.setzlim_mnui)
        self.quit_mnui = wx.MenuItem(self.file_mnu,
                                     wx.ID_ANY,
                                     text="Exit Plotter\tCTRL+Q")
        self.Bind(wx.EVT_MENU, self.on_quit, id=self.quit_mnui.GetId())
        self.file_mnu.AppendItem(self.quit_mnui)
        self.menubar.Append(self.file_mnu, "Operation")
        self.SetMenuBar(self.menubar)

    def on_plot_data(self, evt):
        """Handles request to plot data"""
        allfiles_wildcard = "All Files (*.*)|*.*"
        txt_wildcards = "Text Files|*.txt;*.csv;*.dat;*.tab;*.asc"
        wildcards = "|".join([txt_wildcards, allfiles_wildcard])
        file_dlg = wx.FileDialog(parent=self,
                                 message="Please specify a file",
                                 wildcard=wildcards,
                                 style=wx.FD_OPEN)
        if file_dlg.ShowModal() == wx.ID_OK:
            self.data_fname = file_dlg.GetPath()
            self.plot_data(self.data_fname)
            self.SetTitle(' - '.join(
                [self.base_title,
                 os.path.basename(self.data_fname)]))

    def plot_data(self, data_fname):
        """Reads and plots the specified data file"""
        self.figure.clf()
        self.axes = self.figure.add_subplot(111, projection='3d')
        self.axes.grid(True)
        try:
            wx.BeginBusyCursor()
            x, y, z = self.get_data(data_fname)
            if self.plot_pointcloud_mnui.IsChecked():
                # Plot a point cloud
                self.axes.plot(x,
                               y,
                               z,
                               c='#4F6581',
                               linestyle='',
                               marker=',',
                               rasterized=True)
            else:
                xi = np.linspace(min(x), max(x), num=100)
                yi = np.linspace(min(y), max(y), num=100)
                X, Y = np.meshgrid(xi, yi)
                Z = griddata(x, y, z, xi, yi)
                if self.plot_surface_mnui.IsChecked():
                    # Interpolate a surface from the point cloud to plot
                    surf = self.axes.plot_surface(X,
                                                  Y,
                                                  Z,
                                                  rstride=3,
                                                  cstride=3,
                                                  cmap=cm.get_cmap('spectral'),
                                                  linewidth=1,
                                                  antialiased=True)
                    colorbar = self.figure.colorbar(surf)
                    colorbar.set_label("Z Position [mm]")
                elif self.plot_wireframe_mnui.IsChecked():
                    # Interpolate a wireframe surface from the point cloud to plot
                    # Uses a higher resolution presentation than the surface - surface tends to bog down
                    # on some systems with stride set to 1
                    surf = self.axes.plot_wireframe(X,
                                                    Y,
                                                    Z,
                                                    rstride=1,
                                                    cstride=1,
                                                    color='#4F6581',
                                                    linewidth=1,
                                                    antialiased=True)
                self.axes.set_zlim3d(np.min(Z), np.max(Z))
            self.axes.set_xlabel('X Position [mm]')
            self.axes.set_ylabel('Y Position [mm]')
            self.axes.set_zlabel('Z Position [mm]')
            self.axes.set_title(os.path.basename(self.data_fname))

            self.refresh_plot()
        except IOError:  # no data
            err_dlg = wx.MessageDialog(
                self,
                caption="Invalid Data File",
                message="Unable to read data from {0}.".format(data_fname),
                style=wx.ICON_ERROR)
            err_dlg.ShowModal()
            err_dlg.Destroy()
            return
        except ValueError:  # couldn't convert to floating point
            err_dlg = wx.MessageDialog(
                self,
                caption="Invalid Input",
                message=
                "An error occurred reading the data.\nPlease ensure the data is properly formatted.",
                style=wx.ICON_ERROR)
            err_dlg.ShowModal()
            err_dlg.Destroy()
            return
        finally:
            wx.EndBusyCursor()

    def get_data(self, data_fname):
        """Reads the specified data file, optionally filtering the data before returning it as X,Y,Z."""
        x, y, z = np.genfromtxt(data_fname, delimiter=",", unpack=True)
        if not self.plotrawdata.IsChecked():
            xi = x[z > -20]
            yi = y[z > -20]
            zi = scipy.signal.wiener(z[z > -20], mysize=15, noise=1)
        else:
            xi = x
            yi = y
            zi = z
        return xi, yi, zi

    def get_zlim(self):
        """Wrapper for matplotlib API changes in retrieving Z limits"""
        try:
            min_val, max_val = self.axes.get_zlim()
        except AttributeError:
            min_val, max_val = self.axes.get_zlim3d()
        finally:
            return min_val, max_val

    def set_zlim(self, limits_tuple):
        """Wrapper for matplotlib API changes in setting Z limits"""
        try:
            self.axes.set_zlim(limits_tuple)
        except AttributeError:
            self.axes.set_zlim3d(limits_tuple)

    def on_setzlim(self, evt):
        """Handles request to reset the Z axis limits"""
        if hasattr(self, 'axes'):
            rng_dlg = FloatRangeDialog(dlg_title="Set Z Axis Limits")
            min_val, max_val = self.get_zlim()
            rng_dlg.setValues(min_val, max_val)
            if rng_dlg.ShowModal() == wx.ID_OK:
                min_val, max_val = rng_dlg.GetValue()
                if min_val is not None and max_val is not None:
                    self.set_zlim((min_val, max_val))
                    self.refresh_plot()
            rng_dlg.Destroy()

    def on_plot_type(self, evt):
        """Handles change in choice of plot type"""
        if hasattr(self, 'data_fname'):
            if self.data_fname is not None:
                axis_limits = self.get_zlim()
                self.plot_data(self.data_fname)
                self.set_zlim(axis_limits)
                self.refresh_plot()

    def on_filter_data(self, evt):
        """Handles change in choice of filtering data"""
        if hasattr(self, 'data_fname'):
            if self.data_fname is not None:
                self.plot_data(self.data_fname)

    def refresh_plot(self):
        """Forces plot to redraw itself"""
        self.canvas.draw()

    def on_quit(self, evt):
        """Handles request to exit the program"""
        self.Destroy()
Ejemplo n.º 18
0
class CanvasFrameRetMap(wxFrame):
    def __init__(self):
        wxFrame.__init__(self, None, -1, 'Return Map', size=(1700, 900))

        IBIs = []
        IBITimes = []
        for i in range(len(pixelvec)):

            ibis = []
            timeZ = []
            j = 0
            thresh = Threshold[i]
            print thresh
            xlp = FilteredLongTS[i]

            for i in range(2 * 71990):
                #for i in range(len(longvec)-1):
                j += 1
                if ((xlp[i] < thresh) & (xlp[i + 1] > thresh)):
                    ibis.append(j)
                    timeZ.append(i)
                    j = 0
            print 'ibis length, i ', len(ibis), i
            IBIs.append(ibis)
            IBITimes.append(timeZ)

#	print LongTSPixelMat
        print len(LongTSPixelMat)

        IBIsA = []
        IBIsB = []

        for i in range(len(pixelvec)):
            ibisa = IBIs[i][0:len(IBIs[i]) - 1]
            ibisb = IBIs[i][1:len(IBIs[i])]
            IBIsA.append(ibisa)
            IBIsB.append(ibisb)

        print 'IBI len ', len(IBIs[0])

        print 'IBIsA len ', len(IBIsA)

        self.SetBackgroundColour(wxNamedColor("BLACK"))

        #	print Threshold

        self.figure = Figure(figsize=(6, 6), dpi=150)
        self.axes1 = self.figure.add_subplot(231)

        self.axes2 = self.figure.add_subplot(232)
        self.axes2.set_title(str(FileString[0]))

        self.axes3 = self.figure.add_subplot(233)

        self.axes4 = self.figure.add_subplot(234)

        self.axes5 = self.figure.add_subplot(235)

        #        self.axes5.set_xlabel(str(FileString[0]), fontsize = 8)
        self.axes5.set_xlabel('dfgs', fontsize=8)

        if (len(pixelvec) > 0):
            self.axes1.plot(IBIsA[0], IBIsB[0], '.', markersize=2)
            self.axes1.plot(range(300))
            self.axes1.set_xlim([-10, 300])
            self.axes1.set_ylim([-10, 300])
            self.axes1.set_xlabel(str(coords[0]), fontsize=8)

        if (len(pixelvec) > 1):
            self.axes2.plot(IBIsA[1], IBIsB[1], '.', markersize=2)
            self.axes2.plot(range(300))
            self.axes2.set_xlim([-10, 300])
            self.axes2.set_ylim([-10, 300])
            self.axes2.set_xlabel(str(coords[1]), fontsize=8)

        if (len(pixelvec) > 2):
            self.axes3.plot(IBIsA[2], IBIsB[2], '.', markersize=2)
            self.axes3.plot(range(300))
            self.axes3.set_xlim([-10, 300])
            self.axes3.set_ylim([-10, 300])
            self.axes3.set_xlabel(str(coords[2]), fontsize=8)

        if (len(pixelvec) > 3):
            self.axes4.plot(IBIsA[3], IBIsB[3], '.', markersize=2)
            self.axes4.plot(range(300))
            self.axes4.set_xlim([-10, 300])
            self.axes4.set_xlabel(str(coords[3]), fontsize=8)
            self.axes4.set_ylim([-10, 300])

        if (len(pixelvec) > 4):
            self.axes5.plot(IBIsA[4], IBIsB[4], '.', markersize=2)
            self.axes5.plot(range(300))
            self.axes5.set_xlim([-10, 300])
            self.axes5.set_ylim([-10, 300])
            self.axes5.set_xlabel(str(coords[4]), fontsize=8)

        self.canvas = FigureCanvas(self, -1, self.figure)

        self.sizer = wxBoxSizer(wxVERTICAL)
        self.sizer.Add(self.canvas, 1, wxTOP | wxLEFT | wxEXPAND)
        # Capture the paint message
        EVT_PAINT(self, self.OnPaint)

        self.toolbar = MyNavigationToolbar(self.canvas, True)
        self.toolbar.Realize()
        if wxPlatform == '__WXMAC__':
            # Mac platform (OSX 10.3, MacPython) does not seem to cope with
            # having a toolbar in a sizer. This work-around gets the buttons
            # back, but at the expense of having the toolbar at the top
            self.SetToolBar(self.toolbar)
        else:
            # On Windows platform, default window size is incorrect, so set
            # toolbar width to figure width.
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            # By adding toolbar in sizer, we are able to put it at the bottom
            # of the frame - so appearance is closer to GTK version.
            # As noted above, doesn't work for Mac.
            self.toolbar.SetSize(wxSize(fw, th))
            self.sizer.Add(self.toolbar, 0, wxLEFT | wxEXPAND)

        # update the axes menu on the toolbar
        self.toolbar.update()
        self.SetSizer(self.sizer)
        self.Fit()

    def OnPaint(self, event):
        self.canvas.draw()
        event.Skip()
Ejemplo n.º 19
0
class RetMapSection(wxFrame):
    def __init__(self):
        wxFrame.__init__(self, None, -1, 'Return Map', size=(1700, 900))

        print RetMapLims[0]
        print RetMapLims[1]
        print ChosenIBIMap

        i = ChosenIBIMap[len(ChosenIBIMap) - 1] - 1
        k = i
        ibis = []
        timeZ = []

        j = 0
        thresh = Threshold[i]
        print thresh
        xlp = FilteredLongTS[i]
        print len(xlp), 'xlp'
        RMVec = xlp[RetMapLims[0]:RetMapLims[1]]
        print len(RMVec), 'RMVec'
        for i in range(len(RMVec) - 1):
            #for i in range(len(longvec)-1):
            j += 1
            if ((RMVec[i] < thresh) & (RMVec[i + 1] > thresh)):
                ibis.append(j)
                timeZ.append(i)
                j = 0
        print 'ibis length, i ', len(ibis), i

        ibisa = ibis[0:len(ibis) - 1]
        ibisb = ibis[1:len(ibis)]

        self.SetBackgroundColour(wxNamedColor("BLACK"))

        #	print Threshold

        self.figure = Figure(figsize=(6, 6), dpi=150)
        self.axes1 = self.figure.add_subplot(111)
        self.axes1.set_title(str(FileString[0]), fontsize=12)

        self.axes1.plot(ibisa, ibisb, '.', markersize=2)
        self.axes1.plot(range(300))
        self.axes1.set_xlim([-10, 300])
        self.axes1.set_ylim([-10, 300])

        print k
        print coords[k]
        print RetMapLims[0]
        print RetMapLims[1]

        self.axes1.set_xlabel(str(coords[k]) + 'Frames ' + str(RetMapLims[0]) +
                              'to ' + str(RetMapLims[1]),
                              fontsize=8)

        self.canvas = FigureCanvas(self, -1, self.figure)

        self.sizer = wxBoxSizer(wxVERTICAL)
        self.sizer.Add(self.canvas, 1, wxTOP | wxLEFT | wxEXPAND)
        # Capture the paint message
        EVT_PAINT(self, self.OnPaint)

        self.toolbar = MyNavigationToolbar(self.canvas, True)
        self.toolbar.Realize()
        if wxPlatform == '__WXMAC__':
            # Mac platform (OSX 10.3, MacPython) does not seem to cope with
            # having a toolbar in a sizer. This work-around gets the buttons
            # back, but at the expense of having the toolbar at the top
            self.SetToolBar(self.toolbar)
        else:
            # On Windows platform, default window size is incorrect, so set
            # toolbar width to figure width.
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            # By adding toolbar in sizer, we are able to put it at the bottom
            # of the frame - so appearance is closer to GTK version.
            # As noted above, doesn't work for Mac.
            self.toolbar.SetSize(wxSize(fw, th))
            self.sizer.Add(self.toolbar, 0, wxLEFT | wxEXPAND)

        # update the axes menu on the toolbar
        self.toolbar.update()
        self.SetSizer(self.sizer)
        self.Fit()

    def OnPaint(self, event):
        self.canvas.draw()
        event.Skip()

        print RetMapLims[0]
        print RetMapLims[1]
        print ChosenIBIMap
Ejemplo n.º 20
0
class PlotFigure(Frame):
    def __init__(self):
        Frame.__init__(self, None, -1, "Test embedded wxFigure")

        self.fig = Figure((5, 4), 100)
        self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()

        # On Windows, default frame size behaviour is incorrect
        # you don't need this under Linux
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(Size(fw, th))

        # Create a figure manager to manage things

        # Now put all into a sizer
        sizer = BoxSizer(VERTICAL)
        # This way of adding to sizer allows resizing
        sizer.Add(self.canvas, 1, LEFT | TOP | GROW)
        # Best to allow the toolbar to resize!
        sizer.Add(self.toolbar, 0, GROW)
        self.SetSizer(sizer)
        self.Fit()
        EVT_TIMER(self, TIMER_ID, self.onTimer)

    def init_plot_data(self):

        # initialize data array and plot for the 1st time
        data = np.array([])

        # jdh you can add a subplot directly from the fig rather than
        # the fig manager
        self.ax1 = self.fig.add_axes([0.15, 0.15, 0.8, 0.8])
        # create subplot 1
        self.line, = self.ax1.plot(data, 'bo-', lw=2, label='Cell Count')
        self.ax1.grid(True)
        self.ax1.set_xlabel('Frame Number')
        self.ax1.set_ylabel('Cells detected')

    def GetToolBar(self):
        # You will need to override GetToolBar if you are using an
        # unmanaged toolbar in your frame
        return self.toolbar

    def onTimer(self, evt):

        data = np.loadtxt(options.filename, delimiter='\t')
        self.line.set_xdata(data[:, 0])  # update the data
        self.line.set_ydata(data[:, 1])  # update the data
        #self.ax1.autoscale(enable=True, axis='both', tight=False)
        self.ax1.set_xlim([data[0, 0] - 1, data[-1, 0] + 1])
        self.ax1.set_ylim([data[:, 1].min() * 0.9, data[:, 1].max() * 1.1])

        self.canvas.draw()
        #self.canvas.gui_repaint()  # jdh wxagg_draw calls this already

    def onEraseBackground(self, evt):
        # this is supposed to prevent redraw flicker on some X servers...
        pass
Ejemplo n.º 21
0
class AppFrame(wx.Frame):
	def __init__(self):
		setBaseDB('dass.db')
		initializeBaseDB()
		
		def makeSP(name, labels, statictexts = None):
			panel = wx.Panel(self.sidePanel, -1)
			box = wx.StaticBox(panel,-1, name)
			sizer = wx.StaticBoxSizer(box, wx.VERTICAL)
			
			panel.rangeValue = {}

			for name, min_value, value, max_value in labels:
				sp = SpinPanel(panel, name, min_value, value, max_value, self.OnSpinback)
				panel.rangeValue[name] = sp
				sizer.Add(sp, 0, wx.EXPAND)

			print "done"
			panel.SetSizer(sizer)
			return panel

		wx.Frame.__init__(self, None, title = "CLUSTERING ALGORITHM")

		################ Adding Drawing Panel ################

		self.displayPanel = DisplayPanel(self)
		self.figure = Figure()
		self.axes = self.figure.add_subplot(111)
		self.axes.set_axis_bgcolor('white')
		self.canvas = Canvas(self.displayPanel, -1, self.figure)

		################ Connecting the canvas to events for selecting intial centroid & nuclei ###################
		self.figure.canvas.mpl_connect('button_press_event', self.onGraphClick)
		self.figure.canvas.mpl_connect('pick_event', self.onNucleiPick)
		################ Connecting the canvas to events for selecting intial centroid & nuclei ###################
		
		sizer = wx.BoxSizer(wx.HORIZONTAL)
		sizer.Add(self.canvas, 1, wx.EXPAND)
		self.displayPanel.SetSizer(sizer)
		self.displayPanel.Fit()
		self.toolbar = NavigationToolbar(self.canvas)
		self.SetToolBar(self.toolbar)
		self.toolbar.Realize()
		tw, th = self.toolbar.GetSizeTuple()
		fw, fh = self.canvas.GetSizeTuple()
		self.toolbar.SetSize(wx.Size(fw, th))
		self.toolbar.update()
		self.redraw_timer = wx.Timer(self)
		self.Bind(wx.EVT_TIMER, self.on_redraw_timer, self.redraw_timer)
		self.stopStart = threading.Event()
		self.data = None
		self.centroids = []
		self.clusterIds = None
		self.colors = None
		self.k = 0
		self.iterTimer = 0
		self.iterations = 20
		self.sidePanel = wx.Panel(self)
		self.pointToPick = 0
		self.selectedFeaturesCount = 0
		self.isPickCentroids = False

		################ Adding Drawing Panel ################

		################ defining features for clustering algorithm ################

		self.dictionary = {'Area':'AREA', 'Perimeter':'PERIMETER',
							'Roundness':'ROUNDNESS','Equi-Diameter':'EQUI_DIAMETER',
							'Orientation':'ORIENTATION',
							'Convex Area':'CONVEX_AREA', 'Solidity': 'SOLIDITY',
							'Major Axis':'MAJOR_AXIS_LEN','Minor Axis': 'MINOR_AXIS_LEN',
							'Eccentricity':'ECCENTRICITY', 'Min Enclosing Rad':'CIR_RADIUS',
							'Shape Index':'SHAPE_INDEX','Border Index':'BORDER_INDEX','Aspect Ratio':'ASPECT_RATION', 
							'Mean Pixel Intensity':'MEAN_PIXEL_DEN',
							'Max Pixel Intensity':'MAX_PIXEL_DEN','Min Pixel Intensity':'MIN_PIXEL_DEN' 
							}

		featureList = ['Area', 'Perimeter', 'Roundness', 'Equi-Diameter','Orientation', 
						'Convex Area', 'Solidity', 'Major Axis', 'Minor Axis',
						'Eccentricity','Min Enclosing Rad','Shape Index','Border Index','Aspect Ratio',
						'Mean Pixel Intensity','Max Pixel Intensity', 'Min Pixel Intensity']

		################ defining features for clustering algorithm ################


		################ Adding File Open Dialog to Show the tiles Info ################ 

		self.chooseImagePanel = wx.Panel(self.sidePanel, -1)
		box = wx.StaticBox(self.chooseImagePanel, -1, 'Choose Image')
		self.subPanel = wx.Panel(self.chooseImagePanel, -1)

		sizer = wx.BoxSizer(wx.VERTICAL)
		self.filebrowser = filebrowse.FileBrowseButtonWithHistory(
							self.subPanel, -1, size=(450, -1), changeCallback = self.updateHistory)

		button = wx.Button(self.subPanel, -1, "View Image")
		button.Bind(wx.EVT_BUTTON, self.viewImage)

		sizer.Add(self.filebrowser,0,wx.EXPAND)
		sizer.Add(button,0,wx.ALL|wx.RIGHT|wx.ALIGN_RIGHT,5)
		self.subPanel.SetSizer(sizer)

		sizer = wx.StaticBoxSizer(box, wx.VERTICAL)
		sizer.Add(self.subPanel)
		self.chooseImagePanel.SetSizer(sizer)

		################ Adding File Open Dialog to Show the tiles Info ################ 

		################ Adding Algorithm Options Info ################ 

		self.algorithmPanel = wx.Panel(self.sidePanel, -1)
		box = wx.StaticBox(self.algorithmPanel, -1, 'Algorithms')
		self.subPanel = wx.Panel(self.algorithmPanel, -1)
		sizer = wx.BoxSizer(wx.HORIZONTAL)
		
		self.algorithm1 = wx.RadioButton(self.subPanel, label="K-MEANS", style = wx.RB_GROUP)		
		self.algorithm2 = wx.RadioButton(self.subPanel, label="OPTICS")
		self.algorithm1.Bind(wx.EVT_RADIOBUTTON, self.kmeansSelected)
		self.algorithm2.Bind(wx.EVT_RADIOBUTTON, self.opticsSelected)

		sizer.Add(self.algorithm1 ,0,wx.ALL|wx.RIGHT|wx.ALIGN_LEFT, 5)
		sizer.Add((1,1),1)
		sizer.Add((1,1),1)
		sizer.Add(self.algorithm2 ,1,wx.ALL|wx.RIGHT|wx.ALIGN_RIGHT,5)
		self.subPanel.SetSizer(sizer)

		sizer = wx.StaticBoxSizer(box, wx.VERTICAL)
		sizer.Add(self.subPanel)
		self.algorithmPanel.SetSizer(sizer)

		################ Adding Algorithm Options Info ################ 

		################ Adding Features Panel ################ 

		self.featuresPanel = wx.Panel(self.sidePanel, -1)
		box = wx.StaticBox(self.featuresPanel, -1, 'Features')
		self.subPanel = wx.Panel(self.featuresPanel, -1)
		sizer = wx.GridSizer(rows = 6, cols = 3)

		global featureCB

		for feature in featureList:
			cb = wx.CheckBox(self.subPanel, label=feature)
			cb.Bind(wx.EVT_CHECKBOX, self.featuresSelected)
			featureCB[feature] = cb
			sizer.Add(cb, 0, wx.BOTTOM|wx.LEFT, 2)
		
		self.subPanel.SetSizer(sizer)

		sizer = wx.StaticBoxSizer(box, wx.VERTICAL)
		sizer.Add(self.subPanel)
		self.featuresPanel.SetSizer(sizer)

		################ Adding Features Panel ################ 

		################ Adding Feature1, Feature2 Range Value ################ 

		self.feature1 = makeSP('FEATURE 1 RANGES',
							  (('Minimum', 1, 1, 3600),
								('Maximum', 1, 3600, 3600)))

		self.feature2 = makeSP('FEATURE 2 RANGES',
							  (('Minimum', 1, 1, 3600),
								('Maximum', 1, 3600, 3600)))

		################ Adding Feature1, Feature2 Range Value ################ 

		################ Adding all the panels to the main window ################ 

		self.optionPanel = OptionsPanel(self,self.sidePanel, self.displayPanel)
		self.buttonStart = wx.Button(self.sidePanel, -1, "Start")
		self.buttonStart.Bind(wx.EVT_BUTTON, self.startProcess)

		buttonClose = wx.Button(self.sidePanel, -1, "Close")
		buttonClose.Bind(wx.EVT_BUTTON, self.stopProcess)

		self.buttonGenerate = wx.Button(self.sidePanel, -1, "Generate Image")
		self.buttonGenerate.Bind(wx.EVT_BUTTON, self.generateImage)
		self.buttonReset = wx.Button(self.sidePanel, -1, "Show Image/Reset")
		self.buttonReset.Bind(wx.EVT_BUTTON, self.resetProcess)

		self.feature1.Enable(False)
		self.feature2.Enable(False)
		self.buttonStart.Enable(False)
		self.buttonGenerate.Enable(False)
		self.algorithmPanel.Enable(False)
		self.optionPanel.Enable(False)
		self.buttonReset.Enable(False)

		panelSizer = wx.BoxSizer(wx.VERTICAL)
		panelSizer.Add(self.chooseImagePanel, 0, wx.EXPAND|wx.TOP|wx.LEFT|wx.RIGHT, 5)
		panelSizer.Add(self.featuresPanel, 0, wx.EXPAND|wx.TOP|wx.LEFT|wx.RIGHT, 5)
		panelSizer.Add(self.feature1, 0, wx.EXPAND|wx.TOP|wx.LEFT|wx.RIGHT, 5)
		panelSizer.Add(self.feature2, 0, wx.EXPAND|wx.TOP|wx.LEFT|wx.RIGHT, 5)
		panelSizer.Add(self.algorithmPanel, 0, wx.EXPAND|wx.TOP|wx.LEFT|wx.RIGHT, 5)
		panelSizer.Add(self.optionPanel, 0, wx.EXPAND|wx.TOP|wx.LEFT|wx.RIGHT, 5)

		sizer = wx.BoxSizer(wx.HORIZONTAL)
		sizer.Add(self.buttonStart ,0,wx.ALL|wx.RIGHT|wx.ALIGN_LEFT, 5)
		# sizer.Add((1,1),1)
		sizer.Add(self.buttonGenerate ,0,wx.ALL|wx.RIGHT|wx.ALIGN_CENTER,5)
		# sizer.Add((1,1),1)
		sizer.Add(self.buttonReset,0,wx.ALL|wx.RIGHT|wx.ALIGN_CENTER,5)
		
		sizer.Add(buttonClose ,0,wx.ALL|wx.RIGHT|wx.ALIGN_RIGHT,5)

		panelSizer.Add(sizer,0, wx.EXPAND|wx.TOP|wx.LEFT|wx.RIGHT, 5)
		# panelSizer.Add(buttonStart, 0, wx.EXPAND|wx.TOP|wx.LEFT|wx.RIGHT, 5)
		# panelSizer.Add(buttonClose, 0, wx.EXPAND|wx.TOP|wx.LEFT|wx.RIGHT, 5)
		self.sidePanel.SetSizer(panelSizer)

		mainSizer = wx.BoxSizer(wx.HORIZONTAL)
		mainSizer.Add(self.displayPanel, 1, wx.EXPAND)
		mainSizer.Add(self.sidePanel, 0, wx.EXPAND)
		self.SetSizer(mainSizer)

		mainSizer.Fit(self)
		rw, rh = self.displayPanel.GetSize()
		sw, sh = self.sidePanel.GetSize()
		fw, fh = self.GetSize()
		h = max(600, fh)
		w = h + fw - rw

		if verbose:
			print 'Display Panel Size', (rw, rh)
			print 'Side Panel Size', (sw, sh)
			print 'Frame Size', (fw, fh)

		self.SetSize((w,h))
		self.Show()

		################ Adding all the panels to the main window ################

	################################################################################# 
	# featureSelected - event handler called when the feature check box is selected #
	#################################################################################
	
	def featuresSelected(self,event):
		if event.IsChecked():
			self.selectedFeaturesCount += 1
			if self.selectedFeaturesCount > 1 :
				self.optionPanel.Enable(True)
				self.algorithmPanel.Enable(True)
				self.buttonGenerate.Enable(True)
				self.buttonReset.Enable(True)
				self.feature1.Enable(True)
				self.feature2.Enable(True)
				if (self.algorithm1.GetValue()):
					self.buttonStart.Enable(True)

			if self.selectedFeaturesCount == 1:
				self.feature1.Enable(True)
				for key in featureCB.keys():
					if featureCB[key].GetValue() and key == "Mean Pixel Intensity":
						self.optionPanel.Enable(True)
						self.algorithmPanel.Enable(True)
						self.buttonGenerate.Enable(True)
						self.buttonStart.Enable(True)
						print key

		else:
			self.selectedFeaturesCount -= 1
			if self.selectedFeaturesCount <=1 :
				self.optionPanel.Enable(False)
				self.algorithmPanel.Enable(False)
				self.buttonStart.Enable(False)
				self.buttonGenerate.Enable(False)
				self.buttonReset.Enable(False)						
				self.feature1.Enable(False)
				self.feature2.Enable(False)
				self.axes.clear()
				self.canvas.draw()
			if self.selectedFeaturesCount == 1:
				for key in featureCB.keys():
					if featureCB[key].GetValue() and key == "Mean Pixel Intensity":
						self.optionPanel.Enable(True)
						self.algorithmPanel.Enable(True)
						self.buttonGenerate.Enable(True)
						self.buttonStart.Enable(True)
						print key
				self.feature1.Enable(True)


	def OnSpinback(self, name, value):
		if verbose:
			print 'On Spin Back', name, value



	################################################
	# stopProcess - event handler for close button #
	################################################
	
	def stopProcess(self,event):
		closeConnBaseDB()
		sys.exit()


	############################################################
	# resetProcess - event handler for reset/show image button #
	############################################################

	def resetProcess(self,event):
		self.axes.clear()
		self.canvas.draw()
		self.pointToPick = int(self.optionPanel.textBox.GetValue())
		if self.algorithm1.GetValue():
			self.buttonStart.Enable(True)
		else:
			self.buttonStart.Enable(False)

		featureList = []
		for key in featureCB.keys():
			if featureCB[key].GetValue():
				featureList.append(key)

		print featureList
		self.filename = self.filebrowser.GetValue().split('/')[-1].split('.')[0]
		self.fullFilename = self.filebrowser.GetValue()
		datalist = getFeatures(self.filename, self.dictionary[featureList[0]],
					 self.dictionary[featureList[1]])
		self.data = vstack([(f1,f2) for (f,n, f1, f2) in datalist])
		self.init_plot(self.data, self.k, featureList[0], featureList[1])
		self.centroids = []
		
	#####################################################################################
	# updateHistory - event handler for file open dialog to store recently opened files #
	#####################################################################################

	def updateHistory(self, event):

		self.featuresPanel.Enable(True)
		value = self.filebrowser.GetValue()
		print 'Update History',value
		if not value:
			return
		history = self.filebrowser.GetHistory()
		if value not in history:
			history.append(value)
			self.filebrowser.SetHistory(history)
			self.filebrowser.GetHistoryControl().SetStringSelection(value)


	##################################################################
	# viewImage - event handler for View Image button which displays #
	# 			  the image selected in the open dialog  #
	##################################################################
	def viewImage(self,event):
		print 'View Image'
		imageFile = self.filebrowser.GetValue()
		print imageFile
		win = wx.Frame(None, title = imageFile, size=(500,500), 
						style = wx.DEFAULT_FRAME_STYLE ^wx.RESIZE_BORDER) 
		ipanel = wx.Panel(win, -1)

		image = wx.ImageFromBitmap(wx.Bitmap(imageFile))
		image = image.Scale(500,500, wx.IMAGE_QUALITY_HIGH)
		bitmap = wx.BitmapFromImage(image)

		control = wx.StaticBitmap(ipanel,-1,bitmap)
		control.SetPosition((10,10))
		win.Show(True)


	#################################################################
	# generateImage - event handler for Generate Image image button #
	#################################################################

	def generateImage(self,event):
		print 'generate Image'
		self.generate_image()

	##############################################################################
	# generate_image -  method for generating an image of the tiles	   	     #
	#		    with mapping of clustered output i.e. each		     #
	#		    cluster is mapped in the tile image with specific colors # 
	##############################################################################

	def generate_image(self):
	#Red,Green,Blue,Marooon,Cyan,Yellow,Magenta,Purple,Navy,Gray(BGR format NOT RGB)
		#colors = {0:(0,0,255),1:(0,255,0),2:(255,0,0),3:(0,0,128),4:(255,255,0),5:(0,255,255),6:(255,0,255),7:(128,0,128)
		#		,8:(128,0,0),9:(128,128,128)}
		colors = [(0,0,255), (0,255,0), (255,0,0)]
		for i in range(self.k):
			colors.append((random.choice(range(256)), random.choice(range(256)),random.choice(range(256))))
		conn = getConnBaseDB()
		#Query DB to get boundary values for this image.
		c = conn.cursor()
		c.execute("SELECT BOUNDARY_VALS FROM Features WHERE IMAGE_NAME = '%s'" %self.filename)
		rows = c.fetchall()
		contour_list = []
		for row in rows:
			boundary_vals = row[0].strip().split(';')
			boundary_vals.pop()
			boundary_vals = [[int(float(n)) for n in i.split(',')] for i in boundary_vals]
			contr = np.array(boundary_vals)
			contour_list.append(contr)

		print self.fullFilename
		im = cv2.imread(self.fullFilename)
		for index,i in enumerate(self.clusterIds):
			cv2.drawContours(im,contour_list,index,colors[i],-1)

		outputfile = "Output_"+self.filename+"_clustered_"+str(int(time.time()))+".tif"
		cv2.imwrite(outputfile,im);


		print "'Done Displaying the image"
		imageFile = outputfile
                print imageFile
                win = wx.Frame(None, title = imageFile, size=(500,500),
                                                style = wx.DEFAULT_FRAME_STYLE ^wx.RESIZE_BORDER)
                ipanel = wx.Panel(win, -1)

		image = wx.ImageFromBitmap(wx.Bitmap(imageFile))
		image = image.Scale(500,500, wx.IMAGE_QUALITY_HIGH)
		
		bitmap = wx.BitmapFromImage(image)
		control = wx.StaticBitmap(ipanel,-1,bitmap)
		control.SetPosition((10,10))
		win.Show(True)

		#cv2.imshow('image',im)
		#print "show window"
		#cv2.waitKey()
		print "byee"
		#closeConnBaseDB()
		#return(im)



	######################################################################
	# pickInputCentroids -  method for indicating whether to pick intial #
	#			centroids or not 			     #
	######################################################################

	def pickInputCentroids(self,userCentroid):
		self.pointToPick = int(self.optionPanel.textBox.GetValue())
		if userCentroid:
			self.buttonStart.Enable(False)
		else:
			self.buttonStart.Enable(True)


	##########################################################################
	# opticsSelected - radio button event for selecting OPTICS algortithm 	 #
	##########################################################################
	def opticsSelected(self,event):
		self.optionPanel.showUpdates.Enable(False)
		self.optionPanel.chooseCentroid.Enable(False)
		self.buttonStart.Enable(True)
		self.buttonGenerate.Enable(False)


	#######################################################################
	# kmeansSelected -  adio button event for selecting KMEANS algortithm #
	#######################################################################
	def kmeansSelected(self,event):
		self.optionPanel.showUpdates.Enable(True)
		self.optionPanel.chooseCentroid.Enable(True)
		self.buttonGenerate.Enable(True)
		if self.optionPanel.chooseCentroid.GetValue() and self.pointToPick == 0:
			self.buttonStart.Enable(True)
		elif not self.optionPanel.chooseCentroid.GetValue():
			self.buttonStart.Enable(True)
		


	######################################################################
	# onGraphClick -  mouse click event handler for selecting intial set #
	#				   of centroids from user  	     #
	######################################################################
	def onGraphClick(self,event):
		print 'button=%d, x=%d, y=%d, xdata=%f, ydata=%f'%(
			event.button, event.x, event.y, event.xdata, event.ydata)

		print self.optionPanel.chooseCentroid.GetValue()
		print self.pointToPick

		if self.optionPanel.chooseCentroid.GetValue() and self.pointToPick > 0:
			self.pointToPick -= 1
			#self.axes.plot(event.xdata,event.ydata, color='b',picker=5)
			self.axes.plot(event.xdata,event.ydata,color='r', marker='H',markersize=20.0,picker=5)
			self.canvas.draw()
			self.centroids.append([event.xdata,event.ydata])
			#np.concatenate((self.centroids,[event.xdata,event.ydata]))
			if self.pointToPick == 0 :
				self.buttonStart.Enable(True)



	######################################################################
	# onNucleiPick -  mouse click event handler for showing the metadata #
	#				  of selected nuclei 		     #
	######################################################################
	def onNucleiPick(self,event):
		thisline = event.artist
		xdata = thisline.get_xdata()
		ydata = thisline.get_ydata()
		ind = event.ind
		print thisline
		print event
		featureList = []
		featureKeys = ['IMAGE FILE','ID','AREA','PERIMETER','ROUNDNESS','EQUI_DIAMETER','CONVEX_AREA','SOLIDITY','MAJOR_AXIS_LEN','MINOR_AXIS_LEN','ORIENTATION','ECCENTRICITY',
				'CIR_RADIUS','SHAPE_INDEX','BORDER_INDEX','ASPECT_RATIO','MAX_PIXEL_DEN','MIN_PIXEL_DEN']
		for key in featureCB.keys():
			if featureCB[key].GetValue():
				featureList.append(key)
	
		print "xdata",xdata[ind][0]
		print "ydata",ydata[ind][0]
	
		dataList = getAllFeatures(self.filename, self.dictionary[featureList[0]],
			self.dictionary[featureList[1]],float(xdata[ind][0]),float(ydata[ind][0]));
		
		print dataList
		data = dataList[0]
		print len(data)
		win = wx.Frame(None, title = 'Nuclei Metadata', size=(500,500),
                                                style = wx.DEFAULT_FRAME_STYLE ^wx.RESIZE_BORDER)
		
		print "Creating New Frame"
		sizer = wx.GridSizer(rows = len(data), cols=2)	
		ipanel = wx.Panel(win, -1)
		for i in range (0,len(data)):
			label = wx.StaticText(ipanel, -1, featureKeys[i])
			sizer.Add(label, 0, wx.BOTTOM|wx.LEFT, 2)
			labCtrl = wx.TextCtrl(ipanel, -1, str(data[i]), style = wx.TE_READONLY)
			sizer.Add(labCtrl, 0, wx.BOTTOM|wx.LEFT, 2)
		ipanel.SetSizer(sizer)
		boxSizer = wx.BoxSizer(wx.VERTICAL)
		boxSizer.Add(ipanel)
		win.SetSizer(boxSizer)
		win.Fit()	
		win.Show(True)


	###########################################################################
	# startProcess -  event handler for start button 			  #
	#		  It initiates the process of clustering  		  #
	###########################################################################		
	def startProcess(self, event):
		print 'in kmeans'
		featureList =[]
		isShowUpdate = False
		k = self.optionPanel.textBox.GetValue()
		isShowUpdate = self.optionPanel.showUpdates.GetValue()
		isKmeans = self.algorithm1.GetValue()
		isOptics = self.algorithm2.GetValue()
		self.isPickCentroids = self.optionPanel.chooseCentroid.GetValue()

		print 'spin_panels', spinPanels.keys()
		for key in featureCB.keys():
			if featureCB[key].GetValue():
				featureList.append(key)
				print featureCB[key].GetValue()

		print "Feature List = ",featureList
		print "k-value = ",k
		print "Show Update = ",isShowUpdate
		print "Kmeans Selected= ",isKmeans
		print "OPTICS Selected= ",self.algorithm2.GetValue()

		self.buttonReset.Enable(True)
		self.buttonStart.Enable(False)

		for key in spinPanels.keys():
			print self.feature1.rangeValue[key].sc.GetValue()
			print self.feature2.rangeValue[key].sc.GetValue()

		print self.filebrowser.GetValue()
		self.filename = self.filebrowser.GetValue().split('/')[-1].split('.')[0]
		self.fullFilename = self.filebrowser.GetValue()
		if isKmeans:	
			#start the kmean process
			self.k = int(k)
			if not 'Mean Pixel Intensity' in featureList and len(featureList) > 2:
				print 'Performing kmeans for multiple features'
				fList = []
				for item in featureList:
					fList.append(self.dictionary[item])

				dataList = getFeaturesList(self.filename,fList)
				#print dataList
				
				list1 = []
				list2 = []
				for index,j in enumerate(fList):
					list1.append('f'+str(index))
				
				list2 = ['f','n'] + list1
				new_list = [map(float,list2[2:])  for list2 in dataList]
				#new_list = [(float(j) for j in i)for i in new_list]
					
				#print "new_list",new_list
				#self.data = vstack([list1  for list2 in dataList])
				self.data = vstack(new_list)
				#print self.data	
				self.init_plot(self.data, self.k, featureList[0], featureList[1])
				self.cluster_kmeansMul(fList, self.k, False)

			elif not 'Mean Pixel Intensity' in featureList and len(featureList) == 2:
				print self.filename
				datalist = getFeatures(self.filename, self.dictionary[featureList[0]],
							 self.dictionary[featureList[1]])
				#print datalist
				self.data = vstack([(f1,f2) for (f,n, f1, f2) in datalist])
				#Intial clusters from selecting points -- start


				#Intial clusters from selecting points -- end
				self.animation = isShowUpdate
				self.init_plot(self.data, self.k, featureList[0], featureList[1])
				time.sleep(1)
				if not self.animation:
					self.cluster_kmeans(datalist, self.k, False)
				else:
					print "isPickCentroids =",self.isPickCentroids
					print "initial centroisds = ", self.centroids
					if not self.isPickCentroids:
						self.centroids = self.init_cluster()
					self.iterTimer = 0
					self.redraw_timer.Start(2000)
			else:
				self.data = vstack(self.helper_mean())
				self.pixel_kmeans()
		elif isOptics:
			print 'Calling OPTICS'
			self.gen_optic_cluster(featureList[0], featureList[1])
		else:
			print 'Select an algorithm'



	######################################################################
	# gen_optic_cluster -  method for executing OPTICS algorithm 	     #
	######################################################################

	def gen_optic_cluster(self, f1, f2):
		# generate some spatial data with varying densities
		np.random.seed(0)
		con = getConnBaseDB()
		X = []
		cur = con.cursor()
		stuple = (self.filename,)
		cur.execute("SELECT "+self.dictionary[f1]+", "+self.dictionary[f2]+" FROM Features WHERE IMAGE_NAME = '%s'" % stuple)
		rows = cur.fetchall()
		for row in rows:
			X.append([row[0], row[1]])
		print len(X)
		#plot scatterplot of points
		X = np.asarray(X)
		self.data = X
		#fig = plt.figure()
		#ax = fig.add_subplot(111)
		self.axes.clear()
		self.xlabel = f1
		self.ylabel = f2
		self.axes.set_xlabel(self.xlabel)
		self.axes.set_ylabel(self.ylabel)
		self.axes.set_title('Intial scatter plot before clustering')
		pylab.setp(self.axes.get_xticklabels(), fontsize=8)
		pylab.setp(self.axes.get_yticklabels(), fontsize=8)
		self.axes.plot(X[:,0], X[:,1], 'bo')
		self.canvas.draw()
		#plt.savefig('Graph.png', dpi=None, facecolor='w', edgecolor='w',
		#	orientation='portrait', papertype=None, format=None,
		#	transparent=False, bbox_inches=None, pad_inches=0.1)
		#plt.show()



		#run the OPTICS algorithm on the points, using a smoothing value (0 = no smoothing)
		RD, CD, order = OP.optics(X,9)

		RPlot = []
		RPoints = []
			
		for item in order:
				RPlot.append(RD[item]) #Reachability Plot
				RPoints.append([X[item][0],X[item][1]]) #points in their order determined by OPTICS

		#hierarchically cluster the data
		rootNode = AutoC.automaticCluster(RPlot, RPoints)

		#print Tree (DFS)
		#AutoC.printTree(rootNode, 0)

		#graph reachability plot and tree
		#AutoC.graphTree(rootNode, RPlot)

		#array of the TreeNode objects, position in the array is the TreeNode's level in the tree
		array = AutoC.getArray(rootNode, 0, [0])

		#get only the leaves of the tree
		leaves = AutoC.getLeaves(rootNode, [])
		print 'leaves length = ',len(leaves)
		#graph the points and the leaf clusters that have been found by OPTICS
		#fig = plt.figure()
		#ax = fig.add_subplot(111)
		self.axes.clear()
		self.xlabel = f1
		self.ylabel = f2
		self.axes.set_xlabel(self.xlabel)
		self.axes.set_ylabel(self.ylabel)
		self.axes.set_title('Final clusters formed')
		pylab.setp(self.axes.get_xticklabels(), fontsize=8)
		pylab.setp(self.axes.get_yticklabels(), fontsize=8)
		self.axes.plot(X[:,0], X[:,1], 'yo')
		#colors = cycle('gmkrcbgrcmk')
		colors = ['r','g','b']
		colors.extend([(random.random(), 
			random.random(), random.random()) for i in range(len(leaves)-3)])
		for item, c in zip(leaves, colors):
				node = []
				for v in range(item.start,item.end):
					node.append(RPoints[v])
				node = np.array(node)
				self.axes.plot(node[:,0],node[:,1], color=c,marker='o',linestyle='None',picker=5)
		self.canvas.draw()
		#plt.savefig('Graph2.png', dpi=None, facecolor='w', edgecolor='w',
			#orientation='portrait', papertype=None, format=None,
			#transparent=False, bbox_inches=None, pad_inches=0.1)
		#plt.show()


	############################################################################
	# pixel_kmeans -  method for executing kmeans algorithm for image related  #
	#				  features (mean pixel density). 	   #
	############################################################################
	def pixel_kmeans(self, feature1Bound=None,
						feature2Bound=None,iter=None):
		random.seed(time.time())
		km_obj = KMeans(n_clusters=self.k, init='random', n_init=1,
                        max_iter=self.iterations, tol=0.0001, precompute_distances=True,
                         n_jobs=-1, random_state=None)
		km_obj.fit(self.data)
		self.centroids = km_obj.cluster_centers_
		self.clusterIds = km_obj.labels_
		#self.centroids,_ = kmeans2(self.data, self.k)
		print len(self.centroids)
		#self.clusterIds,_ = vq(self.data,self.centroids)
		sets = set(self.clusterIds)
		print sets
		self.generate_image()
		#TODO: If initial centroid not given only
		#self.centroids,_ = kmeans2(self.data, self.k, thresh=1e-05, minit='random')
		#lastCentroids = None
		#print self.centroids
		#print '\n'
		#i = 0
		#while not array_equal(lastCentroids,self.centroids) and i < self.iterations:
		#	i+=1
		#	lastCentroids = vstack(list(self.centroids)[:])
		#	self.centroids,_ = kmeans2(self.data, lastCentroids, iter=1, thresh=1e-05, minit='matrix')
		#	self.clusterIds,_ = vq(self.data,self.centroids)
		#self.redraw(-1)
		#print i, self.iterations
		#print self.centroids


	#######################################################################
	# helper_mean -  helper method for getting mean pixel density feature #
	#				 data for clustering.  	 	      #
	#######################################################################
	def helper_mean(self):
		conn = getConnBaseDB()
		c = conn.cursor()
		c.execute("SELECT MEAN_PIXEL_DEN FROM Features WHERE IMAGE_NAME = '%s'" %self.filename)
		rows = c.fetchall()
		data_list = []
		for row in rows:
			item = str(row[0])
			match = re.search(r'\((.*)\)',item)
			if match:
				data = match.group(1).split(',')
				data_list.append(data)
		data_list = [[float(j) for j in i ] for i in data_list]			
		#dbsetup.closeConnBaseDB()
		return data_list


	#######################################################################
	# init_cluster -  method for getting the initial set of centroids for #
	#				  kmeans CLUSTERING		      #
	#######################################################################
	def init_cluster(self):
		print "init_cluster function"
		km_obj = KMeans(n_clusters=self.k, init='random', n_init=1,
                        max_iter=1, tol=0.0001, precompute_distances=True,
                         n_jobs=-1, random_state=None)
                km_obj.fit(self.data)
		centroids = km_obj.cluster_centers_
		return centroids


	######################################################################
	# timer_kmeans - method performs kmeans clustering and is invoked    #
	#		 when show updates option is enabled		     #
	######################################################################
	def timer_kmeans(self):
		lastCentroids = vstack(list(self.centroids)[:])
		print "timer Kmeans"
		print "last Centroids", lastCentroids
		km_obj = KMeans(n_clusters=self.k, init=lastCentroids, n_init=1,
                        max_iter=1, tol=0.0001, precompute_distances=True,
                         n_jobs=-1, random_state=None)
                km_obj.fit(self.data)
		self.centroids = km_obj.cluster_centers_
		self.clusterIds = km_obj.labels_
		self.redraw(self.iterTimer)
		return array_equal(lastCentroids,self.centroids)


	#############################################################################
	# on_redraw_timer - method for calling the plot method to draw the clusters #
	#		    during each update in kmeans process 		    #
	#		    Called only when show updates method is selected 	    #
	#############################################################################
	def on_redraw_timer(self, event):
		print "self.iterTimer",self.iterTimer
		if self.iterTimer < self.iterations:
			changed = self.timer_kmeans()
			self.iterTimer+=1
			if self.iterTimer == self.iterations-1 or changed:
				self.redraw_timer.Stop()
				#self.redraw(self.data,self.centroids, clusterIds, self.k, -1)
				self.redraw(-1)



	#######################################################################
	# init_plot -  method for displaying the intial plot of the data with #
	#			   selected features.			      #
	#######################################################################
	def init_plot(self,data,k, feature1, feature2):
		self.axes.clear()
		x = array([d[0] for d in data])
		y = array([d[1] for d in data])
		maxX = max(x)
		minX = min(x)
		maxY = max(y)
		minY = min(y)
		self.xlabel = feature1
		self.ylabel = feature2
		self.axes.set_xlabel(self.xlabel)
		self.axes.set_ylabel(self.ylabel)
		self.axes.set_title('Intial scatter plot before clustering')
		pylab.setp(self.axes.get_xticklabels(), fontsize=8)
		pylab.setp(self.axes.get_yticklabels(), fontsize=8)
		self.axes.plot(x,y,'bo')
		self.canvas.draw()
		self.colors = ['r','g','b']
		self.colors.extend([(random.random(), 
			random.random(), random.random()) for i in range(k)])




	#############################################################################
	# cluster_kmeansMul -  method performing kmeans for more than two features  # 
	#			selected and writes the cluster output to text file # 
	#############################################################################
	def cluster_kmeansMul(self, featureList,feature1Bound=None,
						feature2Bound=None,iter=None):
		random.seed(time.time())
		outputfile = "Output.txt"
		fh = open(outputfile, "w")
		
		km_obj = KMeans(n_clusters=self.k, init='random', n_init=1,
                        max_iter=self.iterations, tol=0.0001, precompute_distances=True,
                         n_jobs=-1, random_state=None)
		km_obj.fit(self.data)
		self.centroids = km_obj.cluster_centers_
		self.clusterIds = km_obj.labels_	

		fh.write(str(self.centroids.tolist()))
		fh.write("Current clusters formed\n")
		for j in range(self.k):
			fh.write("Data points of cluster "+str(j)+"\n")
			for l in range(len(self.data)):
				if self.clusterIds[l] == j:
					fh.write(str(self.data[l])+"\n")
		#fh.write(str(self.clusterIds.tolist()))
		#print self.data
		fh.close()
		print 'done'
		self.redraw(-1)
		



	########################################################################
	# cluster_kmeans -  method performing kmeans algorithm on data for     #
	#					selected features. This called if two features are #
	#					selected.										   #
	########################################################################

	def cluster_kmeans(self, feature1Bound=None,
						feature2Bound=None,iter=None):
		random.seed(time.time())
		if not self.isPickCentroids:
                        km_obj = KMeans(n_clusters=self.k, init='random', n_init=1,
                        max_iter=self.iterations, tol=0.0001, precompute_distances=True,
                         n_jobs=-1, random_state=None)
                        km_obj.fit(self.data)
                else :
                        km_obj = KMeans(n_clusters=self.k, init=self.centroids, n_init=1,
                        max_iter=self.iterations, tol=0.0001, precompute_distances=True,
                         n_jobs=-1, random_state=None)
			km_obj.fit(self.data)
                self.centroids = km_obj.cluster_centers_
                self.clusterIds = km_obj.labels_ #vq(self.data,self.centroids)
                self.redraw(-1)
		#print i, self.iterations
		#print self.centroids


	#####################################################################
	# redraw - method for invoking actual plot drawing module			#
	#####################################################################
	def redraw(self, iteration):
		 wx.CallAfter(self.redraw_actual, iteration)



	######################################################################
	# redraw_actual -   method for plotting the cluster output onto the  #
	#					scatter plot and display the number of clusters  #
	#					alomg with the centroids. 						 #	
	######################################################################
	def redraw_actual(self, iteration):
		self.axes.clear()
		self.axes.set_xlabel(self.xlabel)
		self.axes.set_ylabel(self.ylabel)
		if iteration == -1:
			self.axes.set_title('Final clusters formed')
		else:
			self.axes.set_title('Clusters during kmeans iteration '+str(iteration))
		pylab.setp(self.axes.get_xticklabels(), fontsize=8)
		pylab.setp(self.axes.get_yticklabels(), fontsize=8)
		for i in range(self.k):
			self.axes.plot(self.data[self.clusterIds==i,0],self.data[self.clusterIds==i,1],color=self.colors[i],marker='o',linestyle='None',picker=5)
			self.axes.plot(self.centroids[i,0],self.centroids[i,1],color=self.colors[i], marker='H',markersize=20.0,picker=5)
		print(self.centroids)		
#for i in range(len(self.data)):  
			#self.axes.plot([self.data[i,0],self.centroids[self.clusterIds[i],0]],[self.data[i,1],self.centroids[self.clusterIds[i],1]], color=self.colors[self.clusterIds[i]],picker=5)
		self.canvas.draw()
Ejemplo n.º 22
0
class CanvasPanel(wx.Panel):
    def __init__(self,parent, plot_number):
        wx.Panel.__init__(self, parent)
        self.SetBackgroundColour(wx.NamedColour("WHITE"))

        #self.figure = Figure()
        #self.axes = self.figure.add_subplot(111)
        #self.change_plot(0)

        self.figure,self.axes=return_figure_test(plot_number)

        self.canvas = FigureCanvas(self, -1, self.figure)

        self.sizer = wx.BoxSizer(wx.VERTICAL)
        #self.add_buttonbar()
        self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
        self.add_toolbar()  # comment this out for no toolbar


        self.SetSizer(self.sizer)
        self.Fit()

    # def add_buttonbar(self):
    #     self.button_bar = wx.Panel(self)
    #     self.button_bar_sizer = wx.BoxSizer(wx.HORIZONTAL)
    #     self.sizer.Add(self.button_bar, 0, wx.LEFT | wx.TOP | wx.GROW)

    #     for i, (mt, func) in enumerate(functions):
    #         bm = mathtext_to_wxbitmap(mt)
    #         button = wx.BitmapButton(self.button_bar, 1000 + i, bm)
    #         self.button_bar_sizer.Add(button, 1, wx.GROW)
    #         self.Bind(wx.EVT_BUTTON, self.OnChangePlot, button)

    #     self.button_bar.SetSizer(self.button_bar_sizer)

    def add_toolbar(self):
        """Copied verbatim from embedding_wx2.py"""
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if IS_MAC:
            self.SetToolBar(self.toolbar)
        else:
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        self.toolbar.update()

    def OnPaint(self, event):
        self.canvas.draw()

    def OnChangePlot(self, event):
        self.change_plot(event.GetId() - 1000)

    def change_plot(self, plot_number):
        t = arange(1.0,3.0,0.01)
        s = functions[plot_number][1](t)
        self.axes.clear()
        self.axes.plot(t, s)
        self.Refresh()

    def change_plot2(self):
        self.axes.clear()
        self.figure,self.axes=return_figure_test(3)
        self.canvas = FigureCanvas(self, -1, self.figure)
        self.Refresh()
Ejemplo n.º 23
0
class TopTalkersPlotPanel(wx.Panel):
    def __init__(self, parent):
        wx.Panel.__init__(self, parent)

        limit = '8'
        sql = "select dstaddr as dst_addr, sum(octets)/1024 from flow where dstaddr like '192.168.0%' group by dstaddr order by sum(octets) desc limit " + limit
        sql_total_volume = "select sum(octets)/1048576 from flow where dstaddr like '192.168.0%'"

        self.figure = Figure()
        self.canvas = FigureCanvas(self, -1, self.figure)
        self.ax = self.figure.add_subplot(111)
        #self.ax = self.figure.add_subplot(111, polar=True)
        self.ax.yaxis.grid(True, which='major')
        self.ax.grid(True)

        self.timeControlPanel = TimeControlPanel(self)
        self.start_date = self.timeControlPanel.datepicker_end_date.GetValue()

        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.timeControlPanel, 0, wx.LEFT | wx.TOP | wx.GROW)
        self.sizer.Add(self.canvas, 0, wx.LEFT | wx.TOP | wx.GROW)
        self.SetSizer(self.sizer)
        #self.sizer.Fit (parent)
        self.Fit()
        self.SetSize(panel_size)
        self.add_toolbar()  # comment this out for no toolbar

        #self.Bind(wx.EVT_BUTTON, self.eventDatesChanged, self.buttonDatesChanged)
        self.Bind(wx.EVT_BUTTON, self.eventDatesChanged)

        #EVT_PAINT(self, self.OnPaint)

        rowset = getRowset(sql)
        total_traffic_volume = getRowset(sql_total_volume)

        self.ax.set_title("Top Talkers - Total Volume: %s MB" %
                          total_traffic_volume[0])
        labels = []
        host_labels = [""]  #for offsetting the -1 appearing on the graph
        #host_labels = []
        traffic_volume = []
        for row in rowset:
            labels.append(str(row[0]))
            host_labels.append(str(row[0]))
            traffic_volume.append(row[1])

        #Plot the horizontal bar chart
        self.ax.barh(arange(len(labels)), traffic_volume, align='center')
        self.ax.set_ylabel('Hosts')
        self.ax.set_xlabel('Volume (Kilobytes)')
        self.ax.set_yticklabels(host_labels)

        #print labels
        for label in self.ax.yaxis.get_ticklabels():
            label.set_color('blue')
        #self.Pack()

    def OnPaint(self, event):
        self.canvas.draw()

    def eventDatesChanged(self, event):
        self.start_date = self.timeControlPanel.datepicker_start_date.GetValue(
        )
        #print "Top talkers, eventDatesChanged...start_date = ", self.start_date
        #event.Skip()

    def eventTimeChoiceChanged(self, event):
        print "Top talkers eventTimeChoiceChanged' Time selected"
        event.Skip()

    def add_toolbar(self):
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if wx.Platform == '__WXMAC__':
            # Mac platform (OSX 10.3, MacPython) does not seem to cope with
            # having a toolbar in a sizer. This work-around gets the buttons
            # back, but at the expense of having the toolbar at the top
            self.SetToolBar(self.toolbar)
        else:
            # On Windows platform, default window size is incorrect, so set
            # toolbar width to figure width.
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            # By adding toolbar in sizer, we are able to put it at the bottom
            # of the frame - so appearance is closer to GTK version.
            # As noted above, doesn't work for Mac.
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        # update the axes menu on the toolbar
        self.toolbar.update()
Ejemplo n.º 24
0
class PageOne(wx.Panel):
    def __init__(self, parent, hw_ver, frame):
        self.frame = frame
        self.multiplier_list = [1, 2, 4, 5, 8, 10, 16, 20]
        wx.Panel.__init__(self, parent)
        self.hw_ver = hw_ver
        main_sizer = wx.BoxSizer(wx.HORIZONTAL)
        grid = wx.GridBagSizer(hgap=5, vgap=5)
        grid_2 = wx.GridBagSizer(hgap=5, vgap=5)
        horizontal_sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
        horizontal_sizer = wx.BoxSizer(wx.VERTICAL)
        plot_sizer = wx.BoxSizer(wx.VERTICAL)
        self.input_label = wx.StaticBox(self, -1, 'Analog input')
        self.input_sizer = wx.StaticBoxSizer(self.input_label, wx.HORIZONTAL)
        self.sample_list = []
        for i in range(1, 9):
            self.sample_list.append("A" + str(i))
        self.label_ch_1 = wx.StaticText(self, label="Ch+")
        grid.Add(self.label_ch_1, pos=(0, 0))
        self.edit_ch_1 = wx.ComboBox(self,
                                     size=(95, -1),
                                     choices=self.sample_list,
                                     style=wx.CB_READONLY)
        self.edit_ch_1.SetSelection(0)
        grid.Add(self.edit_ch_1, pos=(0, 1))
        if self.hw_ver == 1:
            self.sample_list = ("AGND", "VREF", "A5", "A6", "A7", "A8")
        else:
            if self.hw_ver == 2:
                self.sample_list = ("AGND", "A2")
        self.label_ch_2 = wx.StaticText(self, label="Ch-")
        grid.Add(self.label_ch_2, pos=(1, 0))
        self.edit_ch_2 = wx.ComboBox(self,
                                     size=(95, -1),
                                     choices=self.sample_list,
                                     style=wx.CB_READONLY)
        self.edit_ch_2.SetSelection(0)
        grid.Add(self.edit_ch_2, pos=(1, 1))
        self.Bind(wx.EVT_COMBOBOX, self.edit_ch_1_change, self.edit_ch_1)
        self.Bind(wx.EVT_COMBOBOX, self.edit_ch_2_change, self.edit_ch_2)
        if self.hw_ver == 1:
            self.sample_list = ("+-12 V", "+-4 V", "+-2 V", "+-0.4 V",
                                "+-0.04 V")
            self.label_range = wx.StaticText(self, label="Range")
        else:
            if self.hw_ver == 2:
                self.sample_list = ("x1", "x2", "x4", "x5", "x8", "x10", "x16",
                                    "x20")
                self.label_range = wx.StaticText(self, label="Multiplier")
        grid.Add(self.label_range, pos=(2, 0))
        self.edit_range = wx.ComboBox(self,
                                      size=(95, -1),
                                      choices=self.sample_list,
                                      style=wx.CB_READONLY)
        self.edit_range.SetSelection(0)
        grid.Add(self.edit_range, pos=(2, 1))
        if self.hw_ver == 2:
            self.edit_range.Enable(False)

        self.label_rate = wx.StaticText(self, label="Rate(s)")
        grid.Add(self.label_rate, pos=(3, 0))
        self.edit_rate = (FloatSpin(self,
                                    value=1,
                                    min_val=0.1,
                                    max_val=65.535,
                                    increment=0.1,
                                    digits=1))
        grid.Add(self.edit_rate, pos=(3, 1))
        self.button_play = wx.Button(self, label="Play", size=(95, 25))
        self.Bind(wx.EVT_BUTTON, self.play_event, self.button_play)
        self.button_stop = wx.Button(self, label="Stop", size=(95, 25))
        self.Bind(wx.EVT_BUTTON, self.stop_event, self.button_stop)
        self.button_stop.Enable(False)
        grid.Add(self.button_play, pos=(4, 0))
        grid.Add(self.button_stop, pos=(4, 1))
        self.label_value = wx.StaticText(self, label="Last value (V)")
        grid.Add(self.label_value, pos=(5, 0))
        self.input_value = wx.TextCtrl(self,
                                       style=wx.TE_READONLY,
                                       size=(95, 25))
        grid.Add(self.input_value, pos=(5, 1))
        self.input_sizer.Add(grid, 0, wx.ALL, border=10)
        self.output_label = wx.StaticBox(self, -1, 'Analog output')
        self.output_sizer = wx.StaticBoxSizer(self.output_label, wx.HORIZONTAL)
        if hw_ver == 1:
            self.edit_value = FloatSpin(self,
                                        value=0,
                                        min_val=-4.0,
                                        max_val=4.0,
                                        increment=0.1,
                                        digits=3)
        elif hw_ver == 2:
            self.edit_value = FloatSpin(self,
                                        value=0,
                                        min_val=0,
                                        max_val=4.0,
                                        increment=0.1,
                                        digits=3)
        self.Bind(wx.lib.agw.floatspin.EVT_FLOATSPIN, self.slider_change,
                  self.edit_value)
        self.lblDAC = wx.StaticText(self, label="DAC value (V)")
        grid_2.Add(self.lblDAC, pos=(0, 0))
        grid_2.Add(self.edit_value, pos=(0, 3))
        self.output_sizer.Add(grid_2, 0, wx.ALL, border=10)
        self.export_label = wx.StaticBox(self, -1, 'Export')
        self.export_sizer = wx.StaticBoxSizer(self.export_label, wx.HORIZONTAL)
        self.png = wx.Button(self, label="As PNG file...", size=(98, 25))
        self.Bind(wx.EVT_BUTTON, self.save_as_png_event, self.png)
        self.csv = wx.Button(self, label="As CSV file...", size=(98, 25))
        self.Bind(wx.EVT_BUTTON, self.save_as_csv_event, self.csv)
        horizontal_sizer_2.Add(self.png, 0, wx.ALL)
        horizontal_sizer_2.Add(self.csv, 0, wx.ALL)
        self.export_sizer.Add(horizontal_sizer_2, 0, wx.ALL, border=10)
        self.figure = Figure(facecolor='#ece9d8')
        self.axes = self.figure.add_subplot(111)
        self.canvas = FigureCanvas(self, -1, self.figure)
        self.axes.set_xlabel("Time (s)", fontsize=12)
        self.axes.set_ylabel("Voltage (mV)", fontsize=12)
        self.canvas.SetInitialSize(size=(600, 600))
        self.add_toolbar()

        self.cidUpdate = self.canvas.mpl_connect('motion_notify_event',
                                                 self.UpdateStatusBar)
        plot_sizer.Add(self.toolbar, 0, wx.CENTER)
        plot_sizer.Add(self.canvas, 0, wx.ALL)
        horizontal_sizer.Add(self.input_sizer, 0, wx.CENTRE)
        horizontal_sizer.Add(self.output_sizer, 0, wx.EXPAND)
        horizontal_sizer.Add(self.export_sizer, 0, wx.EXPAND)
        main_sizer.Add(horizontal_sizer, 0, wx.ALL, border=10)
        main_sizer.Add(plot_sizer, 0, wx.ALL)
        self.SetSizerAndFit(main_sizer)

        self.data_packet = []
        self.x = []
        self.y = []

        # Create a publisher receiver
        pub.subscribe(self.new_data, "newdata")
        pub.subscribe(self.clear_canvas, "clearcanvas")

    def new_data(self, msg):
        data = msg.data
        if isinstance(msg.data, float):
            self.input_value.Clear()
            self.input_value.AppendText(str(data))
            if (self.toolbar.mode == "pan/zoom"):
                return
            if (self.toolbar.mode == "zoom rect"):
                return
            self.canvas.mpl_disconnect(self.frame.page_1.cidUpdate)
            self.axes.cla()
            self.axes.grid(color='gray', linestyle='dashed')
            self.axes.plot(self.y, self.x)
            self.canvas.draw()
            self.cidUpdate = self.frame.page_1.canvas.mpl_connect(
                'motion_notify_event', self.frame.page_1.UpdateStatusBar)

    def clear_canvas(self, msg):
        self.input_value.Clear()
        self.axes.cla()
        self.axes.grid(color='gray', linestyle='dashed')
        self.axes.plot(self.y, self.x)
        self.canvas.draw()

    def UpdateStatusBar(self, event):
        if event.inaxes:
            x, y = event.xdata, event.ydata
            self.frame.status_bar.SetStatusText(
                ("x= " + "%.4g" % x + "  y=" + "%.4g" % y), 1)

    def add_toolbar(self):
        self.toolbar = MyCustomToolbar(self.canvas)
        self.toolbar.Realize()
        # On Windows platform, default window size is incorrect, so set
        # toolbar width to figure width.
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        # By adding toolbar in sizer, we are able to put it at the bottom
        # of the frame - so appearance is closer to GTK version.
        # As noted above, doesn't work for Mac.
        self.toolbar.SetSize(wx.Size(fw, th))
        #self.main_sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        # update the axes menu on the toolbar
        self.toolbar.update()

    def save_as_png_event(self, event):
        self.directory_name = ''
        dlg = wx.FileDialog(self, "Choose a file", self.directory_name, "",
                            "*.png", wx.OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            self.file_name = dlg.GetFilename()
            self.directory_name = dlg.GetDirectory()
            self.figure.savefig(self.directory_name + "\\" + self.file_name)
        dlg.Destroy()

    def save_as_csv_event(self, event):
        self.directory_name = ''
        dlg = wx.FileDialog(self, "Choose a file", self.directory_name, "",
                            "*.odq", wx.OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            self.file_name = dlg.GetFilename()
            self.directory_name = dlg.GetDirectory()
            with open(self.directory_name + "\\" + self.file_name,
                      'wb') as file:
                spamwriter = csv.writer(file, quoting=csv.QUOTE_MINIMAL)
                for i in range(len(self.frame.comunication_thread.data)):
                    spamwriter.writerow([
                        self.frame.comunication_thread.x[i],
                        self.frame.comunication_thread.y[i]
                    ])
        dlg.Destroy()

    def zoom_up(self, event):
        pass

    def play_event(self, event):
        self.data_packet = []
        self.x = []
        self.y = []
        self.ch_1 = self.edit_ch_1.GetCurrentSelection()
        self.ch_2 = self.edit_ch_2.GetCurrentSelection()
        self.range = self.edit_range.GetCurrentSelection()
        self.rate = self.edit_rate.GetValue() * 1000
        self.edit_rate.SetValue(self.edit_rate.GetValue())
        self.edit_value.SetValue(self.edit_value.GetValue())
        if self.ch_1 == -1:
            self.frame.show_error_parameters()
            return
        if self.ch_2 == -1:
            self.frame.show_error_parameters()
            return
        if self.range == -1:
            self.frame.show_error_parameters()
            return
        if self.hw_ver == 2 and self.ch_2 == 1:
            self.ch_2 = self.edit_ch_2.GetValue()
            self.ch_2 = self.ch_2[1]
        if self.hw_ver == 1:
            if self.ch_2 == 1:
                self.ch_2 = 25
            elif self.ch_2 > 1:
                self.ch_2 += 3
        self.frame.comunication_thread.config(self.ch_1, int(self.ch_2),
                                              self.range, self.rate)
        self.button_play.Enable(False)
        self.button_stop.Enable(True)
        self.edit_ch_1.Enable(False)
        self.edit_ch_2.Enable(False)
        self.edit_range.Enable(False)
        self.edit_rate.Enable(False)
        self.frame.daq.set_led(3)
        wx.CallAfter(pub.sendMessage, "clearcanvas", None)
        if self.frame.comunication_thread.is_alive():
            self.frame.comunication_thread.restart()
        else:
            self.frame.comunication_thread.start()
            self.frame.comunication_thread.stop()
            self.play_event(0)

    def stop_event(self, event):
        self.button_play.Enable(True)
        self.button_stop.Enable(False)
        self.edit_ch_1.Enable(True)
        self.edit_ch_2.Enable(True)
        self.edit_rate.Enable(True)
        if (self.hw_ver == 1
                or (self.hw_ver == 2 and self.edit_ch_2.GetValue() != "AGND")):
            self.edit_range.Enable(True)

        self.frame.daq.set_led(1)
        self.frame.comunication_thread.stop()

    def slider_change(self, event):
        dac_value = self.edit_value.GetValue()
        self.frame.daq.set_analog(dac_value)

    def edit_ch_1_change(self, event):
        if self.hw_ver == 1:
            return
        value = self.edit_ch_1.GetValue()
        self.edit_ch_2.Clear()
        self.edit_ch_2.Append("AGND")
        if (int(value[1]) % 2) == 0:
            self.edit_ch_2.Append("A" + str(int(value[1]) - 1))
        else:
            self.edit_ch_2.Append("A" + str(int(value[1]) + 1))
        self.edit_ch_2.SetSelection(0)
        self.edit_range.SetSelection(0)
        self.edit_range.Enable(False)

    def edit_ch_2_change(self, event):
        if self.hw_ver == 1:
            return
        if self.edit_ch_2.GetValue() == "AGND":
            self.edit_range.Enable(False)
            self.edit_range.SetSelection(0)
        else:
            self.edit_range.Enable(True)
Ejemplo n.º 25
0
class TopApplicationsPlotPanel(wx.Panel):
    def __init__( self, parent):

        wx.Panel.__init__( self, parent)
        # initialize matplotlib stuff
        self.figure = Figure()
        self.canvas = FigureCanvas( self, -1, self.figure )
        self.ax = self.figure.add_subplot(111)

        #print "Top Applications ..."
        self.timeControlPanel = TimeControlPanel(self)

        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.timeControlPanel, 0, wx.LEFT | wx.TOP | wx.GROW)
        self.sizer.Add(self.canvas, 0, wx.LEFT | wx.TOP | wx.GROW)
        self.SetSizer(self.sizer)
       
        self.SetSize(panel_size)
        self.add_toolbar()  # comment this out for no toolbar
        self.ax.set_title('Most active applications', bbox={'facecolor':'0.8', 'pad':5})

        self.Fit()
        #print sql
        rowset = getRowset(sql)
        print "sql = " + sql_total_volume
        total_traffic_volume = getRowset(sql_total_volume)
        labels = []
        prot_num_array = []
        prot_totals_array=[]
        total_outbound_traffic = 0;
        for row in total_traffic_volume:
            total_outbound_traffic = row[0]
        #print total_outbound_traffic
        other_traffic = 0
        less_than_one_percent = 0
        for row in rowset:
            port_num = row[0]
            port_total = row[1]
            percentage = (float(port_total)/total_outbound_traffic)*100
            if application_dictionary.has_key(port_num):
                #print port_num
                if (percentage>1):
                    #print percentage
                    prot_num_array.append(port_num)
                    prot_totals_array.append(port_total)
                else:
                    less_than_one_percent = less_than_one_percent + port_total
            else:
                other_traffic  = other_traffic + port_total
        for item in prot_num_array:
            labels.append(application_dictionary.__getitem__(item))
        labels.append("<1%")
        labels.append("Other")
        prot_totals_array.append(less_than_one_percent)
        prot_totals_array.append(other_traffic)

        #print labels
        self.ax.pie(prot_totals_array, explode=None, labels=labels, autopct='%1.1f%%', shadow=True)
        #title('Most active applications', bbox={'facecolor':'0.8', 'pad':5})

    def add_toolbar(self):
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if wx.Platform == '__WXMAC__':
             self.SetToolBar(self.toolbar)
        else:
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        # update the axes menu on the toolbar
        self.toolbar.update()
Ejemplo n.º 26
0
class DataPlotPanel(wx.Panel):
    """Class for plotting data from FitResultTable. Implements
    'observer' for FitResultTable."""
    
    colors = 'kbgcmr'
    """@ivar: list of colors for multiple plots"""

    colors_rgba = matplotlib.colors.ColorConverter().to_rgba_array(colors)

    markers = 'os^vd'
    """@ivar: list of marker styles for plots with multiple data"""

    linestyles = ['-', '--', '-.', ':']

    ID_AutoscaleX = wx.NewId()
    ID_AutoscaleY = wx.NewId()
    ID_Save       = wx.NewId()

    def __init__(self, parent, name = ''):
        """create panel and axes"""
        self.name = name
        wx.Panel.__init__(self, parent, size = (400, 300))
        self._create_canvas(parent)
        self.axs = []

    def _create_canvas(self, parent):
        self.fig = pylab.Figure()
        self.canvas = FigureCanvas(self, -1, self.fig)
        #self.canvas = FigureCanvas(parent, -1, self.fig)

        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
        self.SetSizer(self.sizer)
        self._create_toolbar()
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(wx.Size(fw, th))
        self.toolbar.update() #??
        self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)

        self.Fit()
        
        self.canvas.mpl_connect('pick_event', self.onpick)

    def _create_toolbar(self):
        """create standard toolbar and add tools for toggling
        automatic scaling"""
        
        self.toolbar = NavigationToolbar2Wx(self.canvas)

        self.toolbar.DeleteTool(self.toolbar._NTB2_SAVE)
        self.toolbar.DeleteTool(self.toolbar._NTB2_SUBPLOT)
        

        self.toolbar.AddLabelTool(self.ID_Save,
                                  'Save',
                                  wx.Bitmap(os.path.join(settings.bitmappath,
                                                         'save.png'),
                                            wx.BITMAP_TYPE_PNG),
                                  shortHelp = "Save Image",
                                  longHelp = "Save Image to File")

        self.toolbar.AddSeparator()
        self.toolbar.AddCheckTool(self.ID_AutoscaleX,
                                  wx.Bitmap(os.path.join(settings.bitmappath,
                                                         'Xscale.png'),
                                            wx.BITMAP_TYPE_PNG),
                                  shortHelp = 'Autoscale X',
                                  longHelp = 'automatic scaling of X-axis')
        self.toolbar.AddCheckTool(self.ID_AutoscaleY,
                                  wx.Bitmap(os.path.join(settings.bitmappath,
                                                         'Yscale.png'),
                                            wx.BITMAP_TYPE_PNG),
                                  shortHelp = 'Autoscale Y',
                                  longHelp = 'automatic scaling of Y-axis')

        wx.EVT_TOOL(self, self.ID_Save, self.OnSave)
        wx.EVT_TOOL(self, self.ID_AutoscaleX, self.OnAutoscaleX)
        wx.EVT_TOOL(self, self.ID_AutoscaleY, self.OnAutoscaleY)

        self.toolbar.ToggleTool(self.ID_AutoscaleX, True)
        self.toolbar.ToggleTool(self.ID_AutoscaleY, True)

        self.autoscaleX = True
        self.autoscaleY = True

        self.toolbar.Realize()

    def draw(self):
        self.fig.canvas.draw()
        
    def update(self, subject):

        """update status by requesting and storing data from calling
        subject (given as argument), using the plotdata property"""

        #store pointer to subject (table) which sends message that
        #data has changed, needed for displaying mouse selection of
        #data
        self.subject = subject

        #get data from subject
        xdata, ydatas, d = subject.plotdata


        if d['xcol']: # and len(d['ycols']) > 0: #note xcol could be None
            self.datax = xdata
            self.datasy = ydatas
            self.dataid = d['yid']
            self.datagidx = d['gidx']
            self.datamask = d['masked']
            self.datadict = d

            self.refresh()

        else:
            #TODO: something wrong here!
            if False:
                #no valid data: escape
                self.datax = []
                self.datasy = []
                self.dataid = []
                self.datagidx = []
                self.datamask = []
                #TODO: fix for group data
                return


    def prepare_axes(self, n):
        """create n subplots (axes) by adding or removing subplots
        (axes), try to keep existing limits"""
        
        nold = len(self.axs)

        if n == nold:
            return

        #save old limits
        lims = [(a.get_xlim(), a.get_ylim()) for a in self.axs]

        #delete old axes
        for a in self.axs: self.fig.delaxes(a)
        self.axs = []

        #create new axes
        for k in range(n):
            if k>0:
                ax = self.fig.add_subplot(n,1,k+1, sharex = self.axs[0])
            else:
                ax = self.fig.add_subplot(n,1,k+1)
                
            if k>nold-1:
                #newly appended axis

                #need x autoscaling if no old axis exists
                if nold == 0:
                    ax.cam_need_autoscalex = True
                else:
                    ax.set_xlim(lims[0][0])
                    ax.cam_need_autoscalex = False
                
                #appended axes need autoscaling for first plot                    
                ax.cam_need_autoscaley = True
                
            else:
                ax.set_xlim(lims[k][0])
                ax.cam_need_autoscalex = False
                ax.set_ylim(lims[k][1])
                ax.cam_need_autoscaley = False
                
            ax.set_picker(True)
            self.axs.append(ax)


    def refresh(self):
        """refresh plot based on saved status"""

        if not self.canvas.IsShownOnScreen():
            return

        #plot data, store handles
        self.phs = []

        self.prepare_axes( len(self.datasy) )


        #do empty plots for group values legend
        #save axes limits
        xlimits = self.axs[0].get_xlim()
        ylimits = self.axs[0].get_ylim()
        self.axs[0].set_autoscale_on(False)
        gvals = self.datadict['gvals']
        sh = []
        st = []
        for k, gval in enumerate(gvals):
            h = self.axs[0].plot([], [], color = 'k', 
                                 linestyle = self.linestyles[k%len(self.linestyles)],
                                 )
            sh.append(h[0])
            st.append('%g'%gval)

        #restore limits
        self.axs[0].set_xlim(xlimits)
        self.axs[0].set_ylim(ylimits)

        # prepare 2 row of fields for saving averaged data of 2 subplots
        self.avgdatafields = []
        
        self.avg_plotted_data = []
        for k in range(len(self.datasy)):
            h = self.do_plot(self.axs[k],
                             self.datax, self.datasy[k],
                             self.datadict['ycollabels'][k],
                             self.datadict['ycols'][k],
                             groupidx = self.datagidx,
                             dataid = self.dataid,
                             showtitle = (k==0),
                             showxlabel = (k+1 == len(self.axs)),
                            )
            self.phs.append(h)
            
            fieldsrow = [self.datadict.get('xcollabel')]
            ylabels = self.datadict['ycollabels'][k]
            for icolumn in range(len(ylabels)):
                yfield = ylabels[icolumn]
                groups = numpy.unique(self.datagidx)
                if len(groups)>1:
                    yfield = ""
                    for gidx in groups:
                        if gidx<0:
                            pass
                        else:
                            fieldsrow.append(ylabels[icolumn]+"_"+st[gidx])
                            fieldsrow.append(ylabels[icolumn]+"_"+st[gidx]+"_err")
                else:
                    fieldsrow.append(ylabels[icolumn])
                    fieldsrow.append(ylabels[icolumn]+"_err")
            
            self.avgdatafields.append(fieldsrow)

        if sh:
            import matplotlib.legend
            l = matplotlib.legend.Legend(self.fig, sh, st, loc = 'upper left')
            self.axs[0].add_artist(l)
            #self.axs[0].legend(sh, st, loc = 'best')

        self.do_autoscale()
        
        #self.draw()
        #self.axs[0].get_xaxis().set_picker(True)

    def do_plot(self, ax, datax, datay, ylabels, ycols, groupidx, dataid, showtitle = True, showxlabel = True):
        """do plot in single axis. do not change axes limits"""

        if len(datax) == 0 or len(datay) == 0:
            print "no data, no plot"
            ax.clear()
            return #TODO: ????

        #create a masked array to store averaged data
        unique_datax = numpy.ma.array(numpy.unique(datax))
        avg_p_data = numpy.ma.vstack((unique_datax,numpy.ma.masked_all((2,len(unique_datax)))))
        avg_p_data = avg_p_data.transpose()
        
        #save axes limits
        xlimits = ax.get_xlim()
        ylimits = ax.get_ylim()

        ##workaround for 0.98.3, xlimits return view of internal data,
        ##need to copy data
        #if isinstance(xlimits, numpy.ndarray):
        #    xlimits = xlimits.copy()

        #if isinstance(ylimits, numpy.ndarray):
        #    ylimits = ylimits.copy()

        #clear and initialize axis
        ax.clear()
        ax.hold(True)
        ax.set_autoscale_on(False)

        handles = []

        for col in range(datay.shape[1]):
            try:
                groups = numpy.unique(groupidx)
                for gidx in groups:
                    if gidx<0 and len(groups)>1:
                        pass
                    else:
                        sel = groupidx == gidx
                        dysel = datay[sel, col]
                        #
                        dysel.shape = (-1, 1)
                        xmed, ymed, yerr = avgdata(datax[sel], dysel)
                        valid = ~ymed.mask.ravel()
                        #
                        ax.plot(xmed[valid],
                                ymed[valid],
                                color = self.colors[ycols[col]%len(self.colors)],
                                linestyle = self.linestyles[gidx%len(self.linestyles)],
                                )
                        ### fill the masked array of averaged data
                        for idatax in range(len(unique_datax)):
                            for ixmed in range(len(xmed[valid])):
                                if xmed[valid][ixmed] == avg_p_data[idatax,0]:
                                    avg_p_data[idatax,-2] = ymed[valid][ixmed]
                                    avg_p_data[idatax,-1] = yerr[valid][ixmed]
                        avg_p_data = numpy.ma.hstack((avg_p_data,numpy.ma.masked_all((len(unique_datax),2))))
                        
                        
                if False: #True:
                    #plot all data
                    h = ax.plot(datax, datay[:,col], 'o',
                               label = ylabels[col],
                               marker = self.markers[ycols[col]%len(self.markers)],
                               color = self.colors[ycols[col]%len(self.colors)],
                               picker = 3.0,
                               )
                    handles.extend(h)

                    #plot masked data
                    #TODO: error if all values of y are not valid
                    xd = datax[self.datamask]
                    yd = datay[self.datamask, col]

                    try:
                        ax.plot(datax[self.datamask],
                               datay[self.datamask, col],
                               'o',
                               label = '_nolegend_',
                               #marker = self.markers[ycols[col]%len(self.markers)],
                               markersize = 9,
                               markeredgecolor = 'b',
                               markerfacecolor = 'w',
                               alpha = 0.5,
                               )
                    except StandardError, e:
                       print "Error plotting masked data"
                       pass
                    
                else:
                    #use scatter to plot masked and non masked data
                    #points, using scatter. Note: problems with alpha
                    #handling in scatter need fixes, see
                    #sandbox/testscatter
                    cc = self.colors_rgba[[ycols[col]%len(self.colors)]*len(datax)]
                    cc[:,3] = 1.0 - self.datamask*0.7
                    #cc[dataid[-1],3] = 0.5

                    #TODO: emphasize last data point

                    h = ax.scatter(datax, datay[:,col],
                                   s = 15*groupidx+30 + 15,
                                   c = cc,
                                   marker = self.markers[ycols[col]%len(self.markers)],
                                   picker = 3.0,
                                   label = ylabels[col],
                                )
                    handles.extend([h])
                    
            except StandardError, e:
                print "Error in plotting data:", e
                raise
                return []
Ejemplo n.º 27
0
class plot_2d_data(wx.Frame):
    """Generic 2d plotting routine - inputs are:
    - data (2d array of values),
    - x and y extent of the data,
    - title of graph, and
    - pixel mask to be used during summation  - must have same dimensions as data
    (only data entries corresponding to nonzero values in pixel_mask will be summed)
    - plot_title, x_label and y_label are added to the 2d-plot as you might expect"""

    def __init__(self, data, extent, caller = None, scale = 'log', window_title = 'log plot', pixel_mask = None, plot_title = "data plot", x_label = "x", y_label = "y", parent=None):
        wx.Frame.__init__(self, parent=None, title=window_title, pos = wx.DefaultPosition, size=wx.Size(800,600))
        print parent
        self.extent = extent
        self.data = data
        self.caller = caller
        self.window_title = window_title
        x_range = extent[0:2]
        #x_range.sort()
        self.x_min, self.x_max = x_range
        y_range = extent[2:4]
        #y_range.sort()
        self.y_min, self.y_max = y_range
        self.plot_title = plot_title
        self.x_label = x_label
        self.y_label = y_label
        self.slice_xy_range = (x_range, y_range)
        self.ID_QUIT = wx.NewId()
        self.ID_LOGLIN = wx.NewId()
        self.ID_UPCOLLIM = wx.NewId()
        self.ID_LOWCOLLIM = wx.NewId()

        menubar = wx.MenuBar()
        filemenu = wx.Menu()
        quit = wx.MenuItem(filemenu, 1, '&Quit\tCtrl+Q')
        #quit.SetBitmap(wx.Bitmap('icons/exit.png'))
        filemenu.AppendItem(quit)

        plotmenu = wx.Menu()
        self.menu_log_lin_toggle = plotmenu.Append(self.ID_LOGLIN, 'Plot 2d data with log color scale', 'plot 2d on log scale', kind=wx.ITEM_CHECK)
        self.Bind(wx.EVT_MENU, self.toggle_2d_plot_scale, id=self.ID_LOGLIN)
        menu_upper_colormap_limit = plotmenu.Append(self.ID_UPCOLLIM, 'Set upper limit of color map', 'Set upper limit of color map')
        self.Bind(wx.EVT_MENU, self.set_new_upper_color_limit, id=self.ID_UPCOLLIM)
        menu_lower_colormap_limit = plotmenu.Append(self.ID_LOWCOLLIM, 'Set lower limit of color map', 'Set lower limit of color map')
        self.Bind(wx.EVT_MENU, self.set_new_lower_color_limit, id=self.ID_LOWCOLLIM)
        #live_on_off = wx.MenuItem(live_update, 1, '&Live Update\tCtrl+L')
        #quit.SetBitmap(wx.Bitmap('icons/exit.png'))
        #live_update.AppendItem(self.live_toggle)
        #self.menu_log_lin_toggle.Check(True)

        menubar.Append(filemenu, '&File')
        menubar.Append(plotmenu, '&Plot')
        self.SetMenuBar(menubar)
        self.Centre()

        if pixel_mask == None:
            pixel_mask = ones(data.shape)

        if pixel_mask.shape != data.shape:
            print "Warning: pixel mask shape incompatible with data"
            pixel_mask = ones(data.shape)

        self.pixel_mask = pixel_mask

        self.show_data = transpose(data.copy())
        #self.minimum_intensity = self.data[pixel_mask.nonzero()].min()
        # correct for floating-point weirdness:
        self.minimum_intensity = self.data[self.data > 1e-17].min()

        #if scale == 'log':
            #self.show_data = log ( self.data.copy().T + self.minimum_intensity/2.0 )
            #self._scale = 'log'
            #self.menu_log_lin_toggle.Check(True)

        #elif (scale =='lin' or scale == 'linear'):
            #self._scale = 'lin'
            #self.menu_log_lin_toggle.Check(True)


        #self.bin_data = caller.bin_data
        #self.params = caller.params
        #fig = figure()
        self.fig = Figure(dpi=80, figsize=(5,5))
        #self.fig = figure()
        fig = self.fig
        self.canvas = Canvas(self, -1, self.fig)
        self.show_sliceplots = False # by default, sliceplots on
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.canvas, 1, wx.TOP | wx.LEFT | wx.EXPAND)

        #self.toolbar = Toolbar(self.canvas)
        self.toolbar = MyNavigationToolbar(self.canvas, True, self)
        self.toolbar.Realize()
        if wx.Platform == '__WXMAC__':
            # Mac platform (OSX 10.3, MacPython) does not seem to cope with
            # having a toolbar in a sizer. This work-around gets the buttons
            # back, but at the expense of having the toolbar at the top
            self.SetToolBar(self.toolbar)
        else:
            # On Windows platform, default window size is incorrect, so set
            # toolbar width to figure width.
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            # By adding toolbar in sizer, we are able to put it at the bottom
            # of the frame - so appearance is closer to GTK version.
            # As noted above, doesn't work for Mac.
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)

        self.statusbar = self.CreateStatusBar()
        self.statusbar.SetFieldsCount(2)
        self.statusbar.SetStatusWidths([-1, -2])
        self.statusbar.SetStatusText("Current Position:", 0)

        self.canvas.mpl_connect('motion_notify_event', self.onmousemove)
        #self.canvas.mpl_connect('button_press_event', self.right_click_handler)
        #self.axes = fig.add_subplot(111)
        #self.axes = self.fig.gca()
        #ax = self.axes
        self.mapper = FigureImage(self.fig)
        #im = self.axes.pcolor(x,y,V,shading='flat')
        #self.mapper.add_observer(im)



        #self.show_data = transpose(log(self.show_data + self.minimum_intensity / 2.0))

        #self.canvas.mpl_connect('pick_event', self.log_lin_select)

        ax = fig.add_subplot(221, label='2d_plot')
        fig.sx = fig.add_subplot(222, label='sx', picker=True)
        fig.sx.xaxis.set_picker(True)
        fig.sx.yaxis.set_picker(True)
        fig.sx.yaxis.set_ticks_position('right')
        fig.sx.set_zorder(1)
        fig.sz = fig.add_subplot(223, label='sz', picker=True)
        fig.sz.xaxis.set_picker(True)
        fig.sz.yaxis.set_picker(True)
        fig.sz.set_zorder(1)
        self.RS = RectangleSelector(ax, self.onselect, drawtype='box', useblit=True)
        fig.slice_overlay = None

        ax.set_position([0.125,0.1,0.7,0.8])
        fig.cb = fig.add_axes([0.85,0.1,0.05,0.8])
        fig.cb.set_zorder(2)

        fig.ax = ax
        fig.ax.set_zorder(2)
        self.axes = ax
        ax.set_title(plot_title)
        #connect('key_press_event', self.toggle_selector)
        if scale == 'log':
            self.show_data = log ( self.data.copy().T + self.minimum_intensity/2.0 )
            self.__scale = 'log'
            self.fig.cb.set_xlabel('$\log_{10}I$')
            self.menu_log_lin_toggle.Check(True)

        elif (scale =='lin' or scale == 'linear'):
            self.__scale = 'lin'
            self.fig.cb.set_xlabel('$I$')
            self.menu_log_lin_toggle.Check(False)

        im = self.axes.imshow(self.show_data, interpolation='nearest', aspect='auto', origin='lower',cmap=cm.jet, extent=extent)
        #im = ax.imshow(data, interpolation='nearest', aspect='auto', origin='lower',cmap=cm.jet, extent=extent)
        fig.im = im
        ax.set_xlabel(x_label, size='large')
        ax.set_ylabel(y_label, size='large')
        self.toolbar.update()
        #zoom_colorbar(im)

        #fig.colorbar(im, cax=fig.cb)
        zoom_colorbar(im=im, cax=fig.cb)
        #figure(fig.number)
        #fig.canvas.draw()
        #return


        self.SetSizer(self.sizer)
        self.Fit()

        self.canvas.Bind(wx.EVT_RIGHT_DOWN, self.OnContext)
        self.Bind(wx.EVT_CLOSE, self.onExit)
        self.sliceplots_off()
        self.SetSize(wx.Size(800,600))
        self.canvas.draw()
        return

    def onExit(self, event):
        self.Destroy()

    def exit(self, event):
        wx.GetApp().Exit()


    def set_new_upper_color_limit(self, evt = None):
        current_uplim = self.fig.im.get_clim()[1]
        current_lowlim = self.fig.im.get_clim()[0]
        dlg = wx.TextEntryDialog(None, "Change upper limit of color map (currently %f)" % current_uplim, defaultValue = "%f" % current_uplim)
        if dlg.ShowModal() == wx.ID_OK:
            new_val = dlg.GetValue()
            xlab = self.fig.cb.get_xlabel()
            ylab = self.fig.cb.get_ylabel()
            self.fig.im.set_clim((current_lowlim, float(new_val)))
            self.fig.cb.set_xlabel(xlab)
            self.fig.cb.set_ylabel(ylab)
            self.fig.canvas.draw()
        dlg.Destroy()

    def set_new_lower_color_limit(self, evt = None):
        current_uplim = self.fig.im.get_clim()[1]
        current_lowlim = self.fig.im.get_clim()[0]
        dlg = wx.TextEntryDialog(None, "Change lower limit of color map (currently %f)" % current_lowlim, defaultValue = "%f" % current_lowlim)
        if dlg.ShowModal() == wx.ID_OK:
            new_val = dlg.GetValue()
            xlab = self.fig.cb.get_xlabel()
            ylab = self.fig.cb.get_ylabel()
            self.fig.im.set_clim((float(new_val), current_uplim))
            self.fig.cb.set_xlabel(xlab)
            self.fig.cb.set_ylabel(ylab)
            self.fig.canvas.draw()
        dlg.Destroy()

    def OnContext(self, evt):
        print self.show_sliceplots
        mpl_x = evt.X
        mpl_y = self.fig.canvas.GetSize()[1] - evt.Y
        mpl_mouseevent = matplotlib.backend_bases.MouseEvent('button_press_event', self.canvas, mpl_x, mpl_y, button = 3)

        if (mpl_mouseevent.inaxes == self.fig.ax):
            self.area_context(mpl_mouseevent, evt)
        elif ((mpl_mouseevent.inaxes == self.fig.sx or mpl_mouseevent.inaxes == self.fig.sz) and (self.show_sliceplots == True)):
            self.lineplot_context(mpl_mouseevent, evt)

    def area_context(self, mpl_mouseevent, evt):
        area_popup = wx.Menu()
        item1 = area_popup.Append(wx.ID_ANY,'&Grid on/off', 'Toggle grid lines')
        wx.EVT_MENU(self, item1.GetId(), self.OnGridToggle)
        cmapmenu = CMapMenu(self, callback = self.OnColormap, mapper=self.mapper, canvas=self.canvas)
        item2 = area_popup.Append(wx.ID_ANY,'&Toggle log/lin', 'Toggle log/linear scale')
        wx.EVT_MENU(self, item2.GetId(), lambda evt: self.toggle_log_lin(mpl_mouseevent))
        item3 = area_popup.AppendMenu(wx.ID_ANY, "Colourmaps", cmapmenu)
        self.PopupMenu(area_popup, evt.GetPositionTuple())

    def figure_list_dialog(self):
        figure_list = get_fignums()
        figure_list_names = []
        for fig in figure_list:
            figure_list_names.append('Figure ' + str(fig))
        figure_list_names.insert(0, 'New Figure')
        figure_list.insert(0, None)
        #selection_num = wx.GetSingleChoiceIndex('Choose other plot', '', other_plot_names)
        dlg = wx.SingleChoiceDialog(None, 'Choose figure number', '', figure_list_names)
        dlg.SetSize(wx.Size(640,480))
        if dlg.ShowModal() == wx.ID_OK:
            selection_num=dlg.GetSelection()
        dlg.Destroy()
        print selection_num
        return figure_list[selection_num]

    def lineplot_context(self, mpl_mouseevent, evt):
        popup = wx.Menu()
        item1 = popup.Append(wx.ID_ANY,'&Toggle log/lin', 'Toggle log/linear scale of slices')
        wx.EVT_MENU(self, item1.GetId(), lambda evt: self.toggle_log_lin(mpl_mouseevent))
        if mpl_mouseevent.inaxes == self.fig.sx:
            item2 = popup.Append(wx.ID_ANY, "Save x slice", "save this slice")
            wx.EVT_MENU(self, item2.GetId(), self.save_x_slice)
            item3 = popup.Append(wx.ID_ANY, '&Popout plot', 'Open this data in a figure window')
            wx.EVT_MENU(self, item3.GetId(), lambda evt: self.popout_x_slice())
        elif mpl_mouseevent.inaxes == self.fig.sz:
            item2 = popup.Append(wx.ID_ANY, "Save y slice", "save this slice")
            wx.EVT_MENU(self, item2.GetId(), self.save_y_slice)
            item3 = popup.Append(wx.ID_ANY, '&Popout plot', 'Open this data in a new plot window')
            wx.EVT_MENU(self, item3.GetId(), lambda evt: self.popout_y_slice())
        self.PopupMenu(popup, evt.GetPositionTuple())


    def popout_y_slice(self, event=None, figure_num = None, label = None):
        if figure_num == None:
            figure_num = self.figure_list_dialog()
        fig = figure(figure_num) # if this is None, matplotlib automatically increments figure number to highest + 1
        ax = self.fig.sz
        slice_desc = '\nsliceplot([%f,%f],[%f,%f])' % (self.slice_xy_range[0][0],self.slice_xy_range[0][1],self.slice_xy_range[1][0],self.slice_xy_range[1][1])
        if figure_num == None:
            default_title = self.plot_title + slice_desc
            dlg = wx.TextEntryDialog(None, 'Enter title for plot', defaultValue = default_title)
            if dlg.ShowModal() == wx.ID_OK:
                title = dlg.GetValue()
            else:
                title = default_title
            dlg.Destroy()
            new_ax = fig.add_subplot(111)
            new_ax.set_title(title, size='large')
            new_ax.set_xlabel(self.x_label, size='x-large')
            new_ax.set_ylabel('$I_{summed}$', size='x-large')
        else:
            new_ax = fig.axes[0]
        if label == None:
            default_label = self.window_title + ': ' + self.plot_title + slice_desc
            dlg = wx.TextEntryDialog(None, 'Enter data label (for plot legend)', defaultValue = default_label)
            if dlg.ShowModal() == wx.ID_OK:
                label = dlg.GetValue()
            else:
                label = default_label
            dlg.Destroy()
        xy = ax.lines[0].get_data()
        x = xy[0]
        y = xy[1]
        new_ax.plot(x,y, label = label)
        font = FontProperties(size='small')
        lg = legend(prop=font)
        drag_lg = DraggableLegend(lg)
        drag_lg.connect()
        fig.canvas.draw()
        fig.show()

    def popout_x_slice(self, event=None, figure_num = None, label = None):
        if figure_num == None:
            figure_num = self.figure_list_dialog()
        fig = figure(figure_num)
        ax = self.fig.sx
        slice_desc = '\nsliceplot([%f,%f],[%f,%f])' % (self.slice_xy_range[0][0],self.slice_xy_range[0][1],self.slice_xy_range[1][0],self.slice_xy_range[1][1])
        if figure_num == None:
            default_title = self.plot_title + slice_desc
            dlg = wx.TextEntryDialog(None, 'Enter title for plot', defaultValue = default_title)
            if dlg.ShowModal() == wx.ID_OK:
                title = dlg.GetValue()
            else:
                title = default_title
            dlg.Destroy()
            new_ax = fig.add_subplot(111)
            new_ax.set_title(title, size='large')
            new_ax.set_xlabel(self.y_label, size='x-large')
            new_ax.set_ylabel('$I_{summed}$', size='x-large')
        else:
            new_ax = fig.axes[0]
        if label == None:
            default_label = self.window_title + ': ' + self.plot_title + slice_desc
            dlg = wx.TextEntryDialog(None, 'Enter data label (for plot legend)', defaultValue = default_label)
            if dlg.ShowModal() == wx.ID_OK:
                label = dlg.GetValue()
            else:
                label = default_label
            dlg.Destroy()
        xy = ax.lines[0].get_data()
        x = xy[1]
        y = xy[0]
        new_ax.plot(x,y, label = label)
        font = FontProperties(size='small')
        lg = legend(prop=font)
        drag_lg = DraggableLegend(lg)
        drag_lg.connect()
        fig.canvas.draw()
        fig.show()

    def save_x_slice(self, event=None, outFileName=None):
        if outFileName == None:
            dlg = wx.FileDialog(None, "Save 2d data as:", '', "", "", wx.FD_SAVE)
            if dlg.ShowModal() == wx.ID_OK:
                fn = dlg.GetFilename()
                fd = dlg.GetDirectory()
            dlg.Destroy()
            outFileName = fd + '/' + fn
        outFile = open(outFileName, 'w')
        outFile.write('#'+self.title+'\n')
        outFile.write('#xmin: ' + str(self.slice_xy_range[0][0]) + '\n')
        outFile.write('#xmax: ' + str(self.slice_xy_range[0][1]) + '\n')
        outFile.write('#ymin: ' + str(self.slice_xy_range[1][0]) + '\n')
        outFile.write('#ymax: ' + str(self.slice_xy_range[1][1]) + '\n')
        outFile.write("#y\tslice_x_data\n")
        if not (self.slice_x_data == None):
            for i in range(self.slice_x_data.shape[0]):
                x = self.y[i]
                y = self.slice_x_data[i]
                outFile.write(str(x) + "\t" + str(y) + "\n")
        outFile.close()
        print('saved x slice in %s' % (outFileName))
        return

    def save_y_slice(self, event=None, outFileName=None):
        if outFileName == None:
            dlg = wx.FileDialog(None, "Save 2d data as:", '', "", "", wx.FD_SAVE)
            if dlg.ShowModal() == wx.ID_OK:
                fn = dlg.GetFilename()
                fd = dlg.GetDirectory()
            dlg.Destroy()
            outFileName = fd + '/' + fn
        outFile = open(outFileName, 'w')
        outFile.write('#'+self.title+'\n')
        outFile.write('#xmin: ' + str(self.slice_xrange[0]) + '\n')
        outFile.write('#xmax: ' + str(self.slice_xrange[1]) + '\n')
        outFile.write('#ymin: ' + str(self.slice_yrange[0]) + '\n')
        outFile.write('#ymax: ' + str(self.slice_yrange[1]) + '\n')
        outFile.write("#x\tslice_y_data\n")
        if not (self.slice_y_data == None):
            for i in range(self.slice_y_data.shape[0]):
                x = self.x[i]
                y = self.slice_y_data[i]
                outFile.write(str(x) + "\t" + str(y) + "\n")
        outFile.close()
        print('saved y slice in %s' % (outFileName))
        return


    def OnGridToggle(self, event):
        self.fig.ax.grid()
        self.fig.canvas.draw_idle()

    def OnColormap(self, name):
        print "Selected colormap",name
        self.fig.im.set_cmap(get_cmap(name))
        self.fig.canvas.draw()

    def toggle_2d_plot_scale(self, event=None):
        if self.__scale == 'log':
            self.show_data = self.data.T
            self.fig.im.set_array(self.show_data)
            self.fig.im.autoscale()
            self.fig.cb.set_xlabel('$I$')
            self.__scale = 'lin'
            self.menu_log_lin_toggle.Check(False)
            self.statusbar.SetStatusText("%s scale" % self.__scale, 0)
            self.fig.canvas.draw_idle()
        elif self.__scale == 'lin':
            self.show_data = log ( self.data.copy().T + self.minimum_intensity/2.0 )
            self.fig.im.set_array(self.show_data)
            self.fig.im.autoscale()
            self.fig.cb.set_xlabel('$\log_{10}I$')
            self.__scale = 'log'
            self.menu_log_lin_toggle.Check(True)
            self.statusbar.SetStatusText("%s scale" % self.__scale, 0)
            self.fig.canvas.draw_idle()


    def toggle_log_lin(self,event):

        ax = event.inaxes
        label = ax.get_label()

        if label == '2d_plot':
            self.toggle_2d_plot_scale()

        if label == 'sz':
            scale = ax.get_yscale()
            if scale == 'log':
                ax.set_yscale('linear')
                ax.figure.canvas.draw_idle()
            elif scale == 'linear':
                ax.set_yscale('log')
                ax.figure.canvas.draw_idle()

        elif label == 'sx':
            scale = ax.get_xscale()
            if scale == 'log':
                ax.set_xscale('linear')
                ax.figure.canvas.draw_idle()
            elif scale == 'linear':
                ax.set_xscale('log')
                ax.figure.canvas.draw_idle()


    def onmousemove(self,event):
        # the cursor position is given in the wx status bar
        #self.fig.gca()
        if event.inaxes:
            x, y = event.xdata, event.ydata
            self.statusbar.SetStatusText("%s scale x = %.3g, y = %.3g" % (self.__scale,x,y), 1)
            #self.statusbar.SetStatusText("y = %.3g" %y, 2)


    def onselect(self, eclick, erelease):
        x_range = [eclick.xdata, erelease.xdata]
        y_range = [eclick.ydata, erelease.ydata]
        ax = eclick.inaxes
        self.sliceplot((x_range, y_range), ax)
        print 'sliceplot(([%f,%f],[%f,%f]))' % (x_range[0],x_range[1],y_range[0],y_range[1])

    def sliceplots_off(self):
        self.fig.ax.set_position([0.125,0.1,0.7,0.8])
        self.fig.cb.set_position([0.85,0.1,0.05,0.8])
        #self.fig.cb.set_visible(True)
        self.fig.sx.set_visible(False)
        self.fig.sz.set_visible(False)
        if self.fig.slice_overlay:
            self.fig.slice_overlay[0].set_visible(False)
        self.RS.set_active(False)
        self.show_sliceplots = False
        self.fig.canvas.draw()

    def sliceplots_on(self):
        self.fig.ax.set_position([0.125,0.53636364, 0.35227273,0.36363636])
        self.fig.cb.set_position([0.49,0.53636364, 0.02, 0.36363636])
        self.fig.sx.set_position([0.58,0.53636364, 0.35227273,0.36363636])
        self.fig.sx.set_visible(True)
        self.fig.sz.set_visible(True)
        #self.fig.cb.set_visible(False)
        if self.fig.slice_overlay:
            self.fig.slice_overlay[0].set_visible(True)
        self.RS.set_active(True)
        self.show_sliceplots = True
        self.fig.canvas.draw()

    def toggle_sliceplots(self):
        """switch between views with and without slice plots"""
        if self.show_sliceplots == True:
            self.sliceplots_off()
        else: # self.show_sliceplots == False
            self.sliceplots_on()

    def show_slice_overlay(self, x_range, y_range, x, slice_y_data, y, slice_x_data):
        """sum along x and z within the box defined by qX- and qZrange.
        sum along qx is plotted to the right of the data,
        sum along qz is plotted below the data.
        Transparent white rectangle is overlaid on data to show summing region"""
        from matplotlib.ticker import FormatStrFormatter, ScalarFormatter

        if self.fig == None:
            print('No figure for this dataset is available')
            return

        fig = self.fig
        ax = fig.ax
        extent = fig.im.get_extent()

        if fig.slice_overlay == None:
            fig.slice_overlay = ax.fill([x_range[0],x_range[1],x_range[1],x_range[0]],[y_range[0],y_range[0],y_range[1],y_range[1]],fc='white', alpha=0.3)
            fig.ax.set_ylim(extent[2],extent[3])
        else:
            fig.slice_overlay[0].xy = [(x_range[0],y_range[0]), (x_range[1],y_range[0]), (x_range[1],y_range[1]), (x_range[0],y_range[1])]
        fig.sz.clear()
        default_fmt = ScalarFormatter(useMathText=True)
        default_fmt.set_powerlimits((-2,4))
        fig.sz.xaxis.set_major_formatter(default_fmt)
        fig.sz.yaxis.set_major_formatter(default_fmt)
        fig.sz.xaxis.set_major_formatter(FormatStrFormatter('%.2g'))
        fig.sz.set_xlim(x[0], x[-1])
        fig.sz.plot(x, slice_y_data)
        fig.sx.clear()
        fig.sx.yaxis.set_major_formatter(default_fmt)
        fig.sx.xaxis.set_major_formatter(default_fmt)
        fig.sx.yaxis.set_ticks_position('right')
        fig.sx.yaxis.set_major_formatter(FormatStrFormatter('%.2g'))
        fig.sx.set_ylim(y[0], y[-1])
        fig.sx.plot(slice_x_data, y)

        fig.im.set_extent(extent)
        fig.canvas.draw()

    def copy_intensity_range_from(self, other_plot):
        if isinstance(other_plot, type(self)):
            xlab = self.fig.cb.get_xlabel()
            ylab = self.fig.cb.get_ylabel()

            self.fig.im.set_clim(other_plot.fig.im.get_clim())
            self.fig.cb.set_xlabel(xlab)
            self.fig.cb.set_ylabel(ylab)
            self.fig.canvas.draw()

    def sliceplot(self, xy_range, ax = None):
        """sum along x and z within the box defined by qX- and qZrange.
        sum along qx is plotted to the right of the data,
        sum along qz is plotted below the data.
        Transparent white rectangle is overlaid on data to show summing region"""
        self.sliceplots_on()
        x_range, y_range = xy_range
        x, slice_y_data, y, slice_x_data = self.do_xy_slice(x_range, y_range)
        self.x = x
        self.slice_y_data = slice_y_data
        self.y = y
        self.slice_x_data = slice_x_data
        self.slice_xy_range = xy_range

        self.show_slice_overlay(x_range, y_range, x, slice_y_data, y, slice_x_data)

    def do_xy_slice(self, x_range, y_range):
        """ slice up the data, once along x and once along z.
        returns 4 arrays:  a y-axis for the x data,
        an x-axis for the y data."""
        #params = self.params
        print 'doing xy slice'
        data = self.data
        pixels = self.pixel_mask
        # zero out any pixels in the sum that have zero in the pixel count:
        data[pixels == 0] = 0

        normalization_matrix = ones(data.shape)
        normalization_matrix[pixels == 0] = 0
        x_min = min(x_range)
        x_max = max(x_range)
        y_min = min(y_range)
        y_max = max(y_range)

        x_size,y_size = data.shape
        global_x_range = (self.x_max - self.x_min)
        global_y_range = (self.y_max - self.y_min)

        x_pixel_min = round( (x_min - self.x_min) / global_x_range * x_size )
        x_pixel_max = round( (x_max - self.x_min) / global_x_range * x_size )
        y_pixel_min = round( (y_min - self.y_min) / global_y_range * y_size )
        y_pixel_max = round( (y_max - self.y_min) / global_y_range * y_size )

        #correct any sign switches:
        if (x_pixel_min > x_pixel_max):
            new_min = x_pixel_max
            x_pixel_max = x_pixel_min
            x_pixel_min = new_min

        if (y_pixel_min > y_pixel_max):
            new_min = y_pixel_max
            y_pixel_max = y_pixel_min
            y_pixel_min = new_min

        new_x_min = x_pixel_min / x_size * global_x_range + self.x_min
        new_x_max = x_pixel_max / x_size * global_x_range + self.x_min
        new_y_min = y_pixel_min / y_size * global_y_range + self.y_min
        new_y_max = y_pixel_max / y_size * global_y_range + self.y_min

        x_pixel_min = int(x_pixel_min)
        x_pixel_max = int(x_pixel_max)
        y_pixel_min = int(y_pixel_min)
        y_pixel_max = int(y_pixel_max)

        y_norm_factor = sum(normalization_matrix[x_pixel_min:x_pixel_max,y_pixel_min:y_pixel_max], axis=1)
        x_norm_factor = sum(normalization_matrix[x_pixel_min:x_pixel_max,y_pixel_min:y_pixel_max], axis=0)
        # make sure the normalization has a minimum value of 1 everywhere,
        # to avoid divide by zero errors:
        y_norm_factor[y_norm_factor == 0] = 1
        x_norm_factor[x_norm_factor == 0] = 1

        slice_y_data = sum(data[x_pixel_min:x_pixel_max,y_pixel_min:y_pixel_max], axis=1) / y_norm_factor
        slice_x_data = sum(data[x_pixel_min:x_pixel_max,y_pixel_min:y_pixel_max], axis=0) / x_norm_factor

        #slice_y_data = slice_y_data
        #slice_x_data = slice_x_data

        x_vals = arange(slice_y_data.shape[0], dtype = 'float') / slice_y_data.shape[0] * (new_x_max - new_x_min) + new_x_min
        y_vals = arange(slice_x_data.shape[0], dtype = 'float') / slice_x_data.shape[0] * (new_y_max - new_y_min) + new_y_min

        return x_vals, slice_y_data, y_vals, slice_x_data
Ejemplo n.º 28
0
class CanvasFrameTS(wxFrame):
    def __init__(self):
        wxFrame.__init__(self, None, -1, 'Time Series', size=(1450, 1100))

        self.SetBackgroundColour(wxNamedColor("BLACK"))

        self.figure = Figure(figsize=(5, 5), dpi=100)
        self.axes1 = self.figure.add_subplot(511)
        self.axes2 = self.figure.add_subplot(512)
        self.axes3 = self.figure.add_subplot(513)
        self.axes4 = self.figure.add_subplot(514)
        self.axes5 = self.figure.add_subplot(515)
        self.axes5.set_xlabel(str(FileString[0]), fontsize=8)

        if (len(pixelvec) > 0):  ###Might try all on one axis system
            self.axes1.plot(FilteredLongTS[0])
            tvec = Threshold[0] + ones(len(FilteredLongTS[0]))
            self.axes1.plot(tvec)

        if (len(pixelvec) > 1):
            self.axes2.plot(FilteredLongTS[1])
            tvec = Threshold[1] + ones(len(FilteredLongTS[0]))
            self.axes2.plot(tvec)

        if (len(pixelvec) > 2):
            self.axes3.plot(FilteredLongTS[2])
            tvec = Threshold[2] + ones(len(FilteredLongTS[0]))
            self.axes3.plot(tvec)

        if (len(pixelvec) > 3):
            self.axes4.plot(FilteredLongTS[3])
            tvec = Threshold[3] + ones(len(FilteredLongTS[0]))
            self.axes4.plot(tvec)

        if (len(pixelvec) > 4):
            self.axes5.plot(FilteredLongTS[4])
            tvec = Threshold[4] + ones(len(FilteredLongTS[0]))
            self.axes5.plot(tvec)

        self.canvas = FigureCanvas(self, -1, self.figure)

        self.sizer = wxBoxSizer(wxVERTICAL)
        self.sizer.Add(self.canvas, 1, wxTOP | wxLEFT | wxEXPAND)
        # Capture the paint message
        EVT_PAINT(self, self.OnPaint)

        self.toolbar = MyNavigationToolbar(self.canvas, True)
        self.toolbar.Realize()
        if wxPlatform == '__WXMAC__':
            # Mac platform (OSX 10.3, MacPython) does not seem to cope with
            # having a toolbar in a sizer. This work-around gets the buttons
            # back, but at the expense of having the toolbar at the top
            self.SetToolBar(self.toolbar)
        else:
            # On Windows platform, default window size is incorrect, so set
            # toolbar width to figure width.
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            # By adding toolbar in sizer, we are able to put it at the bottom
            # of the frame - so appearance is closer to GTK version.
            # As noted above, doesn't work for Mac.
            self.toolbar.SetSize(wxSize(fw, th))
            self.sizer.Add(self.toolbar, 0, wxLEFT | wxEXPAND)

        # update the axes menu on the toolbar
        self.toolbar.update()
        self.SetSizer(self.sizer)
        self.Fit()

    def OnPaint(self, event):
        self.canvas.draw()
        event.Skip()
Ejemplo n.º 29
0
class CanvasFrame(wx.Frame):
    def __init__(self, parent, title):
        wx.Frame.__init__(self, parent, -1, title, size=(550, 350))
        self.SetBackgroundColour(wx.NamedColour("WHITE"))

        self.figure = Figure()
        self.axes = self.figure.add_subplot(111)
        self.change_plot(0)

        self.canvas = FigureCanvas(self, -1, self.figure)

        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.add_buttonbar()
        self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
        self.add_toolbar()  # comment this out for no toolbar

        menuBar = wx.MenuBar()

        # File Menu
        menu = wx.Menu()
        menu.Append(wx.ID_EXIT, "E&xit\tAlt-X", "Exit this simple sample")
        menuBar.Append(menu, "&File")

        if IS_GTK or IS_WIN:
            # Equation Menu
            menu = wx.Menu()
            for i, (mt, func) in enumerate(functions):
                bm = mathtext_to_wxbitmap(mt)
                item = wx.MenuItem(menu, 1000 + i, "")
                item.SetBitmap(bm)
                menu.AppendItem(item)
                self.Bind(wx.EVT_MENU, self.OnChangePlot, item)
            menuBar.Append(menu, "&Functions")

        self.SetMenuBar(menuBar)

        self.SetSizer(self.sizer)
        self.Fit()

    def add_buttonbar(self):
        self.button_bar = wx.Panel(self)
        self.button_bar_sizer = wx.BoxSizer(wx.HORIZONTAL)
        self.sizer.Add(self.button_bar, 0, wx.LEFT | wx.TOP | wx.GROW)

        for i, (mt, func) in enumerate(functions):
            bm = mathtext_to_wxbitmap(mt)
            button = wx.BitmapButton(self.button_bar, 1000 + i, bm)
            self.button_bar_sizer.Add(button, 1, wx.GROW)
            self.Bind(wx.EVT_BUTTON, self.OnChangePlot, button)

        self.button_bar.SetSizer(self.button_bar_sizer)

    def add_toolbar(self):
        """Copied verbatim from embedding_wx2.py"""
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        if IS_MAC:
            self.SetToolBar(self.toolbar)
        else:
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(wx.Size(fw, th))
            self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
        self.toolbar.update()

    def OnPaint(self, event):
        self.canvas.draw()

    def OnChangePlot(self, event):
        self.change_plot(event.GetId() - 1000)

    def change_plot(self, plot_number):
        t = arange(1.0, 3.0, 0.01)
        s = functions[plot_number][1](t)
        self.axes.clear()
        self.axes.plot(t, s)
        self.Refresh()
Ejemplo n.º 30
0
class PlotFigure(wx.Frame):
    def OnKeyPressed(self, event):
        key = event.key
        if key == 'q':
            self.OnClose(event)

    def __init__(self, func, timer_period):
        wx.Frame.__init__(self, None, -1, "Plot Figure")

        self.fig = Figure((12, 9), 75)
        self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
        self.canvas.mpl_connect('key_press_event', self.OnKeyPressed)
        self.toolbar = NavigationToolbar2Wx(self.canvas)
        self.toolbar.Realize()
        self.func = func
        self.plot = None

        self.timer_period = timer_period
        self.timer = wx.Timer(self)
        self.is_stopped = False

        if os.name == 'nt':
            # On Windows, default frame size behaviour is incorrect
            # you don't need this under Linux
            tw, th = self.toolbar.GetSizeTuple()
            fw, fh = self.canvas.GetSizeTuple()
            self.toolbar.SetSize(Size(fw, th))

        # Create a figure manager to manage things

        # Now put all into a sizer
        sizer = wx.BoxSizer(wx.VERTICAL)
        # This way of adding to sizer allows resizing
        sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
        # Best to allow the toolbar to resize!
        sizer.Add(self.toolbar, 0, wx.GROW)
        self.SetSizer(sizer)
        self.Fit()
        self.Bind(wx.EVT_TIMER, self.OnTimerWrap, self.timer)
        self.Bind(wx.EVT_CLOSE, self.OnClose)

        self.timer.Start(timer_period)

    def GetToolBar(self):
        # You will need to override GetToolBar if you are using an
        # unmanaged toolbar in your frame
        return self.toolbar

    def OnClose(self, event):
        self.is_stopped = True
        print('Closing PlotFigure, please wait.')
        self.timer.Stop()
        self.Destroy()

    def OnTimerWrap(self, evt):
        if self.is_stopped:
            print('Ignoring timer callback')
            return
        t = time.time()
        try:
            self.OnTimer(evt)
        except KeyboardInterrupt:
            self.OnClose(evt)
        duration = 1000 * (time.time() - t)
        if duration > self.timer_period:
            print('Changing timer_period from %s to %s msec' %
                  (self.timer_period, 1.2 * duration))
            self.timer_period = 1.2 * duration
            self.timer.Stop()
            self.timer.Start(self.timer_period)

    def OnTimer(self, evt):

        try:
            xdata, ydata_list, legend = self.func()
        except RuntimeError:
            traceback.print_exc(file=sys.stderr)
            self.OnClose(evt)
            return
        if len(ydata_list.shape) == 1:
            ydata_list = ydata_list.reshape((1, ydata_list.size))
        if self.plot is None:
            self.axes = self.fig.add_axes([0.1, 0.1, 0.8, 0.8])
            l = []
            for ydata in ydata_list:
                l.extend([xdata, ydata])
            self.plot = self.axes.plot(*l)
            self.axes.set_xlabel('Seconds')
            self.axes.set_ylabel('Volts')
            self.axes.set_title('nof samples=%s' % (len(xdata)))
            self.axes.legend(legend)
        else:
            self.axes.set_xlim(xmin=xdata[0], xmax=xdata[-1])
            ymin, ymax = 1e9, -1e9
            for line, data in zip(self.plot, ydata_list):
                line.set_xdata(xdata)
                line.set_ydata(data)
                ymin, ymax = min(data.min(), ymin), max(data.max(), ymax)
            dy = (ymax - ymin) / 20
            self.axes.set_ylim(ymin=ymin - dy, ymax=ymax + dy)
        self.canvas.draw()

    def onEraseBackground(self, evt):
        # this is supposed to prevent redraw flicker on some X servers...
        pass