Inheritance diagram for imu_stream_plot.GraphFrame:

Collaboration diagram for imu_stream_plot.GraphFrame:

Public Member Functions
def	__init__ (self)

def	create_menu (self)

def	create_main_panel (self)

def	create_status_bar (self)

def	init_plot (self)

def	draw_plot (self)

def	on_pause_button (self, event)

def	on_update_pause_button (self, event)

def	on_cb_grid (self, event)

def	on_cb_xlab (self, event)

def	on_save_plot (self, event)

def	on_redraw_timer (self, event)

def	on_exit (self, event)

def	flash_status_message (self, msg, flash_len_ms=1500)

def	on_flash_status_off (self, event)

Public Attributes
	datagen

	data

	paused

	redraw_timer

	menubar

	panel

	canvas

	xmin_control

	xmax_control

	ymin_control

	ymax_control

	pause_button

	cb_grid

	cb_xlab

	hbox1

	hbox2

	vbox

	statusbar

	dpi

	fig

	axes

	plot_data

	timeroff

Static Public Attributes
string	title = 'Demo: dynamic matplotlib graph'

Detailed Description

The main frame of the application

Constructor & Destructor Documentation

def imu_stream_plot.GraphFrame.__init__ ( self )

     def __init__(self):
         wx.Frame.__init__(self, None, -1, self.title)
         
         self.datagen = DataGen()
         self.data = [self.datagen.next()]
         self.paused = False
         
         self.create_menu()
         self.create_status_bar()
         self.create_main_panel()
         
         self.redraw_timer = wx.Timer(self)
         self.Bind(wx.EVT_TIMER, self.on_redraw_timer, self.redraw_timer)        
         self.redraw_timer.Start(100)
 

Member Function Documentation

def imu_stream_plot.GraphFrame.create_menu ( self )

     def create_menu(self):
         self.menubar = wx.MenuBar()
         
         menu_file = wx.Menu()
         m_expt = menu_file.Append(-1, "&Save plot\tCtrl-S", "Save plot to file")
         self.Bind(wx.EVT_MENU, self.on_save_plot, m_expt)
         menu_file.AppendSeparator()
         m_exit = menu_file.Append(-1, "E&xit\tCtrl-X", "Exit")
         self.Bind(wx.EVT_MENU, self.on_exit, m_exit)
                 
         self.menubar.Append(menu_file, "&File")
         self.SetMenuBar(self.menubar)
 

def imu_stream_plot.GraphFrame.create_main_panel ( self )

     def create_main_panel(self):
         self.panel = wx.Panel(self)
 
         self.init_plot()
         self.canvas = FigCanvas(self.panel, -1, self.fig)
 
         self.xmin_control = BoundControlBox(self.panel, -1, "X min", 0)
         self.xmax_control = BoundControlBox(self.panel, -1, "X max", 50)
         self.ymin_control = BoundControlBox(self.panel, -1, "Y min", 0)
         self.ymax_control = BoundControlBox(self.panel, -1, "Y max", 100)
         
         self.pause_button = wx.Button(self.panel, -1, "Pause")
         self.Bind(wx.EVT_BUTTON, self.on_pause_button, self.pause_button)
         self.Bind(wx.EVT_UPDATE_UI, self.on_update_pause_button, self.pause_button)
         
         self.cb_grid = wx.CheckBox(self.panel, -1, 
             "Show Grid",
             style=wx.ALIGN_RIGHT)
         self.Bind(wx.EVT_CHECKBOX, self.on_cb_grid, self.cb_grid)
         self.cb_grid.SetValue(True)
         
         self.cb_xlab = wx.CheckBox(self.panel, -1, 
             "Show X labels",
             style=wx.ALIGN_RIGHT)
         self.Bind(wx.EVT_CHECKBOX, self.on_cb_xlab, self.cb_xlab)        
         self.cb_xlab.SetValue(True)
         
         self.hbox1 = wx.BoxSizer(wx.HORIZONTAL)
         self.hbox1.Add(self.pause_button, border=5, flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL)
         self.hbox1.AddSpacer(20)
         self.hbox1.Add(self.cb_grid, border=5, flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL)
         self.hbox1.AddSpacer(10)
         self.hbox1.Add(self.cb_xlab, border=5, flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL)
         
         self.hbox2 = wx.BoxSizer(wx.HORIZONTAL)
         self.hbox2.Add(self.xmin_control, border=5, flag=wx.ALL)
         self.hbox2.Add(self.xmax_control, border=5, flag=wx.ALL)
         self.hbox2.AddSpacer(24)
         self.hbox2.Add(self.ymin_control, border=5, flag=wx.ALL)
         self.hbox2.Add(self.ymax_control, border=5, flag=wx.ALL)
         
         self.vbox = wx.BoxSizer(wx.VERTICAL)
         self.vbox.Add(self.canvas, 1, flag=wx.LEFT | wx.TOP | wx.GROW)        
         self.vbox.Add(self.hbox1, 0, flag=wx.ALIGN_LEFT | wx.TOP)
         self.vbox.Add(self.hbox2, 0, flag=wx.ALIGN_LEFT | wx.TOP)
         
         self.panel.SetSizer(self.vbox)
         self.vbox.Fit(self)
     

