class WidgetsWrapper(object): def __init__(self): self.widgets = gtk.glade.XML('mpl_with_glade.glade') self.widgets.signal_autoconnect(GladeHandlers.__dict__) self['windowMain'].connect('destroy', lambda x: gtk.main_quit()) self['windowMain'].move(10, 10) self.figure = Figure(figsize=(8, 6), dpi=72) self.axis = self.figure.add_subplot(111) t = arange(0.0, 3.0, 0.01) s = sin(2 * pi * t) self.axis.plot(t, s) self.axis.set_xlabel('time (s)') self.axis.set_ylabel('voltage') self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea self.canvas.show() self.canvas.set_size_request(600, 400) self.canvas.set_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK) self.canvas.set_flags(gtk.HAS_FOCUS | gtk.CAN_FOCUS) self.canvas.grab_focus() def keypress(widget, event): print('key press') def buttonpress(widget, event): print('button press') self.canvas.connect('key_press_event', keypress) self.canvas.connect('button_press_event', buttonpress) def onselect(xmin, xmax): print(xmin, xmax) span = SpanSelector(self.axis, onselect, 'horizontal', useblit=False, rectprops=dict(alpha=0.5, facecolor='red')) self['vboxMain'].pack_start(self.canvas, True, True) self['vboxMain'].show() # below is optional if you want the navigation toolbar self.navToolbar = NavigationToolbar(self.canvas, self['windowMain']) self.navToolbar.lastDir = '/var/tmp/' self['vboxMain'].pack_start(self.navToolbar) self.navToolbar.show() sep = gtk.HSeparator() sep.show() self['vboxMain'].pack_start(sep, True, True) self['vboxMain'].reorder_child(self['buttonClickMe'], -1) def __getitem__(self, key): return self.widgets.get_widget(key)
class WidgetsWrapper(object): def __init__(self): self.widgets = gtk.glade.XML('mpl_with_glade.glade') self.widgets.signal_autoconnect(GladeHandlers.__dict__) self['windowMain'].connect('destroy', lambda x: gtk.main_quit()) self['windowMain'].move(10, 10) self.figure = Figure(figsize=(8, 6), dpi=72) self.axis = self.figure.add_subplot(111) t = arange(0.0, 3.0, 0.01) s = sin(2*pi*t) self.axis.plot(t, s) self.axis.set_xlabel('time (s)') self.axis.set_ylabel('voltage') self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea self.canvas.show() self.canvas.set_size_request(600, 400) self.canvas.set_events( gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK ) self.canvas.set_flags(gtk.HAS_FOCUS | gtk.CAN_FOCUS) self.canvas.grab_focus() def keypress(widget, event): print('key press') def buttonpress(widget, event): print('button press') self.canvas.connect('key_press_event', keypress) self.canvas.connect('button_press_event', buttonpress) def onselect(xmin, xmax): print(xmin, xmax) span = SpanSelector(self.axis, onselect, 'horizontal', useblit=False, rectprops=dict(alpha=0.5, facecolor='red')) self['vboxMain'].pack_start(self.canvas, True, True) self['vboxMain'].show() # below is optional if you want the navigation toolbar self.navToolbar = NavigationToolbar(self.canvas, self['windowMain']) self.navToolbar.lastDir = '/var/tmp/' self['vboxMain'].pack_start(self.navToolbar) self.navToolbar.show() sep = gtk.HSeparator() sep.show() self['vboxMain'].pack_start(sep, True, True) self['vboxMain'].reorder_child(self['buttonClickMe'], -1) def __getitem__(self, key): return self.widgets.get_widget(key)
class template: def __init__(self): self.builder = gtk.Builder() self.builder.add_from_file(os.path.splitext(__file__)[0]+".glade") self.window = self.builder.get_object("window") dic = { "on_toolbutton_refresh_clicked" : self.generate_testdata, "on_button1_clicked" : self.generate_testdata, "on_vboxMain_button_press_event" : self.button_press_event, "on_vboxMain_button_release_event" : self.button_release_event, "on_vboxMain_drag" : self.drag_begin, "on_vboxMain_motion_notify_event" : self.drag_begin, "on_toolbar_clear_clicked" : self.clear_selections, "on_toolbar_zoomin_clicked" : self.zoomin_time, "on_toolbar_zoomout_clicked" : self.zoomout_time, "on_go_back_clicked" : self.go_back, "on_go_forward_clicked" : self.go_forward, "on_toolbutton_preferences_clicked" : self.preferences_open, "on_button_pref_apply_activate" : self.pref_apply, "set_channel_groups" : self.set_channel_groups, } self.builder.connect_signals(dic) self.create_draw_frame('none') self.space = 0 self.generate_testdata(None) def create_draw_frame(self,widget): self.fig = Figure(figsize=[100,100], dpi=72) self.canvas = FigureCanvas(self.fig) self.canvas.connect("scroll_event", self.scroll_event) #self.canvas.connect('button_press_event', self.button_press_event) self.canvas.show() self.figure = self.canvas.figure self.axes = self.fig.add_axes([0.045, 0.05, 0.93, 0.925], axisbg='#FFFFCC') self.vb = self.builder.get_object("vboxMain") self.vb.pack_start(self.canvas, gtk.TRUE, gtk.TRUE) self.vb.show() def preferences_open(self,widget): self.win_prefs = self.builder.get_object("window_prefs") self.win_prefs.show() self.channel_tree(None) def scroll_event(self, widget, event): if event.direction == gdk.SCROLL_UP: direction = 1 self.space = self.space + .1*self.scalefact else: direction = -1 self.space = self.space - .1*self.scalefact if self.space < 0: self.space = 0 print 'space', self.space print (arange(0,size(self.data2plot,1))*(self.space)) self.space_data() self.redraw(None) curpos = self.axes.get_position() l1 = curpos.x0 b1 = curpos.y0 w1 = curpos.x1 h1 = curpos.y1 def space_data(self): self.data2plot = self.data[self.tstart:self.tstop,self.chanind] + \ (arange(0,size(self.data[self.tstart:self.tstop,self.chanind],1)) * \ (self.space)) def get_cursor_position(self,event): ap = self.axes.get_position() x,y = self.canvas.get_width_height() posx = ((event.x/x)-ap.x0)*(1/(ap.x1-ap.x0)) posy = ((event.y/y)-(1-ap.y0))*(1/(ap.y0-ap.y1)) self.sx = (posx*(self.time[-1]-self.time[0]))+self.time[0] self.sy = (posy*(self.data2plot.max()-self.data2plot.min()))+self.data2plot.min() print self.sx, self.sy def button_press_event(self,widget,event): self.get_cursor_position(event) print 'button pushed',event.button,event.type if event.type == gtk.gdk.BUTTON_PRESS: print "single click" if event.button == 1: #clicked line #self.axes.axvline(x=self.sx) self.xstart = self.sx elif event.type == gtk.gdk._2BUTTON_PRESS: print "double click" #highlight channel #self.axes.axhspan(self.sy-1, self.sy+1, xmin=0, xmax=1, color='yellow') elif event.type == gtk.gdk._3BUTTON_PRESS: print "triple click. ouch, you hurt your user." if event.type == gtk.gdk.BUTTON_PRESS and event.button == 2: print 'highlighting channel' self.axes.axhspan(self.sy-self.scalefact, \ self.sy+self.scalefact, xmin=0, xmax=1, color='g') #refresh canvas self.canvas.draw() def button_release_event(self,widget,event): pass self.get_cursor_position(event) #print event#.button if event.type == gtk.gdk.BUTTON_RELEASE and event.button == 1: self.axes.axvspan(ymin=0, ymax=1, xmin=self.xstart, xmax=self.sx, color='b') try: self.selections = vstack((self.selections,[self.xstart,self.sx])) except AttributeError: self.selections = array([[self.xstart,self.sx]]) print 'sels',self.selections self.canvas.draw() def clear_selections(self,widget): del self.selections self.redraw(None) def drag_begin(self,widget,event): pass #self.get_cursor_position(event) def redraw(self,widget): #print 'button press' print len(self.time),self.data2plot.shape self.color = 'black' self.axes.cla() self.axes = self.figure.axes[0] self.axes.plot(self.time, self.data2plot,color=self.color) self.axes.axis('tight') #self.axes.axis('off') try: print 'd',self.selections for i in self.selections: self.axes.axvspan(ymin=0, ymax=1, xmin=i[0], xmax=i[1], color='b') except: pass self.canvas.draw() def zoomin_time(self,widget): startind = self.tstart; stopind = self.tstop-((self.tstop-self.tstart)/2) self.check_scale(startind,stopind) def zoomout_time(self,widget): startind = self.tstart; stopind = self.tstop+((self.tstop-self.tstart)*2) self.check_scale(startind,stopind) def go_forward(self,widget): startind = ((self.tstop-self.tstart)/2)+self.tstart; stopind = ((self.tstop-self.tstart)/2)+self.tstop; self.check_scale(startind,stopind) def go_back(self,widget): startind = self.tstart-((self.tstop-self.tstart)/2); stopind = self.tstop-((self.tstop-self.tstart)/2); self.check_scale(startind,stopind) def check_scale(self,startind,stopind): print 'req',startind,stopind, self.tstart,self.tstop if startind < 0: startind = 0 stopind = self.tstop if stopind > len(self.t): startind = self.tstart stopind = len(self.t) if stopind < 0: stopind = self.tstop print 'set',startind,stopind,self.tstart,self.tstop self.tstart = startind self.tstop = stopind self.time = self.t[self.tstart:self.tstop] self.data2plot = self.data[self.tstart:self.tstop,self.chanind] self.space_data() self.redraw(None) def page_down(self,widget): pass def channel_tree(self,widget): print('updating list') self.View = self.builder.get_object("treeview1") self.dataList = gtk.ListStore(str,str) self.AddListColumn('Number', 0) self.AddListColumn('Label', 1) for k in range(0,self.numchannels): iter = self.dataList.append([k,'label'+str(k)]) self.View.set_model(self.dataList) print 'adding channels' def AddListColumn(self, title, columnId): column = gtk.TreeViewColumn(title, gtk.CellRendererText(), text=columnId) column.set_resizable(True) column.set_sort_column_id(columnId) self.View.append_column(column) self.View.get_selection().set_mode(gtk.SELECTION_MULTIPLE) def pref_apply(self, widget): liststore,iter = self.View.get_selection().get_selected_rows() self.chanind = [] for i in iter: print i, liststore[i][1] self.chanind.append(int(liststore[i][0])) #print self.dataList.get_value(iter,0) print self.chanind self.space_data() self.redraw(None) def set_channel_groups(self,widget): print widget.get_label(), widget #for i in self.builder.get_object('vbox2').get_children(): #if i.get_active() == True: #print(i) #print i.get_label() if widget.get_label() == 'meg' and widget.get_active() == True: #self.View.get_selection().select_all() #self.View.get_selection().select_all() self.View.get_selection().select_range(0,2) if widget.get_label() == 'Clear': self.View.get_selection().unselect_all() if widget.get_label() == 'all' and widget.get_active() == True: self.View.get_selection().select_all() def generate_testdata(self,widget): numpts = 10 self.numchannels = 10 self.t = arange(0,numpts, .01) self.data = zeros((len(self.t),self.numchannels)) self.scalefact = 1e-9 for i in arange(0,self.numchannels): r = random.randn() self.data[:,i] = float32((sin(2*0.32*pi*self.t*r) * sin(2*2.44*pi*self.t*r)))#+ self.space self.data = self.data * self.scalefact self.tstart = 0; self.tstop = len(self.t) self.time = copy(self.t[self.tstart:self.tstop]) print self.tstart,self.tstop self.chanind = arange(0,self.numchannels) self.data2plot = self.data self.space_data() #self.time_view() self.redraw(None) def datahandler(data=None): pass
class band_graph(gtk.VBox): def init(self): toolbar = gtk.Toolbar() toolbar.set_style(gtk.TOOLBAR_ICONS) toolbar.set_size_request(-1, 50) self.pack_start(toolbar, False, False, 0) tool_bar_pos=0 save = gtk.ToolButton(gtk.STOCK_SAVE) save.connect("clicked", self.callback_save_image) toolbar.insert(save, tool_bar_pos) toolbar.show_all() tool_bar_pos=tool_bar_pos+1 self.my_figure=Figure(figsize=(5,4), dpi=100) self.canvas = FigureCanvas(self.my_figure) # a gtk.DrawingArea self.canvas.figure.patch.set_facecolor('white') self.canvas.set_size_request(600, 400) self.canvas.show() self.pack_start(self.canvas, False, False, 0) self.canvas.connect('key_press_event', self.on_key_press_event) self.show_all() def on_key_press_event(self,widget, event): keyname = gtk.gdk.keyval_name(event.keyval) if keyname == "c": if event.state == gtk.gdk.CONTROL_MASK: self.do_clip() self.canvas.draw() def do_clip(self): print "doing clip" snap = self.my_figure.canvas.get_snapshot() pixbuf = gtk.gdk.pixbuf_get_from_drawable(None, snap, snap.get_colormap(),0,0,0,0,snap.get_size()[0], snap.get_size()[1]) clip = gtk.Clipboard() clip.set_image(pixbuf) def callback_save_image(self, widget): dialog = gtk.FileChooserDialog("Save plot", None, gtk.FILE_CHOOSER_ACTION_SAVE, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK)) dialog.set_default_response(gtk.RESPONSE_OK) dialog.set_action(gtk.FILE_CHOOSER_ACTION_CREATE_FOLDER) filter = gtk.FileFilter() filter.set_name("png") filter.add_pattern("*.png") dialog.add_filter(filter) response = dialog.run() if response == gtk.RESPONSE_OK: self.my_figure.savefig(dialog.get_filename()) elif response == gtk.RESPONSE_CANCEL: print 'Closed' dialog.destroy() def set_data_file(self,file): self.optical_mode_file=os.path.join(os.getcwd(),"light_dump",file) def draw_graph(self): self.layer_end=[] self.layer_name=[] n=0 self.my_figure.clf() ax1 = self.my_figure.add_subplot(111) ax2 = ax1.twinx() x_pos=0.0 layer=0 color =['r','g','b','y','o','r','g','b','y','o'] start=0.0 for i in range(0,epitaxy_get_layers()): if epitaxy_get_electrical_layer(i)=="none": start=start-epitaxy_get_width(i) else: break print "START=",start start=start*1e9 x_pos=start for i in range(0,epitaxy_get_layers()): label=epitaxy_get_mat_file(i) layer_ticknes=epitaxy_get_width(i) layer_material=epitaxy_get_mat_file(i) delta=float(layer_ticknes)*1e9 if epitaxy_get_electrical_layer(i)=="none": mat_file=os.path.join(os.getcwd(),'materials',layer_material,'mat.inp') myfile = open(mat_file) self.mat_file_lines = myfile.readlines() myfile.close() for ii in range(0, len(self.mat_file_lines)): self.mat_file_lines[ii]=self.mat_file_lines[ii].rstrip() lumo=-float(self.mat_file_lines[1]) Eg=float(self.mat_file_lines[3]) else: lines=[] if inp_load_file(lines,epitaxy_get_electrical_layer(i)+".inp")==True: lumo=-float(inp_search_token_value(lines, "#Xi")) Eg=float(inp_search_token_value(lines, "#Eg")) x = [x_pos,x_pos+delta,x_pos+delta,x_pos] lumo_delta=lumo-0.1 h**o=lumo-Eg homo_delta=h**o-0.1 if Eg==0.0: lumo_delta=-7.0 h**o=0.0 lumo_shape = [lumo,lumo,lumo_delta,lumo_delta] x_pos=x_pos+delta self.layer_end.append(x_pos) self.layer_name.append(layer_material) ax2.fill(x,lumo_shape, color[layer],alpha=0.4) ax2.text(x_pos-delta/1.5, lumo-0.4, epitaxy_get_name(i)) if h**o!=0.0: homo_shape = [h**o,h**o,homo_delta,homo_delta] ax2.fill(x,homo_shape, color[layer],alpha=0.4) layer=layer+1 n=n+1 state=plot_state() get_plot_file_info(state,self.optical_mode_file) #summary="<big><b>"+self.store[path[0]][0]+"</b></big>\n"+"\ntitle: "+state.title+"\nx axis: "+state.x_label+" ("+latex_to_pygtk_subscript(state.x_units)+")\ny axis: "++" ("+latex_to_pygtk_subscript(state.y_units)+")\n\n<big><b>Double click to open</b></big>" print "ROD!!!!",state.y_label,self.optical_mode_file ax1.set_ylabel(state.y_label) ax1.set_xlabel('Position (nm)') ax2.set_ylabel('Energy (eV)') ax2.set_xlim([start, x_pos]) #ax2.axis(max=)#autoscale(enable=True, axis='x', tight=None) loaded=False if os.path.isfile("light_dump.zip"): zf = zipfile.ZipFile("light_dump.zip", 'r') lines = zf.read(self.optical_mode_file).split("\n") zf.close() loaded=True elif os.path.isfile(self.optical_mode_file): print "I want to load",self.optical_mode_file f = open(self.optical_mode_file) lines = f.readlines() f.close() loaded=True if loaded==True: xx=[] yy=[] zz=[] lines_to_xyz(xx,yy,zz,lines) t = asarray(xx) s = asarray(yy) t=t*1e9 ax1.plot(t,s, 'black', linewidth=3 ,alpha=0.5) self.my_figure.tight_layout()
class Gtk_NetworkCanvas: """Gtk_NetworkCanvas class. This class contains the canvas to draw the topology. It implements event listener and zoom. Parameters ---------- canvas : the gtk canvas to draw adjustement : used for zoom scroll bar zoom_scale : a scroll bar to zoom redraw : a button to redraw the graph popup : a popup for interaction on right click bRefresh : bool. if True enable refresh with do_refresh function corners : the limit of the canvas drawing area press : bool. True if mouse click on canvas (used for zoom) x_old, y_old : position for zoom """ def __init__(self): fig = plt.figure(num=None, facecolor='w', edgecolor='k') plt.axis('off') plt.subplots_adjust(left=0., right=1., bottom=0., top=1., wspace=0.2, hspace=0.2) self.canvas = FigureCanvas(fig) self.canvas.add_events( gtk.gdk.EXPOSURE_MASK | gtk.gdk.LEAVE_NOTIFY_MASK | gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.BUTTON_RELEASE_MASK) self.canvas.connect("motion_notify_event", self.on_motion) self.canvas.connect("button-press-event", self.on_click) self.canvas.connect("button-release-event", self.on_release) self.canvas.connect("scroll-event", self.on_scroll) self.canvas.connect("leave-notify-event", self.on_lose_focus) self.adjustement = gtk.Adjustment(0.0, 0.0, 100.0, 1.0, 1.0, 1.0) self.adjustement_signal = self.adjustement.connect("value-changed", self.on_zoom_changed) self.zoom_scale = gtk.HScale(self.adjustement) self.zoom_scale.set_draw_value(False) self.zoom_value = 0.0 self.redraw = gtk.Button("Redraw") self.redraw.connect("clicked", self.on_redraw) self.hbox = gtk.HBox() self.hbox.pack_start(self.zoom_scale, True, True, 0) self.hbox.pack_end(self.redraw, False, False, 0) self.vbox = gtk.VBox() self.vbox.pack_start(self.canvas, True, True, 0) self.vbox.pack_end(self.hbox, False, False, 0) self.popup = Gtk_NewtworkPopupMenu() self.bRefresh = True self.corners = None self.press = False self.x_old = 0 self.y_old = 0 self.bg_img = None def on_click(self, widget, event): """Event listener : click If double left click : - on edge, show edges rules - on firewall, show firewall conf - on interface, add note If left click : - on edge, show message - on firewall, show message interaction firewall - on interface, show message interaction interface - else move x/y limit drawing area If right click : - on edge, show edge menu - on firewall, show firewall menu - on interface, show interface menu - else show canvas menu """ if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS: dbl_click = False dbl_click |= self.on_dblclick_edge() dbl_click |= self.on_dblclick_node() if not dbl_click: Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message(Gtk_Message.TOPOLOGY_MESSAGE) if event.button == 3 and event.type == gtk.gdk.BUTTON_PRESS: right_click = False right_click |= self.on_right_click_edge(event) right_click |= self.on_right_click_node(event) if not right_click: Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message(Gtk_Message.ON_BACKGROUND_CLICK) self.popup.popup_clear(event) if event.button == 1 and event.type == gtk.gdk.BUTTON_PRESS: left_click = False left_click |= self.on_left_click_edge() left_click |= self.on_left_click_node() if not left_click: self.press = True self.x_old = event.x self.y_old = event.y Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message(Gtk_Message.TOPOLOGY_MESSAGE) return True def on_dblclick_edge(self): """Show interface rules""" def get_firewall(x, y): if isinstance(x, Firewall): return x elif isinstance(y, Firewall): return y return None def get_ip(x, y): if isinstance(x, Ip): return x elif isinstance(y, Ip): return y return None g = NetworkGraph.NetworkGraph() for elem in g.graph.edges(data=True): edge = elem[2]['object'] if edge.gtk_press: fw = get_firewall(elem[0], elem[1]) ip = get_ip(elem[0], elem[1]) result = [] [result.append(acl) for acl in g.get_acl_list(src=ip, dst=None, firewall=fw)] [result.append(acl) for acl in g.get_acl_list(src=None, dst=ip, firewall=fw)] if not result: Gtk_DialogBox("No rules found for this interface !") [Gtk_Main.Gtk_Main().notebook.add_interface_tab(acl) for acl in result] return True return False def on_dblclick_node(self): """Event listener, on double click node, if firewall show conf file else add note""" g = NetworkGraph.NetworkGraph() for k, v in g.graph.node.items(): if v['object'].gtk_press and isinstance(v['object'].object, Firewall): Gtk_Main.Gtk_Main().notebook.add_conf_tab(v['object'].object.name, v['object'].object.hostname) return True if v['object'].gtk_press and isinstance(v['object'].object, Ip): self.popup.node = v['object'] self.popup.on_add_note(None) return True return False def on_right_click_edge(self, event): """Event listener, on right click edge, popup menu showing acl list of related to this interface""" g = NetworkGraph.NetworkGraph() for elem in g.graph.edges(data=True): edge = elem[2]['object'] if edge.gtk_press: self.popup.popup(elem, event, edge) edge.gtk_press = False return True return False def on_right_click_node(self, event): """Event listener, on right click node, show popup menu for node""" g = NetworkGraph.NetworkGraph() for k, v in g.graph.node.items(): if v['object'].gtk_press: self.popup.popup(None, event, v['object']) v['object'].gtk_press = False return True return False def on_left_click_node(self): """Show node details""" g = NetworkGraph.NetworkGraph() for k, v in g.graph.node.items(): if v['object'].gtk_press: Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message(Gtk_Message.ON_CLICK_NODE) Gtk_Main.Gtk_Main().lateral_pane.details.clear() tmp_intf = [e[2]['object'].object for e in g.graph.edges(k, data=True)] for e in sorted(tmp_intf, key=lambda tmp_intf: tmp_intf.nameif): message = "%s:\n- %s\n- %s" % (e.nameif, e.name, e.network.to_string()) for key, value in e.attributes.items(): message += "\n- %s : %s" % (key, value) Gtk_Main.Gtk_Main().lateral_pane.details.add_row(message) Gtk_Main.Gtk_Main().lateral_pane.focus_details() return True return False def on_left_click_edge(self): """If left click edge, show help message""" g = NetworkGraph.NetworkGraph() for edge in g.graph.edges(): if g.graph[edge[0]][edge[1]]['object'].gtk_press: Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message(Gtk_HelpMessage.Gtk_Message.ON_CLICK_EDGE) return True return False def on_motion(self, widget, event): """If not click node, then move axis""" if self.press and self.corners: xlim = list(plt.gca().get_xlim()) ylim = list(plt.gca().get_ylim()) x = (self.x_old - event.x) / (1. * self.canvas.window.get_size()[0] / (xlim[1] - xlim[0])) y = (event.y - self.y_old) / (1. * self.canvas.window.get_size()[1] / (ylim[1] - ylim[0])) self.x_old = event.x self.y_old = event.y self.axes_move(x, y, x, y) self.do_refresh() def refresh(self): """refresh function. This function is call periodically by do_refresh""" self.bRefresh = True def do_refresh(self): """Update the graph if bRefresh is True""" if self.bRefresh: self.bRefresh = False self.canvas.draw() gtk.timeout_add(30, self.refresh) def on_release(self, widget, event): """Event listener : release""" self.press = False def on_scroll(self, widget, event): """Event listener : scroll. Update zoom""" if event.direction == 0 and self.adjustement.get_value() < 99: self.adjustement.set_value(self.adjustement.get_value() + 1) elif event.direction == 1 and self.adjustement.get_value() > 0: self.adjustement.set_value(self.adjustement.get_value() - 1) def on_zoom_changed(self, widget): """Event listerner : HScale change. Update zoom""" if self.corners: im = None if self.bg_img: im = self.bg_img.get_children()[0] if widget.value != 0: zoom = (self.zoom_value - widget.value) * (self.corners[1][0] - self.corners[0][0]) / 200 self.axes_zoom(-zoom, -zoom, zoom, zoom) if im: dim = min(1. * self.canvas.window.get_size()[0] / len(im.properties()['data'][0]), 1. * self.canvas.window.get_size()[1] / len(im.properties()['data'])) corners = min(self.corners[1][0] - self.corners[0][0], self.corners[1][1] - self.corners[0][1]) im.set_zoom(im.get_zoom() - zoom * 2 * dim / corners) else: plt.gca().set_xlim((self.corners[0][0], self.corners[1][0])) plt.gca().set_ylim((self.corners[0][1], self.corners[1][1])) if im: im.set_zoom(min(1. * self.canvas.window.get_size()[0] / len(im.properties()['data'][0]), 1. * self.canvas.window.get_size()[1] / len(im.properties()['data']))) self.zoom_value = widget.value self.do_refresh() def on_lose_focus(self, widget, event): """Event listener : focus""" self.press = False NetworkGraph.NetworkGraph().node_click = False for node in NetworkGraph.NetworkGraph().graph.nodes(data=True): node[1]['object'].press = False for edge in NetworkGraph.NetworkGraph().graph.edges(data=True): edge[2]['object'].press = False self.do_refresh() def on_redraw(self, widget): """Event listener : button redraw""" self.draw() def axes_move(self, x0, y0, x1, y1): """Change axis position according to the drawing area limit. Parameters ---------- x0 : float. x minimal value x1 : float. x maximal value y0 : float. y minimal value y1 : float. y maximal value """ if self.corners: x = list(plt.gca().get_xlim()) y = list(plt.gca().get_ylim()) if ((x0 < 0 and x[0] + x0 >= self.corners[0][0]) or (x0 > 0 and x[0] + x0 < x[1])) and \ ((x1 > 0 and x[1] + x1 <= self.corners[1][0]) or (x1 < 0 and x[1] + x1 > x[0])): x[0] += x0 x[1] += x1 if ((y0 < 0 and y[0] + y0 >= self.corners[0][1]) or (y0 > 0 and y[0] + y0 < y[1])) and \ ((y1 > 0 and y[1] + y1 <= self.corners[1][1]) or (y1 < 0 and y[1] + y1 > y[0])): y[0] += y0 y[1] += y1 plt.gca().set_xlim((x[0], x[1])) plt.gca().set_ylim((y[0], y[1])) def axes_zoom(self, x0, y0, x1, y1): """Zoom axis position according to the drawing area limit. Parameters ---------- x0 : float. x minimal value x1 : float. x maximal value y0 : float. y minimal value y1 : float. y maximal value """ if self.corners: x = list(plt.gca().get_xlim()) y = list(plt.gca().get_ylim()) if (x0 < 0 and x[0] >= self.corners[0][0]) or (x0 > 0 and x[0] + x0 < x[1]): x[0] += x0 if (x1 > 0 and x[1] <= self.corners[1][0]) or (x1 < 0 and x[1] - x1 > x[0]): x[1] += x1 if (y0 < 0 and y[0] >= self.corners[0][1]) or (y0 > 0 and y[0] + y0 < y[1]): y[0] += y0 if (y1 > 0 and y[1] <= self.corners[1][1]) or (y1 < 0 and y[1] - y1 > y[0]): y[1] += y1 plt.gca().set_xlim((x[0], x[1])) plt.gca().set_ylim((y[0], y[1])) def background_image(self, file): """Set the file image as background image""" if self.bg_img: self.bg_img.remove() datafile = get_sample_data(file) img = plt.imread(datafile) im = OffsetImage(img) im.set_zoom(min(1. * self.canvas.window.get_size()[0] / len(im.properties()['data'][0]), 1. * self.canvas.window.get_size()[1] / len(im.properties()['data']))) self.bg_img = AnnotationBbox(im, (0.5, 0.5), xycoords='data', frameon=False) self.bg_img.set_zorder(-1) plt.gca().add_artist(self.bg_img) self.do_refresh() def draw(self): """Draw the netowrk graph and set limit corners""" g = NetworkGraph.NetworkGraph() g.layout_graph() g.draw(self.canvas) self.corners = (-0.05, -0.05), (1.05, 1.05) plt.gca().set_xlim((-0.05, 1.05)) plt.gca().set_ylim((-0.05, 1.05)) self.do_refresh()
class _Matplotlib: def __init__ (self, pp, progressbar): self.pp = pp self.pb = progressbar self.figure = pylab.figure () self.canvas = FigureCanvas (self.figure) self.toolbar = NavigationToolbar (self.canvas, pp ["MainWindow"]) self.pp ["BoxPlotArea"].pack_start (self.toolbar, expand = False, fill = False) self.pp ["BoxPlotArea"].pack_start (self.canvas , expand = True, fill = True) self.canvas.connect ("button_press_event", self.on_button_press_event) self.l = 0 self.dataAreOld = True self.pathLength = None self.pathId = None self.dl = None def get_x_cursor_position(self,event): gca = self.figure.gca () ap = gca.get_position () xmin, xmax = gca.get_xbound () x,y = self.canvas.get_width_height() posx = ((event.x/x)-ap.x0)*(1/(ap.x1-ap.x0)) sx = (posx*(xmax - xmin)) + xmin return sx def on_button_press_event (self, w, event): if not event.type == gtk.gdk._2BUTTON_PRESS \ or not event.button == 1: return False l = self.get_x_cursor_position(event) self.pp ["PathScale"].set_value (l) return True def selectData (self, x, ys): self.x = x self.ys = ys if not self.pathLength == self.pp.pathLength \ or not self.pathId == self.pp.pathId \ or not self.dl == self.pp.dl: self.dataAreOld = True self.pathId = self.pp.pathId self.pathLength = self.pp.pathLength self.dl = self.pp.dl self.l = 0 self.datas = list () else: self.dataAreOld = False def init_pulse (self): if self.dataAreOld: self.pb.set_text ("Generating datas...") self.pb.set_fraction (0) glib.idle_add (self.getData_pulse) else: glib.idle_add (self.genPlot_pulse) return False def getData_pulse (self): d = [ self.l, ] d.extend (self.pp.client.problem.configAtParam (self.pathId, self.l)) self.datas.append (d) self.l += self.dl if self.l < self.pathLength: self.pb.set_fraction (self.l / self.pathLength) return True else: self.pb.set_fraction (1) glib.idle_add (self.genPlot_pulse) return False def genPlot_pulse (self): self.pb.set_text ("Generating plots...") self.npdatas = np.matrix (self.datas) self.figure.clf () gca = pylab.gca () for elt in self.ys: pylab.plot (self.npdatas [:,self.x[1]], self.npdatas [:,elt[1]], label=elt[0]) gca.set_xlabel (self.x[0]) pylab.legend (loc='best') self.canvas.draw () self.pb.set_text ("Idle") return False
class Gtk_NetworkCanvas: """Gtk_NetworkCanvas class. This class contains the canvas to draw the topology. It implements event listener and zoom. Parameters ---------- canvas : the gtk canvas to draw adjustement : used for zoom scroll bar zoom_scale : a scroll bar to zoom redraw : a button to redraw the graph popup : a popup for interaction on right click bRefresh : bool. if True enable refresh with do_refresh function corners : the limit of the canvas drawing area press : bool. True if mouse click on canvas (used for zoom) x_old, y_old : position for zoom """ def __init__(self): fig = plt.figure(num=None, facecolor='w', edgecolor='k') plt.axis('off') plt.subplots_adjust(left=0., right=1., bottom=0., top=1., wspace=0.2, hspace=0.2) self.canvas = FigureCanvas(fig) self.canvas.add_events(gtk.gdk.EXPOSURE_MASK | gtk.gdk.LEAVE_NOTIFY_MASK | gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.BUTTON_RELEASE_MASK) self.canvas.connect("motion_notify_event", self.on_motion) self.canvas.connect("button-press-event", self.on_click) self.canvas.connect("button-release-event", self.on_release) self.canvas.connect("scroll-event", self.on_scroll) self.canvas.connect("leave-notify-event", self.on_lose_focus) self.adjustement = gtk.Adjustment(0.0, 0.0, 100.0, 1.0, 1.0, 1.0) self.adjustement_signal = self.adjustement.connect( "value-changed", self.on_zoom_changed) self.zoom_scale = gtk.HScale(self.adjustement) self.zoom_scale.set_draw_value(False) self.zoom_value = 0.0 self.redraw = gtk.Button("Redraw") self.redraw.connect("clicked", self.on_redraw) self.hbox = gtk.HBox() self.hbox.pack_start(self.zoom_scale, True, True, 0) self.hbox.pack_end(self.redraw, False, False, 0) self.vbox = gtk.VBox() self.vbox.pack_start(self.canvas, True, True, 0) self.vbox.pack_end(self.hbox, False, False, 0) self.popup = Gtk_NewtworkPopupMenu() self.bRefresh = True self.corners = None self.press = False self.x_old = 0 self.y_old = 0 self.bg_img = None self.i = 1 def on_click(self, widget, event): """Event listener : click If double left click : - on edge, show edges rules - on firewall, show firewall conf - on interface, add note If left click : - on edge, show message - on firewall, show message interaction firewall - on interface, show message interaction interface - else move x/y limit drawing area If right click : - on edge, show edge menu - on firewall, show firewall menu - on interface, show interface menu - else show canvas menu """ if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS: dbl_click = False dbl_click |= self.on_dblclick_edge() dbl_click |= self.on_dblclick_node() if not dbl_click: Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message( Gtk_Message.TOPOLOGY_MESSAGE) if event.button == 3 and event.type == gtk.gdk.BUTTON_PRESS: right_click = False right_click |= self.on_right_click_edge(event) right_click |= self.on_right_click_node(event) if not right_click: Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message( Gtk_Message.ON_BACKGROUND_CLICK) self.popup.popup_clear(event) if event.button == 1 and event.type == gtk.gdk.BUTTON_PRESS: left_click = False left_click |= self.on_left_click_edge() left_click |= self.on_left_click_node() if not left_click: self.press = True self.x_old = event.x self.y_old = event.y Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message( Gtk_Message.TOPOLOGY_MESSAGE) return True def on_dblclick_edge(self): """Show interface rules""" def get_firewall(x, y): if isinstance(x, Firewall): return x elif isinstance(y, Firewall): return y return None def get_ip(x, y): if isinstance(x, Ip): return x elif isinstance(y, Ip): return y return None g = NetworkGraph.NetworkGraph() for elem in g.graph.edges(data=True): edge = elem[2]['object'] if edge.gtk_press: fw = get_firewall(elem[0], elem[1]) ip = get_ip(elem[0], elem[1]) result = [] [ result.append(acl) for acl in g.get_acl_list(src=ip, dst=None, firewall=fw) ] [ result.append(acl) for acl in g.get_acl_list(src=None, dst=ip, firewall=fw) ] if not result: Gtk_DialogBox("No rules found for this interface !") [ Gtk_Main.Gtk_Main().notebook.add_interface_tab(acl) for acl in result ] return True return False def on_dblclick_node(self): """Event listener, on double click node, if firewall show conf file else add note""" g = NetworkGraph.NetworkGraph() for k, v in g.graph.node.items(): if v['object'].gtk_press and isinstance(v['object'].object, Firewall): Gtk_Main.Gtk_Main().notebook.add_conf_tab( v['object'].object.name, v['object'].object.hostname) return True if v['object'].gtk_press and isinstance(v['object'].object, Ip): self.popup.node = v['object'] self.popup.on_add_note(None) return True return False def on_right_click_edge(self, event): """Event listener, on right click edge, popup menu showing acl list of related to this interface""" g = NetworkGraph.NetworkGraph() for elem in g.graph.edges(data=True): edge = elem[2]['object'] if edge.gtk_press: self.popup.popup(elem, event, edge) edge.gtk_press = False return True return False def on_right_click_node(self, event): """Event listener, on right click node, show popup menu for node""" g = NetworkGraph.NetworkGraph() for k, v in g.graph.node.items(): if v['object'].gtk_press: self.popup.popup(None, event, v['object']) v['object'].gtk_press = False return True return False def on_left_click_node(self): """Show node details""" g = NetworkGraph.NetworkGraph() for k, v in g.graph.node.items(): if v['object'].gtk_press: Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message( Gtk_Message.ON_CLICK_NODE) Gtk_Main.Gtk_Main().lateral_pane.details.clear() tmp_intf = [ e[2]['object'].object for e in g.graph.edges(k, data=True) ] if isinstance(tmp_intf, Interface): for e in sorted(tmp_intf, key=lambda tmp_intf: tmp_intf.nameif): message = "%s:\n- %s\n- %s" % (e.nameif, e.name, e.network.to_string()) for key, value in e.attributes.items(): message += "\n- %s : %s" % (key, value) Gtk_Main.Gtk_Main().lateral_pane.details.add_row( message) Gtk_Main.Gtk_Main().lateral_pane.focus_details() return True if isinstance(v['object'].object, Route_info): lateral_pane = Gtk_Main.Gtk_Main().lateral_pane notebook_routes = Gtk_Main.Gtk_Main( ).lateral_pane.notebook_routes treeview_routes = Gtk_Main.Gtk_Main( ).lateral_pane.routes_tab_treeview scrolled_window = lateral_pane.routes_tab_treeview.scrolled_window data = v['object'].object.data notebook_routes.notebook.set_tab_label( scrolled_window, gtk.Label('Networks reached by ' + v['object'].object.iface.nameif)) treeview_routes.clear() for gateway, networks in data.iteritems(): parent = treeview_routes.add_row(None, gateway, foreground='black', background='grey') for network in networks: treeview_routes.add_row(parent, network) if lateral_pane.vpane.get_child1( ) == lateral_pane.notebook_path.notebook: lateral_pane.vpane.remove( lateral_pane.notebook_path.notebook) elif lateral_pane.vpane.get_child1( ) == lateral_pane.notebook_details.notebook: lateral_pane.vpane.remove( lateral_pane.notebook_details.notebook) lateral_pane.vpane.pack1( lateral_pane.notebook_routes.notebook, True, False) lateral_pane.vpane.pack2(lateral_pane.help_message.eb, True, False) Gtk_Main.Gtk_Main().hpaned.set_position( 4 * Gtk_Main.Gtk_Main().window.get_size()[0] / 5) lateral_pane.vpane.show_all() return False def on_left_click_edge(self): """If left click edge, show help message""" g = NetworkGraph.NetworkGraph() for edge in g.graph.edges(): if g.graph[edge[0]][edge[1]]['object'].gtk_press: Gtk_Main.Gtk_Main().lateral_pane.help_message.change_message( Gtk_HelpMessage.Gtk_Message.ON_CLICK_EDGE) return True return False def on_motion(self, widget, event): """If not click node, then move axis""" if self.press and self.corners: xlim = list(plt.gca().get_xlim()) ylim = list(plt.gca().get_ylim()) x = (self.x_old - event.x) / (1. * self.canvas.window.get_size()[0] / (xlim[1] - xlim[0])) y = (event.y - self.y_old) / (1. * self.canvas.window.get_size()[1] / (ylim[1] - ylim[0])) self.x_old = event.x self.y_old = event.y self.axes_move(x, y, x, y) self.do_refresh() def refresh(self): """refresh function. This function is call periodically by do_refresh""" self.bRefresh = True def do_refresh(self): """Update the graph if bRefresh is True""" if self.bRefresh: self.bRefresh = False self.canvas.draw() gtk.timeout_add(30, self.refresh) def on_release(self, widget, event): """Event listener : release""" self.press = False def on_scroll(self, widget, event): """Event listener : scroll. Update zoom""" if event.direction == 0 and self.adjustement.get_value() < 99: self.adjustement.set_value(self.adjustement.get_value() + 1) elif event.direction == 1 and self.adjustement.get_value() > 0: self.adjustement.set_value(self.adjustement.get_value() - 1) def on_zoom_changed(self, widget): """Event listerner : HScale change. Update zoom""" if self.corners: im = None if self.bg_img: im = self.bg_img.get_children()[0] if widget.value != 0: zoom = (self.zoom_value - widget.value) * ( self.corners[1][0] - self.corners[0][0]) / 200 self.axes_zoom(-zoom, -zoom, zoom, zoom) if im: dim = min( 1. * self.canvas.window.get_size()[0] / len(im.properties()['data'][0]), 1. * self.canvas.window.get_size()[1] / len(im.properties()['data'])) corners = min(self.corners[1][0] - self.corners[0][0], self.corners[1][1] - self.corners[0][1]) im.set_zoom(im.get_zoom() - zoom * 2 * dim / corners) else: plt.gca().set_xlim((self.corners[0][0], self.corners[1][0])) plt.gca().set_ylim((self.corners[0][1], self.corners[1][1])) if im: im.set_zoom( min( 1. * self.canvas.window.get_size()[0] / len(im.properties()['data'][0]), 1. * self.canvas.window.get_size()[1] / len(im.properties()['data']))) self.zoom_value = widget.value self.do_refresh() def on_lose_focus(self, widget, event): """Event listener : focus""" self.press = False NetworkGraph.NetworkGraph().node_click = False for node in NetworkGraph.NetworkGraph().graph.nodes(data=True): node[1]['object'].press = False for edge in NetworkGraph.NetworkGraph().graph.edges(data=True): edge[2]['object'].press = False self.do_refresh() def on_redraw(self, widget): """Event listener : button redraw""" self.draw() def axes_move(self, x0, y0, x1, y1): """Change axis position according to the drawing area limit. Parameters ---------- x0 : float. x minimal value x1 : float. x maximal value y0 : float. y minimal value y1 : float. y maximal value """ if self.corners: x = list(plt.gca().get_xlim()) y = list(plt.gca().get_ylim()) if ((x0 < 0 and x[0] + x0 >= self.corners[0][0]) or (x0 > 0 and x[0] + x0 < x[1])) and \ ((x1 > 0 and x[1] + x1 <= self.corners[1][0]) or (x1 < 0 and x[1] + x1 > x[0])): x[0] += x0 x[1] += x1 if ((y0 < 0 and y[0] + y0 >= self.corners[0][1]) or (y0 > 0 and y[0] + y0 < y[1])) and \ ((y1 > 0 and y[1] + y1 <= self.corners[1][1]) or (y1 < 0 and y[1] + y1 > y[0])): y[0] += y0 y[1] += y1 plt.gca().set_xlim((x[0], x[1])) plt.gca().set_ylim((y[0], y[1])) def axes_zoom(self, x0, y0, x1, y1): """Zoom axis position according to the drawing area limit. Parameters ---------- x0 : float. x minimal value x1 : float. x maximal value y0 : float. y minimal value y1 : float. y maximal value """ if self.corners: x = list(plt.gca().get_xlim()) y = list(plt.gca().get_ylim()) if (x0 < 0 and x[0] >= self.corners[0][0]) or (x0 > 0 and x[0] + x0 < x[1]): x[0] += x0 if (x1 > 0 and x[1] <= self.corners[1][0]) or (x1 < 0 and x[1] - x1 > x[0]): x[1] += x1 if (y0 < 0 and y[0] >= self.corners[0][1]) or (y0 > 0 and y[0] + y0 < y[1]): y[0] += y0 if (y1 > 0 and y[1] <= self.corners[1][1]) or (y1 < 0 and y[1] - y1 > y[0]): y[1] += y1 plt.gca().set_xlim((x[0], x[1])) plt.gca().set_ylim((y[0], y[1])) def background_image(self, file): """Set the file image as background image""" if self.bg_img: self.bg_img.remove() datafile = get_sample_data(file) img = plt.imread(datafile) im = OffsetImage(img) im.set_zoom( min( 1. * self.canvas.window.get_size()[0] / len(im.properties()['data'][0]), 1. * self.canvas.window.get_size()[1] / len(im.properties()['data']))) self.bg_img = AnnotationBbox(im, (0.5, 0.5), xycoords='data', frameon=False) self.bg_img.set_zorder(-1) plt.gca().add_artist(self.bg_img) self.do_refresh() def draw(self): """Draw the netowrk graph and set limit corners""" g = NetworkGraph.NetworkGraph() g.layout_graph() g.draw(self.canvas) self.corners = (-0.05, -0.05), (1.05, 1.05) plt.gca().set_xlim((-0.05, 1.05)) plt.gca().set_ylim((-0.05, 1.05)) self.do_refresh()
class _Matplotlib: def __init__(self, pp, progressbar): self.pp = pp self.pb = progressbar self.figure = pylab.figure() self.canvas = FigureCanvas(self.figure) self.toolbar = NavigationToolbar(self.canvas, pp["MainWindow"]) self.pp["BoxPlotArea"].pack_start(self.toolbar, expand=False, fill=False) self.pp["BoxPlotArea"].pack_start(self.canvas, expand=True, fill=True) self.canvas.connect("button_press_event", self.on_button_press_event) self.l = 0 self.dataAreOld = True self.pathLength = None self.pathId = None self.dl = None def get_x_cursor_position(self, event): gca = self.figure.gca() ap = gca.get_position() xmin, xmax = gca.get_xbound() x, y = self.canvas.get_width_height() posx = ((event.x / x) - ap.x0) * (1 / (ap.x1 - ap.x0)) sx = (posx * (xmax - xmin)) + xmin return sx def on_button_press_event(self, w, event): if not event.type == gtk.gdk._2BUTTON_PRESS \ or not event.button == 1: return False l = self.get_x_cursor_position(event) self.pp["PathScale"].set_value(l) return True def selectData(self, x, ys): self.x = x self.ys = ys if not self.pathLength == self.pp.pathLength \ or not self.pathId == self.pp.pathId \ or not self.dl == self.pp.dl: self.dataAreOld = True self.pathId = self.pp.pathId self.pathLength = self.pp.pathLength self.dl = self.pp.dl self.l = 0 self.datas = list() else: self.dataAreOld = False def init_pulse(self): if self.dataAreOld: self.pb.set_text("Generating datas...") self.pb.set_fraction(0) glib.idle_add(self.getData_pulse) else: glib.idle_add(self.genPlot_pulse) return False def getData_pulse(self): d = [ self.l, ] d.extend(self.pp.client.problem.configAtParam(self.pathId, self.l)) self.datas.append(d) self.l += self.dl if self.l < self.pathLength: self.pb.set_fraction(self.l / self.pathLength) return True else: self.pb.set_fraction(1) glib.idle_add(self.genPlot_pulse) return False def genPlot_pulse(self): self.pb.set_text("Generating plots...") self.npdatas = np.matrix(self.datas) self.figure.clf() gca = pylab.gca() for elt in self.ys: pylab.plot(self.npdatas[:, self.x[1]], self.npdatas[:, elt[1]], label=elt[0]) gca.set_xlabel(self.x[0]) pylab.legend(loc='best') self.canvas.draw() self.pb.set_text("Idle") return False
class Plot(gtk.HBox): """ Base class for LivePlots. This class is an abstract class. In addition to inheriting from this class it is also required to take the following actions to achieve a functioning plot: Bla bla bla """ def __init__(self, dpi=100, x_pixel_size=500, y_pixel_size=400): gtk.HBox.__init__(self) # If the class is being reinitialized, we need to remove the old plot [self.remove(child) for child in self.get_children()] self.vbox = gtk.VBox() self.pack_start(self.vbox) # this is bad with labels, I have to figure out why self.connect('size_allocate', self._full_update) self.fig = Figure(figsize=(float(x_pixel_size)/dpi, float(y_pixel_size)/dpi), dpi=dpi) self.fig.set_facecolor('white') self.canvas = FigureCanvasGTKAgg(self.fig) self.ax = self.fig.add_subplot(111) self.vbox.pack_end(self.canvas) self.canvas.connect('button_press_event', self._on_mouse_click) self.first_update = True self.settings = {} self.n_lines = None #self.line_styles = None #self.line_colors = None self.lines = None self.saved_window_size = None self.background = None self.auto_x_scale = False self.auto_y_scale = False def _change_settings_common(self, number_of_lines, **kw): """ Change the subset of settings that are common for all plots """ self.settings.update(kw) self.n_lines = number_of_lines self.line_styles = kw['line_styles'] if kw.has_key('line_styles')\ else ['']*self.n_lines self.line_colors = kw['line_colors'] if kw.has_key('line_colors')\ else self._get_colors(self.n_lines) self.lines = None self.background = None if self.settings['legends'] is not None: c = matplotlib.colors.ColorConverter() colors = [matplotlib.colors.rgb2hex(c.to_rgb(color)) for color in self.line_colors] self.legends = Legends(self.settings['legends'], colors, self.settings['legend_placement'], self.settings['legend_cols']) if self.settings['legend_placement'] == 'top': self.vbox.pack_end(self.legends, expand=False) else: self.pack_end(self.legends, expand=False) def _on_mouse_click(self, widget, event): if event.type == gtk.gdk.BUTTON_PRESS and event.button == 3: b1 = gtk.MenuItem("A button") b2 = gtk.MenuItem("Another") menu = gtk.Menu() menu.append(b1) menu.append(b2) b1.show() b2.show() menu.popup(None, None, None, event.button, event.time) def _update_bounds(self): return self._update_x_bounds() or self._update_y_bounds() def _update_x_bounds(self): if not self.auto_x_scale: return False def _update_y_bounds(self): modified = False if not self.auto_y_scale: return modified # Combine data (double loop), sort out None and get min/max y_min = min([inner for outer in self.y for inner in outer\ if inner is not None]) y_max = max([inner for outer in self.y for inner in outer\ if inner is not None]) delta = y_max - y_min if delta < 1E-10: return modified br = 0.2 if y_min < self.settings['y_bounds'][0]: self.settings['y_bounds'] =\ (y_min-br*delta, self.settings['y_bounds'][1]) modified = True elif y_min > self.settings['y_bounds'][0] + br*delta: self.settings['y_bounds'] =\ (y_min, self.settings['y_bounds'][1]) modified = True if y_max > self.settings['y_bounds'][1]: self.settings['y_bounds'] =\ (self.settings['y_bounds'][0], y_max+br*delta) modified = True elif y_max < self.settings['y_bounds'][1] - br*delta: self.settings['y_bounds'] =\ (self.settings['y_bounds'][0], y_max) modified = True return modified def update_legends(self): if self.settings['legends'] is not None: for n in range(self.n_lines): point = self.y[n][-1] self.legends.set_legend_text(n, point) def _quick_update(self): if self.first_update: self._full_update() self.first_update = False self.canvas.restore_region(self.background) [line.set_ydata(y_data) for line, y_data in zip(self.lines, self.y)] [self.ax.draw_artist(line) for line in self.lines] # just redraw the axes rectangle self.canvas.blit(self.ax.bbox) def _full_update(self, widget=None, size=None): # This does not work properly, FIXME if widget is not None: if [size.width, size.height] != self.saved_window_size: self.saved_window_size = [size.width, size.height] else: return # Plot if self.first_update: plot = self.ax.semilogy if self.settings['logscale'] else self.ax.plot self.lines = [plot(x, y, style, color=color, animated=True)[0] for x, y, color, style in zip(self.x, self.y, self.line_colors, self.line_styles)] # Title and axis labels if self.settings['title'] is not None: self.ax.set_title(self.settings['title']) if self.settings['x_label'] is not None: self.ax.set_xlabel(self.settings['x_label']) if self.settings['y_label'] is not None: self.ax.set_ylabel(self.settings['y_label']) self.fig.subplots_adjust(left=0.25, bottom=0.15) else: [line.set_ydata(y_data) for line, y_data in zip(self.lines, self.y)] # Get or set boundaries if self.first_update: if self.settings['x_bounds'] is None: self.settings['x_bounds'] = self.ax.get_xlim() if self.settings['y_bounds'] is None: self.settings['y_bounds'] = self.ax.get_ylim() else: self.ax.set_xlim(*self.settings['x_bounds']) self.ax.set_ylim(*self.settings['y_bounds']) # Get the background for later use self.canvas.draw() self.background = self.canvas.copy_from_bbox(self.ax.bbox) # First draw update [line.set_animated(False) for line in self.lines] self.canvas.draw() [line.set_animated(True) for line in self.lines] def _get_colors(self, n): """ Generate colors for the lines if they are not provided. First use 6 of the standard colors and then generate random colors Parameters: n -- the number of colors requested """ standard = ['r', 'g', 'b', 'c', 'm', 'k'] if n <= len(standard): out = standard[:n] else: out = standard if n > len(standard): for i in range(len(standard), n): out.append((random.random(), random.random(), random.random())) return out
class setup_gui: def __init__(self): self.builder = gtk.Builder() self.builder.add_from_file(os.path.splitext(__file__)[0]+".glade") self.window = self.builder.get_object("window") dic = { "on_toolbutton_refresh_clicked" : self.generate_testdata, "on_button1_clicked" : self.generate_testdata, "on_vboxMain_button_press_event" : self.button_press_event, "on_vboxMain_button_release_event" : self.button_release_event, "on_vboxMain_drag" : self.drag_begin, "on_vboxMain_motion_notify_event" : self.drag_begin, "on_toolbar_clear_clicked" : self.clear_selections, "on_toolbar_zoomin_clicked" : self.zoomin_time, "on_toolbar_zoomout_clicked" : self.zoomout_time, "on_go_back_clicked" : self.page_back, "on_go_forward_clicked" : self.page_forward, "on_toolbutton_setup_toggled" : self.preferences_open, "on_button_channel_apply_clicked" : self.channel_selection_apply, "set_channel_groups" : self.set_channel_groups, "showpopupmenu" : self.showpopupmenu, "on_toolbar_plot_clicked" : self.plot_contour, "on_plot_contour_activate" : self.plot_contour, "on_button_delete_selection_clicked" : self.event_selection_delete, "gtk_widget_hide" : self.hideinsteadofdelete, "on_button_display_apply_clicked": self.display_apply, "on_go_up_clicked" : self.page_up, "on_go_down_clicked" : self.page_down, "on_toolbutton_load_clicked" : self.load_data, "on_menu_offset_correct_clicked" : self.offset_correct, "on_button_epoch_clicked" : self.add_selections_to_event_process, "on_store_event_clicked" : self.store_event, "on_menu_save_noise_activate" : self.store_noise, "on_menu_save_event_activate" : self.store_event, "on_key_press_event" : self.key_press_event, } self.builder.connect_signals(dic) try: self.prefs = readwrite.readdata(os.getenv('HOME')+'/.pymeg.pym') except IOError: self.prefs = {}; readwrite.writedata(self.prefs, os.getenv('HOME')+'/.pymeg') try: self.line_r,self.line_g,self.line_b = self.prefs['LineColor'][0],self.prefs['LineColor'][1],self.prefs['LineColor'][2] self.back_r,self.back_g,self.back_b = self.prefs['BackColor'][0],self.prefs['BackColor'][1],self.prefs['BackColor'][2] except: self.line_r,self.line_g,self.line_b = 1.,1.,1. self.back_r,self.back_g,self.back_b = .9,.9,.9 self.color = (self.line_r,self.line_g,self.line_b) self.create_draw_frame('none') self.create_spec_frame('none') self.create_csd_frame('none') self.space = 0 #self.generate_testdata(None) self.preferences_open(None) def printtest(self,widget): print 'something' def store_noise(self,widget): print widget,'wid',widget.get_parent().get_name() self.callback(widget) def store_event(self,widget): print widget,'wid',widget.get_parent().get_name() self.callback(widget) def create_draw_frame(self,widget): self.fig = Figure(figsize=[100,100], dpi=40) self.canvas = FigureCanvas(self.fig) self.canvas.connect("scroll_event", self.scroll_event) self.canvas.connect("key-press-event", self.key_press_event) #self.canvas.connect('button_press_event', self.button_press_event) self.canvas.show() self.figure = self.canvas.figure self.axes = self.fig.add_axes([0.045, 0.05, 0.93, 0.925], \ axisbg=(self.back_r,self.back_g,self.back_b)) #axisbg='#FFFFCC') self.vb = self.builder.get_object("vbox3") self.vb.pack_start(self.canvas, gtk.TRUE, gtk.TRUE) self.vb.show() def create_spec_frame(self,widget): self.specfig = Figure(figsize=[10,10], dpi=40) self.specfig.text(0.25,0.5,'Middle Click Channel for Specgram',\ fontsize=20) self.speccanvas = FigureCanvas(self.specfig) self.speccanvas.show() self.specfigure = self.speccanvas.figure self.specaxes = self.specfig.add_axes([0.045, 0.05, 0.93, 0.925], \ axisbg=(self.back_r,self.back_g,self.back_b)) #self.specaxes.axis('off') self.vb2 = self.builder.get_object("vbox8") self.vb2.pack_end(self.speccanvas, gtk.TRUE, gtk.TRUE) self.vb2.show() def create_csd_frame(self,widget): self.csdfig = Figure(figsize=[10,10], dpi=40) self.csdfig.text(0.25,0.5,'Middle Click Channel for CSD',fontsize=20) self.csdcanvas = FigureCanvas(self.csdfig) self.csdcanvas.show() self.csdfigure = self.csdcanvas.figure self.csdaxes = self.csdfig.add_axes([0.045, 0.05, 0.93, 0.925], \ axisbg=(self.back_r,self.back_g,self.back_b)) #self.csdaxes.axis('off') self.vb3 = self.builder.get_object("vbox9") self.vb3.pack_end(self.csdcanvas, gtk.TRUE, gtk.TRUE) self.vb3.show() def data_loaded_setup(self): self.channel_tree(None) self.builder.get_object("spinbutton1").set_range(0,self.numchannels) self.builder.get_object("spinbutton1").set_value(self.numchannels) self.builder.get_object("spinbutton2").set_range(self.t[0],self.t[-1]) self.builder.get_object("spinbutton2").set_value(self.t[0]) self.builder.get_object("spinbutton3").set_range(self.t[0],self.t[-1]) #if self.t[-1] - self.t[0] > 1: #alot of time, save time in plotting and set low if len(self.t) > 1000: self.builder.get_object("spinbutton3").set_value(self.t[1000]) print '.....reducing time var' else: print '.....showing all time' self.builder.get_object("spinbutton3").set_value(self.t[-1]) #self.builder.get_object("spinbutton3").set_value(self.t[-1]) #self.builder.get_object("spinbutton5").set_value(self.scalefact) self.builder.get_object("entry1").set_text(str(self.space)) self.builder.get_object("entry2").set_text(str(self.scalefact)) def preferences_open(self,widget): self.win_prefs = self.builder.get_object("window_prefs") #try: self.prefs = readwrite.readdata(os.getenv('HOME')+'/.pymeg.pym') #except IOError: self.prefs = {}; readwrite.writedata(self.prefs, os.getenv('HOME')+'/.pymeg') try: #r,g,b = self.prefs['LineColor'][0],self.prefs['LineColor'][1],self.prefs['LineColor'][2] self.builder.get_object("colorbutton1").set_color(color=gtk.gdk.Color(self.line_r,self.line_g,self.line_b)) self.builder.get_object("colorbutton2").set_color(color=gtk.gdk.Color(self.back_r,self.back_g,self.back_b)) except IOError: pass #print 'color',self.builder.get_object("colorbutton1").get_color() #self.builder.get_object("colorbutton1").set_color(color=gtk.gdk.Color(111)) #print 'color',self.builder.get_object("colorbutton1").get_color() if self.builder.get_object('toolbutton12').get_active() == True: self.win_prefs.show() else: self.win_prefs.hide() self.selections_tree(None) def key_press_event(self, widget, event): print event.keyval def scroll_event(self, widget, event): if event.direction == gdk.SCROLL_UP: direction = 1 self.space = self.space + 2*self.scalefact print 'sf',self.scalefact else: direction = -1 self.space = self.space - 2*self.scalefact print 'sf',self.scalefact if self.space < 0: self.space = 0 print 'space', self.space #print (arange(0,size(self.data2plot,1))*(self.space)) self.space_data() self.redraw(None) def space_data(self,space=None): self.data2plot = self.data[self.tstart:self.tstop,self.chanind2plot]+\ (arange(0,size(self.data[self.tstart:self.tstop,self.chanind2plot],1))*\ (self.space)) def get_cursor_position(self,event): ap = self.axes.get_position() x,y = self.canvas.get_width_height() posx = ((event.x/x)-ap.x0)*(1/(ap.x1-ap.x0)) posy = ((event.y/y)-(1-ap.y0))*(1/(ap.y0-ap.y1)) self.sx = (posx*(self.time[-1]-self.time[0]))+self.time[0] self.sy = (posy*(self.data2plot.max()-self.data2plot.min())) + \ self.data2plot.min() #print self.sx, self.sy def button_press_event(self,widget,event): self.get_cursor_position(event) #print 'button pushed',event.button,event.type if event.type == gtk.gdk.BUTTON_PRESS: print "single click" if event.button == 1: self.xstart = self.sx #elif event.type == gtk.gdk._2BUTTON_PRESS: #print "double click" #elif event.type == gtk.gdk._3BUTTON_PRESS: #print "triple click. ouch, you hurt your user." if event.type == gtk.gdk.BUTTON_PRESS and event.button == 2: closest_data = nearest.nearest(self.data2plot[0,:],self.sy) print 'nearest',closest_data print 'highlighting channel' self.axes.axhspan(self.data2plot[:,closest_data].min(), \ self.data2plot[:,closest_data].max(), xmin=0, xmax=1, color='g',\ alpha=0.2) self.canvas.draw() self.specaxes.cla() NFFT = 1024 Fs = self.srate #(1/self.srate) print NFFT,int(Fs),'d' self.specaxes.specgram( self.data2plot[:,closest_data[0]], NFFT=NFFT, Fs=Fs,noverlap=900) #self.specaxes.axis('off') self.speccanvas.draw() self.csdaxes.csd(self.time, self.data2plot[:,closest_data[0]], NFFT=NFFT, Fs=Fs) #, noverlap=Noverlap, #cmap=cm.jet)#, xextent=xextent) #self.csdaxes.axis('off') self.csdcanvas.draw() def button_release_event(self,widget,event): self.get_cursor_position(event) if event.type == gtk.gdk.BUTTON_RELEASE and event.button == 1: self.axes.axvspan(ymin=0, ymax=1, xmin=self.xstart, xmax=self.sx, \ color='b',alpha=0.4) if self.xstart > self.sx: #selection going from later to earlier tmp = copy(self.sx) self.sx = copy(self.xstart) self.xstart = tmp try: self.selections = vstack((self.selections,\ [self.xstart,self.sx])) except AttributeError: self.selections = \ array([[self.xstart,self.sx]]) print 'sels',self.selections self.canvas.draw() self.selections_tree(None) def clear_selections(self,widget): del self.selections self.redraw(None) def drag_begin(self,widget,event): pass def redraw(self,widget): print len(self.time),self.data2plot.shape #self.color = 'black' self.axes.cla() self.axes = self.figure.axes[0] print 'cur color', self.color self.axes.plot(self.time, self.data2plot,color=self.color) self.axes.axis('tight') try: print 'current selections',self.selections for i in self.selections: self.axes.axvspan(ymin=0,ymax=1,xmin=i[0],xmax=i[1],color='b',\ alpha=.4) except: pass self.axes.yaxis.set_ticks((arange(0,size(self.data2plot,1)) * \ (self.space))) self.axes.yaxis.set_ticklabels(self.chanlabels2plot, fontsize=17) self.canvas.draw() ion() def zoomin_time(self,widget): startind = self.tstart; stopind = self.tstop-((self.tstop-self.tstart)/2) self.check_scale(startind,stopind) self.redraw(None) def zoomout_time(self,widget): startind = self.tstart; stopind = self.tstop+((self.tstop-self.tstart)*2) self.check_scale(startind,stopind) self.redraw(None) def page_forward(self,widget): startind = ((self.tstop-self.tstart)/2)+self.tstart; stopind = ((self.tstop-self.tstart)/2)+self.tstop; self.check_scale(startind,stopind) self.redraw(None) def page_back(self,widget): startind = self.tstart-((self.tstop-self.tstart)/2); stopind = self.tstop-((self.tstop-self.tstart)/2); self.check_scale(startind,stopind) self.redraw(None) def page_up(self,widget): self.curchannel = self.curchannel+self.numofch if self.curchannel >= len(self.chanind): self.curchannel = len(self.chanind)-self.numofch self.chanind2plot = \ self.chanind[self.curchannel:self.curchannel+self.numofch] self.chanlabels2plot = \ self.chanlabels[self.curchannel:self.curchannel+self.numofch] self.check_scale(self.tstart,self.tstop) self.redraw(None)#self.display_apply(None) def page_down(self,widget): self.curchannel = self.curchannel-self.numofch if self.curchannel < 0: self.curchannel = 0 self.chanind2plot = \ self.chanind[self.curchannel:self.curchannel+self.numofch] self.chanlabels2plot = \ self.chanlabels[self.curchannel:self.curchannel+self.numofch] self.check_scale(self.tstart,self.tstop) self.redraw(None)#self.display_apply(None) def display_apply(self,widget): color = self.builder.get_object('colorbutton1') r = color.get_color().red_float g = color.get_color().green_float b = color.get_color().blue_float self.line_color = self.color = (r,g,b) self.prefs['LineColor'] = self.line_color color = self.builder.get_object('colorbutton2') r = color.get_color().red_float g = color.get_color().green_float b = color.get_color().blue_float self.back_color = (r,g,b) self.prefs['BackColor'] = self.back_color readwrite.writedata(self.prefs, os.getenv('HOME')+'/.pymeg') self.numofch = int(self.builder.get_object("spinbutton1").get_value()) self.chanind2plot = \ self.chanind[self.curchannel:self.curchannel+self.numofch] self.chanlabels2plot = \ self.chanlabels[self.curchannel:self.curchannel+self.numofch] st = float(self.builder.get_object("spinbutton2").get_value()) ed = float(self.builder.get_object("spinbutton3").get_value()) self.space = float(self.builder.get_object("entry1").get_text()) self.scalefact = float(self.builder.get_object("entry2").get_text()) #print 'se',st,ed, self.t startind = nearest.nearest(self.t,st)[0] stopind = nearest.nearest(self.t,ed)[0] print 'se',startind,stopind self.check_scale(startind,stopind) self.space_data() self.redraw(None) def check_scale(self,startind,stopind): print 'req',startind,stopind, self.tstart,self.tstop if startind < 0: startind = 0 stopind = self.tstop if stopind > len(self.t): startind = self.tstart stopind = len(self.t) if stopind < 0: stopind = self.tstop print 'set',startind,stopind,self.tstart,self.tstop self.tstart = startind self.tstop = stopind self.time = self.t[self.tstart:self.tstop] self.data2plot = self.data[self.tstart:self.tstop,self.chanind2plot] self.space_data() #self.redraw(None) def channel_tree(self,widget): print('updating list') self.View = self.builder.get_object("treeview1") self.dataList = gtk.ListStore(int,str) self.AddListColumn('Number', 0, self.View) self.AddListColumn('Label', 1, self.View) for k in range(0,self.numchannels): iter = self.dataList.append([k,self.chanlabels[k]]) self.View.set_model(self.dataList) print 'adding channels' def AddListColumn(self, title, columnId, viewtype): column = gtk.TreeViewColumn(title,gtk.CellRendererText(),text=columnId) column.set_resizable(True) column.set_sort_column_id(columnId) viewtype.append_column(column) viewtype.get_selection().set_mode(gtk.SELECTION_MULTIPLE) def channel_selection_apply(self, widget): liststore,iter = self.View.get_selection().get_selected_rows() self.chanind = []; self.chanlabels = []; for i in iter: self.chanind.append(int(liststore[i][0])) self.chanlabels.append(liststore[i][1]) print self.chanlabels self.chanind2plot = self.chanind self.chanlabels2plot = self.chanlabels self.space_data() self.redraw(None) def set_channel_groups(self,widget): l = self.View.get_model() i = l.get_iter_first() v = [] while ( i != None ): v.append(l.get_value(i,1)) i = l.iter_next(i) print widget.get_label(), widget if widget.get_label() == 'meg' and widget.get_active() == True: for i in range(0,len(v)): if v[i].startswith('A'): self.View.get_selection().select_path(i) if widget.get_label() == 'De-Select All': self.View.get_selection().unselect_all() if widget.get_label() == 'Select All': self.View.get_selection().select_all() if widget.get_label() == 'reference' and widget.get_active() == True: for i in range(0,len(v)): if v[i].startswith('M') or v[i].startswith('G'): self.View.get_selection().select_path(i) if widget.get_label() == 'trigger' and widget.get_active() == True: for i in range(0,len(self.chanlabels)): if v[i].startswith('TRIGG'): self.View.get_selection().select_path(i) if widget.get_label() == 'response' and widget.get_active() == True: for i in range(0,len(v)): if v[i].startswith('RESP'): self.View.get_selection().select_path(i) def selections_tree(self,widget): try: if self.win_prefs.get_property('visible') == True: print('updating selections') self.SelView = self.builder.get_object("treeview2") self.selectionList = gtk.ListStore(int,str) if self.SelView.get_columns() == []: self.AddListColumn('Event Number', 0,self.SelView) self.AddListColumn('Selection', 1,self.SelView) for k in range(0,len(self.selections)): iter=self.selectionList.append([k,str(self.selections[k])]) self.SelView.set_model(self.selectionList) print 'adding selections' except AttributeError: pass #window not initiated yet def event_selection_delete(self, widget): liststore,iter = self.SelView.get_selection().get_selected_rows() #self.selections = delete(self.selections,iter,axis=0) del_ind = [] for i in iter: print 'deleting event:',liststore[i][0] del_ind.append(liststore[i][0]) self.selections = delete(self.selections,del_ind,axis=0) self.selections_tree(None) self.redraw(None) def showpopupmenu(self,widget,event): print('button ',event.button) if event.button == 3: m = self.builder.get_object("menufunctions") print(widget, event) m.show_all() m.popup(None,None,None,3,0) def get_time_selection(self,widget,current=True): print 'name',widget.get_parent().get_name() sel_ind = [] sel_onset_ind = [] def selection_to_ind(sels,sele,inc): print 'getting sel' if sele == sels: #only one point selected sele = sels+inc nearest.nearest(self.t,arange(sels,sele,inc)) sel_ind = nearest.nearest(self.t,arange(sels,sele,inc)) return sel_ind if widget.get_parent().get_name() == 'GtkMenu' and current == True: #call from editor menu print 'call from right click menu' try: self.sel_ind = selection_to_ind(self.selections[-1][0],\ self.selections[-1][1],self.t[1]-self.t[0]) except AttributeError: print 'no selections yet' return -1 else: #call from selector print 'call from selector window' liststore,iter = self.SelView.get_selection().get_selected_rows() for i in iter: j = int(liststore[i][0]) sel_ind.extend(selection_to_ind(self.selections[j][0],\ self.selections[j][1],self.t[1]-self.t[0])) sel_onset_ind.extend(selection_to_ind(self.selections[j][0],\ self.selections[j][0],self.t[1]-self.t[0])) self.sel_ind = sel_ind self.sel_onset_ind = sel_onset_ind def plot_contour(self,widget): if size(self.data,1) < 4: self.builder.get_object("messagedialog1").format_secondary_text\ ('Contour Plot Requires at least 4 Channels') self.builder.get_object("messagedialog1").show() return -1 print widget.get_parent().get_name() if self.get_time_selection(widget) == -1: #no selections self.builder.get_object("messagedialog1").format_secondary_text\ ('No Selection Made Yet') self.builder.get_object("messagedialog1").show() return -1 try: print 'state',self.mc.window.get_property('visible') if self.mc.window.get_property('visible') == False: #someone closed the window self.mc.window.show() print 'done replotting' except AttributeError: #first call. setup print 'first plot' self.mc = contour_gtk.setup_gui() self.mc.window.show() self.mc.fig.clf() self.mc.display(self.data[self.sel_ind,:],self.channels, subplot='on', labels=self.chanlabels) def generate_testdata(self,widget): self.quick_load_pdf_script() #numpts = 100 #self.numchannels = 10 #self.t = arange(0,numpts, .01) #self.data = zeros((len(self.t),self.numchannels)) #self.scalefact = 1e-9 #for i in arange(0,self.numchannels): #r = random.randn() #self.data[:,i] = float32((sin(2*0.32*pi*self.t*r) * \ #sin(2*2.44*pi*self.t*r)))#+ self.space #self.data[:,0] = random.randn((len(self.t))) #self.data = self.data * self.scalefact #self.tstart = 0; self.tstop = len(self.t) #self.time = copy(self.t[self.tstart:self.tstop]) #print self.tstart,self.tstop #self.chanind = arange(0,self.numchannels) #self.chanlabels = arange(0,self.numchannels) self.data2plot = self.data self.display_apply(None) #self.space_data() #self.redraw(None) def quick_load_pdf_script(self): from pdf2py import pdf datapath = '/home/danc/programming/python/data/' p = pdf.read(datapath+'test/e,rfhp1.0Hz,ra') #p = pdf.read(datapath+'0611/0611piez/e,rfhp1.0Hz') #p = pdf.read(datapath+'data/0611/drawing3/01%01%01@01:01/2/c,rfDC') p.data.setchannels('meg') #p.data.setchannellabels(['A1','A69','A130'])#meg') #p.data.setchannellabels(['A178']) p.data.getdata(0,p.data.pnts_in_file) self.numchannels = size(p.data.data_block,1) self.t = p.data.wintime #eventtime self.data = p.data.data_block self.tstart = 0; self.tstop = len(self.t) self.time = copy(self.t[self.tstart:self.tstop]) self.chanind = arange(self.numchannels) self.chanlabels = p.data.channels.labellist self.scalefact = (p.data.data_block.min()+p.data.data_block.max())/2 self.channels = p.data.channels.chanlocs self.srate = p.hdr.header_data.sample_period self.data_loaded_setup() self.curchannel = 0 def hideinsteadofdelete(self,widget, ev=None): widget.hide() return True def load_data(self,widget): from gui.gtk import filechooser fn = filechooser.open() try: #pdf load method self.data_assist = meg_assistant.setup(path = fn[0], \ callback=self.load_data_callback) except: print 'something wrong with load' return -1 def load_data_callback(self, widget): print 'DONE!' p = self.data_assist.pdfdata #4D MEG file format input_dict = {'data_block':p.data.data_block,'srate':p.data.srate,'wintime':p.data.wintime,'labellist':p.data.channels.labellist,'chanlocs':p.data.channels.chanlocs} self.data_handler(widget, input_dict) def data_handler(self, widget, input_dict, callback=None): ''' datahandler(data,srate,wintime,chanlabels,chanlocs) - data = 2D array srate = type(float or int) wintime = type(list or array) of same length as first dimension of data chanlabels = type(list of strings) of same length as second dimension of data chanlocs = shape is 2Xnumber of channels, ie, (2,248) and contains page coordinates for each channel. Position of X and Y is between -.5 and .5 ''' ####!!!!!!! '''should rerwite the following as well as the filechooser method to make simple and compatible with dictionary based load and read''' data = input_dict['data_block'] srate = input_dict['srate'] wintime = input_dict['wintime'] chanlabels = input_dict['labellist'] chanlocs = input_dict['chanlocs'] print type(data),srate,type(wintime),type(chanlabels),type(chanlocs) print len(chanlabels),size(data,1),len(wintime),size(data,0),\ size(chanlocs,1) if len(chanlabels) != size(data,1) or len(wintime) != size(data,0): #or size(chanlocs,1) != size(data,1): print 'error matching wintime or chlabels or chanlocs with data' #self.builder.get_object("messagedialog1").format_secondary_text\ #('error matching wintime or chlabels or chanlocs with data') #self.builder.get_object("messagedialog1").show() #raise RuntimeError self.data = data self.srate = srate self.chanlabels = chanlabels self.t = array(wintime) self.tstart = 0; self.tstop = len(self.t) self.time = copy(self.t[self.tstart:self.tstop]) self.numchannels = size(data,1) self.chanind = arange(self.numchannels) self.scalefact = (data.min()+data.max())/2 print 'scalefact', self.scalefact self.channels = chanlocs self.curchannel = 0 self.tstart = 0; self.tstop = len(self.t) self.data_loaded_setup() self.data2plot = self.data self.display_apply(None) try: callback(widget); self.callback = callback except TypeError, NameError: print('no callback') def offset_correct(self,widget): print self.get_time_selection(widget) if self.get_time_selection(widget) == -1: #no selections ###self.builder.get_object("messagedialog1").format_secondary_text\ ###('No Selection Made Yet') ###self.builder.get_object("messagedialog1").show() print('no selections detected') return -1 self.data = self.data - average(self.data[self.sel_ind,:],axis=0) print 'Data offset corrected, now trying to replot' self.display_apply(None) print widget,'wid:',widget.get_label() self.callback(widget) def add_selections_to_event_process(self,widget): try: if self.ed.window.get_property('visible') == False: #self.ed = event_process.setup_gui() self.ed.window.show() except AttributeError: #first call. setup self.ed = event_process.setup_gui() self.ed.window.show() if self.get_time_selection(widget) == -1: print('no selections detected') return -1 print('passing selection indices',self.sel_onset_ind) self.ed.set_selected_events_passed(None,self.data,self.sel_onset_ind,self.t) self.ed.builder.get_object("button1").set_sensitive(False)