def imu_stream_plot.GraphFrame.create_status_bar ( self )

     def create_status_bar(self):
         self.statusbar = self.CreateStatusBar()
 

def imu_stream_plot.GraphFrame.init_plot ( self )

     def init_plot(self):
         self.dpi = 100
         self.fig = Figure((3.0, 3.0), dpi=self.dpi)
 
         self.axes = self.fig.add_subplot(111)
         self.axes.set_axis_bgcolor('black')
         self.axes.set_title('IMU data', size=12)
         
         pylab.setp(self.axes.get_xticklabels(), fontsize=8)
         pylab.setp(self.axes.get_yticklabels(), fontsize=8)
 
         # plot the data as a line series, and save the reference 
         # to the plotted line series
         #
         self.plot_data = self.axes.plot(
             self.data, 
             linewidth=1,
             color=(1, 1, 0),
             )[0]
 

def imu_stream_plot.GraphFrame.draw_plot ( self )

Redraws the plot

     def draw_plot(self):
         """ Redraws the plot
         """
         # when xmin is on auto, it "follows" xmax to produce a 
         # sliding window effect. therefore, xmin is assigned after
         # xmax.
         #
         if self.xmax_control.is_auto():
             xmax = len(self.data) if len(self.data) > 50 else 50
         else:
             xmax = int(self.xmax_control.manual_value())
             
         if self.xmin_control.is_auto():            
             xmin = xmax - 50
         else:
             xmin = int(self.xmin_control.manual_value())
 
         # for ymin and ymax, find the minimal and maximal values
         # in the data set and add a mininal margin.
         # 
         # note that it's easy to change this scheme to the 
         # minimal/maximal value in the current display, and not
         # the whole data set.
         # 
         if self.ymin_control.is_auto():
             ymin = round(min(self.data), 0) - 1
         else:
             ymin = int(self.ymin_control.manual_value())
         
         if self.ymax_control.is_auto():
             ymax = round(max(self.data), 0) + 1
         else:
             ymax = int(self.ymax_control.manual_value())
 
         self.axes.set_xbound(lower=xmin, upper=xmax)
         self.axes.set_ybound(lower=ymin, upper=ymax)
         
         # anecdote: axes.grid assumes b=True if any other flag is
         # given even if b is set to False.
         # so just passing the flag into the first statement won't
         # work.
         #
         if self.cb_grid.IsChecked():
             self.axes.grid(True, color='gray')
         else:
             self.axes.grid(False)
 
         # Using setp here is convenient, because get_xticklabels
         # returns a list over which one needs to explicitly 
         # iterate, and setp already handles this.
         #  
         pylab.setp(self.axes.get_xticklabels(), 
             visible=self.cb_xlab.IsChecked())
         
         self.plot_data.set_xdata(np.arange(len(self.data)))
         self.plot_data.set_ydata(np.array(self.data))
         
         self.canvas.draw()
     

def imu_stream_plot.GraphFrame.on_pause_button	(	self,
		event
	)

     def on_pause_button(self, event):
         self.paused = not self.paused
     

def imu_stream_plot.GraphFrame.on_update_pause_button	(	self,
		event
	)

     def on_update_pause_button(self, event):
         label = "Resume" if self.paused else "Pause"
         self.pause_button.SetLabel(label)
     

def imu_stream_plot.GraphFrame.on_cb_grid	(	self,
		event
	)

     def on_cb_grid(self, event):
         self.draw_plot()
     

def imu_stream_plot.GraphFrame.on_cb_xlab	(	self,
		event
	)

     def on_cb_xlab(self, event):
         self.draw_plot()
     

def imu_stream_plot.GraphFrame.on_save_plot	(	self,
		event
	)

     def on_save_plot(self, event):
         file_choices = "PNG (*.png)|*.png"
         
         dlg = wx.FileDialog(
             self, 
             message="Save plot as...",
             defaultDir=os.getcwd(),
             defaultFile="plot.png",
             wildcard=file_choices,
             style=wx.SAVE)
         
         if dlg.ShowModal() == wx.ID_OK:
             path = dlg.GetPath()
             self.canvas.print_figure(path, dpi=self.dpi)
             self.flash_status_message("Saved to %s" % path)
     

def imu_stream_plot.GraphFrame.on_redraw_timer	(	self,
		event
	)

     def on_redraw_timer(self, event):
         # if paused do not add data, but still redraw the plot
         # (to respond to scale modifications, grid change, etc.)
         #
         if not self.paused:
             self.data.append(self.datagen.next())
         
         self.draw_plot()
     

def imu_stream_plot.GraphFrame.on_exit	(	self,
		event
	)

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

def imu_stream_plot.GraphFrame.flash_status_message	(	self,
		msg,
		flash_len_ms = `1500`
	)

     def flash_status_message(self, msg, flash_len_ms=1500):
         self.statusbar.SetStatusText(msg)
         self.timeroff = wx.Timer(self)
         self.Bind(
             wx.EVT_TIMER, 
             self.on_flash_status_off, 
             self.timeroff)
         self.timeroff.Start(flash_len_ms, oneShot=True)
     

def imu_stream_plot.GraphFrame.on_flash_status_off	(	self,
		event
	)

     def on_flash_status_off(self, event):
         self.statusbar.SetStatusText('')

Member Data Documentation

string imu_stream_plot.GraphFrame.title = 'Demo: dynamic matplotlib graph'

static

imu_stream_plot.GraphFrame.datagen

imu_stream_plot.GraphFrame.data

imu_stream_plot.GraphFrame.paused

imu_stream_plot.GraphFrame.redraw_timer

imu_stream_plot.GraphFrame.menubar

imu_stream_plot.GraphFrame.panel

imu_stream_plot.GraphFrame.canvas

imu_stream_plot.GraphFrame.xmin_control

imu_stream_plot.GraphFrame.xmax_control

imu_stream_plot.GraphFrame.ymin_control

imu_stream_plot.GraphFrame.ymax_control

imu_stream_plot.GraphFrame.pause_button

imu_stream_plot.GraphFrame.cb_grid

imu_stream_plot.GraphFrame.cb_xlab

imu_stream_plot.GraphFrame.hbox1

imu_stream_plot.GraphFrame.hbox2

imu_stream_plot.GraphFrame.vbox

imu_stream_plot.GraphFrame.statusbar

imu_stream_plot.GraphFrame.dpi

imu_stream_plot.GraphFrame.fig

imu_stream_plot.GraphFrame.axes

imu_stream_plot.GraphFrame.plot_data

imu_stream_plot.GraphFrame.timeroff

The documentation for this class was generated from the following file:

imu_stream_plot.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation