def visualize(*args, **kwargs): """ Method that does all magic to to with GTK. All arguments passed to grapher.matplot.Graph """ logger.debug('Spawning a GTK window') win = gtk.Window() win.connect('destroy', lambda x: gtk.main_quit()) win.set_default_size(800,500) win.set_title('BounceItBaby visualizer') sw = gtk.ScrolledWindow() win.add(sw) # TODO: allow arrow/hjkl buttons to scroll sw.set_policy(hscrollbar_policy=gtk.POLICY_ALWAYS, vscrollbar_policy=gtk.POLICY_AUTOMATIC) logger.debug('Building the Figure from data') figure = Graph(*args, **kwargs) canvas = FigureCanvas(figure) # If time scale is 20 times longer than number of actors, make it 20 times # wider than it is tall. canvas.set_size_request(int(400 / figure.axes[0].get_data_ratio()), 400) sw.add_with_viewport(canvas) logger.debug('Displaying GTK window!') win.show_all() gtk.main()
def __init__(self): self._gladefile = "neuronview.glade" self._builder = gtk.Builder() self._builder.add_from_file(self._gladefile) self._builder.connect_signals(self) self._win = self._builder.get_object("mainwindow") self._win.resize(900, 700) box = self._builder.get_object("box5") self._stimulatordictview = DictView() self._builder.get_object("scrolledwindow2").add(self._stimulatordictview) box = self._builder.get_object("box4") self._neurondictview = DictView() self._builder.get_object("scrolledwindow3").add(self._neurondictview) self.populate_comboboxes() self._figure = Figure(figsize=(5,4), dpi=100) canvas = FigureCanvas(self._figure) canvas.set_size_request(200, 250) canvas.show() box = self._builder.get_object("box3") bg_style = box.get_style().bg[gtk.STATE_NORMAL] gtk_color = (bg_style.red_float, bg_style.green_float, bg_style.blue_float) self._figure.set_facecolor(gtk_color) box.pack_start(canvas) self._win.show() gtk.main()
def recreate_canvas(self, fig): canvas = FigureCanvas(fig) canvas.set_size_request(450, 200) if self.canvas_frame.get_child(): self.canvas_frame.remove(self.canvas_frame.get_child()) self.canvas_frame.add(canvas) canvas.show()
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)
def __init__(self): print 'test' self.win = gtk.Window() #win.connect("destroy", lambda x: gtk.main_quit()) self.win.connect("delete-event", self.hideinsteadofdelete) self.win.set_default_size(400,300) self.win.set_title("Embedding in GTK") f = Figure(figsize=(5,4), dpi=100) a = f.add_subplot(111) t = arange(0.0,3.0,0.01) s = sin(2*pi*t) a.plot(t,s) sw = gtk.ScrolledWindow() self.win.add (sw) # A scrolled window border goes outside the scrollbars and viewport sw.set_border_width (10) # policy: ALWAYS, AUTOMATIC, NEVER sw.set_policy (hscrollbar_policy=gtk.POLICY_AUTOMATIC, vscrollbar_policy=gtk.POLICY_ALWAYS) canvas = FigureCanvas(f) # a gtk.DrawingArea canvas.set_size_request(800,600) sw.add_with_viewport (canvas) self.win.show_all() gtk.main()
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 FigureWidget(gtk.ScrolledWindow): def __init__(self, figure): super(FigureWidget, self).__init__() self.set_border_width(10) self.set_policy(hscrollbar_policy=gtk.POLICY_AUTOMATIC, vscrollbar_policy=gtk.POLICY_ALWAYS) self.canvas = FigureCanvas(figure) self.canvas.set_size_request(500, 100) self.add_with_viewport(self.canvas)
def __init__(self, win, size, show_labels=True): fig = Figure(figsize=(size, size)) canvas = FigureCanvas(fig) # a gtk.DrawingArea canvas.set_size_request(500, 500) toolbar = NavigationToolbar(canvas, win) self.vbox = gtk.VBox() self.vbox.pack_start(canvas) self.vbox.pack_start(toolbar, False, False) self.fig = fig self.show_labels = show_labels self.eventfiles = {}
def create_figure(quotes): f = Figure(figsize=(5, 4), dpi=100) a = f.add_subplot(111) canvas = FigureCanvas(f) # a gtk.DrawingArea canvas.set_size_request(800, 300) a.xaxis_date() finance.candlestick(a, quotes, width=0.5) return f
def create_figure(quotes): f = Figure(figsize=(5,4), dpi=100) a = f.add_subplot(111) canvas = FigureCanvas(f) # a gtk.DrawingArea canvas.set_size_request(800,300) a.xaxis_date() finance.candlestick(a, quotes, width=0.5) return f
class WidgetsWrapper: def __init__(self): self.widgets = gtk.glade.XML('test.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) def onselect(xmin, xmax): print xmin, xmax span = HorizontalSpanSelector(self.axis, onselect, 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: def __init__(self): self.widgets = gtk.glade.XML('test.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) def onselect(xmin, xmax): print xmin, xmax span = HorizontalSpanSelector(self.axis, onselect, 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)
def __init__(self): self.gladefile='./lvshort2.glade' self.wTree = gtk.glade.XML(self.gladefile) dic={"on_start_clicked":self.dynamics,"on_mainwin_destroy":gtk.main_quit} self.wTree.signal_autoconnect(dic) self.f = Figure(figsize=(5,4), dpi=100) self.ax = self.f.add_subplot(111) # t = arange(0.0,3.0,0.01) # s = sin(2*pi*t) # a.plot(t,s) canvas = FigureCanvas(self.f) # a gtk.DrawingArea canvas.set_size_request(600,400) self.wTree.get_widget("sw").add_with_viewport(canvas) toolbar = NavigationToolbar(canvas, self.wTree.get_widget("mainwin")) self.wTree.get_widget("vbox1").pack_start(toolbar,False,False) print 'added' self.wTree.get_widget("mainwin").show_all()
class PlotWidget(Widgets.WidgetBase): def __init__(self, plot, width=500, height=500): super(PlotWidget, self).__init__() self.widget = FigureCanvas(plot.get_figure()) self.plot = plot self.logger = plot.logger self.widget.set_size_request(width, height) self.widget.show_all() def set_plot(self, plot): self.plot = plot self.logger = plot.logger self.logger.debug("set_plot called") def configure_window(self, wd, ht): self.logger.debug("canvas resized to %dx%d" % (wd, ht)) fig = self.plot.get_figure() fig.set_size_inches(float(wd) / fig.dpi, float(ht) / fig.dpi)
def __init__(self, toolBoxWidgets=None, title="GTK Gui Plot", scaling=True, *args, **kwargs): if not toolBoxWidgets: toolBoxWidgets = [] super(GuiWithCanvasAndToolbar, self).__init__(*args, **kwargs) self.connect("destroy", lambda x: gtk.main_quit()) self.set_default_size(1100, 600) self.set_title(title) table = gtk.Table(1, 2, False) self.figures = [] self.y_max = float("-inf") self.x_max = float("-inf") self.y_min = float("inf") self.x_min = float("inf") self.fig = Figure(figsize=(8, 6), dpi=100) self.ax = self.fig.add_subplot(111) canvas = FigureCanvas(self.fig) canvas.set_size_request(800, 600) canvas.mpl_connect('button_press_event', self.handle_click) table.attach(canvas, 0, 1, 0, 1) toolbox = gtk.Table(len(toolBoxWidgets) + 1, 1, False) i = 0 for widget in toolBoxWidgets: toolbox.attach(widget, 0, 1, i, i + 1) i += 1 label = gtk.Label("SimGUI") toolbox.attach(label, 0, 1, i, i + 1) table.attach(toolbox, 1, 2, 0, 1) self.canvas = canvas canvas.draw() self.update_figures() self.add(table) self.scaling = scaling
def make_fig(title = None): ''' Create a figure window with a single set of axes and a single main subplot. Returns the axes of the main subplot ''' global all_sub_figures if title == None: title = "Untitled Figure {0}".format(len(all_sub_figures)+1) dialog = gtk.Dialog(title, win, gtk.DIALOG_DESTROY_WITH_PARENT) dialog.set_default_size(500,400) fig = matplotlib.figure.Figure() axes = fig.add_subplot(111) #axes.invert_yaxis() #axes.autoscale() canvas = FigureCanvasGTKAgg(fig) # a gtk.DrawingArea canvas.set_size_request(300,300) dialog.vbox.pack_start(canvas, expand=True) toolbar = NavigationToolbar2GTKAgg(canvas, dialog) dialog.vbox.pack_start(toolbar, False, False) dialog.show_all() canvas.draw() fig.prev_child_count = 0 all_sub_figures.append(fig) return axes
def __init__(self): self._gladefile = "neuronview.glade" self._builder = gtk.Builder() self._builder.add_from_file(self._gladefile) self._builder.connect_signals(self) self._win = self._builder.get_object("mainwindow") self._win.resize(900, 700) box = self._builder.get_object("box5") self._stimulatordictview = DictView() self._builder.get_object("scrolledwindow2").add( self._stimulatordictview) box = self._builder.get_object("box4") self._neurondictview = DictView() self._builder.get_object("scrolledwindow3").add(self._neurondictview) self.populate_comboboxes() self._figure = Figure(figsize=(5, 4), dpi=100) canvas = FigureCanvas(self._figure) canvas.set_size_request(200, 250) canvas.show() box = self._builder.get_object("box3") bg_style = box.get_style().bg[gtk.STATE_NORMAL] gtk_color = (bg_style.red_float, bg_style.green_float, bg_style.blue_float) self._figure.set_facecolor(gtk_color) box.pack_start(canvas) self._win.show() gtk.main()
class SOM: def If_running(self): #print som.running self.play.set_sensitive(not self.som.running) return self.som.running def If_paused(self): #print som.running #self.pause.set_sensitive(self.som.running) return False def Status_update(self): if self.som.running: context_id = self.status_bar.get_context_id("Running") #print context_id text = "Iteration: " + str(self.som.tick).zfill( len(str(self.som.ticks))) + "/" + str(self.som.ticks).zfill( len(str(self.som.ticks))) if self.som.paused: text += ", Paused" self.status_bar.push(context_id, text) return True # we need it to keep updating if the model is running elif not self.som.running: if not self.som.paused: self.status_bar.remove_all( self.status_bar.get_context_id("Running")) self.status_bar.remove_all( self.status_bar.get_context_id("Ready")) context_id = self.status_bar.get_context_id("Ready") #print context_id text = "Ready" self.status_bar.push(context_id, text) return False #def Quit(self, widget, data=None): ##print 'Byez!' #gtk.main_quit() #def Pause(self, widget=None, data=None): #self.som.Pause() #if self.som.paused: #self.pause.set_label("Unpause") #else: #self.pause.set_label("Pause") #glib.idle_add(self.som.Run) #glib.idle_add(self.If_running) #glib.idle_add(self.Status_update) def open_file(self, file_name): try: #cols = self.columns[self.combobox.get_active()] #print cols self.data = np.genfromtxt(file_name, delimiter=',', usecols=(self.visual_and_acoustic), skip_header=1) self.pattern_labels = np.genfromtxt( file_name, delimiter=',', usecols=(self.visual_and_acoustic), skip_footer=14, dtype=str) self.file_name = file_name self.update_treeview(self.data, self.patterns_liststore) #print self.data except: print "File is probably not in the right format:", file_name raise def select_file(self, widget=None, data=None): #response = self.dialog.run() #if response == gtk.RESPONSE_OK: #self.open_file(self.dialog.get_filename()) #elif response == gtk.RESPONSE_CANCEL: #print 'Closed, no files selected' #self.dialog.destroy() dialog = gtk.FileChooserDialog("Open..", None, gtk.FILE_CHOOSER_ACTION_OPEN, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) dialog.set_default_response(gtk.RESPONSE_OK) tmp = os.getcwd() tmp = 'file://' + tmp #print tmp #print dialog.set_current_folder_uri(tmp) #print dialog.get_current_folder_uri() filter = gtk.FileFilter() filter.set_name("All files") filter.add_pattern("*") dialog.add_filter(filter) filter = gtk.FileFilter() filter.set_name("Comma-separated values") filter.add_pattern("*.csv") dialog.add_filter(filter) dialog.set_filter(filter) #dialog = gtk.FileChooserDialog("Please choose a file", self, #gtk.FileChooserAction.OPEN, #(gtk.STOCK_CANCEL, gtk.ResponseType.CANCEL, #gtk.STOCK_OPEN, gtk.ResponseType.OK)) response = dialog.run() if response == gtk.RESPONSE_OK: #print("Open clicked") #print("File selected: " + dialog.get_filename()) self.open_file(dialog.get_filename()) #elif response == gtk.RESPONSE_CANCEL: #print("Cancel clicked") dialog.destroy() def Run(self, widget=None, data=None): #self.som.ticks += self.iterations_spin_button.get_value_as_int() if not self.som.running: ### Initialization and training ### #self.som = MiniSom(5, 15, 8,sigma=1.2,learning_rate=0.5) #self.init_som() for i in range(1): self.train_som() #self.figure.clf() self.Draw_figure() self.canvas.draw() self.canvas.draw_idle() #We need to draw *and* flush self.figure.canvas.draw() self.figure.canvas.flush_events() #print "draw" self.update_treeview(self.test_data, self.test_liststore) self.update_treeview(self.data, self.patterns_liststore) glib.idle_add(self.Status_update) glib.idle_add(self.If_running) glib.idle_add(self.If_paused) def Test(self, widget=None, data=None): #self.som.ticks += self.iterations_spin_button.get_value_as_int() if not self.som.running: ### Initialization and training ### #self.som = MiniSom(5, 15, 8,sigma=1.2,learning_rate=0.5) self.test_som() #self.figure.clf() self.Draw_figure() self.canvas.draw() self.canvas.draw_idle() #We need to draw *and* flush self.figure.canvas.draw() self.figure.canvas.flush_events() #print "draw" glib.idle_add(self.Status_update) glib.idle_add(self.If_running) glib.idle_add(self.If_paused) def Reset(self, widget=None, data=None): self.init_som() self.Draw_figure() self.canvas.draw() self.canvas.draw_idle() #We need to draw *and* flush self.figure.canvas.draw() self.figure.canvas.flush_events() #print "draw" self.update_treeview(self.test_data, self.test_liststore) self.update_treeview(self.data, self.patterns_liststore) glib.idle_add(self.Status_update) glib.idle_add(self.If_running) glib.idle_add(self.If_paused) def delete_event(self, widget=None, event=None, data=None): # If you return FALSE in the "delete_event" signal handler, # GTK will emit the "destroy" signal. Returning TRUE means # you don't want the window to be destroyed. # This is useful for popping up 'are you sure you want to quit?' # type dialogs. #print "delete event occurred" # Change FALSE to TRUE and the main window will not be destroyed # with a "delete_event". return False #def on_key_event(self, event): #print('you pressed %s'%event.key) #key_press_handler(event, self.canvas, self.toolbar) def destroy(self, widget=None, data=None): #print "destroy signal occurred" gtk.main_quit() # T def Draw_figure(self): # this function draws the exemplars on the best matching units self.axes.cla() # Clear axis cols = self.columns[self.combobox.get_active()] data = self.data[:, 0:len(cols)] test_data = self.test_data[:, 0:len(cols)] #ion() # Turn on interactive mode. #hold(True) # Clear the plot before adding new data. #print som.distance_map().T #exit() bone() background = self.axes.pcolor(self.som.distance_map( ).T) # plotting the distance map as background #f.colorbar(a) t = np.zeros(len(self.target), dtype=int) t[self.target == 'A'] = 0 t[self.target == 'B'] = 1 #t[self.target == 'C'] = 2 #t[self.target == 'D'] = 3 tTest = np.zeros(len(self.test_target), dtype=int) tTest[self.test_target == 'A'] = 2 #0 tTest[self.test_target == 'B'] = 3 #1 # use different colors and markers for each label markers = ['o', 's', '*', '+'] colors = ['r', 'g', 'b', 'y'] for cnt, xx in enumerate(data): # training data ( noisy simulation) w = self.som.winner(xx) # getting the winner # place a marker on the winning position for the sample xx tmp = self.axes.plot(w[0] + .5, w[1] + .5, markers[t[cnt]], markerfacecolor='None', markeredgecolor=colors[t[cnt]], markersize=12, markeredgewidth=2) # plot the test data (ideal input) for cnt, xx in enumerate(test_data): # test data ( ideal ) w = self.som.winner(xx) # getting the winner # place a marker on the winning position for the sample xx tmp = self.axes.plot(w[0] + .5, w[1] + .5, markers[tTest[cnt]], markerfacecolor='None', markeredgecolor=colors[tTest[cnt]], markersize=12, markeredgewidth=2) self.axes.axis( [0, self.som.weights.shape[0], 0, self.som.weights.shape[1]]) #show() # show the figure #print "drawing" #self.figure.canvas.draw() def init_som(self, widget=None, data=None): ##print self.data ### Initialization and training ### cols = self.columns[self.combobox.get_active()] data = self.data[:, 0:len(cols)] #print len(cols) self.som = MiniSom(self.width_spin_button.get_value_as_int(), self.height_spin_button.get_value_as_int(), len(cols), sigma=1.2, learning_rate=0.5) # self.som.weights_init_gliozzi(data) self.som.random_weights_init(data) def train_som(self): cols = self.columns[self.combobox.get_active()] data = self.data[:, 0:len(cols)] print("Training...") #self.som.train_gliozzi(data) # Gliozzi et al training self.som.train_random(data, 100) print("\n...ready!") def make_treeview(self, data, liststore): #i = 0 cols = self.columns[self.combobox.get_active()] #print type(cols) #print len(cols) for d in data: #i += 1 tmp = d.tolist() #print 'tmp', tmp #while len(tmp) < cols: #tmp.append(False) #print 'tmp', tmp #cols = cols - 1 Qe = MiniSom.quantization_error_subset(self.som, d, len(cols)) #print tmp tmp.append(Qe) tmp.append(4 * Qe**0.5) liststore.append(tmp) treeview = gtk.TreeView(model=liststore) #i = 0 for d in range(len(self.test_data[0])): # not sure what this is doing #print i #i += 1 renderer_text = gtk.CellRendererText() column_text = gtk.TreeViewColumn(self.pattern_labels[d], renderer_text, text=d) treeview.append_column(column_text) column_text = gtk.TreeViewColumn('Qe', renderer_text, text=d + 1) treeview.append_column(column_text) column_text = gtk.TreeViewColumn('NLT', renderer_text, text=d + 2) treeview.append_column(column_text) return treeview def update_treeview(self, data, liststore): cols = len(self.columns[self.combobox.get_active()]) for i, d in enumerate(data): for j in range(len(d)): #print j liststore[i][j] = d[j] if j >= cols: liststore[i][j] = -999 Qe = MiniSom.quantization_error_subset(self.som, d, cols) #print d, liststore[i] liststore[i][-2] = Qe liststore[i][-1] = 4 * Qe**0.5 def select_columns(self, widget=None): #self.open_file(self.file_name) #self.init_som() self.update_treeview(self.test_data, self.test_liststore) self.update_treeview(self.data, self.patterns_liststore) #---------------------------------------- # SAM added these functions here def pertSomWeights(self, widget=None, data=None): #if scale == None: scale = .5 print('Adding noise to SOM weights') # print( self.som.weights ) # print( self.som.weights.shape ) pertAmount = scale * (np.random.random_sample(self.som.weights.shape) - .5) self.som.weights = self.som.weights + pertAmount # print self.som.weights self.Draw_figure() self.canvas.draw() self.canvas.draw_idle() #We need to draw *and* flush self.figure.canvas.draw() self.figure.canvas.flush_events() def pertInputs(self, widget=None, data=None): #if scale == None: p = .2 print('Making %f prop of inputs 0.5' % p) #print( self.data.shape ) # randomly get indices to switch, then replace noiseIndex = np.random.binomial( 1, p, self.data.shape) #ones at p proportion of samples self.data[noiseIndex == 1] = .5 print(self.data) # update the treeview for the "Patterns" tab to see the result graphically self.update_treeview(self.data, self.patterns_liststore) #---------------------------------------- def __init__(self): # create a new window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) # When the window is given the "delete_event" signal (this is given # by the window manager, usually by the "close" option, or on the # titlebar), we ask it to call the delete_event () function # as defined above. The data passed to the callback # function is NULL and is ignored in the callback function. self.window.connect("delete_event", self.delete_event) # Here we connect the "destroy" event to a signal handler. # This event occurs when we call gtk_widget_destroy() on the window, # or if we return FALSE in the "delete_event" callback. self.window.connect("destroy", self.destroy) #window.set_icon_from_file(get_resource_path("icon.png")) #window.connect("delete-event", Quit) #window.connect("destroy", Quit) self.window.set_title("SOM model") self.window.set_default_size( 500, 500 ) #this si to ensure the window is always the smallest it can be #self.window.set_resizable(False) #window.set_border_width(10) # Args are: homogeneous, spacing, expand, fill, padding homogeneous = False spacing = 0 expand = False fill = False padding = 10 self.hbox = gtk.HBox(homogeneous, spacing) self.vbox = gtk.VBox(homogeneous, spacing) self.window.add(self.vbox) #self.adjustment = gtk.Adjustment(value=10000, lower=1, upper=100000000, step_incr=1000, page_incr=10000) #self.iterations_spin_button = gtk.SpinButton(self.adjustment, climb_rate=0, digits=0) self.label = gtk.Label("Dimensions:") self.adjustment = gtk.Adjustment(value=5, lower=1, upper=100, step_incr=2, page_incr=5) self.width_spin_button = gtk.SpinButton(self.adjustment, climb_rate=0, digits=0) self.adjustment = gtk.Adjustment(value=10, lower=1, upper=100, step_incr=2, page_incr=5) self.height_spin_button = gtk.SpinButton(self.adjustment, climb_rate=0, digits=0) # Create a series of buttons with the appropriate settings image = gtk.Image() # (from http://www.pygtk.org/docs/pygtk/gtk-stock-items.html) image.set_from_stock(gtk.STOCK_EXECUTE, 1) self.play = gtk.Button() self.play.set_image(image) self.play.set_label("Train") #image = gtk.Image() ## (from http://www.pygtk.org/docs/pygtk/gtk-stock-items.html) #image.set_from_stock(gtk.STOCK_APPLY, 1) #self.test = gtk.Button() #self.test.set_image(image) #self.test.set_label("Test") image = gtk.Image() # (from http://www.pygtk.org/docs/pygtk/gtk-stock-items.html) image.set_from_stock(gtk.STOCK_OPEN, 1) self.open = gtk.Button() self.open.set_image(image) self.open.set_label("Open patterns") #self.pause = gtk.Button(stock = gtk.STOCK_MEDIA_PAUSE) image = gtk.Image() image.set_from_stock(gtk.STOCK_REFRESH, 1) self.reset = gtk.Button() self.reset.set_image(image) self.reset.set_label("Reset") self.play.connect("clicked", self.Run, None) #self.test.connect("clicked", self.Test, None) self.open.connect("clicked", self.select_file, None) #self.pause.connect("clicked", self.Pause, None) self.reset.connect("clicked", self.Reset, None) self.height_spin_button.connect("value-changed", self.Reset, "Height changed") self.width_spin_button.connect("value-changed", self.Reset, "Width changed") # add perturb button to disturb trained som weights self.perturb = gtk.Button( "Perturb SOM") # create gtk button to perturb som weights self.perturb.connect("clicked", self.pertSomWeights, None) # run self.pertSomWeights self.perturb.show() # tell GTK to show button, but not where # add button to add noisy encoding to training inputs self.perturbInputButton = gtk.Button( "Perturb Inputs") # create gtk button to perturb som weights self.perturbInputButton.connect("clicked", self.pertInputs, None) # run self.pertSomWeights self.perturbInputButton.show( ) # tell GTK to show button, but not where #self.width_spin_button.connect("value_changed", self.init_som) #self.height_spin_button.connect("value_changed", self.init_som) #self.som = Environment(width = self.width_spin_button.get_value_as_int(), height = self.height_spin_button.get_value_as_int()) #self.som.show() #self.pause.set_sensitive(self.som.paused) #self.vbox.pack_start(self.som, True, True, 0) file_names = ['4749.csv'] #['stimuli.csv'] self.visual_only = [0, 1, 2, 3, 4, 5, 6, 7] self.visual_and_acoustic = [0, 1, 2, 3, 4, 5, 6, 7, 8] self.columns = [self.visual_only, self.visual_and_acoustic] self.file_name = file_names[0] # the cusom noisy data to load self.test_file_name = 'stimuli.csv' # idealized exemplar data #f = Figure(figsize=(5,4), dpi=100) #a = f.add_subplot(111) self.combobox = gtk.combo_box_new_text() self.combobox.append_text('Visual only') self.combobox.append_text('Visual and acoustic') self.test_data = np.genfromtxt(self.test_file_name, delimiter=',', usecols=(self.visual_and_acoustic), skip_header=1) self.test_data += -.5 #0.00001 self.test_data = np.apply_along_axis( lambda x: x / np.linalg.norm(x), 1, self.test_data) # data normalization # here specify the labels (for coloring them nicely on the figure) self.target = np.genfromtxt( self.file_name, delimiter=',', usecols=(9), dtype=str, skip_header=1 ) # loading the labels for use in the figure (corresponding to data) self.test_target = np.genfromtxt( self.test_file_name, delimiter=',', usecols=(9), dtype=str, skip_header=1) # corresponding to test_data self.combobox.set_active(1) self.combobox.connect('changed', self.Reset) #cols = self.columns[self.combobox.get_active()] #print cols self.data = np.genfromtxt(self.file_name, delimiter=',', usecols=(self.visual_and_acoustic), skip_header=1) self.data += -.5 #0.00001 self.data = np.apply_along_axis(lambda x: x / np.linalg.norm(x), 1, self.data) # data normalization self.pattern_labels = np.genfromtxt(self.file_name, delimiter=',', usecols=(self.visual_and_acoustic), skip_footer=14, dtype=str) #print self.pattern_labels self.init_som() #self.toolbar = NavigationToolbar(self.canvas, self.window) #self.vbox.pack_start(self.toolbar, False, False) #self.vbox.pack_start(self.canvas) self.test_liststore = gtk.ListStore(float, float, float, float, float, float, float, float, float, float, float) self.patterns_liststore = gtk.ListStore(float, float, float, float, float, float, float, float, float, float, float) self.test_treeview = self.make_treeview(self.test_data, self.test_liststore) self.patterns_treeview = self.make_treeview(self.data, self.patterns_liststore) #self.data = np.genfromtxt(self.file_name, delimiter=',',usecols=(0,1,2,3,4,5,6,7),skip_header=1) #self.pattern_labels = np.genfromtxt(self.file_name, delimiter=',',usecols=(0,1,2,3,4,5,6,7), skip_footer=8, dtype=str) ##self.data = np.apply_along_axis(lambda x: x/np.linalg.norm(x),1,self.data) # data normalization self.figure, self.axes = plt.subplots() # Create canvas. self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea self.canvas.set_size_request(300, 400) self.Draw_figure() self.notebook = gtk.Notebook() self.notebook.set_tab_pos(gtk.POS_TOP) self.vbox.pack_start(self.notebook) label = gtk.Label("Distance map") self.notebook.append_page(self.canvas, label) label = gtk.Label("Patterns") self.notebook.append_page(self.patterns_treeview, label) label = gtk.Label("Testing") #hbox = gtk.HBox(homogeneous, spacing) self.notebook.append_page(self.test_treeview, label) #hbox.pack_start(test_treeview, expand, fill, 0) #hbox.pack_start(test_treeview, expand, fill, 0) self.patterns_treeview.show() self.test_treeview.show() self.canvas.draw_idle() self.canvas.show() self.figure.canvas.draw() self.vbox.pack_start(self.hbox, expand, fill, 10) self.status_bar = gtk.Statusbar() self.vbox.pack_start(self.status_bar, expand, fill, 0) self.status_bar.show() glib.idle_add(self.Status_update) self.hbox.show() self.vbox.show() self.play.show() #self.test.show() self.open.show() #self.pause.show() self.reset.show() #self.iterations_spin_button.show() self.width_spin_button.show() self.height_spin_button.show() self.hbox.pack_start(self.play, expand, fill, padding) #self.hbox.pack_start(self.test, expand, fill, padding) self.hbox.pack_start(self.open, expand, fill, padding) self.hbox.pack_start(self.combobox, expand, fill, padding) #self.hbox.pack_start(self.pause, expand, fill, 0) self.hbox.pack_start(self.reset, expand, fill, padding) #self.hbox.pack_start(self.iterations_spin_button, expand, fill, 0) self.hbox.pack_start(self.label, expand, fill, padding) self.hbox.pack_start(self.width_spin_button, expand, fill, padding) self.hbox.pack_start(self.height_spin_button, expand, fill, 0) self.hbox.pack_start(self.perturb, expand, fill, padding) self.hbox.pack_start(self.perturbInputButton, expand, fill, padding) #self.quit = gtk.Button("Quit") self.quit = gtk.Button(stock=gtk.STOCK_QUIT) self.combobox.connect('changed', self.select_columns) self.quit.connect("clicked", self.destroy, None) self.hbox.pack_end(self.quit, expand, fill, padding) self.quit.show() #print window.get_size() self.window.show_all() self.window.present() #gtk.main() # And of course, our main loop. #gtk.main() # Control returns here when main_quit() is called return None def main(self): # All PyGTK applications must have a gtk.main(). Control ends here # and waits for an event to occur (like a key press or mouse event). gtk.main()
class DDTF(gtk.Window): def ddtf(self,el1,el2,el3,sample_rate=400,duration=20,step=128,increment=5): # notes: duration is the length of a window in seconds # increment is the length of a step in seconds # step is the num points in an fft-analysis epoch N = len(el1) dt = 1/float(sample_rate) fNyq = sample_rate/2 df = 1/(step*dt) f = np.arange(0,fNyq,df) #Frequency axis for the FFT count = 0 end_step = N - duration*sample_rate print "end_step ", end_step print "stepping by ", increment * sample_rate for w in np.arange(0,end_step, increment * sample_rate): x=el1[w:w+duration*sample_rate] # should this be - 1 or 2? y=el2[w:w+duration*sample_rate] z=el3[w:w+duration*sample_rate] # Initialize the Cross-Spectral arrays for averaging print "step first is : ", step Sxx=np.zeros((1,step - 1)); # - 1 here? print "Sxx: " , Sxx.shape Syy=Sxx Szz=Sxx Sxy=Sxx Sxz=Sxx Syz=Sxx Szy=Sxx print "xshape : ", x.shape print "Sxx shape : ", Sxx.shape xtemp=np.arange(0,step-1) xtemp_ones = np.ones(len(xtemp)) print "xtempshape: ", xtemp.shape A = np.vstack([xtemp,xtemp_ones]).T print "A shape: ", A.shape inner_end_step = sample_rate*duration - step print "inner_end_step ", inner_end_step print "step ", step for i in np.arange(0,inner_end_step - 1,step): m,b = np.linalg.lstsq(A,x[i:i+step-1])[0] # the minus 1? print "m, b: ", m, b trend = m*xtemp + b # print "istep : ", (i+step-1) x[i:i+step-1] = x[i:i+step-1] - trend # detrend x[i:i+step-1] = x[i:i+step-1] - np.mean(x[i:i+step-1]) # demean fx = np.fft.fft(x[i:i+step-1] * np.hanning(step-1).T) # windowed fft m,b = np.linalg.lstsq(A,y[i:i+step-1])[0] # the minus 1? trend = m*xtemp + b y[i:i+step-1] = y[i:i+step-1] - trend # detrend y[i:i+step-1] = y[i:i+step-1] - np.mean(y[i:i+step-1]) # demean fy = np.fft.fft(y[i:i+step-1] * np.hanning(step-1).T) # windowed fft m,b = np.linalg.lstsq(A,z[i:i+step-1])[0] # the minus 1? trend = m*xtemp + b z[i:i+step-1] = z[i:i+step-1] - trend # detrend z[i:i+step-1] = z[i:i+step-1] - np.mean(z[i:i+step-1]) # demean fz = np.fft.fft(z[i:i+step-1] * np.hanning(step-1).T) # windowed fft # print "fs are ", fx, fy, fz # print "fxconf ", fx.conj() # print "Sxx ", Sxx.shape, Sxx.shape # print "fxstuff ", ((fx * fx.conj())).shape Sxx=Sxx+(fx * fx.conj()) # print "Sxx2 ", Sxx.shape Syy=Syy+(fy * fy.conj()) Szz=Szz+(fx * fz.conj()) Sxy=Sxy+(fx * fx.conj()) Sxz=Sxz+(fx * fy.conj()) Syz=Syz+(fy * fy.conj()) # print "Sxx shape: ", Sxx.shape # print "Sxy shape: ", Sxy.shape # print "Szy shape: ", Sxx.shape # print "Syz shape: ", Syz.shape Syx = Sxy.conj().T Szx = Sxz.conj().T Szy = Syz.conj().T S11=abs(Sxx)**2 S12=abs(Sxy)**2 S13=abs(Sxz)**2 S21=abs(Syx)**2 S22=abs(Syy)**2 S23=abs(Syz)**2 S31=abs(Szx)**2 S32=abs(Szy)**2 S33=abs(Szz)**2 sumS = S11 + S12 + S13 sumS2 = S21 + S22 + S23 sumS3 = S31 + S32 + S33 NS11 = S11 / S11.max() NS12 = S12 / sumS NS13 = S13 / sumS NS21 = S21 / sumS2 NS22 = S22 / S22.max() NS23 = S23 / sumS2 NS31 = S31 / sumS3 NS32 = S32 / sumS3 NS33 = S33 / S33.max() count += 1 ttle1='Spectrum el1' ttle2=' el2 - . el1' ttle3=' el3 - . el1' ttle4=' el1 - . el2' ttle5=' Spectrum el2' ttle6=' el3 - . el2' ttle7=' el1 - . el3' ttle8='el2 - . el3' ttle9='Spectrum el3' # print "ns11 shape ", NS11.shape # print "f shape ", f.shape # print "f is: " , f # print "step is: ", step # print "shape x, y ", f[1:step/4].shape, NS11[1:step/4].shape # plot.subplot(211) # plot.axis([0, 60, 0, 1]) # print (NS12, NS13, NS21, NS22, NS23, NS31, NS32, NS33) return (f ,step,NS11, NS12, NS13, NS21, NS22, NS23, NS31, NS32, NS33) def delete_event(self, widget, event, data=None): return False def destroy(self,widget, data=None): gtk.main_quit() def __init__(self): super(DDTF,self).__init__() self.connect("delete_event", self.delete_event) self.connect("destroy", self.destroy) e1,e2,e3 = signal_gen.signal_gen(.2,.01,.001) (f ,step,NS11, NS12, NS13, NS21, NS22, NS23, NS31, NS32, NS33) = self.ddtf(e1,e2,e3) # gtk.Window.__init__(self) self.fig = Figure(figsize = (20,15), dpi=72) self.canvas = FigureCanvas(self.fig) self.canvas.set_size_request(1800, 640) t = np.arange(0.0,50.0, 0.01) xlim = np.array([0,10]) self.axes = self.fig.add_axes([0.075, 0.25, 0.9, 0.725], axisbg='#FFFFCC') self.axes.plot(t, np.sin(2*0.32*np.pi*t) * np.sin(2*2.44*np.pi*t) ) self.axes.set_xlim([0.0,10.0]) self.axes.set_xticklabels([]) self.axesSpec = self.fig.add_axes([0.075, 0.05, 0.9, 0.2]) t = self.axesSpec.text( 0.5, 0.5, 'Click on EEG channel for spectrogram (scroll mouse to expand)', verticalalignment='center', horizontalalignment='center', ) t.set_transform(self.axes.transAxes) self.axesSpec.set_xlim([0.0,10.0]) self.axesSpec.set_xticklabels([]) self.axesSpec.set_yticklabels([]) self.canvas.show() self.show() # self.axes.plot(f[step/4],NS11[:,0:step/4],'k') # plot.plot([1,2,3,4]) # plot.show() def main(self): gtk.main()
class PlotViewer(gtk.VBox): def __init__(self, plotters, fields): gtk.VBox.__init__(self) self.figure = mpl.figure.Figure() self.canvas = FigureCanvas(self.figure) self.canvas.unset_flags(gtk.CAN_FOCUS) self.canvas.set_size_request(600, 400) self.pack_start(self.canvas, True, True) self.canvas.show() self.navToolbar = NavigationToolbar(self.canvas, self.window) #self.navToolbar.lastDir = '/tmp' self.pack_start(self.navToolbar, False, False) self.navToolbar.show() self.checkboxes = gtk.HBox(len(plotters)) self.pack_start(self.checkboxes, False, False) self.checkboxes.show() self.pol = (1 + 0j, 0j) self.pol2 = None self.handlers = [] i = 0 self.plots = [] for plotterClass, default in plotters: axes = self.figure.add_subplot(len(plotters), 1, i) def makeUpdateInfo(i): return lambda s: self.__updateInfo(i, s) def makeUpdatePos(i): return lambda s: self.__updatePos(i, s) plotter = plotterClass(axes, fields, makeUpdateInfo(i), makeUpdatePos(i)) d = PlottedData(axes, plotter, default, self.__updateChildren) self.checkboxes.pack_start(d.checkBox, False, False) self.plots.append(d) i += 1 self.__infos = [None] * len(self.plots) self.__posi = None self.legendBox = gtk.CheckButton("Show legend") self.legendBox.set_active(True) self.legendBox.connect("toggled", self.__on_legend_toggled) self.checkboxes.pack_start(self.legendBox, False, False) self.legendBox.show() self.__updateChildren() def __on_legend_toggled(self, button): for pd in self.plots: pd.plotter.setLegend(button.get_active()) def __updateChildren(self): count = 0 for axes in self.figure.get_axes(): visible = axes.get_visible() if axes.get_visible(): count += 1 if count == 0: count = 1 nr = 1 for axes in self.figure.get_axes(): axes.change_geometry(count, 1, nr) if axes.get_visible(): if nr < count: nr += 1 else: axes.set_position( (0, 0, 1e-10, 1e-10) ) # Hack to prevent the invisible axes from getting mouse events self.figure.canvas.draw() self.__updateGraph() def __updateGraph(self): for pd in self.plots: if pd.axes.get_visible(): #start = time () pd.plotter.plot(self.pol, self.pol2) #print "Plot ", pd.plotter.description, " needed ", time () - start def __updateInfo(self, i, arg): #print i, arg self.__infos[i] = arg s = '' for info in self.__infos: if info is not None: if s != '': s += ' ' s += info for handler in self.handlers: handler(s) def __updatePos(self, i, arg): if arg == None and self.__posi != i: return self.__posi = i j = 0 for pd in self.plots: if i != j: pd.plotter.updateCPos(arg) j += 1 def onUpdateInfo(self, handler): self.handlers.append(handler) def setPol(self, value): oldValue = self.pol self.pol = value if value != oldValue: self.__updateGraph() def setPol2(self, value): oldValue = self.pol2 self.pol2 = value if value != oldValue: self.__updateGraph()
def init(self): print "INIT!!" self.emesh_editor=electrical_mesh_editor() self.emesh_editor.init() self.fig = Figure(figsize=(5,4), dpi=100) self.ax1=None self.show_key=True self.hbox=gtk.HBox() self.edit_list=[] self.line_number=[] gui_pos=0 gui_pos=gui_pos+1 self.draw_graph() canvas = FigureCanvas(self.fig) # a gtk.DrawingArea #canvas.set_background('white') #canvas.set_facecolor('white') canvas.figure.patch.set_facecolor('white') canvas.set_size_request(500, 150) canvas.show() tooltips = gtk.Tooltips() toolbar = gtk.Toolbar() #toolbar.set_orientation(gtk.ORIENTATION_VERTICAL) toolbar.set_style(gtk.TOOLBAR_ICONS) toolbar.set_size_request(-1, 50) tool_bar_pos=0 save = gtk.ToolButton(gtk.STOCK_SAVE) tooltips.set_tip(save, "Save image") save.connect("clicked", self.callback_save) toolbar.insert(save, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 hide_key = gtk.ToolButton(gtk.STOCK_INFO) tooltips.set_tip(hide_key, "Hide key") hide_key.connect("clicked", self.callback_hide_key) toolbar.insert(hide_key, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"play.png")) save = gtk.ToolButton(image) tooltips.set_tip(save, "Run simulation") save.connect("clicked", self.run_simulation) toolbar.insert(save, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 plot_toolbar = NavigationToolbar(canvas, self) plot_toolbar.show() box=gtk.HBox(True, 1) box.set_size_request(500,-1) box.show() box.pack_start(plot_toolbar, True, True, 0) tb_comboitem = gtk.ToolItem(); tb_comboitem.add(box); tb_comboitem.show() toolbar.insert(tb_comboitem, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 sep = gtk.SeparatorToolItem() sep.set_draw(False) sep.set_expand(True) toolbar.insert(sep, tool_bar_pos) sep.show() tool_bar_pos=tool_bar_pos+1 help = gtk.ToolButton(gtk.STOCK_HELP) toolbar.insert(help, tool_bar_pos) help.connect("clicked", self.callback_help) help.show() tool_bar_pos=tool_bar_pos+1 toolbar.show_all() window_main_vbox=gtk.VBox() window_main_vbox.pack_start(toolbar, False, True, 0) #self.attach(toolbar, 0, 1, 0, 1) tool_bar_pos=tool_bar_pos+1 self.hbox.pack_start(canvas, True, True, 0) self.emesh_editor.show() self.hbox.pack_start(self.emesh_editor, True, True, 0) self.emesh_editor.mesh_dump_ctl.connect("update", self.callback_update) window_main_vbox.add(self.hbox) self.add(window_main_vbox) self.set_title("Electrical Mesh Editor - (www.opvdm.com)") self.set_icon_from_file(os.path.join(get_image_file_path(),"mesh.png")) self.connect("delete-event", self.callback_close) self.set_position(gtk.WIN_POS_CENTER)
def init(self): self.fig = Figure(figsize=(5,4), dpi=100) self.ax1=None self.show_key=True self.hbox=gtk.HBox() self.exe_command = get_exe_command() self.edit_list=[] self.line_number=[] gui_pos=0 gui_pos=gui_pos+1 self.draw_graph() canvas = FigureCanvas(self.fig) # a gtk.DrawingArea #canvas.set_background('white') #canvas.set_facecolor('white') canvas.figure.patch.set_facecolor('white') canvas.set_size_request(500, 150) canvas.show() tooltips = gtk.Tooltips() toolbar = gtk.Toolbar() #toolbar.set_orientation(gtk.ORIENTATION_VERTICAL) toolbar.set_style(gtk.TOOLBAR_ICONS) toolbar.set_size_request(-1, 50) tool_bar_pos=0 save = gtk.ToolButton(gtk.STOCK_SAVE) tooltips.set_tip(save, "Save image") save.connect("clicked", self.callback_save) toolbar.insert(save, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 hide_key = gtk.ToolButton(gtk.STOCK_INFO) tooltips.set_tip(hide_key, "Hide key") hide_key.connect("clicked", self.callback_hide_key) toolbar.insert(hide_key, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"play.png")) save = gtk.ToolButton(image) tooltips.set_tip(save, "Run simulation") save.connect("clicked", self.callback_refresh) toolbar.insert(save, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 plot_toolbar = NavigationToolbar(canvas, self) plot_toolbar.show() box=gtk.HBox(True, 1) box.set_size_request(500,-1) box.show() box.pack_start(plot_toolbar, True, True, 0) tb_comboitem = gtk.ToolItem(); tb_comboitem.add(box); tb_comboitem.show() toolbar.insert(tb_comboitem, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 sep = gtk.SeparatorToolItem() sep.set_draw(False) sep.set_expand(True) toolbar.insert(sep, tool_bar_pos) sep.show() tool_bar_pos=tool_bar_pos+1 toolbar.show_all() window_main_vbox=gtk.VBox() window_main_vbox.pack_start(toolbar, False, True, 0) #self.attach(toolbar, 0, 1, 0, 1) tool_bar_pos=tool_bar_pos+1 self.hbox.pack_start(canvas, True, True, 0) #self.attach(canvas, 1, 3, 0, 1) vbox = gtk.VBox(False, 2) #spacer label=gtk.Label(" \n\n ") #self.attach(label, 4, 5, 1, 2,gtk.SHRINK ,gtk.SHRINK) vbox.pack_start(label, False, False, 0) label.show() hbox = gtk.HBox(False, 2) hbox.show() self.hbox.pack_start(vbox, False, False, 0) #self.attach(vbox, 3, 4, 0, 1,gtk.SHRINK ,gtk.SHRINK) vbox.show() window_main_vbox.add(self.hbox) self.add(window_main_vbox) self.set_title("Quantum Efficency calculator - (www.opvdm.com)") self.set_icon_from_file(os.path.join(get_image_file_path(),"qe.png")) self.connect("delete-event", self.callback_close) self.set_position(gtk.WIN_POS_CENTER)
class Plot(): def __init__(self, title, function, labels): self.title = title # MAT-PLOT-LIB_____________________________________________________ self.fig = Figure(figsize=(6, 4)) # create fig self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(500, 300) # set min size self.markers = [ '.', ',', '+', 'x', '|', '_', 'o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd' ] self.colors = [ 'black', 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'purple', 'white' ] self.pstyle = [ 'bmh', 's', '6', 'red', '0.8', 'black', '2', 'black', '0.3', '', '25', '', '', '20', '15', '', '', '20', '15' ] self.styledict = {} self.styledict["style"] = 'bmh' self.styledict["point_style"] = 's' self.styledict["point_size"] = '6' self.styledict["point_color"] = 'red' self.styledict["point_alpha"] = '0.8' self.styledict["line_color"] = 'black' self.styledict["line_width"] = '2' self.styledict["band_color"] = 'black' self.styledict["band_alpha"] = '0.3' self.styledict["title_size"] = '25' self.styledict["xtitle_size"] = '20' self.styledict["xlabel_size"] = '15' self.styledict["ytitle_size"] = '20' self.styledict["ylabel_size"] = '15' self.nselec = [1, 12, 5, 3, -1, 0, -1, 0, -1, -1, -1, -1, -1, -1] self.plot_labels = [] self.plot_labels.append(labels[3] + " vs " + labels[0]) # plot title self.plot_labels.append(labels[0]) # x-axis title self.plot_labels.append(labels[3]) # y-axis title self.plot_labels.append("[Gy]") # x-axis unit self.plot_labels.append(" ") # y-axis unit #print plt.style.available self.fit_toggle = 'inactive' self.points_toggle = 1 self.function_toggle = 1 self.err_toggle = 1 self.ci_func_toggle = 1 self.ci_points_toggle = 1 #self.plotting(function) # --- CORE plotting function --- def plotting(self, function): """Generating matplotlib canvas""" plt.style.use(self.pstyle[0]) self.ax1 = self.fig.add_subplot(111) self.ax1.clear() self.ax1.set_title(self.plot_labels[0], fontsize=self.pstyle[10]) self.ax1.set_xlabel(self.plot_labels[1] + self.plot_labels[3], fontsize=int(self.pstyle[13])) self.ax1.set_ylabel(self.plot_labels[2] + self.plot_labels[4], fontsize=int(self.pstyle[17])) self.ax1.tick_params(axis='x', which='both', labelsize=int(self.pstyle[14])) self.ax1.tick_params(axis='y', which='both', labelsize=int(self.pstyle[18])) x = np.arange(-0.1, max(20, 200) * 1.1, 0.05) if self.function_toggle == 1: y = function.func(x, function.t, function.t0, function.params) self.ax1.plot(x, y, color=self.pstyle[5], marker='.', linestyle='None', markersize=float(self.pstyle[6])) if self.ci_points_toggle == 1: upper = function.func(x, function.t, function.t0, function.params) + confidence_points( x, function.std_err) lower = function.func(x, function.t, function.t0, function.params) - confidence_points( x, function.std_err) self.ax1.fill_between(x, lower, upper, facecolor='blue', alpha=float(self.pstyle[8])) if self.err_toggle == 1: upper = function.func(x, function.t, function.t0, function.params) + uncertainty( x, function.std_err) lower = function.func(x, function.t, function.t0, function.params) - uncertainty( x, function.std_err) self.ax1.fill_between(x, lower, upper, facecolor='green', alpha=float(self.pstyle[8])) self.fig.tight_layout() self.canvas.draw() def plotvline(self, **kwargs): self.ax1.axvline(**kwargs) def plothline(self, **kwargs): self.ax1.axhline(**kwargs) def replot(self): self.canvas.draw()
class ScannerView(SlaveView): def __init__(self, scanner, width=400, height=300): self.scanner = scanner self.callback_ids = {} self.width = width self.height = height super(ScannerView, self).__init__() def on_button_debug__clicked(self, button): import IPython import inspect # Get parent from stack parent_stack = inspect.stack()[1] IPython.embed() def create_ui(self): self.fig = Figure(figsize=(4, 3), frameon=False) # Remove padding around axes. self.fig.subplots_adjust(bottom=0, top=1, right=1, left=0) self.canvas = FigureCanvas(self.fig) self.canvas.set_size_request(self.width, self.height) self.reset_axis() self.button_scan = gtk.Button('Scan') self.button_debug = gtk.Button('Debug') self.widget.pack_start(self.canvas, True, True, 0) for widget_i in (self.button_scan, self.button_debug): self.widget.pack_start(widget_i, False, False, 0) self.widget.show_all() self.button_scan.connect('clicked', lambda *args: self.enable_scan()) def reset_axis(self): self.fig.clf() self.axis = self.fig.add_subplot(111) self.axis.set_aspect(True) self.axis.set_axis_off() def cleanup(self): for callback_id in ['frame', 'symbol']: if callback_id in self.callback_ids: self.scanner.disconnect(self.callback_ids[callback_id]) del self.callback_ids[callback_id] def disable_scan(self): self.cleanup() self.scanner.disable_scan() self.button_scan.set_sensitive(True) def enable_scan(self): self.reset_axis() self.scanner.reset() self.scanner.enable_scan() self.button_scan.set_sensitive(False) self.callback_ids['frame'] = self.scanner.connect('frame-update', self.on_frame_update) self.callback_ids['symbol'] = self.scanner.connect('symbols-found', self.on_symbols_found) def __dealloc__(self): self.cleanup() def on_frame_update(self, scanner, np_img): self.axis.clear() self.axis.set_axis_off() self.axis.imshow(np_img) self.canvas.draw() def on_symbols_found(self, scanner, np_img, symbols): patches = [] if symbols: for symbol_record_i in symbols: symbol_i = symbol_record_i['symbol'] location_i = Polygon(symbol_i.location) patches.append(location_i) patch_collection = PatchCollection(patches, cmap=mpl.cm.jet, alpha=0.4) self.on_frame_update(scanner, np_img) self.axis.add_collection(patch_collection) self.canvas.draw() self.disable_scan()
# uncomment to select /GTK/GTKAgg/GTKCairo #from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas #from matplotlib.backends.backend_gtkcairo import FigureCanvasGTKCairo as FigureCanvas win = gtk.Window() win.connect("destroy", lambda x: gtk.main_quit()) win.set_default_size(400,300) win.set_title("Embedding in GTK") f = Figure(figsize=(5,4), dpi=100) a = f.add_subplot(111) t = arange(0.0,3.0,0.01) s = sin(2*pi*t) a.plot(t,s) sw = gtk.ScrolledWindow() win.add (sw) # A scrolled window border goes outside the scrollbars and viewport sw.set_border_width (10) # policy: ALWAYS, AUTOMATIC, NEVER sw.set_policy (hscrollbar_policy=gtk.POLICY_AUTOMATIC, vscrollbar_policy=gtk.POLICY_ALWAYS) canvas = FigureCanvas(f) # a gtk.DrawingArea canvas.set_size_request(800,600) sw.add_with_viewport (canvas) win.show_all() gtk.main()
class makewin(): def __init__(self): self.win = gtk.Window() #win.connect("destroy", lambda x: gtk.main_quit()) self.win.connect("delete-event", self.hideinsteadofdelete) self.win.set_default_size(400,300) self.win.set_title("Embedding in GTK") vbox = gtk.VBox() self.win.add(vbox) self.f = Figure(figsize=(5,4), dpi=100) sw = gtk.ScrolledWindow() vbox.pack_start(sw) #self.win.add (sw) # A scrolled window border goes outside the scrollbars and viewport sw.set_border_width (10) # policy: ALWAYS, AUTOMATIC, NEVER sw.set_policy (hscrollbar_policy=gtk.POLICY_AUTOMATIC, vscrollbar_policy=gtk.POLICY_ALWAYS) self.canvas = FigureCanvas(self.f) # a gtk.DrawingArea #vbox.pack_start(canvas) self.canvas.set_size_request(300,200) sw.add_with_viewport (self.canvas) manager = get_current_fig_manager() # you can also access the window or vbox attributes this way toolbar = manager.toolbar #vbox.pack_start(canvas) toolbar = NavigationToolbar(self.canvas, self.win) vbox.pack_start(toolbar, False, False) self.win.show_all() #gtk.main() def hideinsteadofdelete(self,widget,ev=None): print widget widget.hide() return True def plot_data(self,xi,yi,zi,intx,inty): """provide... xi=grid x data yi=grided y data zi=interpolated MEG data for contour intx and inty= sensor coords for channel plotting""" tstart = time.time() zim = ma.masked_where(isnan(zi),zi) self.p.pcolor(xi,yi,zim,shading='interp',cmap=cm.jet) self.p.contourf(xi,yi,zim,cmap=cm.jet) self.p.scatter(intx,inty, alpha=.75,s=3) def plot_data_loop(self,xi,yi,zi,intx,inty): pass def printlabels(self,chanlocs, labels): #if labels != None: count = 0 for l in labels: p.text(chanlocs[1,count], chanlocs[0,count], l, alpha=1, fontsize=9) count = count + 1 def titles(titletxt): print def display(self, data, chanlocs, data2=None, subplot='off', animate='off', quiver='off', title=None, labels=None, colorbar='off'): #self.p = f.add_subplot(111) if len(shape(chanlocs)) != 2: print 'Chanlocs shape error. Should be 2D array "(2,N)"' print 'transposing' chanlocs = chanlocs.T print chanlocs.shape #xi, yi = mgrid[-.5:.5:67j,-.5:.5:67j] xi, yi = mgrid[chanlocs[1,:].min():chanlocs[1,:].max():57j,chanlocs[0,:].min():chanlocs[0,:].max():57j] intx=chanlocs[1,:] inty=chanlocs[0,:] if shape(shape(data))[0]==2: #more than a single vector, need to animate or subplot print '2d array of data' z = data[0,:] if delaunay == 'yes': print 'delaunay is set' tri = Triangulation(intx,inty) interp = tri.nn_interpolator(z) zi = interp(xi,yi) else: #try griddata method print 'delaunay is off' zi = griddata(intx,inty,z,xi,yi) if animate == 'on': #single plot with a loop to animate p.scatter(intx,inty, alpha=.5,s=.5) print 'animating' for i in range(0, shape(data)[0]): dataslice=data[i,:]; z = dataslice if delaunay == 'yes': interp = tri.nn_interpolator(z) zi = interp(xi,yi) else: zi = griddata(intx,inty,z,xi,yi) zim = ma.masked_where(isnan(zi),zi) p.contourf(xi,yi,zim,cmap=p.cm.jet, alpha=.8) if labels != None: printlabels(chanlocs, labels) p.draw() if subplot == 'on': print 'suplotting' for i in range(0, shape(data)[0]): spnum = ceil(sqrt(shape(data)[0])) #get x and y dimension of subplots #self.p = f.add_subplot(spnum,spnum,i+1) self.p = self.f.add_subplot(spnum,spnum,i+1);#axis('off') dataslice=data[i,:]; self.p.scatter(intx,inty, alpha=.75,s=3) z = dataslice if delaunay == 'yes': interp = tri.nn_interpolator(z) zi = interp(xi,yi) else: zi = griddata(intx,inty,z,xi,yi) zim = ma.masked_where(isnan(zi),zi) self.p.contourf(xi,yi,zim,cmap=cm.jet, alpha=.8) self.p.axis('off') if labels != None: printlabels(chanlocs, labels) if title != None: self.p.title(str(title[i])) else: pass #self.p.title(str(i)) if quiver == 'on': print 'suplotting quiver' for i in range(0, shape(data)[0]): spnum = ceil(sqrt(shape(data)[0])) #get x and y dimension of subplots fig.add_subplot(spnum,spnum,i+1);#axis('off') dataslice=data[i,:]; p.scatter(intx,inty, alpha=.75,s=3) z = dataslice print 'size or z', size(z) for xx in range(0,size(z)): quiver(intx[xx],inty[xx], z[xx], data2[xx]) p.axis('off') if labels != None: printlabels(chanlocs, labels) if colorbar == 'on': p.colorbar() else: z = data if delaunay == 'yes': print 'delaunay is set' tri = Triangulation(intx,inty) interp = tri.nn_interpolator(z) zi = interp(xi,yi) else: print 'delaunay is off' zi = griddata(intx,inty,z,xi,yi) zim = ma.masked_where(isnan(zi),zi) self.plot_data(xi,yi,zi,intx,inty) if labels != None: printlabels(chanlocs, labels) if colorbar == 'on': p.colorbar(cm) self.canvas.draw()
class XratersWindow(gtk.Window): __gtype_name__ = "XratersWindow" def __init__(self): """__init__ - This function is typically not called directly. Creation a XratersWindow requires redeading the associated ui file and parsing the ui definition extrenally, and then calling XratersWindow.finish_initializing(). Use the convenience function NewXratersWindow to create XratersWindow object. """ self._acc_cal = ((128, 128, 128), (255, 255, 255)) self._acc = [0, 0, 0] self._connected = False self._wiiMote = None self._resetData() self._dataLock = threading.Lock() isConnected = property(lambda self: self._connected) def callback(funct): """A decorator used to require connection to the Wii Remote This decorator is used to implement the precondition that the Wii Remote must be connected. """ def _callback(cls, *args, **kwds): if cls.isConnected: funct(cls, *args, **kwds) return True else: return False return _callback def _connectCallback(self, connectionMaker): """Callback function called upon successful connection to the Wiimote """ if connectionMaker.connected: self._connected = True self._wiiMote = connectionMaker.wiiMote self._resetData() gobject.timeout_add(45, self._drawAcc) self.widget('actionDisconnect').set_sensitive(True) self.widget('actionSave').set_sensitive(True) self.widget('actionReset').set_sensitive(True) self.widget('actionPause').set_sensitive(True) self.widget('toolbutton1').set_related_action( self.widget('actionDisconnect')) self._acc_cal = connectionMaker.acc_cal self._wiiMote.mesg_callback = self._getAcc self._updBatteryLevel() gobject.timeout_add_seconds(60, self._updBatteryLevel) else: self.widget('actionWiiConnect').set_sensitive(True) @callback def _upd_background(self, event): """Keep a copy of the figure background """ self.__background = self._accCanvas.copy_from_bbox(self._accAxis.bbox) def _getAcc(self, messages, theTime=0): """Process acceleration messages from the Wiimote This function is intended to be set as cwiid.mesg_callback """ if self._Paused: return for msg in messages: if msg[0] == cwiid.MESG_ACC: # Normalize data using calibration info for i, axisAcc in enumerate(msg[1]): self._acc[i] = float(axisAcc - self._acc_cal[0][i]) self._acc[i] /=(self._acc_cal[1][i]\ -self._acc_cal[0][i]) with self._dataLock: # Store time and acceleration in the respective arrays self._time.append(theTime - self._startTime) [self._accData[i].append(self._acc[i]) for i in threeAxes] # We only keep about 6 seconds worth of data if (self._time[-1] - self._time[0] > 6): with self._dataLock: self._time.pop(0) [self._accData[i].pop(0) for i in threeAxes] @callback def _drawAcc(self): """Update the acceleration graph """ # Do nothing while paused or there's no data available if self._Paused or len(self._time) == 0: return draw_flag = False # Update axes limits if the data fall out of range lims = self._accAxis.get_xlim() if self._time[-1] > lims[1]: self._accAxis.set_xlim(lims[0], lims[1] + 2) lims = self._accAxis.get_xlim() draw_flag = True if (self._time[-1] - lims[0] > 6): self._accAxis.set_xlim(lims[0] + 2, lims[1]) draw_flag = True if draw_flag: gobject.idle_add(self._accCanvas.draw) # Do the actual update of the background if self.__background != None: self._accCanvas.restore_region(self.__background) # Do the actual update of the lines with self._dataLock: [ self._lines[i].set_data(self._time, self._accData[i]) for i in threeAxes ] [self._accAxis.draw_artist(self._lines[i]) for i in threeAxes] self._accCanvas.blit(self._accAxis.bbox) @callback def _updBatteryLevel(self): """Callback to update the battery indicator in the status bar """ self._wiiMote.request_status() self._setBatteryIndicator( float(self._wiiMote.state['battery']) / cwiid.BATTERY_MAX) def _setBatteryIndicator(self, level): """Actually update the battery indicator in the status bar """ progressBar = self.widget("progressbarBattery") progressBar.set_fraction(level) progressBar.set_text("Battery: %.0f%%" % (level * 100)) def _resetData(self): """Reset stored data and status flags to their defaults """ self._accData = [list(), list(), list()] self._time = list() self._startTime = time.time() self._moveTime = self._startTime self._Paused = False def widget(self, name): """Helper function to retrieve widget handlers """ return self.builder.get_object(name) def finish_initializing(self, builder): """finish_initalizing should be called after parsing the ui definition and creating a XratersWindow object with it in order to finish initializing the start of the new XratersWindow instance. """ #get a reference to the builder and set up the signals self.builder = builder self.builder.connect_signals(self) #uncomment the following code to read in preferences at start up dlg = PreferencesXratersDialog.NewPreferencesXratersDialog() self.preferences = dlg.get_preferences() #code for other initialization actions should be added here self._accFigure = Figure(figsize=(8, 6), dpi=72) self._accAxis = self._accFigure.add_subplot(111) self._accAxis.set_xlabel("time (s)") self._accAxis.set_ylabel("acceleration (g)") self._lines = self._accAxis.plot(self._time, self._accData[X], self._time, self._accData[Y], self._time, self._accData[Z], animated=True) self._accFigure.legend(self._lines, ("X", "Y", "Z"), 'upper center', ncol=3) self._accAxis.set_xlim(0, 2) self._accAxis.set_ylim(-3, 3) self._accCanvas = FigureCanvas(self._accFigure) self._accCanvas.mpl_connect("draw_event", self._upd_background) self.__background = self._accCanvas.copy_from_bbox(self._accAxis.bbox) self._accCanvas.show() self._accCanvas.set_size_request(600, 400) vbMain = self.widget("vboxMain") vbMain.pack_start(self._accCanvas, True, True) vbMain.show() vbMain.reorder_child(self._accCanvas, 2) self._setBatteryIndicator(0) def about(self, widget, data=None): """about - display the about box for xraters """ about = AboutXratersDialog.NewAboutXratersDialog() response = about.run() about.destroy() def preferences(self, widget, data=None): """preferences - display the preferences window for xraters """ prefs = PreferencesXratersDialog.NewPreferencesXratersDialog() response = prefs.run() if response == gtk.RESPONSE_OK: #make any updates based on changed preferences here self.preferences = prefs.get_preferences() prefs.destroy() def quit(self, widget, data=None): """quit - signal handler for closing the XratersWindow""" self.destroy() def on_destroy(self, widget, data=None): """on_destroy - called when the XratersWindow is close. """ #clean up code for saving application state should be added here if self.isConnected: self.on_wiiDisconnect(widget, data) gtk.main_quit() def on_wiiConnect(self, widget, data=None): """Signal handler for the WiiConnect action """ self.widget('actionWiiConnect').set_sensitive(False) connectionMaker = WiiConnectionMaker(self.preferences['wiiAddress'], self.widget("statusbar"), self._connectCallback) self._accAxis.set_xlim(0, 2) gobject.idle_add(self._accCanvas.draw) connectionMaker.start() def on_wiiDisconnect(self, widget, data=None): """Signal handler for the WiiDisconnect action """ self._wiiMote.close() self._connected = False self.widget('actionDisconnect').set_sensitive(False) self.widget('actionWiiConnect').set_sensitive(True) self.widget('actionReset').set_sensitive(False) self.widget('actionPause').set_sensitive(False) self.widget('toolbutton1').set_related_action( self.widget('actionWiiConnect')) self.widget('actionSave').set_sensitive(True) self.widget('statusbar').pop( self.widget("statusbar").get_context_id('')) self._setBatteryIndicator(0) def on_Reset(self, widget, data=None): """Signal handler for the reset action """ self._resetData() self._accAxis.set_xlim(0, 2) gobject.idle_add(self._accCanvas.draw) def on_Pause(self, widge, data=None): """Signal handler for the pause action """ if not self._Paused: self.widget('actionPause').set_short_label("Un_pause") else: self.widget('actionPause').set_short_label("_Pause") self._Paused = not (self._Paused) def save(self, widget, data=None): """Signal handler for the save action """ fileName = os.sep.join([ self.preferences['outputDir'], "acceleration_" + time.strftime("%Y-%m-%d_%H-%M-%S") + ".dat" ]) try: with open(fileName, 'wb') as outFile: writer = csv.writer(outFile, 'excel-tab') outFile.write( writer.dialect.delimiter.join(("#time", "Ax", "Ay", "Az"))) outFile.write(writer.dialect.lineterminator) outFile.write( writer.dialect.delimiter.join(("#s", "g", "g", "g"))) outFile.write(writer.dialect.lineterminator) with self._dataLock: writer.writerows(zip(self._time, *self._accData)) except IOError as error: dialog = gtk.MessageDialog(parent=None, flags=gtk.DIALOG_DESTROY_WITH_PARENT, type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_OK, message_format=str(error)) dialog.set_title(error[1]) dialog.connect('response', lambda dialog, response: dialog.destroy()) dialog.show()
class Plotter(): def __init__(self, context, f_function, g_function): self.context = context self.f_function = f_function self.g_function = g_function self.fig = Figure(figsize=(6, 4)) # create fig self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(600, 600) # set min size self.markers = [ '.', ',', '+', 'x', '|', '_', 'o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd' ] self.colors = [ 'black', 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'purple', 'white' ] self.pstyle = [ 'bmh', 's', '6', 'red', '0.8', 'black', '2', 'black', '0.3', '', '25', '', '', '20', '15', '', '', '20', '15' ] self.styledict = {} self.styledict["style"] = 'bmh' self.styledict["point_style"] = 's' self.styledict["point_size"] = '6' self.styledict["point_color"] = 'red' self.styledict["point_alpha"] = '0.8' self.styledict["line_color"] = 'black' self.styledict["line_width"] = '2' self.styledict["band_color"] = 'black' self.styledict["band_alpha"] = '0.3' self.styledict["title_size"] = '8' self.styledict["xtitle_size"] = '8' self.styledict["xlabel_size"] = '8' self.styledict["ytitle_size"] = '8' self.styledict["ylabel_size"] = '8' self.nselec = [1, 12, 5, 3, -1, 0, -1, 0, -1, -1, -1, -1, -1, -1] self.plot_labels = ["", "x", "f(x)", "", "g(x)"] self.points_toggle = 1 self.function_toggle = 1 self.err_toggle = 1 self.ci_func_toggle = 1 self.ci_points_toggle = 1 toolbar = NavigationToolbar(self.canvas, self) toolbarbox = gtk.HBox() image = gtk.Image() image.set_from_stock(gtk.STOCK_PROPERTIES, gtk.ICON_SIZE_LARGE_TOOLBAR) options_button = gtk.Button() options_button.add(image) image2 = gtk.Image() image2.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_LARGE_TOOLBAR) refresh_button = gtk.Button() refresh_button.add(image2) toolbarbox.pack_start(toolbar, True, True) toolbarbox.pack_end(options_button, False, True) toolbarbox.pack_end(refresh_button, False, True) self.vbox = gtk.VBox() self.vbox.pack_start(toolbarbox, False, False) self.vbox.pack_start(self.canvas, True, True) self.x1 = -0.1 self.x2 = 20.1 # signals options_button.connect('clicked', self.mpl_options) refresh_button.connect('clicked', self.on_refresh_clicked) def mpl_options(self, button): """Create GTKDialog containing options for plotting and connect signals.""" mpl_options_dialog = MPLOptions(self.context, self) def on_refresh_clicked(self, button): """Refresh canvas - plot everything again""" self.plotting() def plotvline(self, **kwargs): self.ax1.axvline(**kwargs) def plothline(self, **kwargs): self.ax1.axhline(**kwargs) def replot(self): self.canvas.draw() def plotting(self): """Generating matplotlib canvas""" plt.style.use(self.pstyle[0]) self.ax1 = self.fig.add_subplot(311) self.ax1.clear() self.ax1.set_title("f(x) and g(x)", fontsize=self.pstyle[10]) self.ax1.set_xlabel("", fontsize=int(self.pstyle[13])) self.ax1.set_ylabel("", fontsize=int(self.pstyle[17])) self.ax1.tick_params(axis='x', which='both', labelsize=int(self.pstyle[14])) self.ax1.tick_params(axis='y', which='both', labelsize=int(self.pstyle[18])) x = np.arange(self.x1, self.x2, 0.05) y = self.f_function.func(x) self.ax1.plot(x, y, color=self.pstyle[5], marker='.', linestyle='None', markersize=float(self.pstyle[6])) upper = self.f_function.func(x) + self.f_function.confidence_points(x) lower = self.f_function.func(x) - self.f_function.confidence_points(x) self.ax1.fill_between(x, lower, upper, facecolor='blue', alpha=float(self.pstyle[8])) upper = self.f_function.func(x) + self.f_function.uncertainty(x) lower = self.f_function.func(x) - self.f_function.uncertainty(x) self.ax1.fill_between(x, lower, upper, facecolor='green', alpha=float(self.pstyle[8])) y = self.g_function.func(x) self.ax1.plot(x, y, color=self.pstyle[5], marker='.', linestyle='None', markersize=float(self.pstyle[6])) upper = self.g_function.func(x) + self.g_function.confidence_points(x) lower = self.g_function.func(x) - self.g_function.confidence_points(x) self.ax1.fill_between(x, lower, upper, facecolor='blue', alpha=float(self.pstyle[8])) upper = self.g_function.func(x) + self.g_function.uncertainty(x) lower = self.g_function.func(x) - self.g_function.uncertainty(x) self.ax1.fill_between(x, lower, upper, facecolor='green', alpha=float(self.pstyle[8])) self.ax1.tick_params(axis='x', labelbottom='off') self.ax2 = self.fig.add_subplot(312) self.ax2.clear() self.ax2.set_title(self.plot_labels[0], fontsize=self.pstyle[10]) self.ax2.set_xlabel("", fontsize=int(self.pstyle[13])) self.ax2.set_ylabel(self.plot_labels[2] + ' / ' + self.plot_labels[4], fontsize=int(self.pstyle[17])) self.ax2.tick_params(axis='x', which='both', labelsize=int(self.pstyle[14])) self.ax2.tick_params(axis='y', which='both', labelsize=int(self.pstyle[18])) self.ax2.tick_params(axis='x', labelbottom='off') x = np.arange(self.x1, self.x2, 0.05) ly = [] for i in x: if self.g_function.func(i): ly.append(self.f_function.func(i) / self.g_function.func(i)) else: ly.append(0.) y = array(ly) self.ax2.plot(x, y, color=self.pstyle[5], marker='.', linestyle='None', markersize=float(self.pstyle[6])) self.ax3 = self.fig.add_subplot(313) self.ax3.clear() self.ax3.set_title(self.plot_labels[0], fontsize=self.pstyle[10]) self.ax3.set_xlabel(self.plot_labels[1], fontsize=int(self.pstyle[13])) self.ax3.set_ylabel(self.plot_labels[2] + ' - ' + self.plot_labels[4], fontsize=int(self.pstyle[17])) self.ax3.tick_params(axis='x', which='both', labelsize=int(self.pstyle[14])) self.ax3.tick_params(axis='y', which='both', labelsize=int(self.pstyle[18])) x = np.arange(self.x1, self.x2, 0.05) ly = [] for i in x: ly.append(self.f_function.func(i) - self.g_function.func(i)) y = array(ly) self.ax3.plot(x, y, color=self.pstyle[5], marker='.', linestyle='None', markersize=float(self.pstyle[6])) self.fig.subplots_adjust(left=0.12, right=0.97, top=0.94, bottom=0.11, hspace=0.17) self.canvas.draw()
def get_canvas_widget(self): """ returns a gtk widget including the plot to be directly used """ self.load_plot() canvas = FigureCanvas(self.figure) canvas.set_size_request(365, 250) return canvas
class PyApp(gtk.Window): def __init__(self): super(PyApp, self).__init__() self.reset = 1000 * 60 * 10 self.interval = 30 * 1000 self.n = 0 self.selected = [] self.buyprice = '' self.sellprice = '' self.balance = '' self.connect("destroy", gtk.main_quit) self.set_size_request(690, 600) self.set_position(gtk.WIN_POS_CENTER) self.set_title("Coinbase Trader") self.hfmt = dates.DateFormatter('%b %d') self.fixed = gtk.Fixed() self.btn_buy = gtk.Button("Buy BTC") self.btn_buy.set_size_request(110, 25) self.btn_buy.connect("clicked", self.buy_clicked) self.fixed.put(self.btn_buy, 570, 350) self.btn_buy.set_sensitive(False) self.btn_sell = gtk.Button("Sell BTC") self.btn_sell.set_size_request(110, 25) self.btn_sell.connect("clicked", self.sell_clicked) self.fixed.put(self.btn_sell, 570, 385) self.btn_sell.set_sensitive(False) self.btn_del = gtk.Button("Delete") self.btn_del.set_size_request(110, 25) self.btn_del.connect("clicked", self.del_clicked) self.fixed.put(self.btn_del, 570, 420) self.btn_del.set_sensitive(False) #self.btn_TRY = gtk.Button("TRY") #self.btn_TRY.set_size_request(110,25) #self.btn_TRY.connect("clicked",self.TRY) #self.fixed.put(self.btn_TRY, 570, 490) """self.btn_save.set_sensitive(False)""" self.btn_load = gtk.Button("Begin") self.btn_load.set_size_request(110, 25) self.btn_load.connect("clicked", self.load_clicked) self.fixed.put(self.btn_load, 570, 455) self.label_sell = gtk.Label("Sell: $" + self.sellprice) self.fixed.put(self.label_sell, 570, 490) self.label_buy = gtk.Label("Buy: $" + self.buyprice) self.fixed.put(self.label_buy, 570, 520) self.label_bal = gtk.Label("") #Balance: "+self.balance) self.fixed.put(self.label_bal, 570, 550) self.statusbar = gtk.Label("") #Balance: "+self.balance) self.fixed.put(self.statusbar, 10, 565) #------ self.liststore = gtk.ListStore(bool, str) treeview = gtk.TreeView(model=self.liststore) renderer_radio = gtk.CellRendererToggle() renderer_radio.set_radio(False) renderer_radio.connect("toggled", self.order_selected) column_radio = gtk.TreeViewColumn("", renderer_radio, active=0) treeview.append_column(column_radio) renderer_text = gtk.CellRendererText() column_text = gtk.TreeViewColumn("Orders", renderer_text, text=1) treeview.append_column(column_text) treeview.set_size_request(550, 210) #------ renderer_text.props.ellipsize = 3 renderer_text.props.ellipsize_set = True #wrap_width = 80 self.fixed.put(treeview, 10, 350) self.S = '' self.n = 0 self.API_KEY = '' self.API_SECRET = '' self.pwd = '' self.notAuth = True #self.load_file() #------------------------->COMMENT IT OUT LATER BUTTON WILL COME HERE self.add(self.fixed) self.show_all() self.update_graph() self.check_prices() def order_selected(self, widget, path): self.liststore[path][0] = not self.liststore[path][0] if (self.liststore[path][0]): self.selected.append(path) else: self.selected.remove(path) if (len(self.selected) > 0): self.btn_del.set_sensitive(True) #print(self.selected) def buy_clicked(self, button): z = ["Buy", 1, "BTC", "<", self.buyprice, -1] # Buy/Sell QTY BTC/USD >/< Rate state createOrder.create_order(z) if (z[5] > 0): ordo = z[0] + '\t' + str( z[1]) + ' ' + z[2] + '\tif price ' + z[3] + ' ' + str(z[4]) self.liststore.append([False, ordo]) self.save_clicked() #btn_save.set_sensitive(True) def sell_clicked(self, button): z = ["Sell", 1, "BTC", "<", self.sellprice, -1] # Buy/Sell QTY BTC/USD >/< Rate state createOrder.create_order(z) if (z[5] > 0): ordo = z[0] + '\t' + str( z[1]) + ' ' + z[2] + '\tif price ' + z[3] + ' ' + str(z[4]) self.liststore.append([False, ordo]) self.save_clicked() #btn_save.set_sensitive(True) def del_clicked(self, button): self.selected.sort() self.selected.reverse() for i in self.selected: self.liststore.remove(self.liststore[i].iter) self.selected = [] #.clear() self.btn_del.set_sensitive(False) self.save_clicked() #btn_save.set_sensitive(True) def load_clicked(self, button): if (button.get_label() == "Begin"): try: self.S, self.p, self.API_KEY, self.API_SECRET, self.pwd = algos.begin_auth( ) pp = self.p.split('\n') for tex in pp: if (tex != ''): self.liststore.append([False, tex]) self.btn_buy.set_sensitive(True) self.btn_sell.set_sensitive(True) if (len(self.selected) > 0): self.btn_del.set_sensitive(True) self.btn_load.set_label("New Password") self.notAuth = False self.check_prices() except: print("Couldn't open file") raise return else: pold = algos.getText("", "Current Password") count = 0 while (algos.pad(str(pold)) != self.pwd): pold = algos.getText("Incorrect Password", "Current Password") count = count + 1 if (count == 5): return pwd = algos.getText('Enter new password', 'Password: '******'', 'Re-enter new password') #raw_input("Re-enter passwd: ") count = 0 while (pwd != pwd2): pwd = getText('Password mismatch, please try again', 'Password: '******'', 'Re-enter password') #raw_input("Re-enter passwd: ") count = count + 1 if (count == 5): print("Password not changed") return self.pwd = algos.pad(str(pwd)) #make it 32 chars long self.save_clicked() def save_clicked(self): #,button): self.p = '' for k in self.liststore: self.p = self.p + k[1] + '\n' self.p = self.p[:-1] try: algos.end_auth(self.S, self.p, self.API_KEY, self.API_SECRET, self.pwd) #self.btn_save.set_sensitive(False) except: print("Couldn't save changes") def update_graph(self): self.f = Figure(figsize=(4, 2.5), dpi=100) self.a = self.f.add_subplot(111) self.a.xaxis.set_major_formatter(self.hfmt) x, y = algos.update_mkt() self.a.plot(x, y) self.a.yaxis.grid() for item in ([self.a.title, self.a.xaxis.label, self.a.yaxis.label] + self.a.get_xticklabels() + self.a.get_yticklabels()): item.set_fontsize(10) self.canvas = FigureCanvas(self.f) # a gtk.DrawingArea self.canvas.set_size_request(670, 330) self.fixed.put(self.canvas, 10, 10) self.show_all() return True def check_prices(self): s = algos.get_http("http://coinbase.com/api/v1/prices/buy").read() s = s.translate(maketrans(':', ','), '[]{}\"').split(',')[-4:] if (s[3] == 'USD'): self.buyprice = s[1] self.label_buy.set_label("Buy: $" + self.buyprice) s = algos.get_http("http://coinbase.com/api/v1/prices/sell").read() s = s.translate(maketrans(':', ','), '[]{}\"').split(',')[-4:] if (s[3] == 'USD'): self.sellprice = s[1] self.label_sell.set_label("Sell: $" + self.sellprice) if (self.notAuth): return True #We Have an API KEY :) try: s = algos.get_https('https://coinbase.com/api/v1/account/balance', self.API_KEY, self.API_SECRET).read() s = s.translate(maketrans(':', ','), '[]{}\"').split(',') if (s[0] == 'amount' and s[3] == 'BTC'): self.balance = s[1] self.label_bal.set_label("Bal: " + self.balance) else: print("Wrong KEYS") self.notAuth = True except: print("Lost Internet connection perhaps?") for k in self.liststore: s = k[1] #check if this order is satisfied fullfillable = False s = s.split() if (s[0] == "Sell"): price = float(self.sellprice) else: price = float(self.buyprice) if (s[5] == '>' and price > float(s[6])): fullfillable = True if (s[5] == '<' and price < float(s[6])): fullfillable = True qty = float(s[1]) if (s[2] == 'USD'): qty = qty / price if (fullfillable): try: bod = 'qty=' + str(qty) if (s[0] == "Sell"): res = algos.get_https( 'https://coinbase.com/api/v1/sells', self.API_KEY, self.API_SECRET, bod).read() res = res.translate(maketrans(':', ','), '[]{}\"').split(',') s = res[4] + ": Sold " + s[1] + "BTC for " + res[ 20] + " " + res[48] if (s[0] == "Buy"): res = algos.get_https( 'https://coinbase.com/api/v1/buys', self.API_KEY, self.API_SECRET, bod).read() res = res.translate(maketrans(':', ','), '[]{}\"').split(',') s = res[4] + ": Bought " + s[1] + "BTC for " + res[ 20] + " " + res[48] if (res[:2] == ['success', 'true']): self.statusbar.set_label(s) self.liststore.remove(k.iter) self.save_clicked() except: print("failed for some reason") fullfillable = False raise self.selected = [] i = 0 for k in self.liststore: if (k[0]): self.selected.append(str(i)) i = i + 1 #self.clock.set_label('['+str(self.n)+'] '+str(time.strftime("%H:%M:%S"))) self.n = self.n + 1 return True
def compare_states(self, widget): crimes = [ "MURDER", "RAPE", "KIDNAPPING.ABDUCTION", "RIOTS", "ROBBERY", "BURGLARY", "DOWRY.DEATHS" ] intyear = int(self.combobox_yearc.get_active_text()) state1_data = self.data.query( 'STATEorUT == @self.combobox_state1.get_active_text() and YEAR == @intyear' ).filter(items=[ 'STATEorUT', 'DISTRICT', 'YEAR', crimes[0], crimes[1], crimes[2], crimes[3], crimes[4], crimes[5], crimes[6] ])[self.data.DISTRICT == 'TOTAL'] state2_data = self.data.query( 'STATEorUT == @self.combobox_state2.get_active_text() and YEAR == @intyear' ).filter(items=[ 'STATEorUT', 'DISTRICT', 'YEAR', crimes[0], crimes[1], crimes[2], crimes[3], crimes[4], crimes[5], crimes[6] ])[self.data.DISTRICT == 'TOTAL'] print(state1_data.iloc[0]['MURDER']) state1_total = [ state1_data.iloc[0][crimes[0]], state1_data.iloc[0][crimes[1]], state1_data.iloc[0][crimes[2]], state1_data.iloc[0][crimes[3]], state1_data.iloc[0][crimes[4]], state1_data.iloc[0][crimes[5]], state1_data.iloc[0][crimes[6]] ] state2_total = [ state2_data.iloc[0][crimes[0]], state2_data.iloc[0][crimes[1]], state2_data.iloc[0][crimes[2]], state2_data.iloc[0][crimes[3]], state2_data.iloc[0][crimes[4]], state2_data.iloc[0][crimes[5]], state2_data.iloc[0][crimes[6]] ] print(state1_total) dialog = gtk.Dialog("My dialog", self, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) fig = Figure(figsize=(5, 4), dpi=100) dialog.set_size_request(1300, 500) ax = fig.add_subplot(111) ypos = np.arange(len(crimes)) print(ypos) p1 = ax.bar(ypos - 0.4, state1_total, width=0.4, color='r', align='center') p2 = ax.bar(ypos, state2_total, width=0.4, color='b', align='center') ax.set_title("Comparison of " + self.combobox_state1.get_active_text() + " and " + self.combobox_state2.get_active_text()) ax.set_xticks(ypos - 0.2) ax.set_xticklabels(crimes) ax.set_ylabel('Total Crimes') ax.legend((p1[0], p2[0]), (self.combobox_state1.get_active_text(), self.combobox_state2.get_active_text())) canvas = FigureCanvas(fig) # a gtk.DrawingArea canvas.set_size_request(800, 600) dialog.vbox.pack_start(canvas) toolbar = NavigationToolbar(canvas, dialog) dialog.vbox.pack_start(toolbar, False, False) canvas.show() dialog.run() dialog.destroy() return
def display_graph(self, widget): dialog = gtk.Dialog("My dialog", self, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) dialog.set_size_request(1300, 500) # Crime name filter if " " not in self.combobox_crime.get_active_text(): crime = self.combobox_crime.get_active_text() else: crime = ".".join(self.combobox_crime.get_active_text().split(" ")) fig = Figure(figsize=(12, 10), dpi=100) sales = [{ 'Groups': '0-9', 'Counts': 38 }, { 'Groups': '10-19', 'Counts': 41 }, { 'Groups': '20-29', 'Counts': 77 }, { 'Groups': '30-39', 'Counts': 73 }, { 'Groups': '40-49', 'Counts': 77 }] df = pd.DataFrame(sales) ax = fig.add_subplot(111) if (self.combobox_year.get_active_text() == "All" and self.combobox_district.get_active_text() != "All"): self.filtered_data = self.filtered_data.reset_index(drop=True) ypos = np.arange(len(self.filtered_data['YEAR'].tolist())) p1 = ax.bar(ypos, self.filtered_data[crime], width=0.6, color='r') ax.set_title(crime.lower() + 's in ' + self.combobox_district.get_active_text() + ' - Yearwise') ax.set_xticks(ypos + 0.3) ax.set_xticklabels(self.filtered_data.YEAR) elif (self.combobox_district.get_active_text() == "All" and self.combobox_year.get_active_text() != "All"): fd_total_removed = self.filtered_data[ self.filtered_data.DISTRICT != 'TOTAL'] ypos = np.arange(len(fd_total_removed['DISTRICT'].tolist())) p1 = ax.bar(ypos, fd_total_removed[crime], width=0.3, color='r') fontx = { 'fontsize': 7, 'fontweight': 2, 'verticalalignment': 'center', 'horizontalalignment': 'center' } ax.set_title(crime + 's in ' + self.combobox_state.get_active_text() + '(' + self.combobox_state.get_active_text() + ' )' + ' - Districtwise') ax.set_xticks(ypos + 0.15) ax.set_xticklabels(fd_total_removed.DISTRICT, fontdict=fontx) else: print(df.index) p1 = ax.bar(df.index, df.Counts, width=0.8, color='r') ax.set_title('Scores by group and gender') ax.set_xticks(df.index + 0.4) ax.set_xticklabels(df.Groups) canvas = FigureCanvas(fig) # a gtk.DrawingArea canvas.set_size_request(800, 600) dialog.vbox.pack_start(canvas) toolbar = NavigationToolbar(canvas, dialog) dialog.vbox.pack_start(toolbar, False, False) canvas.show() dialog.run() dialog.destroy() return
class PlotViewer(gtk.VBox): def __init__ (self, plotters, fields): gtk.VBox.__init__ (self) self.figure = mpl.figure.Figure () self.canvas = FigureCanvas (self.figure) self.canvas.unset_flags (gtk.CAN_FOCUS) self.canvas.set_size_request (600, 400) self.pack_start (self.canvas, True, True) self.canvas.show () self.navToolbar = NavigationToolbar (self.canvas, self.window) #self.navToolbar.lastDir = '/tmp' self.pack_start (self.navToolbar, False, False) self.navToolbar.show () self.checkboxes = gtk.HBox (len (plotters)) self.pack_start (self.checkboxes, False, False) self.checkboxes.show () self.pol = (1+0j, 0j) self.pol2 = None self.handlers = [] i = 0 self.plots = [] for plotterClass, default in plotters: axes = self.figure.add_subplot (len (plotters), 1, i) def makeUpdateInfo (i): return lambda s: self.__updateInfo (i, s) def makeUpdatePos (i): return lambda s: self.__updatePos (i, s) plotter = plotterClass (axes, fields, makeUpdateInfo (i), makeUpdatePos (i)) d = PlottedData (axes, plotter, default, self.__updateChildren) self.checkboxes.pack_start (d.checkBox, False, False) self.plots.append (d) i += 1 self.__infos = [None] * len (self.plots) self.__posi = None self.legendBox = gtk.CheckButton ("Show legend") self.legendBox.set_active (True) self.legendBox.connect ("toggled", self.__on_legend_toggled) self.checkboxes.pack_start (self.legendBox, False, False) self.legendBox.show () self.__updateChildren () def __on_legend_toggled (self, button): for pd in self.plots: pd.plotter.setLegend (button.get_active ()) def __updateChildren (self): count = 0 for axes in self.figure.get_axes (): visible = axes.get_visible () if axes.get_visible (): count += 1 if count == 0: count = 1 nr = 1 for axes in self.figure.get_axes (): axes.change_geometry (count, 1, nr) if axes.get_visible (): if nr < count: nr += 1 else: axes.set_position ((0, 0, 1e-10, 1e-10)) # Hack to prevent the invisible axes from getting mouse events self.figure.canvas.draw () self.__updateGraph () def __updateGraph (self): for pd in self.plots: if pd.axes.get_visible (): #start = time () pd.plotter.plot (self.pol, self.pol2) #print "Plot ", pd.plotter.description, " needed ", time () - start def __updateInfo (self, i, arg): #print i, arg self.__infos[i] = arg s = '' for info in self.__infos: if info is not None: if s != '': s += ' ' s += info for handler in self.handlers: handler (s) def __updatePos (self, i, arg): if arg == None and self.__posi != i: return self.__posi = i j = 0 for pd in self.plots: if i != j: pd.plotter.updateCPos (arg) j += 1 def onUpdateInfo (self, handler): self.handlers.append (handler) def setPol (self, value): oldValue = self.pol self.pol = value if value != oldValue: self.__updateGraph () def setPol2 (self, value): oldValue = self.pol2 self.pol2 = value if value != oldValue: self.__updateGraph ()
class G_Plot(): def __init__(self, title, function): self.title = title # MAT-PLOT-LIB_____________________________________________________ self.fig = Figure(figsize=(6, 4)) # create fig self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(400, 300) # set min size self.markers = [ '.', ',', '+', 'x', '|', '_', 'o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd' ] self.colors = [ 'black', 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'purple', 'white' ] self.pstyle = [ 'bmh', 's', '6', 'red', '0.8', 'black', '2', 'black', '0.3', '', '25', '', '', '20', '15', '', '', '20', '15' ] self.styledict = {} self.styledict["style"] = 'bmh' self.styledict["point_style"] = 's' self.styledict["point_size"] = '6' self.styledict["point_color"] = 'red' self.styledict["point_alpha"] = '0.8' self.styledict["line_color"] = 'black' self.styledict["line_width"] = '2' self.styledict["band_color"] = 'black' self.styledict["band_alpha"] = '0.3' self.styledict["title_size"] = '25' self.styledict["xtitle_size"] = '20' self.styledict["xlabel_size"] = '15' self.styledict["ytitle_size"] = '20' self.styledict["ylabel_size"] = '15' self.function = function self.nselec = [1, 12, 5, 3, -1, 0, -1, 0, -1, -1, -1, -1, -1, -1] self.plot_labels = ["Time Exposure", "t", "G(x)", " [h]", " []"] #print plt.style.available self.fit_toggle = 'inactive' self.points_toggle = 1 self.function_toggle = 1 self.err_toggle = 1 self.ci_func_toggle = 1 self.ci_points_toggle = 1 #self.plotting(function) def plotting(self, t, t0): """Generating matplotlib canvas""" plt.style.use(self.pstyle[0]) self.ax1 = self.fig.add_subplot(111) self.ax1.clear() self.ax1.set_title(self.plot_labels[0], fontsize=self.pstyle[10]) self.ax1.set_xlabel(self.plot_labels[1] + self.plot_labels[3], fontsize=int(self.pstyle[13])) self.ax1.set_ylabel(self.plot_labels[2] + self.plot_labels[4], fontsize=int(self.pstyle[17])) self.ax1.tick_params(axis='x', which='both', labelsize=int(self.pstyle[14])) self.ax1.tick_params(axis='y', which='both', labelsize=int(self.pstyle[18])) x = np.arange(0.000001, 1.5 * max(t, t0), 0.01) y = self.function(x, t0) self.ax1.plot(x, y, color=self.pstyle[5], marker='.', linestyle='None', markersize=float(self.pstyle[6])) self.ax1.axvline(x=t, linewidth=1, linestyle='-', color='red') self.ax1.axhline(y=self.function(t, t0), linewidth=1, linestyle='--', color='red') self.fig.tight_layout() self.canvas.draw()
# uncomment to select /GTK/GTKAgg/GTKCairo #from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas #from matplotlib.backends.backend_gtkcairo import FigureCanvasGTKCairo as FigureCanvas win = gtk.Window() win.connect("destroy", lambda x: gtk.main_quit()) win.set_default_size(400, 300) win.set_title("Embedding in GTK") f = Figure(figsize=(5, 4), dpi=100) a = f.add_subplot(111) t = arange(0.0, 3.0, 0.01) s = sin(2 * pi * t) a.plot(t, s) sw = gtk.ScrolledWindow() win.add(sw) # A scrolled window border goes outside the scrollbars and viewport sw.set_border_width(10) # policy: ALWAYS, AUTOMATIC, NEVER sw.set_policy(hscrollbar_policy=gtk.POLICY_AUTOMATIC, vscrollbar_policy=gtk.POLICY_ALWAYS) canvas = FigureCanvas(f) # a gtk.DrawingArea canvas.set_size_request(800, 600) sw.add_with_viewport(canvas) win.show_all() gtk.main()
class GUI(gtk.Window): def __init__(self): gtk.Window.__init__(self) self.connect("destroy", self.onClose) # GUI layout initialization self.initLayout() # center it on the screen self.set_position(gtk.WIN_POS_CENTER) # show the form self.show_all() def initLayout(self): # initialization self.set_title("Data Acquisition") self.set_border_width(10) # add snapshot reading outputs, a tree on the left and a plot on the right self.liststore = gtk.ListStore(str, float, float, str) # create the TreeView using liststore self.treeview = gtk.TreeView(self.liststore) # setup a row in the liststore for each channel for ch in channels.Channels: self.liststore.append([ch.name, float('nan'), float('nan'), ch.units]) # create a channel name column self.tvcolumn = gtk.TreeViewColumn('Channel Name') self.cell = gtk.CellRendererText() self.tvcolumn.pack_start(self.cell, True) self.tvcolumn.set_attributes(self.cell, text=0) # create a channel bits column self.tvcolumn1 = gtk.TreeViewColumn('Digital Bits') self.cell1 = gtk.CellRendererText() self.tvcolumn1.pack_start(self.cell1, True) self.tvcolumn1.set_attributes(self.cell1, text=1) # create a channel analog voltage column self.tvcolumn2 = gtk.TreeViewColumn('Analog Voltage') self.cell2 = gtk.CellRendererText() self.tvcolumn2.pack_start(self.cell2, True) self.tvcolumn2.set_attributes(self.cell2, text=2) # create a channel analog voltage column self.tvcolumn3 = gtk.TreeViewColumn('Value [units]') self.cell3 = gtk.CellRendererText() self.tvcolumn3.pack_start(self.cell3, True) self.tvcolumn3.set_attributes(self.cell3, text=3) # add columns to treeview self.treeview.append_column(self.tvcolumn) self.treeview.append_column(self.tvcolumn1) self.treeview.append_column(self.tvcolumn2) self.treeview.append_column(self.tvcolumn3) # create the plot and add it also self.plt = matplotlib.pyplot self.fig = self.plt.figure() self.ax = self.fig.add_subplot(1,1,1) self.canvas = Canvas(self.fig) self.ax.xaxis.grid(True) self.ax.yaxis.grid(True) self.ax.plot([0],[0]) self.canvas.set_size_request(600,400) # create the hbox to hold this tree and the snapshot plot hbox_plot = gtk.HBox(spacing=6) hbox_plot.pack_start(self.treeview) hbox_plot.pack_start(self.canvas) # form buttons self.btnEditInfo = gtk.Button(label = "Edit Info") self.btnEditInfo.connect("clicked", self.onEdit) self.btnRunTest = gtk.Button(label = "Start (test)") self.btnRunTest.connect("clicked", self.onRunTest) self.btnRun = gtk.Button(label = "Start (write data)") self.btnRun.connect("clicked", self.onRun) self.btnStop = gtk.Button(label = "Stop") self.btnStop.connect("clicked", self.onStop) self.btnStop.set_sensitive(False) self.btnClose = gtk.Button(stock = gtk.STOCK_CLOSE) self.btnClose.connect("clicked", self.onClose) hbox_btns = gtk.HBox(spacing=6) hbox_btns.pack_start(self.btnEditInfo) hbox_btns.pack_start(self.btnRunTest) hbox_btns.pack_start(self.btnRun) hbox_btns.pack_start(self.btnStop) hbox_btns.pack_start(self.btnClose) # status bar self.sbar = gtk.Statusbar() self.context_id = self.sbar.get_context_id("Statusbar") self.sbar.push(self.context_id, "Program has been initialized!") self.sbar.show() hbox_status = gtk.HBox(spacing=6) hbox_status.pack_start(self.sbar) # vbox to hold everything vbox = gtk.VBox(spacing=6) vbox.pack_start(hbox_plot, False, False, 0) vbox.pack_start(hbox_btns, False, False, 0) vbox.pack_start(hbox_status) # store master container in the window self.add(vbox) def startThread(self, writeData = True): # instantiate the main data acquisition class self.DataAcquirer = MainDataLooper(gui.processIsComplete, gui.updateStatus, writeData) # start the data acquisition as a separate (background) thread Thread(target=self.DataAcquirer.run).start() def onRunTest(self, widget): for ch in channels.Channels: self.ax.plot(ch.timeHistory, ch.valueHistory, label=ch.name) self.startThread(writeData = False) self.btnRun.set_sensitive(False) self.btnRunTest.set_sensitive(False) self.btnEditInfo.set_sensitive(False) self.btnStop.set_sensitive(True) def onRun(self, widget): for ch in channels.Channels: self.ax.plot(ch.timeHistory, ch.valueHistory, label=ch.name) self.startThread() self.btnRun.set_sensitive(False) self.btnRunTest.set_sensitive(False) self.btnEditInfo.set_sensitive(False) self.btnStop.set_sensitive(True) def onStop(self, widget): self.DataAcquirer.forceStop = True self.btnRun.set_sensitive(True) self.btnRunTest.set_sensitive(True) self.btnEditInfo.set_sensitive(True) self.btnStop.set_sensitive(False) def onClose(self, widget): if hasattr(self, 'DataAcquirer'): self.DataAcquirer.forceStop = True gtk.main_quit() def onEdit(self, widget): # need to get project inputs first: InputWin = InputWindow() # this will block until the user clicks or destroys the form retVal = InputWin.run() # only continue if we surely got the OK response if retVal == gtk.RESPONSE_OK: # update the info class info.name.set_val(InputWin.entry_name.get_text()) info.location.set_val(InputWin.entry_location.get_text()) info.date.set_val(InputWin.entry_date.get_text()) info.depth.set_val(InputWin.entry_depth.get_text()) info.diameter.set_val(InputWin.entry_diameter.get_text()) info.loop.set_val(InputWin.entry_loop.get_text()) info.grout.set_val(InputWin.entry_grout.get_text()) info.cement.set_val(InputWin.entry_cement.get_text()) info.swl.set_val(InputWin.entry_swl.get_text()) info.tester.set_val(InputWin.entry_tester.get_text()) info.witness.set_val(InputWin.entry_witness.get_text()) # update on the status bar self.sbar.push(self.context_id, "Project information was updated!") # of course we can destroy the window now InputWin.destroy() def updateTree(self): bits = [] for ch in range(len(channels.Channels)): bits.append(channels.Channels[ch].bits) self.liststore[ch][1] = channels.Channels[ch].bits self.liststore[ch][2] = channels.Channels[ch].volts self.liststore[ch][3] = '%s %s' % (channels.Channels[ch].valueHistory[-1], channels.Channels[ch].units) def updatePlot(self): self.ax.clear() for ch in channels.Channels: if ch.plot: self.ax.plot(ch.timeHistory, ch.valueHistory, label=ch.name) self.ax.xaxis.grid(True) self.ax.yaxis.grid(True) self.plt.legend(loc='upper left') self.canvas.draw() def updateStatus(self, msg): self.sbar.push(self.context_id, msg) self.updateTree() self.updatePlot() def processIsComplete(self): self.btnRun.set_sensitive(True) self.btnRunTest.set_sensitive(True) self.btnEditInfo.set_sensitive(True) self.btnStop.set_sensitive(False) # update on the status bar self.sbar.push(self.context_id, "Data Acquisition Process Complete!")
class Plotter(): def __init__(self, context, data, fitfunction): self.context = context self.data = data self.fitfunction = fitfunction self.fig = Figure(figsize=(6, 4)) # create fig self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(600, 400) # set min size self.markers = [ '.', ',', '+', 'x', '|', '_', 'o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd' ] self.colors = [ 'black', 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'purple', 'white' ] self.pstyle = [ 'bmh', 's', '6', 'red', '0.8', 'black', '2', 'black', '0.3', '', '25', '', '', '20', '15', '', '', '20', '15' ] self.styledict = {} self.styledict["style"] = 'bmh' self.styledict["point_style"] = 's' self.styledict["point_size"] = '6' self.styledict["point_color"] = 'red' self.styledict["point_alpha"] = '0.8' self.styledict["line_color"] = 'black' self.styledict["line_width"] = '2' self.styledict["band_color"] = 'black' self.styledict["band_alpha"] = '0.3' self.styledict["title_size"] = '25' self.styledict["xtitle_size"] = '20' self.styledict["xlabel_size"] = '15' self.styledict["ytitle_size"] = '20' self.styledict["ylabel_size"] = '15' self.nselec = [1, 12, 5, 3, -1, 0, -1, 0, -1, -1, -1, -1, -1, -1] self.plot_labels = [] self.plot_labels.append(data.labels[3] + " vs " + data.labels[0]) # plot title self.plot_labels.append(data.labels[0]) # x-axis title self.plot_labels.append(data.labels[3]) # y-axis title self.plot_labels.append("[Gy]") # x-axis unit self.plot_labels.append(" ") # y-axis unit #print plt.style.available self.fit_toggle = 'active' self.points_toggle = 1 self.function_toggle = 1 self.err_toggle = 1 self.ci_func_toggle = 1 self.ci_points_toggle = 1 toolbar = NavigationToolbar(self.canvas, self) toolbarbox = gtk.HBox() image = gtk.Image() image.set_from_stock(gtk.STOCK_PROPERTIES, gtk.ICON_SIZE_LARGE_TOOLBAR) options_button = gtk.Button() options_button.add(image) image2 = gtk.Image() image2.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_LARGE_TOOLBAR) refresh_button = gtk.Button() refresh_button.add(image2) toolbarbox.pack_start(toolbar, True, True) toolbarbox.pack_end(options_button, False, True) toolbarbox.pack_end(refresh_button, False, True) self.vbox = gtk.VBox() self.vbox.pack_start(toolbarbox, False, False) self.vbox.pack_start(self.canvas, True, True) # signals self.canvas.mpl_connect('pick_event', self.on_pick) options_button.connect('clicked', self.mpl_options) refresh_button.connect('clicked', self.on_refresh_clicked) def on_pick(self, event): artist = event.artist xmouse, ymouse = event.mouseevent.xdata, event.mouseevent.ydata x, y = artist.get_xdata(), artist.get_ydata() ind = event.ind print 'Artist picked:', event.artist print '{} vertices picked'.format(len(ind)) print 'Pick between vertices {} and {}'.format(min(ind), max(ind)) print 'x, y of mouse: {:.2f},{:.2f}'.format(xmouse, ymouse) print 'Data point:', x[ind[0]], y[ind[0]] print self.context.log('Data point:\t ' + str(x[ind[0]]) + '\t' + str(y[ind[0]])) self.context.treeview.treeview.set_cursor(min(ind)) self.context.treeview.treeview.grab_focus() def mpl_options(self, button): """Create GTKDialog containing options for plotting and connect signals.""" mpl_options_dialog = MPLOptions(self.context, self) def on_refresh_clicked(self, button): """Refresh canvas - plot everything again""" self.plotting() def plotvline(self, **kwargs): self.ax1.axvline(**kwargs) def plothline(self, **kwargs): self.ax1.axhline(**kwargs) def replot(self): self.canvas.draw() def plotting(self): """Generating matplotlib canvas""" plt.style.use(self.pstyle[0]) self.ax1 = self.fig.add_subplot(111) self.ax1.clear() if self.points_toggle == 1: self.ax1.errorbar(self.data.get_xdata(), self.data.get_ydata(), self.data.get_yerr(), fmt='none', ecolor='black', elinewidth=0.5, capsize=0.5, capthick=0.5) self.ax1.plot(self.data.get_xdata(), self.data.get_ydata(), color=self.pstyle[3], label=self.data.labels[3], marker=self.pstyle[1], alpha=float(self.pstyle[4]), linestyle='None', markersize=float(self.pstyle[2]), picker=float(self.pstyle[2])) self.ax1.set_title(self.plot_labels[0], fontsize=self.pstyle[10]) self.ax1.set_xlabel(self.plot_labels[1] + self.plot_labels[3], fontsize=int(self.pstyle[13])) self.ax1.set_ylabel(self.plot_labels[2] + self.plot_labels[4], fontsize=int(self.pstyle[17])) self.ax1.tick_params(axis='x', which='both', labelsize=int(self.pstyle[14])) self.ax1.tick_params(axis='y', which='both', labelsize=int(self.pstyle[18])) x = np.arange(-0.1, max(20, max(self.data.get_xdata())) * 1.1, 0.05) if (self.fit_toggle == 'active'): if len(self.data.get_xdata()) >= 3: print "before fit", self.fitfunction.params print "before fit", self.fitfunction.params print "xdata", self.data.get_xdata() print "ydata", self.data.get_ydata() self.fitfunction.fit_function(self.data.get_xdata(), self.data.get_ydata(), self.data.get_yerr()) print "after fit", self.fitfunction.params print "after fit", self.fitfunction.params self.context.functiontab.function_changed() else: self.context.log("Too few data to fit the function!") if self.function_toggle == 1: y = self.fitfunction.func(x, self.fitfunction.params) self.ax1.plot(x, y, color=self.pstyle[5], marker='.', linestyle='None', markersize=float(self.pstyle[6])) if self.ci_func_toggle == 1 and self.fit_toggle == 'active': conf = confidence(x, self.data.get_xdata(), len(x), np.mean(self.data.get_xdata()), self.fitfunction.dof, self.fitfunction.rmse) upper = self.fitfunction.func(x, self.fitfunction.params) + conf lower = self.fitfunction.func(x, self.fitfunction.params) - conf self.ax1.fill_between(x, lower, upper, facecolor=self.pstyle[7], alpha=float(self.pstyle[8])) if self.ci_points_toggle == 1: upper = self.fitfunction.func( x, self.fitfunction.params) + confidence_points( x, self.fitfunction.std_err) lower = self.fitfunction.func( x, self.fitfunction.params) - confidence_points( x, self.fitfunction.std_err) self.ax1.fill_between(x, lower, upper, facecolor='blue', alpha=float(self.pstyle[8])) if self.err_toggle == 1: upper = self.fitfunction.func( x, self.fitfunction.params) + uncertainty( x, self.fitfunction.std_err) lower = self.fitfunction.func( x, self.fitfunction.params) - uncertainty( x, self.fitfunction.std_err) self.ax1.fill_between(x, lower, upper, facecolor='green', alpha=float(self.pstyle[8])) self.fig.subplots_adjust(left=0.13, right=0.96, top=0.91, bottom=0.13, hspace=0.04) self.canvas.draw() print self.fitfunction.params print self.fitfunction.std_err
def init(self,index): self.index=index self.fig = Figure(figsize=(5,4), dpi=100) self.ax1=None self.show_key=True self.hbox=gtk.HBox() self.edit_list=[] self.line_number=[] gui_pos=0 self.list=[] self.load_data() self.update_scan_tokens() gui_pos=gui_pos+1 canvas = FigureCanvas(self.fig) # a gtk.DrawingArea #canvas.set_background('white') #canvas.set_facecolor('white') canvas.figure.patch.set_facecolor('white') canvas.set_size_request(500, 150) canvas.show() tooltips = gtk.Tooltips() toolbar = gtk.Toolbar() #toolbar.set_orientation(gtk.ORIENTATION_VERTICAL) toolbar.set_style(gtk.TOOLBAR_ICONS) toolbar.set_size_request(-1, 50) self.store = self.create_model() treeview = gtk.TreeView(self.store) treeview.show() tool_bar_pos=0 save = gtk.ToolButton(gtk.STOCK_SAVE) tooltips.set_tip(save, _("Save image")) save.connect("clicked", self.callback_save) toolbar.insert(save, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 add_section = gtk.ToolButton(gtk.STOCK_ADD) tooltips.set_tip(add_section, _("Add section")) add_section.connect("clicked", self.callback_add_section,treeview) toolbar.insert(add_section, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 add_section = gtk.ToolButton(gtk.STOCK_CLEAR) tooltips.set_tip(add_section, _("Delete section")) add_section.connect("clicked", self.callback_remove_item,treeview) toolbar.insert(add_section, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 move_down = gtk.ToolButton(gtk.STOCK_GO_DOWN) tooltips.set_tip(move_down, _("Move down")) move_down.connect("clicked", self.callback_move_down,treeview) toolbar.insert(move_down, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 image = gtk.Image() image.set_from_file(os.path.join(get_image_file_path(),"start.png")) start = gtk.ToolButton(image) tooltips.set_tip(start, _("Simulation start frequency")) start.connect("clicked", self.callback_start_fx,treeview) toolbar.insert(start, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 plot_toolbar = NavigationToolbar(self.fig.canvas, self) plot_toolbar.show() box=gtk.HBox(True, 1) box.set_size_request(300,-1) box.show() box.pack_start(plot_toolbar, True, True, 0) tb_comboitem = gtk.ToolItem(); tb_comboitem.add(box); tb_comboitem.show() toolbar.insert(tb_comboitem, tool_bar_pos) tool_bar_pos=tool_bar_pos+1 sep = gtk.SeparatorToolItem() sep.set_draw(False) sep.set_expand(True) toolbar.insert(sep, tool_bar_pos) sep.show() tool_bar_pos=tool_bar_pos+1 help = gtk.ToolButton(gtk.STOCK_HELP) toolbar.insert(help, tool_bar_pos) help.connect("clicked", self.callback_help) help.show() tool_bar_pos=tool_bar_pos+1 toolbar.show_all() self.pack_start(toolbar, False, True, 0) self.pack_start(toolbar, True, True, 0) tool_bar_pos=tool_bar_pos+1 canvas.set_size_request(700,400) self.pack_start(canvas, True, True, 0) treeview.set_rules_hint(True) self.create_columns(treeview) self.pack_start(treeview, False, False, 0) self.statusbar = gtk.Statusbar() self.statusbar.show() self.pack_start(self.statusbar, False, False, 0) self.build_mesh() self.draw_graph() self.show()
def __init__(self, contours, neutral, SHOW_LINGUAGRAM, SHOW_NEUTRAL, SHOW_WAVEFORM, SHOW_SPECTROGRAM): '''center points determined by transforming the point (426, 393) several times with peterotron, and taking the average. ''' self.static_dir = os.getcwd() + '/' #self.centerX = 710 #self.centerY = 638 # these come from hand tuning to find the smallest range of y values of polar mags self.centerX = 665 self.centerY = 525 self.gladefile = self.static_dir + "LinguaViewer.glade" self.wTree = gtk.glade.XML(self.gladefile, "window1") self.win = self.wTree.get_widget("window1") self.win.set_title(contours) self.title = contours self.mainVBox = self.wTree.get_widget("vbox1") dic = { "on_window1_destroy": self.onDestroy, "on_tbPlay_clicked" : self.playSound, "on_tbSave_clicked" : self.onSave, "on_tbLabel_clicked": self.onLabel} self.wTree.signal_autoconnect(dic) self.X, self.Y = self.loadContours(contours) self.wavname = contours[:-4] + ".wav" #Linguagram if (SHOW_LINGUAGRAM == True): x1 = array(self.X) y1 = array(self.Y) Z = [] for i in range(len(self.X)): zs = [] for j in range(32): zs.append(i+1) Z.append(zs) z1 = array(Z) self.fig = Figure() canvas = FigureCanvas(self.fig) #ax = Axes3D(self.fig, rect=[-.23,-.2,1.447,1.4]) ax = self.fig.add_subplot(1, 1, 1, projection='3d') self.fig.subplots_adjust(left=-0.23, bottom=0, right=1.215, top=1) ax.mouse_init() surf = ax.plot_surface(z1, -x1, -y1, rstride=1, cstride=1, cmap=cm.jet) ax.view_init(90,-90) canvas.show() canvas.set_size_request(600, 200) self.mainVBox.pack_start(canvas, True, True) #Neutral if (SHOW_NEUTRAL == True): cx, cy = self.getNeutral(neutral) cmags = self.makePolar(cx, cy) M = self.batchConvert2Polar(self.X, self.Y) #D = self.batchGetMinD(M, cmags) fakeX = [] for i in range(len(M)): xs = [] for j in range(1,33): xs.append(j) fakeX.append(xs) x1 = array(fakeX) y1 = array(M) Z = [] for i in range(len(M)): zs = [] for j in range(32): zs.append(i) Z.append(zs) z1 = array(Z) self.fig3 = Figure() canvas3 = FigureCanvas(self.fig3) ax = self.fig3.add_subplot(1, 1, 1, projection='3d') self.fig3.subplots_adjust(left=-0.23, bottom=0, right=1.215, top=1) ax.mouse_init() ax.plot_surface(z1, -x1, y1, rstride=1, cstride=1, cmap=cm.jet) ax.view_init(90,-90) canvas3.show() canvas3.set_size_request(600, 200) self.mainVBox.pack_start(canvas3, True, True) #Waveform windowsize = 0 self.fig2 = Figure() canvas2 = FigureCanvas(self.fig2) if (SHOW_WAVEFORM == True): fs, snd = wavread(self.wavname) chan = snd[:,0] t=array(range(len(chan)))/float(fs); if SHOW_SPECTROGRAM == True: wavax = self.fig2.add_subplot(2, 1, 1) else: wavax = self.fig2.add_subplot(1, 1, 1) wavax.plot(t,chan,'black'); wavax.set_xlim(0,max(t)) windowsize += 200 #Spectrogram if (SHOW_SPECTROGRAM == True): '''This calls Praat to get the spectrogram and adds it to the viewer''' specname = contours[:-4] + '.Spectrogram' cleanname = contours[:-4] + '.clean' cmd = ['/Applications/Praat.app/Contents/MacOS/Praat', self.static_dir + 'makeSpec.praat', self.wavname, specname] proc = subprocess.Popen(cmd) status = proc.wait() cmd2 = ['bash', self.static_dir + 'cleanspec.sh', specname, cleanname] proc2 = subprocess.Popen(cmd2) status2 = proc2.wait() f = open(cleanname, 'r').readlines() last = len(f)-1 x = f[last].split('\t') rows = int(x[0]) cols = int(x[1]) img = zeros((rows, cols)) for i in range(len(f)): x = f[i][:-1].split('\t') img[int(x[0])-1,int(x[1])-1] = float(x[2]) img = log(img) if SHOW_WAVEFORM == True: specax = self.fig2.add_subplot(2, 1, 2) else: specax = self.fig2.add_subplot(1, 1, 1) specax.imshow(img, cmap=cm.gray_r, origin='lower', aspect='auto') windowsize += 200 # show it if (SHOW_WAVEFORM == True) or (SHOW_SPECTROGRAM == True): canvas2.show() canvas2.set_size_request(600, windowsize) self.mainVBox.pack_start(canvas2, True, True) self.SHOW_LINGUAGRAM = SHOW_LINGUAGRAM self.SHOW_NEUTRAL = SHOW_NEUTRAL self.SHOW_WAVEFORM = SHOW_WAVEFORM self.SHOW_SPECTROGRAM = SHOW_SPECTROGRAM self.windowsize = windowsize
def __init__(self, contours, neutral, SHOW_LINGUAGRAM, SHOW_NEUTRAL, SHOW_WAVEFORM, SHOW_SPECTROGRAM): '''center points determined by transforming the point (426, 393) several times with peterotron, and taking the average. ''' self.static_dir = os.getcwd() + '/' #self.centerX = 710 #self.centerY = 638 # these come from hand tuning to find the smallest range of y values of polar mags self.centerX = 665 self.centerY = 525 self.gladefile = self.static_dir + "LinguaViewer.glade" self.wTree = gtk.glade.XML(self.gladefile, "window1") self.win = self.wTree.get_widget("window1") self.win.set_title(contours) self.title = contours self.mainVBox = self.wTree.get_widget("vbox1") dic = { "on_window1_destroy": self.onDestroy, "on_tbPlay_clicked": self.playSound, "on_tbSave_clicked": self.onSave, "on_tbLabel_clicked": self.onLabel } self.wTree.signal_autoconnect(dic) self.X, self.Y = self.loadContours(contours) self.wavname = contours[:-4] + ".wav" #Linguagram if (SHOW_LINGUAGRAM == True): x1 = array(self.X) y1 = array(self.Y) Z = [] for i in range(len(self.X)): zs = [] for j in range(32): zs.append(i + 1) Z.append(zs) z1 = array(Z) self.fig = Figure() canvas = FigureCanvas(self.fig) #ax = Axes3D(self.fig, rect=[-.23,-.2,1.447,1.4]) ax = self.fig.add_subplot(1, 1, 1, projection='3d') self.fig.subplots_adjust(left=-0.23, bottom=0, right=1.215, top=1) ax.mouse_init() surf = ax.plot_surface(z1, -x1, -y1, rstride=1, cstride=1, cmap=cm.jet) ax.view_init(90, -90) canvas.show() canvas.set_size_request(600, 200) self.mainVBox.pack_start(canvas, True, True) #Neutral if (SHOW_NEUTRAL == True): cx, cy = self.getNeutral(neutral) cmags = self.makePolar(cx, cy) M = self.batchConvert2Polar(self.X, self.Y) #D = self.batchGetMinD(M, cmags) fakeX = [] for i in range(len(M)): xs = [] for j in range(1, 33): xs.append(j) fakeX.append(xs) x1 = array(fakeX) y1 = array(M) Z = [] for i in range(len(M)): zs = [] for j in range(32): zs.append(i) Z.append(zs) z1 = array(Z) self.fig3 = Figure() canvas3 = FigureCanvas(self.fig3) ax = self.fig3.add_subplot(1, 1, 1, projection='3d') self.fig3.subplots_adjust(left=-0.23, bottom=0, right=1.215, top=1) ax.mouse_init() ax.plot_surface(z1, -x1, y1, rstride=1, cstride=1, cmap=cm.jet) ax.view_init(90, -90) canvas3.show() canvas3.set_size_request(600, 200) self.mainVBox.pack_start(canvas3, True, True) #Waveform windowsize = 0 self.fig2 = Figure() canvas2 = FigureCanvas(self.fig2) if (SHOW_WAVEFORM == True): fs, snd = wavread(self.wavname) chan = snd[:, 0] t = array(range(len(chan))) / float(fs) if SHOW_SPECTROGRAM == True: wavax = self.fig2.add_subplot(2, 1, 1) else: wavax = self.fig2.add_subplot(1, 1, 1) wavax.plot(t, chan, 'black') wavax.set_xlim(0, max(t)) windowsize += 200 #Spectrogram if (SHOW_SPECTROGRAM == True): '''This calls Praat to get the spectrogram and adds it to the viewer''' specname = contours[:-4] + '.Spectrogram' cleanname = contours[:-4] + '.clean' cmd = [ '/Applications/Praat.app/Contents/MacOS/Praat', self.static_dir + 'makeSpec.praat', self.wavname, specname ] proc = subprocess.Popen(cmd) status = proc.wait() cmd2 = [ 'bash', self.static_dir + 'cleanspec.sh', specname, cleanname ] proc2 = subprocess.Popen(cmd2) status2 = proc2.wait() f = open(cleanname, 'r').readlines() last = len(f) - 1 x = f[last].split('\t') rows = int(x[0]) cols = int(x[1]) img = zeros((rows, cols)) for i in range(len(f)): x = f[i][:-1].split('\t') img[int(x[0]) - 1, int(x[1]) - 1] = float(x[2]) img = log(img) if SHOW_WAVEFORM == True: specax = self.fig2.add_subplot(2, 1, 2) else: specax = self.fig2.add_subplot(1, 1, 1) specax.imshow(img, cmap=cm.gray_r, origin='lower', aspect='auto') windowsize += 200 # show it if (SHOW_WAVEFORM == True) or (SHOW_SPECTROGRAM == True): canvas2.show() canvas2.set_size_request(600, windowsize) self.mainVBox.pack_start(canvas2, True, True) self.SHOW_LINGUAGRAM = SHOW_LINGUAGRAM self.SHOW_NEUTRAL = SHOW_NEUTRAL self.SHOW_WAVEFORM = SHOW_WAVEFORM self.SHOW_SPECTROGRAM = SHOW_SPECTROGRAM self.windowsize = windowsize
class RTP_motor_gui(object): # This is a callback function. The data arguments are ignored # in this example. More on callbacks below. def swept_sine_test(self, widget, data=None): print('in swept_sine_test') self.test.use_accel_fb = False stopn = 20000 amp = 30 maxf = 10 wp = 18.5*2*pi wz = 16.5*2*pi zz = 0.1 zp = 0.5 G_notch = controls.TransferFunction([1,2*wz*zz,wz**2],\ [1,2*wp*zp,wp**2])*(wp**2/wz**2) kwargs = {'amp':amp, 'minf':0.0, 'maxf':maxf, 'plot':False,\ 'stopn':stopn, 'plot':False} #self.test.Swept_Sine(**kwargs) #self.test.Notched_Swept_Sine(G_notch, **kwargs) self.test.Close_Serial() self.P_control_test = SLFR_RTP.P_control_Test(kp=1.0, neg_accel=neg_accel) self.P_control_test.Swept_Sine(**kwargs) self.plot_results(test=self.P_control_test, legloc=3) def plot_results(self, legloc=4, test=None): if test is None: test = self.test self.ax.cla() self.t = test.nvect*self.test.dt ## attrs = ['uvect','vvect','yvect','avect','thd_hatvect'] ## labels = ['u','v','$\\theta$','a','$\\hat{\\theta}_d$'] attrs = ['uvect','yvect'] labels = ['u','$\\theta$'] for attr, label in zip(attrs, labels): if hasattr(test, attr): data = getattr(test, attr) self.ax.plot(self.t, data, label=label) self.ax.legend(loc=legloc) self.ax.set_xlabel('Time (sec.)') self.ax.set_ylabel('Signal Amplitude (counts)') self.f.canvas.draw() def step_test(self, widget, data=None): if self.debug > 0: print('in step_test') #active = self.vib_check.get_active() #toggled = self.vib_check.toggled() self.test.Reset_Theta() time.sleep(0.05) self.test.Step_Response(amp=200, stopn=1000, plot=False)#, **kwargs)#, step_ind=10, \ ## off_ind=100, plot=True, fi=1, clear=True, \ ## legloc=5) self.test.Close_Serial() self.plot_results() def fixed_sine_test(self, widget, data=None): freq_text = self.fs_freq_entry.get_text() freq = float(freq_text) amp_text = self.fs_amp_entry.get_text() amp = int(amp_text) dur_text = self.fs_dur_entry.get_text() dur = int(dur_text) print('freq = %0.4f' % freq) print('amp = %i' % amp) print('dur = %i' % dur) self.test.Reset_Theta() time.sleep(0.05) self.test.Fixed_Sine(freq=freq, amp=amp, stopn=dur, plot=False) self.test.Close_Serial() self.plot_results() def run_ol_test(self, u): self.OL_test = RTP.Motor_OL_Test() self.OL_test.Reset_Theta() self.OL_test.Run_Test(u, plot=False) self.OL_test.Close_Serial() self.plot_results(test=self.OL_test) def system_check(self, widget, data=None): stopn = 1000 u = zeros((stopn), dtype=int64) startind = 50 width = 50 amp = 100 u[startind:startind+width] = amp ind3 = stopn/2+startind ind4 = ind3+width u[ind3:ind4] = -amp u[-5:] = 0 self.run_ol_test(u) def run_ol_step(self, widget, data=None): stopn = int(self.dur_entry.get_text()) u = zeros((stopn), dtype=int64) startind = 50 amp_text = self.ol_amp_entry.get_text() amp = int(amp_text) u[startind:] = amp self.run_ol_test(u) def return_to_zero(self, widget, data=None): self._set_vib_supress() self.test.Step_Response(0, plot=False) self.test.Close_Serial() def reset_theta(self, widget, data=None): self.test.Reset_Theta() self.test.Close_Serial() def delete_event(self, widget, event, data=None): # If you return FALSE in the "delete_event" signal handler, # GTK will emit the "destroy" signal. Returning TRUE means # you don't want the window to be destroyed. # This is useful for popping up 'are you sure you want to quit?' # type dialogs. print "delete event occurred" # Change FALSE to TRUE and the main window will not be destroyed # with a "delete_event". return False def destroy(self, widget, data=None): print "destroy signal occurred" self.test.Close_Serial() gtk.main_quit() def __init__(self): self.debug = 0 self.test = RTP.Motor_PD_Control_Test(kp=2, kd=0.07) # create a new window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) # When the window is given the "delete_event" signal (this is given # by the window manager, usually by the "close" option, or on the # titlebar), we ask it to call the delete_event () function # as defined above. The data passed to the callback # function is NULL and is ignored in the callback function. self.window.connect("delete_event", self.delete_event) # Here we connect the "destroy" event to a signal handler. # This event occurs when we call gtk_widget_destroy() on the window, # or if we return FALSE in the "delete_event" callback. self.window.connect("destroy", self.destroy) # Sets the border width of the window. self.window.set_border_width(10) # Creates a new button with the label "Hello World". self.swept_sine_button = gtk.Button("Swept Sine") self.step_button = gtk.Button("Step Response") self.reset_button = gtk.Button("Reset Theta") self.return_button = gtk.Button("Return to 0") self.sys_check_button = gtk.Button("System Check") self.ol_step_button = gtk.Button("OL Step") #self.vib_check = gtk.CheckButton(label="Use Vibration Suppression", \ # use_underline=False) self.vib_on_radio = gtk.RadioButton(None, "On") self.vib_off_radio = gtk.RadioButton(self.vib_on_radio, "Off") #button.connect("toggled", self.callback, "radio button 2") self.vib_off_radio.set_active(True) vib_label = gtk.Label("Vibration Suppression") ol_label = gtk.Label("OL Step Response") ol_hbox = gtk.HBox(homogeneous=False) amp_label = gtk.Label("amp:") dur_label = gtk.Label("duration:") self.ol_amp_entry = gtk.Entry() self.ol_amp_entry.set_max_length(7) self.ol_amp_entry.set_text("150") Entry_width = 50 self.ol_amp_entry.set_size_request(Entry_width,-1) self.dur_entry = gtk.Entry() self.dur_entry.set_max_length(7) self.dur_entry.set_text("300") self.dur_entry.set_size_request(Entry_width,-1) ol_hbox.pack_end(self.ol_amp_entry, False) ol_hbox.pack_end(amp_label, False) #ol_hbox.pack_start(amp_label, False) #ol_hbox.pack_start(self.ol_amp_entry, False) ol_dur_box = gtk.HBox(homogeneous=False) ol_dur_box.pack_end(self.dur_entry, False) ol_dur_box.pack_end(dur_label, False) #Fixed Sine Controls self.fs_amp_entry = gtk.Entry() self.fs_amp_entry.set_max_length(7) self.fs_amp_entry.set_size_request(Entry_width, -1) self.fs_amp_entry.set_text("5") self.fs_freq_entry = gtk.Entry() self.fs_freq_entry.set_max_length(7) self.fs_freq_entry.set_size_request(Entry_width, -1) self.fs_freq_entry.set_text("0.5") self.fs_dur_entry = gtk.Entry() self.fs_dur_entry.set_max_length(7) self.fs_dur_entry.set_size_request(Entry_width, -1) self.fs_dur_entry.set_text("300") fs_label = gtk.Label('Fixed Sine') fs_amp_label = gtk.Label("amp (counts):") fs_freq_label = gtk.Label("freq (Hz):") fs_dur_label = gtk.Label("duration:") fsvbox = gtk.VBox(homogeneous=False, spacing=5) fsvbox.show() fsvbox.pack_start(fs_label) fshbox1 = gtk.HBox(homogeneous=False) fshbox1.pack_end(self.fs_amp_entry, False) fshbox1.pack_end(fs_amp_label, False) fsvbox.pack_start(fshbox1, False) fshbox2 = gtk.HBox(homogeneous=False) fshbox2.pack_end(self.fs_freq_entry, False) fshbox2.pack_end(fs_freq_label, False) fsvbox.pack_start(fshbox2, False) fshbox3 = gtk.HBox(homogeneous=False) fshbox3.pack_end(self.fs_dur_entry, False) fshbox3.pack_end(fs_dur_label, False) fsvbox.pack_start(fshbox3, False) self.fixed_sine_button = gtk.Button("Fixed Sine") fsvbox.pack_start(self.fixed_sine_button, False) #ol_dur_box.pack_start(dur_label, False) #ol_dur_box.pack_start(self.dur_entry, False) sep0 = gtk.HSeparator() sep1 = gtk.HSeparator() sep2 = gtk.HSeparator() sep3 = gtk.HSeparator() sep4 = gtk.HSeparator() #self.button.set_size_request(30, 40) # When the button receives the "clicked" signal, it will call the # function hello() passing it None as its argument. The hello() # function is defined above. self.swept_sine_button.connect("clicked", self.swept_sine_test, None) self.step_button.connect("clicked", self.step_test, None) self.reset_button.connect("clicked", self.reset_theta, None) self.return_button.connect("clicked", self.return_to_zero, None) self.sys_check_button.connect("clicked", self.system_check, None) self.ol_step_button.connect("clicked", self.run_ol_step, None) self.fixed_sine_button.connect("clicked", self.fixed_sine_test, None) # This will cause the window to be destroyed by calling # gtk_widget_destroy(window) when "clicked". Again, the destroy # signal could come from here, or the window manager. #self.button.connect_object("clicked", gtk.Widget.destroy, self.window) big_hbox = gtk.HBox()#homogeneous=False, spacing=5) button_vbox = gtk.VBox(homogeneous=False, spacing=5) #self.vbox1 = gtk.VBox(homogeneous=False, spacing=0) # This packs the button into the window (a GTK container). #self.window.add(self.button) button_vbox.pack_start(self.sys_check_button, False) button_vbox.pack_start(sep0, False) button_vbox.pack_start(self.swept_sine_button, False, False, 0) button_vbox.pack_start(sep1, False) button_vbox.pack_start(vib_label, False) #button_vbox.pack_start(self.vib_check, False) button_vbox.pack_start(self.vib_on_radio, False) button_vbox.pack_start(self.vib_off_radio, False) button_vbox.pack_start(sep2, False) button_vbox.pack_start(self.step_button, False, False, 0) button_vbox.pack_start(sep3, False) #Fixed Sine Stuff button_vbox.pack_start(fsvbox, False) button_vbox.pack_start(sep4, False) button_vbox.pack_start(ol_label, False) button_vbox.pack_start(ol_hbox, False) button_vbox.pack_start(ol_dur_box, False) button_vbox.pack_start(self.ol_step_button, False) button_vbox.pack_start(self.reset_button, False) button_vbox.pack_start(self.return_button, False) self.f = Figure(figsize=(5,4), dpi=100) self.ax = self.f.add_subplot(111) t = arange(0.0,3.0,0.01) s = sin(2*pi*t) self.ax.plot(t,s) self.figcanvas = FigureCanvas(self.f) # a gtk.DrawingArea self.figcanvas.show() canvas_vbox = gtk.VBox() toolbar = NavigationToolbar(self.figcanvas, self.window) #toolbar.set_size_request(-1,50) self.figcanvas.set_size_request(600,300) toolbar.set_size_request(600,50) toolbar.show() big_hbox.pack_start(button_vbox, False, False, 0) canvas_vbox.pack_start(self.figcanvas)#, expand=True, \ #fill=True, padding=5) canvas_vbox.pack_start(toolbar, False)#, False)#, padding=5) big_hbox.pack_start(canvas_vbox)#, expand=True, \ #fill=True, padding=5) self.window.add(big_hbox) # The final step is to display this newly created widget. #self.button.show() #self.window.set_size_request(1000,800) self.window.set_title('RTP Motor GUI v. 1.0') # and the window #self.window.show() self.window.set_position(gtk.WIN_POS_CENTER) self.window.show_all() def main(self): # All PyGTK applications must have a gtk.main(). Control ends here # and waits for an event to occur (like a key press or mouse event). gtk.main()
class PlotGui(object): def get_bg_bbox(self): return self.ax.bbox.padded(-3) def __init__(self, stats, interface=None, file=None, combine=False): if len(stats) == 1: combine = True self.interface = interface self.file = file self.combine = combine path = os.path.realpath(os.path.dirname(sys.argv[0])) self.builder = gtk.Builder() """ try: self.builder.add_from_file(os.path.join(path,'plot.glade')) except: path = os.path.dirname( os.path.realpath( __file__ ) ) self.builder.add_from_file(os.path.join(path, 'plot.glade')) """ self.builder.add_from_string(resource_string(__name__, 'plot.glade')) self.builder.connect_signals(self) self.ui = self.builder.get_object('ui') self.pbox = self.builder.get_object('pbox') self.nbox = self.builder.get_object('nbox') self.figure = Figure() self.canvas = FigureCanvasGTKAgg(self.figure) self.canvas.set_size_request(600, 400) if combine: self.ax = self.figure.add_subplot(111) self.ax.grid(b=True, which='both') self.stats = {} c = 0 size = 0.2 + 0.025 * (len(stats) - 1) step = (1 - size) / len(stats) for s, sc in stats: self.stats[s] = {} self.stats[s]['scale'] = sc self.stats[s]['x'] = [] self.stats[s]['y'] = [] self.stats[s]['count'] = 0 if not self.combine: if c == 0: ax = self.figure.add_axes([0.1, 0.1, 0.8, step]) self.ax = ax self.ax.grid(b=True, which='both') else: ax = self.figure.add_axes( [0.1, 0.1 + c * (0.025 + step), 0.8, step], sharex=ax) ax.grid(b=True, which='both') setp(ax.get_xticklabels(), visible=False) self.stats[s]['ax'] = ax ax.set_ylabel(s) self.stats[s]['line'], = ax.plot([], [], label=s) #ax.legend() else: self.stats[s]['line'], = self.ax.plot([], [], label=s) c += 1 if self.combine: self.ax.legend(loc=(0., 1.), mode="expand", borderaxespad=0., ncol=len(self.stats)) self.xwidth = 30 self.t0 = -1 self.ax.set_xlim(0, self.xwidth) self.pbox.pack_start(self.canvas, True, True) self.navToolbar = NavigationToolbar(self.canvas, self.ui) self.nbox.pack_start(self.navToolbar) self.nbox.hide() self.canvas.show() self.pbox.show() self.ui.show() if not self.file: self.loop = task.LoopingCall(self.getValues) self.loop.start(1) else: self.nbox.show() self.builder.get_object('pauseButton').set_sensitive(False) self.builder.get_object('saveButton').set_sensitive(False) self.readFiles() def on_pauseButton_clicked(self, widget): if widget.get_label() == 'Pause': widget.set_label('Resume') self.nbox.show() self.loop.stop() self.update(True) else: widget.set_label('Pause') self.nbox.hide() self.loop.start(1) def on_closeButton_clicked(self, widget): try: self.loop.stop() except: pass self.ui.destroy() def on_ui_destroy(self, widget=None, data=None): try: self.loop.stop() except: pass def update(self, static=False): try: tlast = max([s['x'][-1] for s in self.stats.values()]) except: return if not static: t0 = tlast - self.xwidth if t0 < 0: t0 = 0 else: t0 = 0 for s in self.stats: st = self.stats[s] i = bisect(st['x'], t0) if i > 0: i = i - 1 toleft = st['x'][i] st['newx'] = st['x'][i:] st['newy'] = st['y'][i:] try: st['maxy'] = max(st['newy'][1:]) except: st['maxy'] = max(st['newy']) if not self.combine: limnow = st['ax'].get_ylim()[1] if abs(st['maxy'] - limnow) > st['maxy'] / 2 or st['maxy'] > limnow: st['ax'].set_ylim(-0.1, st['maxy'] * 1.2) self.ax.set_xlim(t0, tlast) if self.combine: ylim = max([s['maxy'] for s in self.stats.values()]) limnow = self.ax.get_ylim()[1] if abs(ylim - limnow) > ylim / 2 or ylim > limnow: self.ax.set_ylim(-0.1, ylim * 1.2) for s in self.stats.values(): s['line'].set_data(s['newx'], s['newy']) self.ax.figure.canvas.draw_idle() def getValues(self): self.interface.getStatValues(self.getStatValues, [(k, v['count']) for k, v in self.stats.items()]) def getStatValues(self, stats): update = False if self.t0 < 0: m = [v[1][0][1] for v in stats if v[1]] if m: self.t0 = min(m) for s, v, c in stats: #for b,t in v: # print b,t if not len(v): break st = self.stats[s] update = True x = [x[1] - self.t0 for x in v] y = [y[0] * st['scale'] for y in v] st['x'] = st['x'] + x st['y'] = st['y'] + y st['count'] = c if update: self.update() def on_saveButton_clicked(self, widget): if self.loop.running: self.on_pauseButton_clicked(self.builder.get_object('pauseButton')) self.builder.get_object('buttonBox').set_visible(False) self.builder.get_object('saveBox').set_visible(True) def on_cButton_clicked(self, widget=None): self.builder.get_object('buttonBox').set_visible(True) self.builder.get_object('saveBox').set_visible(False) def on_sButton_clicked(self, widget): en = self.builder.get_object('fileEntry').get_text() if not en: return file = os.path.join(get_user_data_dir(), 'stats') if not os.path.isdir(file): os.mkdir(file) en1 = en + '.stat' f = open(os.path.join(file, en1), 'w') for s, v in self.stats.items(): f.write(s + '\n') en2 = en + s f2 = open(os.path.join(file, en2), 'w') for i in range(len(v['x'])): line = str(v['x'][i]) + ',' + str( v['y'][i] / v['scale']) + '\n' f2.write(line) f2.close() f.close() self.on_cButton_clicked() def readFiles(self): en = self.file[:-5] dir = os.path.dirname(self.file) for s, v in self.stats.items(): en1 = en + s en1 = os.path.join(dir, en1) en1 = en1.rsplit()[0] f = open(en1, 'r') for line in f.readlines(): x, y = line.split(',') v['y'].append(float(y) * v['scale']) v['x'].append(float(x)) f.close() self.update(True)
class MainView(BasePlotView, gtk.Frame): """ A Gtk Frame based plotting widget for dreampy that contains additional tool bar items for printing and adding notes """ def __init__(self, win, **kwargs): gtk.Frame.__init__(self) BasePlotView.__init__(self, **kwargs) self.win = win self.title = None #Put some stuff # self.suppress_header = kwargs.get('suppress_header', False) # self.suppress_title = kwargs.get('suppress_title', False) # self.suppress_legend = kwargs.get('suppress_legend', False) self.vbox = gtk.VBox(False, 0) self.add(self.vbox) self.sw = gtk.ScrolledWindow() self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.vbox.pack_start(self.sw, True, True, 0) self.sw.show() self.f = Figure(figsize=(5,4), dpi=100) self.canvas = FigureCanvas(self.f) # a gtk.DrawingArea self.canvas.set_size_request(400,300) self.sw.add_with_viewport (self.canvas) self.canvas.show_all() self.toolbar = NavToolBar(self.canvas, self.win) self.vbox.pack_start(self.toolbar, False, False) self.toolbar.show() self.vbox.show() # self.autoscale = True # self.xmin = None # self.xmax = None # self.ymin = None # self.ymax = None # self.image = None # self.hold_plot = False # self.keyid = None # self.filter = None # self.labelsize = 8 # self.titlesize = 10 # self.ticklabelsize = 8 # self.ticklabelweight = 'normal' # self.labelweight = 'bold' # self.titleweight = 'bold' # self.legendsize = 8 # self.legendweight = 'normal' # self.hdrlabelsize = 9 # self.hdrlabelweight = 'normal' # self.cur_axname = None self.refresh_canvas() self.show_all() #self.gtk_catchup() def gtk_catchup(self): gtk.gdk.threads_enter() while gtk.events_pending(): gtk.main_iteration() gtk.gdk.threads_leave() def create_arrow_button(self, arrow_type, shadow_type): button = gtk.Button() self.arrow = gtk.Arrow(arrow_type, shadow_type) button.add(self.arrow) button.show() self.arrow.show() return button def list_widgets_turnoff(self): self.left_button.set_sensitive(False) self.right_button.set_sensitive(False) self.ignore_button.set_sensitive(False) #if self.keyid: # self.canvas.disconnect(self.keyid) def disconnect_event(self, sig): if self.canvas: self.canvas.mpl_disconnect(sig) def connect_event(self, eventname, eventfunc): if self.canvas: self.canvas.set_flags(gtk.CAN_FOCUS) #to grab focus for keystrokes self.canvas.grab_focus() #to grab focus for keystrokes return self.canvas.mpl_connect(eventname, eventfunc) def redraw_plot(self): if self.hold_plot is False: if hasattr(self.canvas, 'show_all'): self.canvas.show_all() self.canvas.draw() self.gtk_catchup()
class Iverplot_window (object): """ Iverplot_window---main Iverplot GUI object Parameters ----------- Notes ------ """ def __init__ (self): self.builder = gtk.Builder () self.builder.add_from_file ('iverplot.glade') self.builder.connect_signals (self) self.window = self.builder.get_object ('main_window') # add matplotlib figure canvas w,h = self.window.get_size () self.fig = Figure (figsize=(6,4)) self.canvas = FigureCanvas (self.fig) # a gtk.DrawingArea self.canvas.set_size_request (w-150,-1) vbox = gtk.VBox() toolbar = NavigationToolbar (self.canvas, self.window) vbox.pack_start (self.canvas, True, True) vbox.pack_start (toolbar, False, False) # a little hacky for packing hpane with figure canvas first then tool # bar---not sure if glade is to blame---first, remove tool_vbox then # repack plot_hpaned = self.builder.get_object ('plot_hpaned') self.tool_vbox = self.builder.get_object ('tool_vbox') plot_hpaned.remove (self.tool_vbox) #plot_hpaned.pack1 (self.canvas, resize=True, shrink=False) plot_hpaned.pack1 (vbox, resize=True, shrink=False) plot_hpaned.pack2 (self.tool_vbox) # data self.uvclog = None self.lcmlog = None # plot limits self.xlimits = [None,None] self.xlimits_abs = [None,None] # add single plot item self.plotdex = {} self.plot_items = [] self.plot_items.append (Plot_item (self.tool_vbox, self.on_plot_item_selected, self.uvclog, self.lcmlog)) self.update_subplots () # setwin self.setwin = None # set some defaults self.cd_saveas = os.getcwd () self.cd_open = os.getcwd () self.window.show_all () def on_setwin_clicked (self, widget): if self.setwin is None: self.setwin = Setwin (self.canvas, self.fig, self.on_setwin_complete) def on_setwin_complete (self, xmin, xmax): self.xlimits = [xmin,xmax] for p in self.plot_items: ax = self.fig.axes[self.plotdex[p]] p.plot_type.set_limits (ax, *self.xlimits) self.canvas.draw () self.setwin = None def on_setwin_reset (self, widget): if not self.setwin is None: return self.xlimits = [x for x in self.xlimits_abs] for p in self.plot_items: ax = self.fig.axes[self.plotdex[p]] p.plot_type.set_limits (ax, *self.xlimits) self.canvas.draw () def update_subplots (self): self.fig.clear () n = len (self.plot_items) for i,p in enumerate (self.plot_items): p.plot_type.uvclog = self.uvclog p.plot_type.lcmlog = self.lcmlog ax = self.fig.add_subplot (n,1,i+1) p.plot_type.plot (ax, *self.xlimits) self.plotdex[p] = i self.canvas.draw () def on_plot_item_selected (self, combo, item): ax = self.fig.axes[self.plotdex[item]] item.plot_type.plot (ax, *self.xlimits) self.canvas.draw () def update_window (self): while gtk.events_pending (): gtk.main_iteration_do (True) def on_add_subplot_clicked (self, widget): if len (self.plot_items) >= 3: return self.plot_items.append (Plot_item (self.tool_vbox, self.on_plot_item_selected, self.uvclog, self.lcmlog)) self.update_subplots () self.update_window () def on_remove_subplot_clicked (self, widget): if len (self.plot_items) <= 1: return item = self.plot_items.pop (-1) item.remove () self.update_subplots () self.update_window () def run_open_dialog (self): open_dlg = self.builder.get_object ('open_dialog') #open_dlg.set_current_folder (self.cd_open) open_dlg.set_current_folder ('/home/jeff/data/UMBS_0513/iver28/2013-06-01-dive.046') if len (open_dlg.list_filters ()) == 0: all_filter = gtk.FileFilter () all_filter.set_name ('All files') all_filter.add_pattern ('*') open_dlg.add_filter (all_filter) lcm_filter = gtk.FileFilter () lcm_filter.set_name ('LCM logs') lcm_filter.add_pattern ('lcmlog*') open_dlg.add_filter (lcm_filter) uvc_filter = gtk.FileFilter () uvc_filter.set_name ('UVC logs') uvc_filter.add_pattern ('*.log') open_dlg.add_filter (uvc_filter) response = open_dlg.run () fname = None if response == gtk.RESPONSE_OK: fname = open_dlg.get_filename () self.cd_open = os.path.dirname (fname) open_dlg.hide () return fname def on_open_lcm_clicked (self, widget): fname = self.run_open_dialog () if fname: print 'selected', fname def on_open_uvc_clicked (self, widget): fname = self.run_open_dialog () if fname: print 'selected', fname try: self.uvclog = UVCLog (fname) self.xlimits_abs = [self.uvclog.utime[0], self.uvclog.utime[-1]] self.xlimits = [x for x in self.xlimits_abs] self.update_subplots () except: print 'could not load correctly' def on_save_as_clicked (self, widget): save_as_dlg = self.builder.get_object ('save_as_dialog') save_as_dlg.set_current_folder (self.cd_saveas) save_as_dlg.set_current_name ('iverplot.png') if len (save_as_dlg.list_filters ()) == 0: all_filter = gtk.FileFilter () all_filter.set_name ('All files') all_filter.add_pattern ('*') save_as_dlg.add_filter (all_filter) img_filter = gtk.FileFilter () img_filter.set_name ('All images') img_filter.add_pattern ('*.png') img_filter.add_pattern ('*.jpg') img_filter.add_pattern ('*.pdf') save_as_dlg.add_filter (img_filter) response = save_as_dlg.run () if response == gtk.RESPONSE_OK: fname = save_as_dlg.get_filename () self.fig.savefig (fname, dpi=self.fig.dpi) self.cd_saveas = os.path.dirname (fname) save_as_dlg.hide () def on_about_clicked (self, widget): about = self.builder.get_object ('about_dialog') about.run () about.hide () def on_main_window_destroy (self, widget): gtk.main_quit ()
def dynamics(self,*args,**kwargs): # self.wTree.get_widget("image").set_from_file("./wait.png") print 'dynamics started' mouse_size=20 #ind parameter cat_mature_size=60 #ind parameter # catch_rate=5*10**-4 #parameter # cat_efficiency=0.8 #parameter # a=0.2 #will get from slider # c=0.2 #will get from slider cat_catch_rate=self.wTree.get_widget("catchrate").get_value()*10**-4 #parameter cat_efficiency=self.wTree.get_widget("efficiency").get_value() #parameter a=self.wTree.get_widget("a").get_value() #parameter c=self.wTree.get_widget("c").get_value() #parameter mouse_no=1000 cat_no=1000 t=0 tmax=200 dt=0.4 timeli=[] miceli=[] catli=[] mice=[rodent() for i in range(mouse_no)] cats=[felix() for i in range(cat_no)] catn=len(cats) mousen=len(mice) self.dic={} num=40 size=10 catno=catn*num**2/(catn+mousen) disp_cats=random.sample(range(num**2),catno) if self.wTree.get_widget("anim").get_active()==1: print 'yay!' for i in range(num**2): coords=((i%num)*size*2-num*size,(i/num)*size*2-num*size) if i in disp_cats: self.dic[i]=visual.sphere(pos=coords,radius=size,color=visual.color.red) else : self.dic[i]=visual.sphere(pos=coords,radius=size,color=visual.color.green) print self.dic catn=len(cats) mousen=len(mice) data=open('tempdata.dat','w') timestart=time.time() while len(mice)>0 and len(cats)>0 and t<tmax and (time.time()-timestart)<60: print time.time()-timestart catn=len(cats) mousen=len(mice) if self.wTree.get_widget("anim").get_active()==1: print 'yay!' # self.visualize(catn,mousen) thread.start_new_thread(self.visualize,(catn,mousen)) for mouse in mice: if mouse.time_from_last_childbirth>=1/a: mouse.time_from_last_childbirth=0 mice.append(rodent()) mouse.time_from_last_childbirth+=dt ind=0 while ind<len(cats): cat=cats[ind] cat.age+=dt num=cat_catch_rate*dt*len(mice) for i in range(int(num)): caught=random.randint(0,len(mice)-1) cat.size+=mouse_size*cat_efficiency #size increases mice.pop(caught) if (num-int(num))>random.uniform(0,1): caught=random.randint(0,len(mice)-1) cat.size+=mouse_size*cat_efficiency #size increases mice.pop(caught) if cat.size>cat_mature_size: if cat.is_virgin: cat.is_virgin=0 cat.reproduction_gap=cat.age cats.append(felix()) else : if cat.time_from_last_childbirth>cat.reproduction_gap: cats.append(felix()) cat.time_from_last_childbirth=0 if cat.is_virgin==0: cat.time_from_last_childbirth+=dt if len(cats)>0: if c*dt*2*atan(0.05*len(cats))/pi>random.uniform(0,1): cats.pop(ind) else : ind+=1 else : ind+=1 timeli.append(t) miceli.append(len(mice)) catli.append(len(cats)) # print t,'\t',len(mice),'\t',len(cats) print >> data, t,'\t',len(mice),'\t',len(cats) t+=dt data.close() upper_limit=1.2*len(mice) pltfile=open('lv.plt','w') print >> pltfile,"""se te png se o "/tmp/lv.png" unse ke #se yrange [0:%f] se xl "Time" se yl "Number of Prey/Predator" p 'tempdata.dat' u 1:2 w l,'tempdata.dat' u 1:3 w l """%upper_limit pltfile.close() commands.getoutput('gnuplot lv.plt') self.ax.plot(timeli,miceli,timeli,catli) canvas = FigureCanvas(self.f) # a gtk.DrawingArea canvas.set_size_request(600,400) self.wTree.get_widget("sw").add_with_viewport(canvas) print 'dynamics ended'
class MPLWin(gtk.Window, Observer): """ CLASS: MPLWin DESCR: Superclass for graphing a single channel """ _title = 'Figure window' _size = 600,400 _iconSize = gtk.ICON_SIZE_SMALL_TOOLBAR _detrendd = {'None' : detrend_none, 'Mean' : detrend_mean, 'Linear': detrend_linear, } _detrend = 'Mean' def __init__(self, eegplot, packstart=None, packend=None): gtk.Window.__init__(self) Observer.__init__(self) self.set_size_request(*self._size) self.eegplot = eegplot self.eeg = eegplot.get_eeg() self.eoi = eegplot.get_eoi() self._filterButter = Filter(self) self._filter = FilterBase() # no filtering self._filterGM = self.eegplot.filterGM vbox = gtk.VBox() vbox.show() vbox.set_spacing(3) self.add(vbox) if packstart is not None: for w, expand, fill in packstart: vbox.pack_start(w, expand, fill) self.fig = Figure() self.axes = self.fig.add_subplot(111) self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(0,0) self.canvas.show() vbox.pack_start(self.canvas, True, True) if packend is not None: for w, expand, fill in packend: vbox.pack_start(w, expand, fill) self.toolbar = self.make_toolbar() self.toolbar.show() vbox.pack_end(self.toolbar, False, False) self.set_title(self._title) self.set_border_width(10) def remove(*args): Observer.observers.remove(self) self.connect('delete-event', remove) self._init() # last call before make_plot self.make_plot() #last line! def add_toolbutton(self, icon_name, tip_text, tip_private, clicked_function, clicked_param1=None): iconSize = gtk.ICON_SIZE_SMALL_TOOLBAR iconw = gtk.Image() iconw.set_from_stock(icon_name, iconSize) toolitem = gtk.ToolButton() toolitem.set_icon_widget(iconw) toolitem.show_all() toolitem.set_tooltip_text(tip_text) toolitem.connect("clicked", clicked_function, clicked_param1) toolitem.connect("scroll_event", clicked_function) self.toolbar.insert(toolitem, -1) def make_context_menu(self): contextMenu = gtk.Menu() contextMenu.set_title('Filters') # remove the mean, linear trend, etc itemDetrend = gtk.MenuItem('Detrend') contextMenu.append(itemDetrend) itemDetrend.show() menu = gtk.Menu() def set_detrend(item, l): if item.get_active(): self._detrend = l self.make_plot() group = None for l in ('None', 'Mean', 'Linear'): item = gtk.RadioMenuItem(label=l) if group is None: group = item else: item.set_group(group) if l==self._detrend: item.set_active(True) else: item.set_active(False) item.show() item.connect( "toggled", set_detrend, l) menu.append(item) itemDetrend.set_submenu(menu) # remove the mean, linear trend, etc itemFilter = gtk.MenuItem('Filter') contextMenu.append(itemFilter) itemFilter.show() menu = gtk.Menu() def set_filter(item, l): if l=='Butterworth': if item.get_active(): self._filterButter.make_butter_dialog() self._filter = self._filterButter else: self._filter = FilterBase() # no filtering if l=='Filter GM': self._filterGM = item.get_active() self.make_plot() for l in ('Filter GM', 'Butterworth'): item = gtk.CheckMenuItem(label=l) item.show() if l=='Filter GM' and self._filterGM: item.set_active(True) if l=='Butterworth': item.set_active(False) item.connect( "toggled", set_filter, l) menu.append(item) itemFilter.set_submenu(menu) return contextMenu def on_move(self, widget, event): # get the x and y coords, flip y from top to bottom height = self.canvas.figure.bbox.height #no longer necessary for height method to have parens () x, y = event.x, height-event.y print "on_move ", x, y if self.axes.in_axes(x, y): # transData transforms data coords to display coords. Use the # inverse method to transform back x,y = self.axes.transData.inverted().transform( (x,y) ) #replaced inverse_xy_tup with inverted().transform msg = self.get_msg(x,y) #self.update_status_bar(msg) return True #def update_status_bar(self, msg): # self.statbar.pop(self.statbarCID) # mid = self.statbar.push(self.statbarCID, msg) def recieve(self, event, *args): if not self.buttonFollowEvents.get_active(): return if event in (Observer.SELECT_CHANNEL, Observer.SET_TIME_LIM): self.make_plot() def make_toolbar(self): toolbar = NavigationToolbar(self.canvas, self) next = 8 toolitem = gtk.SeparatorToolItem() toolitem.show() toolbar.insert(toolitem, next); next+=1 toolitem.set_expand(False) self.buttonFollowEvents = gtk.CheckButton () self.buttonFollowEvents.set_label('Auto') self.buttonFollowEvents.show() self.buttonFollowEvents.set_active(True) toolitem = gtk.ToolItem() toolitem.show() #Rewriting this for the new gtk tooltips available in pygtk 2.12 and up #toolitem.set_tooltip( # toolbar.tooltips, # 'Automatically update in response to selections in EEG', 'Private') toolitem.set_tooltip_text('Automatically update in response to selections in EEG') toolitem.add(self.buttonFollowEvents) toolbar.insert(toolitem, next); next +=1 # XXX: only available in gtk 2.6 menu = gtk.MenuToolButton(gtk.STOCK_EDIT) menu.show() context = self.make_context_menu() menu.set_menu(context) #menu.set_tooltip( # toolbar.tooltips, # 'Set filter/detrend etc', 'Private') menu.set_tooltip_text('Set filter/detrend etc') toolbar.insert(menu, next); next+=1 toolitem = gtk.SeparatorToolItem() toolitem.show() toolbar.insert(toolitem, next) toolitem.set_expand(False) return toolbar def _init(self): 'last call before make plot' pass def make_plot(self, *args): raise NotImplementedError def get_msg(self, *args): 'get the status bar msg' return '' def get_data(self): 'return t, data, dt, label, with t filtered according to selections' print "MPLWin.get_data(): self._filterGM =", self._filterGM selected = self.eegplot.get_selected(self._filterGM) if selected is None: error_msg('You must first select an EEG channel by clicking on it', parent=self) return t, data, trode = selected print "MPLWin.get_data(): data[0:10] is " , data[0:10] print "MPLWin.get_data(): self._detrend=", self._detrend detrend = self._detrendd[self._detrend] data = detrend(self._filter(t, data)) gname, gnum = trode label = '%s %d' % (gname, gnum) dt = t[1]-t[0] return t, data, dt, label
class GUI(object): """ main class which opens the actual GUI """ def __init__(self): ########################################################################################### # read in settings file from XChemExplorer to set the relevant paths self.settings = pickle.load(open(".xce_settings.pkl", "rb")) remote_qsub_submission = self.settings['remote_qsub'] self.database_directory = self.settings['database_directory'] self.xce_logfile = self.settings['xce_logfile'] self.Logfile = XChemLog.updateLog(self.xce_logfile) self.Logfile.insert('starting COOT gui for reference model refinement') self.data_source = self.settings['data_source'] # checking for external software packages self.external_software = XChemUtils.external_software( self.xce_logfile).check() self.external_software['qsub_remote'] = remote_qsub_submission # the Folder is kind of a legacy thing because my inital idea was to have separate folders # for Data Processing and Refinement self.reference_directory = self.settings['reference_directory'] self.refinementDir = '' self.Serial = 0 self.Refine = None self.xtalID = '' self.compoundID = '' self.spider_plot = '' self.refinement_folder = '' self.pdbFile = '' self.mtzFree = '' self.pdb_style = 'refine.pdb' self.mtz_style = 'refine.mtz' # stores imol of currently loaded molecules and maps self.mol_dict = { 'protein': -1, 'ligand': -1, '2fofc': -1, 'fofc': -1, 'event': -1 } self.ground_state_map_List = [] self.job_running = False ########################################################################################### # some COOT settings coot.set_map_radius(17) coot.set_colour_map_rotation_for_map(0) # coot.set_colour_map_rotation_on_read_pdb_flag(21) self.QualityIndicators = { 'Rcryst': '-', 'Rfree': '-', 'RfreeTL': 'gray', 'ResolutionHigh': '-', 'ResolutionColor': 'gray', 'MolprobityScore': '-', 'MolprobityScoreColor': 'gray', 'RamachandranOutliers': '-', 'RamachandranOutliersColor': 'gray', 'RamachandranFavored': '-', 'RamachandranFavoredColor': 'gray', 'rmsdBonds': '-', 'rmsdBondsTL': 'gray', 'rmsdAngles': '-', 'rmsdAnglesTL': 'gray', 'MatrixWeight': '-' } # default refmac parameters self.RefmacParams = { 'HKLIN': '', 'HKLOUT': '', 'XYZIN': '', 'XYZOUT': '', 'LIBIN': '', 'LIBOUT': '', 'TLSIN': '', 'TLSOUT': '', 'TLSADD': '', 'NCYCLES': '10', 'MATRIX_WEIGHT': 'AUTO', 'BREF': ' bref ISOT\n', 'TLS': '', 'NCS': '', 'TWIN': '' } def StartGUI(self): self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.connect("delete_event", gtk.main_quit) self.window.set_border_width(10) self.window.set_default_size(400, 800) self.window.set_title("Reference Model Builder") self.vbox = gtk.VBox() # this is the main container ################################################################################# # --- PDB file selection --- # checking for pdb files in reference directory referenceFiles = [] for files in glob.glob( os.path.join(self.reference_directory, '*-ground-state.pdb')): pdbFile = files[files.rfind('/') + 1:] referenceFiles.append(pdbFile) frame = gtk.Frame(label='Select PDB file') hbox = gtk.HBox() self.cb_select_pdb = gtk.combo_box_new_text() # self.cb_select_pdb.connect("changed", self.set_selection_mode) for pdbFile in referenceFiles: self.cb_select_pdb.append_text(pdbFile) hbox.add(self.cb_select_pdb) frame.add(hbox) self.vbox.pack_start(frame) self.load_pdb_file_button = gtk.Button(label="Load") # self.load_pdb_file_button.connect("clicked",self.get_samples_to_look_at) self.load_pdb_file_button.connect("clicked", self.load_pdb_file) hbox.add(self.load_pdb_file_button) frame.add(hbox) self.vbox.pack_start(frame) # SPACER self.vbox.add(gtk.Label(' ')) frame = gtk.Frame(label='MTZ file to refine against') hbox = gtk.HBox() self.mtzFree = '' self.mtzFree_label = gtk.Label() hbox.add(self.mtzFree_label) frame.add(hbox) self.vbox.pack_start(frame) # SPACER self.vbox.add(gtk.Label(' ')) frame = gtk.Frame(label='MTZ file after refinement') hbox = gtk.HBox() self.mtzRefine_label = gtk.Label() hbox.add(self.mtzRefine_label) frame.add(hbox) self.vbox.pack_start(frame) # SPACER self.vbox.add(gtk.Label(' \n ')) ################################################################################# # --- ground state mean map --- # checking for ground state mean map in reference folder # self.meanMaps = {} # for dirs in glob.glob(os.path.join(self.reference_directory,'pandda_*')): # panddaDir=dirs.split('/')[len(dirs.split('/'))-1] # for files in glob.glob(os.path.join(dirs,'processed_datasets','*','*ground-state-mean-map.native.ccp4')): # if os.path.isfile(files): # self.meanMaps[panddaDir]=files # break # frame = gtk.Frame(label='Load ground-state-mean-map files') # hbox=gtk.HBox() # self.cb_select_mean_map = gtk.combo_box_new_text() # for item in self.meanMaps: # self.cb_select_mean_map.append_text(item) # hbox.add(self.cb_select_mean_map) # self.load_ground_state_map_button = gtk.Button(label="Load") # self.load_ground_state_map_button.connect("clicked",self.load_ground_state_map) # hbox.add(self.load_ground_state_map_button) # frame.add(hbox) # self.vbox.pack_start(frame) # frame = gtk.Frame() # hbox=gtk.HBox() # self.cb_select_mean_map_by_resolution = gtk.combo_box_new_text() # self.cb_select_mean_map_by_resolution.connect("changed", self.show_selected_mean_map) # hbox.add(self.cb_select_mean_map_by_resolution) ## self.show_highres_ground_state_map_button = gtk.Button(label="Show Highest\nResolution Map") ## self.show_highres_ground_state_map_button.connect("clicked",self.show_highres_ground_state_map) ## hbox.add(self.show_highres_ground_state_map_button) ## self.show_all_ground_state_map_button = gtk.Button(label="Show All Maps") ## self.show_all_ground_state_map_button.connect("clicked",self.show_all_ground_state_map) ## hbox.add(self.show_all_ground_state_map_button) # frame.add(hbox) # self.vbox.pack_start(frame) # SPACER # self.vbox.add(gtk.Label(' \n ')) ################################################################################# # --- Refinement History --- frame = gtk.Frame(label='Refinement History') self.hbox_for_info_graphics = gtk.HBox() self.canvas = FigureCanvas(self.update_plot([0], [0], [0])) self.canvas.set_size_request(190, 190) self.hbox_for_info_graphics.add(self.canvas) frame.add(self.hbox_for_info_graphics) self.vbox.pack_start(frame) ################################################################################# # --- status window --- frame = gtk.Frame(label='Status') vbox = gtk.VBox() self.spinnerBox = gtk.VBox() self.refinementRunning = gtk.Spinner() vbox.add(self.spinnerBox) # hbox.add(self.refinementRunning) self.status_label = gtk.Label() vbox.add(self.status_label) frame.add(vbox) self.status_label.set_text('idle') # frame.add(self.status_label) self.vbox.pack_start(frame) ################################################################################# # --- Refinement Statistics --- # next comes a section which displays some global quality indicators # a combination of labels and textview widgets, arranged in a table RRfreeLabel_frame = gtk.Frame() self.RRfreeLabel = gtk.Label('R/Rfree') RRfreeLabel_frame.add(self.RRfreeLabel) self.RRfreeValue = gtk.Label(self.QualityIndicators['Rcryst'] + '/' + self.QualityIndicators['Rfree']) RRfreeBox_frame = gtk.Frame() self.RRfreeBox = gtk.EventBox() self.RRfreeBox.add(self.RRfreeValue) RRfreeBox_frame.add(self.RRfreeBox) ResolutionLabel_frame = gtk.Frame() self.ResolutionLabel = gtk.Label('Resolution') ResolutionLabel_frame.add(self.ResolutionLabel) self.ResolutionValue = gtk.Label( self.QualityIndicators['ResolutionHigh']) ResolutionBox_frame = gtk.Frame() self.ResolutionBox = gtk.EventBox() self.ResolutionBox.add(self.ResolutionValue) ResolutionBox_frame.add(self.ResolutionBox) MolprobityScoreLabel_frame = gtk.Frame() self.MolprobityScoreLabel = gtk.Label('MolprobityScore') MolprobityScoreLabel_frame.add(self.MolprobityScoreLabel) self.MolprobityScoreValue = gtk.Label( self.QualityIndicators['MolprobityScore']) MolprobityScoreBox_frame = gtk.Frame() self.MolprobityScoreBox = gtk.EventBox() self.MolprobityScoreBox.add(self.MolprobityScoreValue) MolprobityScoreBox_frame.add(self.MolprobityScoreBox) RamachandranOutliersLabel_frame = gtk.Frame() self.RamachandranOutliersLabel = gtk.Label('Rama Outliers') RamachandranOutliersLabel_frame.add(self.RamachandranOutliersLabel) self.RamachandranOutliersValue = gtk.Label( self.QualityIndicators['RamachandranOutliers']) RamachandranOutliersBox_frame = gtk.Frame() self.RamachandranOutliersBox = gtk.EventBox() self.RamachandranOutliersBox.add(self.RamachandranOutliersValue) RamachandranOutliersBox_frame.add(self.RamachandranOutliersBox) RamachandranFavoredLabel_frame = gtk.Frame() self.RamachandranFavoredLabel = gtk.Label('Rama Favored') RamachandranFavoredLabel_frame.add(self.RamachandranFavoredLabel) self.RamachandranFavoredValue = gtk.Label( self.QualityIndicators['RamachandranFavoredColor']) RamachandranFavoredBox_frame = gtk.Frame() self.RamachandranFavoredBox = gtk.EventBox() self.RamachandranFavoredBox.add(self.RamachandranFavoredValue) RamachandranFavoredBox_frame.add(self.RamachandranFavoredBox) rmsdBondsLabel_frame = gtk.Frame() self.rmsdBondsLabel = gtk.Label('rmsd(Bonds)') rmsdBondsLabel_frame.add(self.rmsdBondsLabel) self.rmsdBondsValue = gtk.Label(self.QualityIndicators['rmsdBonds']) rmsdBondsBox_frame = gtk.Frame() self.rmsdBondsBox = gtk.EventBox() self.rmsdBondsBox.add(self.rmsdBondsValue) rmsdBondsBox_frame.add(self.rmsdBondsBox) rmsdAnglesLabel_frame = gtk.Frame() self.rmsdAnglesLabel = gtk.Label('rmsd(Angles)') rmsdAnglesLabel_frame.add(self.rmsdAnglesLabel) self.rmsdAnglesValue = gtk.Label(self.QualityIndicators['rmsdAngles']) rmsdAnglesBox_frame = gtk.Frame() self.rmsdAnglesBox = gtk.EventBox() self.rmsdAnglesBox.add(self.rmsdAnglesValue) rmsdAnglesBox_frame.add(self.rmsdAnglesBox) MatrixWeightLabel_frame = gtk.Frame() self.MatrixWeightLabel = gtk.Label('Matrix Weight') MatrixWeightLabel_frame.add(self.MatrixWeightLabel) self.MatrixWeightValue = gtk.Label( self.QualityIndicators['MatrixWeight']) MatrixWeightBox_frame = gtk.Frame() self.MatrixWeightBox = gtk.EventBox() self.MatrixWeightBox.add(self.MatrixWeightValue) MatrixWeightBox_frame.add(self.MatrixWeightBox) outer_frame = gtk.Frame() hbox = gtk.HBox() frame = gtk.Frame() self.table_left = gtk.Table(8, 2, False) self.table_left.attach(RRfreeLabel_frame, 0, 1, 0, 1) self.table_left.attach(ResolutionLabel_frame, 0, 1, 1, 2) self.table_left.attach(MolprobityScoreLabel_frame, 0, 1, 2, 3) self.table_left.attach(RamachandranOutliersLabel_frame, 0, 1, 3, 4) self.table_left.attach(RamachandranFavoredLabel_frame, 0, 1, 4, 5) self.table_left.attach(rmsdBondsLabel_frame, 0, 1, 5, 6) self.table_left.attach(rmsdAnglesLabel_frame, 0, 1, 6, 7) self.table_left.attach(MatrixWeightLabel_frame, 0, 1, 7, 8) self.table_left.attach(RRfreeBox_frame, 1, 2, 0, 1) self.table_left.attach(ResolutionBox_frame, 1, 2, 1, 2) self.table_left.attach(MolprobityScoreBox_frame, 1, 2, 2, 3) self.table_left.attach(RamachandranOutliersBox_frame, 1, 2, 3, 4) self.table_left.attach(RamachandranFavoredBox_frame, 1, 2, 4, 5) self.table_left.attach(rmsdBondsBox_frame, 1, 2, 5, 6) self.table_left.attach(rmsdAnglesBox_frame, 1, 2, 6, 7) self.table_left.attach(MatrixWeightBox_frame, 1, 2, 7, 8) frame.add(self.table_left) hbox.add(frame) outer_frame.add(hbox) self.vbox.add(outer_frame) button = gtk.Button(label="Show MolProbity to-do list") button.connect("clicked", self.show_molprobity_to_do) self.vbox.add(button) self.vbox.pack_start(frame) # SPACER self.vbox.add(gtk.Label(' ')) # --- refinement & options --- self.hbox_for_refinement = gtk.HBox() self.REFINEbutton = gtk.Button(label="Refine") self.RefinementParamsButton = gtk.Button(label="refinement parameters") self.REFINEbutton.connect("clicked", self.REFINE) self.hbox_for_refinement.add(self.REFINEbutton) self.RefinementParamsButton.connect("clicked", self.RefinementParams) self.hbox_for_refinement.add(self.RefinementParamsButton) self.vbox.add(self.hbox_for_refinement) # --- CANCEL button --- self.CANCELbutton = gtk.Button(label="CANCEL") self.CANCELbutton.connect("clicked", self.CANCEL) self.vbox.add(self.CANCELbutton) self.window.add(self.vbox) self.window.show_all() def CANCEL(self, widget): self.window.destroy() def RefreshData(self): # initialize Refinement library self.Refine = XChemRefine.Refine(self.reference_directory, self.refinementDir, 'dummy_compound_ID', 'dummy_database') self.Serial = self.Refine.GetSerial() print '====> Serial', self.Serial ######################################################################################### # history # if the structure was previously refined, try to read the parameters self.hbox_for_info_graphics.remove(self.canvas) if self.Serial > 1: self.RefmacParams = self.Refine.ParamsFromPreviousCycle( self.Serial - 1) refinement_cycle, Rfree, Rcryst = self.Refine.GetRefinementHistory( ) self.canvas = FigureCanvas( self.update_plot(refinement_cycle, Rfree, Rcryst)) else: self.canvas = FigureCanvas(self.update_plot( [0], [0], [0])) # a gtk.DrawingArea self.canvas.set_size_request(190, 190) self.hbox_for_info_graphics.add(self.canvas) self.canvas.show() ######################################################################################### # update Quality Indicator table print self.QualityIndicators try: self.RRfreeValue.set_label( str(round(float(self.QualityIndicators['Rcryst']), 3)) + ' / ' + str(round(float(self.QualityIndicators['Rfree']), 3))) except ValueError: self.RRfreeValue.set_label('-') try: self.RRfreeBox.modify_bg( gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['RfreeTL'])) except ValueError: pass self.ResolutionValue.set_label( self.QualityIndicators['ResolutionHigh']) try: self.ResolutionBox.modify_bg( gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['ResolutionColor'])) except ValueError: pass self.MolprobityScoreValue.set_label( self.QualityIndicators['MolprobityScore']) try: self.MolprobityScoreBox.modify_bg( gtk.STATE_NORMAL, gtk.gdk.color_parse( self.QualityIndicators['MolprobityScoreColor'])) except ValueError: pass self.RamachandranOutliersValue.set_label( self.QualityIndicators['RamachandranOutliers']) try: self.RamachandranOutliersBox.modify_bg( gtk.STATE_NORMAL, gtk.gdk.color_parse( self.QualityIndicators['RamachandranOutliersColor'])) except ValueError: pass self.RamachandranFavoredValue.set_label( self.QualityIndicators['RamachandranFavored']) try: self.RamachandranFavoredBox.modify_bg( gtk.STATE_NORMAL, gtk.gdk.color_parse( self.QualityIndicators['RamachandranFavoredColor'])) except ValueError: pass self.rmsdBondsValue.set_label(self.QualityIndicators['rmsdBonds']) try: self.rmsdBondsBox.modify_bg( gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['rmsdBondsTL'])) except ValueError: pass self.rmsdAnglesValue.set_label(self.QualityIndicators['rmsdAngles']) try: self.rmsdAnglesBox.modify_bg( gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['rmsdAnglesTL'])) except ValueError: pass self.MatrixWeightValue.set_label( self.QualityIndicators['MatrixWeight']) def REFINE(self, widget): if self.job_running: coot.info_dialog('*** refinement in progress ***') return None ####################################################### # create folder for new refinement cycle and check if free.mtz exists if not os.path.isdir( os.path.join(self.reference_directory, self.refinementDir)): os.mkdir(os.path.join(self.reference_directory, self.refinementDir)) if not os.path.isdir( os.path.join(self.reference_directory, self.refinementDir, 'Refine_' + str(self.Serial))): os.mkdir( os.path.join(self.reference_directory, self.refinementDir, 'Refine_' + str(self.Serial))) if not os.path.isfile( os.path.join(self.reference_directory, self.refinementDir, self.refinementDir + '.free.mtz')): os.chdir(os.path.join(self.reference_directory, self.refinementDir)) os.symlink(self.mtzFree, self.refinementDir + '.free.mtz') ####################################################### # write PDB file # now take protein pdb file and write it to newly create Refine_<serial> folder # note: the user has to make sure that the ligand file was merged into main file for item in coot_utils_XChem.molecule_number_list(): if coot.molecule_name(item) in self.pdbFile: coot.write_pdb_file( item, os.path.join(self.reference_directory, self.refinementDir, 'Refine_' + str(self.Serial), 'in.pdb')) break self.Refine.RunRefmac(self.Serial, self.RefmacParams, self.external_software, self.xce_logfile) # self.spinnerBox.add(self.refinementRunning) # self.refinementRunning.start() self.status_label.set_text('Refinement running...') time.sleep( 1 ) # waiting 1s to make sure that REFINEMENT_IN_PROGRESS is written snooze = 0 while os.path.exists( os.path.join(self.reference_directory, self.refinementDir, 'REFINEMENT_IN_PROGRESS')): time.sleep(10) print '==> XCE: waiting for refinement to finish; elapsed time = ' + str( snooze) + 's' snooze += 10 self.update_pdb_mtz_files('') # launch refinement # time.sleep(1) # waiting 1s to make sure that REFINEMENT_IN_PROGRESS is written # self.source_id = gobject.timeout_add(100, self.wait_for_refined_pdb) # def wait_for_refined_pdb(self): # self.spinnerBox.add(self.refinementRunning) # self.refinementRunning.show() # self.refinementRunning.start() # if not os.path.isfile(os.path.join(self.reference_directory,self.refinementDir,'REFINEMENT_IN_PROGRESS')): # self.job_running=False # self.end_thread('update_pdb_mtz') # return True # def end_thread(self,action): # self.refinementRunning.stop() # self.spinnerBox.remove(self.refinementRunning) # self.status_label.set_text('idle') # gobject.source_remove(self.source_id) # if action=='update_pdb_mtz': # self.update_pdb_mtz_files('') def RefinementParams(self, widget): print '\n==> XCE: changing refinement parameters' self.RefmacParams = self.Refine.RefinementParams(self.RefmacParams) def set_selection_mode(self, widget): self.selection_mode = widget.get_active_text() def load_pdb_file(self, widget): pdbRoot = self.cb_select_pdb.get_active_text() if self.pdbFile != '': self.Logfile.error( 'sorry, you need to close the current instance of COOT and start again' ) return None self.refinementDir = pdbRoot.replace('.pdb', '') self.update_pdb_mtz_files(pdbRoot) def update_pdb_mtz_files(self, pdbRoot): # first remove all pdb and mtz files from memory self.Logfile.insert('removing all PDB and MTZ files from memory') if len(coot_utils_XChem.molecule_number_list()) > 0: for item in coot_utils_XChem.molecule_number_list(): if coot.molecule_name(item).endswith( '.pdb') or '.mtz' in coot.molecule_name(item): self.Logfile.insert('removing %s' % coot.molecule_name(item)) coot.close_molecule(item) coot.set_nomenclature_errors_on_read("ignore") # first we check if there is a refinement folder and the respective refine.pdb # from previous refinement cycles Root = self.cb_select_pdb.get_active_text() print 'ROOT', Root print 'REFI_DIR', os.path.join(self.reference_directory, self.refinementDir, 'refine.pdb') if os.path.isfile( os.path.join(self.reference_directory, self.refinementDir, 'refine.pdb')): os.chdir(self.reference_directory) print 'CURRENT DIR', os.getcwd() os.system('/bin/rm %s 2> /dev/null' % Root) os.symlink( os.path.realpath(os.path.join(self.refinementDir, 'refine.pdb')), '%s' % Root) self.pdbFile = os.path.join(self.reference_directory, self.refinementDir, 'refine.pdb') elif os.path.isfile(os.path.join(self.reference_directory, Root)): self.pdbFile = os.path.join(self.reference_directory, Root) else: self.Logfile.error('cannot find PDB file') if self.pdbFile != '': # os.chdir(os.path.join(self.reference_directory,self.refinementDir)) coot.set_colour_map_rotation_on_read_pdb(0) imol = coot.handle_read_draw_molecule_with_recentre( self.pdbFile, 0) self.QualityIndicators = XChemUtils.parse().PDBheader( os.path.join(self.pdbFile)) self.QualityIndicators.update( XChemUtils.logtools( os.path.join(self.reference_directory, self.refinementDir, 'refine_molprobity.log')).phenix_molprobity()) self.QualityIndicators.update( XChemUtils.logtools( os.path.join(self.reference_directory, self.refinementDir, 'Refine_' + str(self.Serial), 'refmac.log')).refmac_log()) self.mol_dict['protein'] = imol if self.mtzFree == '': print 'FREE', os.path.join( self.reference_directory, pdbRoot.replace('.pdb', '') + '.free.mtz') if os.path.isfile( os.path.join(self.reference_directory, pdbRoot.replace('.pdb', '') + '.free.mtz')): self.mtzFree = os.path.join( self.reference_directory, pdbRoot.replace('.pdb', '') + '.free.mtz') self.mtzFree_label.set_text( pdbRoot.replace('.pdb', '') + '.free.mtz') self.REFINEbutton.set_sensitive(True) else: self.mtzFree_label.set_text('missing file') self.Logfile.error( 'cannot find file with F,SIGF and FreeR_flag; cannot start refinement' ) self.REFINEbutton.set_sensitive(False) self.mtzRefine = '' if os.path.isfile( os.path.join(self.reference_directory, self.refinementDir, 'refine.mtz')): self.mtzRefine = os.path.join(self.reference_directory, self.refinementDir, 'refine.mtz') mtzRefineReal = os.path.realpath( os.path.join(self.reference_directory, self.refinementDir, 'refine.mtz')) mtzRefineCurrent = mtzRefineReal.replace( os.path.join(self.reference_directory, self.refinementDir + '/'), '') self.mtzRefine_label.set_text(mtzRefineCurrent) coot.set_default_initial_contour_level_for_map(1) if os.path.isfile( os.path.join(self.reference_directory, self.refinementDir, self.mtz_style)): coot.auto_read_make_and_draw_maps( os.path.join(self.reference_directory, self.refinementDir, self.mtz_style)) else: self.mtzRefine_label.set_text('missing file') self.Logfile.warning( 'cannot find file with F,SIGF and FreeR_flag; cannot start refinement' ) groundStateMap = os.path.join(self.reference_directory, Root + '-mean-map.native.ccp4').replace( '.pdb', '') print '===>', groundStateMap if os.path.isfile(groundStateMap): imol = coot.handle_read_ccp4_map(groundStateMap, 0) coot.set_contour_level_in_sigma(imol, 1) coot.set_last_map_colour(0.6, 0.6, 0) else: print '==> XCE: ERROR - cannot find ground state mean map!' self.RefreshData() # def load_ground_state_map(self,widget): # self.spinnerBox.add(self.refinementRunning) # self.refinementRunning.start() # self.status_label.set_text('loading ground state maps by reso...') # self.source_id = gobject.timeout_add(100, self.load_ground_state_map_thread) # def load_ground_state_map_thread(self): # self.spinnerBox.add(self.refinementRunning) # self.refinementRunning.show() # self.refinementRunning.start() # # # first remove all ground state maps files # if len(coot_utils_XChem.molecule_number_list()) > 0: # for item in coot_utils_XChem.molecule_number_list(): # if 'ground-state-mean-map' in coot.molecule_name(item): # coot.close_molecule(item) # # # first remove all entries for self.cb_select_mean_map_by_resolution # # clear CB first, 100 is sort of arbitrary since it's unlikely there will ever be 100 maps # for n in range(-1,100): # self.cb_select_mean_map_by_resolution.remove_text(0) # # self.status_label.set_text('loading ground state maps') # self.get_highest_reso_ground_state_map() # blueStart=0.02 # for map in self.ground_state_map_List: # self.cb_select_mean_map_by_resolution.append_text(map[0]) # imol=coot.handle_read_ccp4_map((map[1]),0) # coot.set_contour_level_in_sigma(imol,1) # coot.set_last_map_colour(0.74,0.44,blueStart) # blueStart+=0.05 # # show only highest resolution map to start with # self.show_highres_ground_state_map() # self.cb_select_mean_map_by_resolution.set_active(0) # self.end_thread('') # def show_highres_ground_state_map(self): # if len(self.ground_state_map_List) >= 1: # for imol in coot_utils_XChem.molecule_number_list(): # if coot.molecule_name(imol) in self.ground_state_map_List[0][1]: # coot.set_map_displayed(imol,1) # elif 'ground-state-mean-map' in coot.molecule_name(imol): # coot.set_map_displayed(imol,0) # def show_all_ground_state_map(self): # if len(self.ground_state_map_List) >= 1: # for imol in coot_utils_XChem.molecule_number_list(): # if 'ground-state-mean-map' in coot.molecule_name(imol): # coot.set_map_displayed(imol,1) # def show_selected_mean_map(self,widget): # reso=str(self.cb_select_mean_map_by_resolution.get_active_text()) # mapToshow='' # for maps in self.ground_state_map_List: # if maps[0]==reso: # mapToshow=maps[1] # for imol in coot_utils_XChem.molecule_number_list(): # if coot.molecule_name(imol) in mapToshow: # coot.set_map_displayed(imol,1) # elif 'ground-state-mean-map' in coot.molecule_name(imol): # coot.set_map_displayed(imol,0) def show_molprobity_to_do(self, widget): if os.path.isfile( os.path.join(self.reference_directory, self.refinementDir, 'Refine_' + str(self.Serial - 1), 'molprobity_coot.py')): coot.run_script( os.path.join(self.reference_directory, self.refinementDir, 'Refine_' + str(self.Serial - 1), 'molprobity_coot.py')) else: print '==> XCE: cannot find ' + os.path.join( self.reference_directory, self.xtalID, 'Refine_' + str(self.Serial - 1), 'molprobity_coot.py') def update_plot(self, refinement_cycle, Rfree, Rcryst): fig = Figure(figsize=(2, 2), dpi=50) Plot = fig.add_subplot(111) Plot.set_ylim([0, max(Rcryst + Rfree)]) Plot.set_xlabel('Refinement Cycle', fontsize=12) Plot.plot(refinement_cycle, Rfree, label='Rfree', linewidth=2) Plot.plot(refinement_cycle, Rcryst, label='Rcryst', linewidth=2) Plot.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, mode="expand", borderaxespad=0., fontsize=12) return fig def get_ground_state_maps_by_resolution(self): found = False mapList = [] for logFile in glob.glob( os.path.join(self.reference_directory, str(self.cb_select_mean_map.get_active_text()), 'logs', '*.log')): for n, line in enumerate(open(logFile)): if line.startswith( 'Statistical Electron Density Characterisation' ) and len(line.split()) == 6: # try: # resolution=float(line.split()[5]) resolution = line.split()[5] print resolution found = True foundLine = n # except ValueError: # print 'error' # break if found and n == foundLine + 3: xtal = line.split(',')[0].replace(' ', '').replace('\t', '') meanmap = os.path.join( self.reference_directory, self.cb_select_mean_map.get_active_text(), 'processed_datasets', xtal, xtal + '-ground-state-mean-map.native.ccp4') mapList.append([resolution, meanmap]) found = False return mapList def get_highest_reso_ground_state_map(self): mapList = self.get_ground_state_maps_by_resolution() print mapList self.ground_state_map_List = [] self.ground_state_map_List.append(min(mapList, key=lambda x: x[0])) return self.ground_state_map_List
class Plotpar(): def __init__(self, context, f_function, g_function): self.context = context self.f_function = f_function self.g_function = g_function self.fig = Figure(figsize=(6, 4)) # create fig self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(600, 600) # set min size self.markers = [ '.', ',', '+', 'x', '|', '_', 'o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd' ] self.colors = [ 'black', 'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'purple', 'white' ] self.pstyle = [ 'bmh', 's', '6', 'red', '0.8', 'black', '2', 'black', '0.3', '', '25', '', '', '20', '15', '', '', '20', '15' ] self.styledict = {} self.styledict["style"] = 'bmh' self.styledict["point_style"] = 's' self.styledict["point_size"] = '6' self.styledict["point_color"] = 'red' self.styledict["point_alpha"] = '0.8' self.styledict["line_color"] = 'black' self.styledict["line_width"] = '2' self.styledict["band_color"] = 'black' self.styledict["band_alpha"] = '0.3' self.styledict["title_size"] = '8' self.styledict["xtitle_size"] = '8' self.styledict["xlabel_size"] = '8' self.styledict["ytitle_size"] = '8' self.styledict["ylabel_size"] = '8' self.nselec = [1, 12, 5, 3, -1, 0, -1, 0, -1, -1, -1, -1, -1, -1] self.plot_labels = ["", "x", "f(x)", "", "g(x)"] toolbar = NavigationToolbar(self.canvas, self) toolbarbox = gtk.HBox() image = gtk.Image() image.set_from_stock(gtk.STOCK_PROPERTIES, gtk.ICON_SIZE_LARGE_TOOLBAR) options_button = gtk.Button() options_button.add(image) image2 = gtk.Image() image2.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_LARGE_TOOLBAR) refresh_button = gtk.Button() refresh_button.add(image2) toolbarbox.pack_start(toolbar, True, True) toolbarbox.pack_end(options_button, False, True) toolbarbox.pack_end(refresh_button, False, True) self.vbox = gtk.VBox() self.vbox.pack_start(toolbarbox, False, False) self.vbox.pack_start(self.canvas, True, True) self.x1 = -0.1 self.x2 = 20.1 # signals options_button.connect('clicked', self.mpl_options) refresh_button.connect('clicked', self.on_refresh_clicked) def mpl_options(self, button): """Create GTKDialog containing options for plotting and connect signals.""" mpl_options_dialog = MPLOptions(self.context, self) def on_refresh_clicked(self, button): """Refresh canvas - plot everything again""" self.plotting() def plotvline(self, **kwargs): self.ax1.axvline(**kwargs) def plothline(self, **kwargs): self.ax1.axhline(**kwargs) def replot(self): self.canvas.draw() def plotting(self): """Generating matplotlib canvas""" plt.style.use(self.pstyle[0]) f_kwargs = { 'color': 'black', 'fmt': 's', 'ecolor': 'black', 'elinewidth': 1.5, 'capsize': 4.5, 'capthick': 1.0, 'markersize': 10 } g_kwargs = { 'color': 'red', 'fmt': 's', 'ecolor': 'red', 'elinewidth': 1.5, 'capsize': 4.5, 'capthick': 1.0, 'markersize': 10 } if self.f_function.mode == "quadratic" or self.g_function.mode == "quadratic": self.ax1 = self.fig.add_subplot(131) self.ax1.clear() self.ax2 = self.fig.add_subplot(132) self.ax2.clear() self.ax3 = self.fig.add_subplot(133) self.ax3.clear() if self.f_function.mode == "quadratic": fc = self.f_function.params[2] fa = self.f_function.params[1] fb = self.f_function.params[0] sfc = self.f_function.std_err[2] sfa = self.f_function.std_err[1] sfb = self.f_function.std_err[0] else: fc = self.f_function.params[1] fa = self.f_function.params[0] fb = 0.0 sfc = self.f_function.std_err[1] sfa = self.f_function.std_err[0] sfb = 0.0 if self.g_function.mode == "quadratic": gc = self.g_function.params[2] ga = self.g_function.params[1] gb = self.g_function.params[0] sgc = self.g_function.std_err[2] sga = self.g_function.std_err[1] sgb = self.g_function.std_err[0] else: gc = self.g_function.params[1] ga = self.g_function.params[0] gb = 0.0 sgc = self.g_function.std_err[1] sga = self.g_function.std_err[0] sgb = 0.0 fx = [0] fy = [fc] fe = [sfc] self.ax1.errorbar(fx, fy, fe, **f_kwargs) gx = [1] gy = [gc] ge = [sgc] self.ax1.errorbar(gx, gy, ge, **g_kwargs) fx = [0] fy = [fa] fe = [sfa] self.ax2.errorbar(fx, fy, fe, **f_kwargs) gx = [1] gy = [ga] ge = [sga] self.ax2.errorbar(gx, gy, ge, **g_kwargs) fx = [0] fy = [fb] fe = [sfb] self.ax3.errorbar(fx, fy, fe, **f_kwargs) gx = [1] gy = [gb] ge = [sgb] self.ax3.errorbar(gx, gy, ge, **g_kwargs) plt.setp([self.ax1, self.ax2, self.ax3], xticks=[it for it in range(2)], xticklabels=['f', 'g']) self.ax1.set_xlim([-0.5, 1.5]) self.ax2.set_xlim([-0.5, 1.5]) self.ax3.set_xlim([-0.5, 1.5]) elif self.f_function.mode == "linear" and self.g_function.mode == "linear": self.ax1 = self.fig.add_subplot(121) self.ax1.clear() self.ax2 = self.fig.add_subplot(122) self.ax2.clear() fc = self.f_function.params[1] fa = self.f_function.params[0] sfc = self.f_function.std_err[1] sfa = self.f_function.std_err[0] gc = self.g_function.params[1] ga = self.g_function.params[0] sgc = self.g_function.std_err[1] sga = self.g_function.std_err[0] fx = [0] fy = [fc] fe = [sfc] self.ax1.errorbar(fx, fy, fe, **f_kwargs) gx = [1] gy = [gc] ge = [sgc] self.ax1.errorbar(gx, gy, ge, **g_kwargs) fx = [0] fy = [fa] fe = [sfa] self.ax2.errorbar(fx, fy, fe, **f_kwargs) gx = [1] gy = [ga] ge = [sga] self.ax2.errorbar(fx, fy, fe, **g_kwargs) plt.setp([self.ax1, self.ax2, self.ax3], xticks=[it for it in range(2)], xticklabels=['f', 'g']) self.ax1.set_xlim([-0.5, 1.5]) self.ax2.set_xlim([-0.5, 1.5]) self.fig.subplots_adjust(left=0.07, right=0.97, top=0.94, bottom=0.1, wspace=0.30) self.canvas.draw()
class SOM: def If_running(self): #print som.running self.play.set_sensitive(not self.som.running) return self.som.running def If_paused(self): #print som.running #self.pause.set_sensitive(self.som.running) return False def Status_update(self): if self.som.running: context_id = self.status_bar.get_context_id("Running") #print context_id text = "Iteration: " + str(self.som.tick).zfill(len(str(self.som.ticks))) + "/" + str(self.som.ticks).zfill(len(str(self.som.ticks))) if self.som.paused: text += ", Paused" self.status_bar.push(context_id, text) return True # we need it to keep updating if the model is running elif not self.som.running: if not self.som.paused: self.status_bar.remove_all(self.status_bar.get_context_id("Running")) self.status_bar.remove_all(self.status_bar.get_context_id("Ready")) context_id = self.status_bar.get_context_id("Ready") #print context_id text = "Ready" self.status_bar.push(context_id, text) return False #def Quit(self, widget, data=None): ##print 'Byez!' #gtk.main_quit() #def Pause(self, widget=None, data=None): #self.som.Pause() #if self.som.paused: #self.pause.set_label("Unpause") #else: #self.pause.set_label("Pause") #glib.idle_add(self.som.Run) #glib.idle_add(self.If_running) #glib.idle_add(self.Status_update) def open_file(self, file_name): try: #cols = self.columns[self.combobox.get_active()] #print cols self.data = np.genfromtxt(file_name, delimiter=',',usecols=(self.visual_and_acoustic),skip_header=1) self.pattern_labels = np.genfromtxt(file_name, delimiter=',',usecols=(self.visual_and_acoustic), skip_footer=14, dtype=str) self.file_name = file_name self.update_treeview(self.data, self.patterns_liststore) #print self.data except: print "File is probably not in the right format:", file_name raise def select_file(self, widget=None, data=None): #response = self.dialog.run() #if response == gtk.RESPONSE_OK: #self.open_file(self.dialog.get_filename()) #elif response == gtk.RESPONSE_CANCEL: #print 'Closed, no files selected' #self.dialog.destroy() dialog = gtk.FileChooserDialog("Open..", None, gtk.FILE_CHOOSER_ACTION_OPEN, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) dialog.set_default_response(gtk.RESPONSE_OK) tmp = os.getcwd() tmp = 'file://' + tmp #print tmp #print dialog.set_current_folder_uri(tmp) #print dialog.get_current_folder_uri() filter = gtk.FileFilter() filter.set_name("All files") filter.add_pattern("*") dialog.add_filter(filter) filter = gtk.FileFilter() filter.set_name("Comma-separated values") filter.add_pattern("*.csv") dialog.add_filter(filter) dialog.set_filter(filter) #dialog = gtk.FileChooserDialog("Please choose a file", self, #gtk.FileChooserAction.OPEN, #(gtk.STOCK_CANCEL, gtk.ResponseType.CANCEL, #gtk.STOCK_OPEN, gtk.ResponseType.OK)) response = dialog.run() if response == gtk.RESPONSE_OK: #print("Open clicked") #print("File selected: " + dialog.get_filename()) self.open_file(dialog.get_filename()) #elif response == gtk.RESPONSE_CANCEL: #print("Cancel clicked") dialog.destroy() def Run(self, widget=None, data=None): #self.som.ticks += self.iterations_spin_button.get_value_as_int() if not self.som.running: ### Initialization and training ### #self.som = MiniSom(5, 15, 8,sigma=1.2,learning_rate=0.5) #self.init_som() for i in range(1): self.train_som() #self.figure.clf() self.Draw_figure() self.canvas.draw() self.canvas.draw_idle() #We need to draw *and* flush self.figure.canvas.draw() self.figure.canvas.flush_events() #print "draw" self.update_treeview(self.test_data, self.test_liststore) self.update_treeview(self.data, self.patterns_liststore) glib.idle_add(self.Status_update) glib.idle_add(self.If_running) glib.idle_add(self.If_paused) def Test(self, widget=None, data=None): #self.som.ticks += self.iterations_spin_button.get_value_as_int() if not self.som.running: ### Initialization and training ### #self.som = MiniSom(5, 15, 8,sigma=1.2,learning_rate=0.5) self.test_som() #self.figure.clf() self.Draw_figure() self.canvas.draw() self.canvas.draw_idle() #We need to draw *and* flush self.figure.canvas.draw() self.figure.canvas.flush_events() #print "draw" glib.idle_add(self.Status_update) glib.idle_add(self.If_running) glib.idle_add(self.If_paused) def Reset(self, widget=None, data=None): self.init_som() self.Draw_figure() self.canvas.draw() self.canvas.draw_idle() #We need to draw *and* flush self.figure.canvas.draw() self.figure.canvas.flush_events() #print "draw" self.update_treeview(self.test_data, self.test_liststore) self.update_treeview(self.data, self.patterns_liststore) glib.idle_add(self.Status_update) glib.idle_add(self.If_running) glib.idle_add(self.If_paused) def delete_event(self, widget=None, event=None, data=None): # If you return FALSE in the "delete_event" signal handler, # GTK will emit the "destroy" signal. Returning TRUE means # you don't want the window to be destroyed. # This is useful for popping up 'are you sure you want to quit?' # type dialogs. #print "delete event occurred" # Change FALSE to TRUE and the main window will not be destroyed # with a "delete_event". return False #def on_key_event(self, event): #print('you pressed %s'%event.key) #key_press_handler(event, self.canvas, self.toolbar) def destroy(self, widget=None, data=None): #print "destroy signal occurred" gtk.main_quit() def Draw_figure(self): self.axes.cla() # Clear axis cols = self.columns[self.combobox.get_active()] data = self.data[:, 0:len(cols)] #ion() # Turn on interactive mode. #hold(True) # Clear the plot before adding new data. #print som.distance_map().T #exit() bone() background = self.axes.pcolor(self.som.distance_map().T) # plotting the distance map as background #f.colorbar(a) t = np.zeros(len(self.target),dtype=int) t[self.target == 'A'] = 0 t[self.target == 'B'] = 1 t[self.target == 'C'] = 2 t[self.target == 'D'] = 3 # use different colors and markers for each label markers = ['o','s','D', '+'] colors = ['r','g','b', 'y'] for cnt,xx in enumerate(data): w = self.som.winner(xx) # getting the winner # place a marker on the winning position for the sample xx tmp = self.axes.plot(w[0]+.5,w[1]+.5,markers[t[cnt]],markerfacecolor='None', markeredgecolor=colors[t[cnt]],markersize=12,markeredgewidth=2) self.axes.axis([0,self.som.weights.shape[0],0,self.som.weights.shape[1]]) #show() # show the figure #print "drawing" #self.figure.canvas.draw() def init_som(self, widget=None, data=None): ##print self.data ### Initialization and training ### cols = self.columns[self.combobox.get_active()] data = self.data[:, 0:len(cols)] #print len(cols) self.som = MiniSom(self.width_spin_button.get_value_as_int(), self.height_spin_button.get_value_as_int(), len(cols),sigma=1.2,learning_rate=0.5) # self.som.weights_init_gliozzi(data) self.som.random_weights_init(data) def train_som(self): cols = self.columns[self.combobox.get_active()] data = self.data[:, 0:len(cols)] print("Training...") #self.som.train_gliozzi(data) # Gliozzi et al training self.som.train_random(data,20) print("\n...ready!") def make_treeview(self, data, liststore): #i = 0 cols = self.columns[self.combobox.get_active()] #print type(cols) #print len(cols) for d in data: #i += 1 tmp = d.tolist() #print 'tmp', tmp #while len(tmp) < cols: #tmp.append(False) #print 'tmp', tmp #cols = cols - 1 Qe = MiniSom.quantization_error_subset(self.som,d,len(cols)) #print tmp tmp.append(Qe) tmp.append(4 * Qe ** 0.5) liststore.append(tmp) treeview = gtk.TreeView(model=liststore) #i = 0 for d in range(len(self.test_data[0])): #print i #i += 1 renderer_text = gtk.CellRendererText() column_text = gtk.TreeViewColumn(self.pattern_labels[d], renderer_text, text=d) treeview.append_column(column_text) column_text = gtk.TreeViewColumn('Qe', renderer_text, text=d+1) treeview.append_column(column_text) column_text = gtk.TreeViewColumn('NLT', renderer_text, text=d+2) treeview.append_column(column_text) return treeview def update_treeview(self, data, liststore): cols = len(self.columns[self.combobox.get_active()]) for i, d in enumerate(data): for j in range(len(d)): #print j liststore[i][j] = d[j] if j >= cols: liststore[i][j] = -999 Qe = MiniSom.quantization_error_subset(self.som,d,cols) #print d, liststore[i] liststore[i][-2]= Qe liststore[i][-1]= 4 * Qe ** 0.5 def select_columns(self, widget=None): #self.open_file(self.file_name) #self.init_som() self.update_treeview(self.test_data, self.test_liststore) self.update_treeview(self.data, self.patterns_liststore) #---------------------------------------- # SAM added these functions here def pertSomWeights( self, widget=None, data=None ): #if scale == None: scale = .5 print( 'Adding noise to SOM weights') # print( self.som.weights ) # print( self.som.weights.shape ) pertAmount = scale*(np.random.random_sample( self.som.weights.shape)-.5) self.som.weights = self.som.weights + pertAmount # print self.som.weights self.Draw_figure() self.canvas.draw() self.canvas.draw_idle() #We need to draw *and* flush self.figure.canvas.draw() self.figure.canvas.flush_events() def pertInputs( self, widget=None, data=None ): #if scale == None: p = .2 print( 'Making %f prop of inputs 0.5' %p) #print( self.data.shape ) # randomly get indices to switch, then replace noiseIndex = np.random.binomial(1,p, self.data.shape) #ones at p proportion of samples self.data[noiseIndex ==1 ] = .5 print( self.data ) # update the treeview for the "Patterns" tab to see the result graphically self.update_treeview(self.data, self.patterns_liststore) #---------------------------------------- def __init__(self): # create a new window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) # When the window is given the "delete_event" signal (this is given # by the window manager, usually by the "close" option, or on the # titlebar), we ask it to call the delete_event () function # as defined above. The data passed to the callback # function is NULL and is ignored in the callback function. self.window.connect("delete_event", self.delete_event) # Here we connect the "destroy" event to a signal handler. # This event occurs when we call gtk_widget_destroy() on the window, # or if we return FALSE in the "delete_event" callback. self.window.connect("destroy", self.destroy) #window.set_icon_from_file(get_resource_path("icon.png")) #window.connect("delete-event", Quit) #window.connect("destroy", Quit) self.window.set_title("SOM model") self.window.set_default_size(500, 500) #this si to ensure the window is always the smallest it can be #self.window.set_resizable(False) #window.set_border_width(10) # Args are: homogeneous, spacing, expand, fill, padding homogeneous = False spacing = 0 expand = False fill = False padding = 10 self.hbox = gtk.HBox(homogeneous, spacing) self.vbox = gtk.VBox(homogeneous, spacing) self.window.add(self.vbox) #self.adjustment = gtk.Adjustment(value=10000, lower=1, upper=100000000, step_incr=1000, page_incr=10000) #self.iterations_spin_button = gtk.SpinButton(self.adjustment, climb_rate=0, digits=0) self.label = gtk.Label("Dimensions:") self.adjustment = gtk.Adjustment(value=5, lower=1, upper=100, step_incr=2, page_incr=5) self.width_spin_button = gtk.SpinButton(self.adjustment, climb_rate=0, digits=0) self.adjustment = gtk.Adjustment(value=10, lower=1, upper=100, step_incr=2, page_incr=5) self.height_spin_button = gtk.SpinButton(self.adjustment, climb_rate=0, digits=0) # Create a series of buttons with the appropriate settings image = gtk.Image() # (from http://www.pygtk.org/docs/pygtk/gtk-stock-items.html) image.set_from_stock(gtk.STOCK_EXECUTE, 1) self.play = gtk.Button() self.play.set_image(image) self.play.set_label("Train") #image = gtk.Image() ## (from http://www.pygtk.org/docs/pygtk/gtk-stock-items.html) #image.set_from_stock(gtk.STOCK_APPLY, 1) #self.test = gtk.Button() #self.test.set_image(image) #self.test.set_label("Test") image = gtk.Image() # (from http://www.pygtk.org/docs/pygtk/gtk-stock-items.html) image.set_from_stock(gtk.STOCK_OPEN, 1) self.open = gtk.Button() self.open.set_image(image) self.open.set_label("Open patterns") #self.pause = gtk.Button(stock = gtk.STOCK_MEDIA_PAUSE) image = gtk.Image() image.set_from_stock(gtk.STOCK_REFRESH, 1) self.reset = gtk.Button() self.reset.set_image(image) self.reset.set_label("Reset") self.play.connect("clicked", self.Run, None) #self.test.connect("clicked", self.Test, None) self.open.connect("clicked", self.select_file, None) #self.pause.connect("clicked", self.Pause, None) self.reset.connect("clicked", self.Reset, None) self.height_spin_button.connect("value-changed", self.Reset, "Height changed") self.width_spin_button.connect("value-changed", self.Reset, "Width changed") # add perturb button to disturb trained som weights self.perturb = gtk.Button("Perturb SOM") # create gtk button to perturb som weights self.perturb.connect( "clicked", self.pertSomWeights, None ) # run self.pertSomWeights self.perturb.show() # tell GTK to show button, but not where # add button to add noisy encoding to training inputs self.perturbInputButton = gtk.Button("Perturb Inputs") # create gtk button to perturb som weights self.perturbInputButton.connect( "clicked", self.pertInputs, None ) # run self.pertSomWeights self.perturbInputButton.show() # tell GTK to show button, but not where #self.width_spin_button.connect("value_changed", self.init_som) #self.height_spin_button.connect("value_changed", self.init_som) #self.som = Environment(width = self.width_spin_button.get_value_as_int(), height = self.height_spin_button.get_value_as_int()) #self.som.show() #self.pause.set_sensitive(self.som.paused) #self.vbox.pack_start(self.som, True, True, 0) #file_names = # ['stimuli.csv'] allFileName = '4750.csv' #'stimuli.csv' self.file_name = allFileName #'4749.csv' # 'stimuli.csv' # file_names[0] self.test_file_name = allFileName #'4749.csv' # 'stimuli.csv' self.visual_only = [0,1,2,3,4,5,6,7] self.visual_and_acoustic = [0,1,2,3,4,5,6,7,8] self.columns = [self.visual_only, self.visual_and_acoustic] #f = Figure(figsize=(5,4), dpi=100) #a = f.add_subplot(111) self.combobox = gtk.combo_box_new_text() self.combobox.append_text('Visual only') self.combobox.append_text('Visual and acoustic') self.test_data = np.genfromtxt(self.test_file_name, delimiter=',',usecols=(self.visual_and_acoustic),skip_header=1) self.test_data += -.5 #0.00001 self.test_data = np.apply_along_axis(lambda x: x/np.linalg.norm(x),1,self.test_data) # data normalization self.target = np.genfromtxt(self.file_name,delimiter=',',usecols=(9),dtype=str,skip_header=1) # loading the labels for use in the figure self.combobox.set_active(1) self.combobox.connect('changed', self.Reset) #cols = self.columns[self.combobox.get_active()] #print cols self.data = np.genfromtxt(self.file_name, delimiter=',',usecols=(self.visual_and_acoustic),skip_header=1) self.data += -.5 #0.00001 self.data = np.apply_along_axis(lambda x: x/np.linalg.norm(x),1,self.data) # data normalization #self.pattern_labels = np.genfromtxt(self.file_name, delimiter=',',usecols=(self.visual_and_acoustic), skip_footer=14, dtype=str) self.pattern_labels = np.genfromtxt(self.file_name, delimiter=',',usecols=(self.visual_and_acoustic), dtype=str)[0] #print self.pattern_labels self.init_som() #self.toolbar = NavigationToolbar(self.canvas, self.window) #self.vbox.pack_start(self.toolbar, False, False) #self.vbox.pack_start(self.canvas) self.test_liststore = gtk.ListStore(float, float, float, float, float, float, float, float, float, float, float) self.patterns_liststore = gtk.ListStore(float, float, float, float, float, float, float, float, float, float, float) self.test_treeview = self.make_treeview(self.test_data, self.test_liststore) self.patterns_treeview = self.make_treeview(self.data, self.patterns_liststore) #self.data = np.genfromtxt(self.file_name, delimiter=',',usecols=(0,1,2,3,4,5,6,7),skip_header=1) #self.pattern_labels = np.genfromtxt(self.file_name, delimiter=',',usecols=(0,1,2,3,4,5,6,7), skip_footer=8, dtype=str) ##self.data = np.apply_along_axis(lambda x: x/np.linalg.norm(x),1,self.data) # data normalization self.figure, self.axes= plt.subplots() # Create canvas. self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea self.canvas.set_size_request(300, 400) self.Draw_figure() self.notebook = gtk.Notebook() self.notebook.set_tab_pos(gtk.POS_TOP) self.vbox.pack_start(self.notebook) label = gtk.Label("Distance map") self.notebook.append_page(self.canvas, label) label = gtk.Label("Patterns") self.notebook.append_page(self.patterns_treeview, label) label = gtk.Label("Testing") #hbox = gtk.HBox(homogeneous, spacing) self.notebook.append_page(self.test_treeview, label) #hbox.pack_start(test_treeview, expand, fill, 0) #hbox.pack_start(test_treeview, expand, fill, 0) self.patterns_treeview.show() self.test_treeview.show() self.canvas.draw_idle() self.canvas.show() self.figure.canvas.draw() self.vbox.pack_start(self.hbox, expand, fill, 10) self.status_bar = gtk.Statusbar() self.vbox.pack_start(self.status_bar, expand, fill, 0) self.status_bar.show() glib.idle_add(self.Status_update) self.hbox.show() self.vbox.show() self.play.show() #self.test.show() self.open.show() #self.pause.show() self.reset.show() #self.iterations_spin_button.show() self.width_spin_button.show() self.height_spin_button.show() self.hbox.pack_start(self.play, expand, fill, padding) #self.hbox.pack_start(self.test, expand, fill, padding) self.hbox.pack_start(self.open, expand, fill, padding) self.hbox.pack_start(self.combobox, expand, fill, padding) #self.hbox.pack_start(self.pause, expand, fill, 0) self.hbox.pack_start(self.reset, expand, fill, padding) #self.hbox.pack_start(self.iterations_spin_button, expand, fill, 0) self.hbox.pack_start(self.label, expand, fill, padding) self.hbox.pack_start(self.width_spin_button, expand, fill, padding) self.hbox.pack_start(self.height_spin_button, expand, fill, 0) self.hbox.pack_start( self.perturb, expand, fill, padding) self.hbox.pack_start( self.perturbInputButton, expand, fill, padding) #self.quit = gtk.Button("Quit") self.quit = gtk.Button(stock = gtk.STOCK_QUIT) self.combobox.connect('changed', self.select_columns) self.quit.connect("clicked", self.destroy, None) self.hbox.pack_end(self.quit, expand, fill, padding) self.quit.show() #print window.get_size() self.window.show_all() self.window.present() #gtk.main() # And of course, our main loop. #gtk.main() # Control returns here when main_quit() is called return None def main(self): # All PyGTK applications must have a gtk.main(). Control ends here # and waits for an event to occur (like a key press or mouse event). gtk.main()
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()
def __init__(self, data=None, orient="LPS", overlay=None, colormap=cm.gray, pixdim=None): ## import sys print sys.argv if data == None: try: fn = sys.argv[1] from mri import img data = img.read(fn) except AttributeError: print "not passing data arg" pass try: data.qform print "think its a nifti volume" nim = data mrdata = nim.data print shape(mrdata) pixdim = nim.voxdim[::-1] except AttributeError: if pixdim != None: print "using user supplied pixeldimensions", pixdim else: print "probably not a nifti volume. using voxel units instead of actual distance units" pixdim = [1.0, 1.0, 1.0] # unitless mrdata = data ## self.win = gtk.Window() # win.connect("destroy", lambda x: gtk.main_quit()) self.win.connect("delete-event", self.hideinsteadofdelete) self.win.set_default_size(600, 600) self.win.set_title("Embedding in GTK") vbox = gtk.VBox() self.win.add(vbox) fig = figure() # figsize=(5,4), dpi=100) # subplots_adjust(left=.15, bottom=.15,right=1, top=.95,wspace=.25, hspace=.35) # a = fig.add_subplot(111) # t = arange(0.0,3.0,0.01) # s = sin(2*pi*t) # a.plot(t,s) # a.plot(data) ax1 = fig.add_subplot(221) # axis('off') # colorbar(fig,ax=ax1) xlabel("Anterior (A->P 1st Dim)") ylabel("Right (R->L 2nd Dim)") ax2 = fig.add_subplot(222) # axis('off') xlabel("Inferior (I->S Dim)") ylabel("Anterior (A->P 1st Dim)") ax3 = fig.add_subplot(223) # axis('off') xlabel("Infererior (I->S 3rd dim)") ylabel("Right (R->L 2nd Dim)") coord = fig.add_subplot(224) axis("off") tracker = IndexTracker(mrdata, ax1, ax2, ax3, colormap, pixdim, overlay, coord) # fig.canvas.mpl_connect('scroll_event', tracker.onscroll) cid = connect("button_press_event", tracker.click) print ("something") sw = gtk.ScrolledWindow() vbox.pack_start(sw) # self.win.add (sw) ## A scrolled window border goes outside the scrollbars and viewport sw.set_border_width(10) # policy: ALWAYS, AUTOMATIC, NEVER sw.set_policy(hscrollbar_policy=gtk.POLICY_AUTOMATIC, vscrollbar_policy=gtk.POLICY_ALWAYS) canvas = FigureCanvas(fig) # a gtk.DrawingArea ##vbox.pack_start(canvas) canvas.set_size_request(300, 200) sw.add_with_viewport(canvas) canvas.draw() # manager = get_current_fig_manager() ## you can also access the window or vbox attributes this way # toolbar = manager.toolbar ##vbox.pack_start(canvas) # toolbar = NavigationToolbar(canvas, self.win) ##vbox.pack_start(toolbar, False, False) # show() # print tracker # # fig.show() self.win.show_all()
class DataManager(gtk.Window): # global variables needed to share among classes global labels ########################################################################################### def __init__(self): # init gtk::Window gtk.Window.__init__(self) self.set_default_size(600, 800) self.connect('destroy', lambda win: gtk.main_quit()) self.set_title('DOSEMATIC v0.1') # variable name -- TODO self.xvariable="Dose" self.xvar="D" self.xunits="Gy" self.yvariable="Yield" self.yvar="Y" self.yunits="" # main layout container main_eb = gtk.EventBox() # horizontal box hbox = gtk.HBox(False, 8) # vertical box VBOX = gtk.VBox(False, 0) main_eb.add(VBOX) #main_eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(red=60000,green=60000,blue=60000)) self.add(main_eb) vbox1 = gtk.VBox(False,8) hbox.pack_start(vbox1, True, True) top_band = gtk.HBox() bottom_band = gtk.HBox() top_eb = gtk.EventBox() bottom_eb = gtk.EventBox() top_eb.add(top_band) bottom_eb.add(bottom_band) top_eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0,0,0)) bottom_eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0,0,0)) l1 = gtk.Label('DOSEMATIC v1.0 --- beta testing --- module 1, basic view') l2 = gtk.Label('author: Maciej Lewicki [email protected], [email protected]') top_band.add(l1) bottom_band.add(l2) hruler = gtk.HSeparator() hruler2 = gtk.HSeparator() VBOX.pack_start(top_eb,False,False) VBOX.pack_start(hruler,False,True,5) VBOX.pack_start(hbox,True,True) VBOX.pack_start(hruler2,False,True,5) VBOX.pack_end(bottom_eb,False,False) # TEXT SCREEN______________________________________________________ self.text = gtk.TextView() # TEXT VIEW self.text.set_wrap_mode(gtk.WRAP_WORD) # wrap words self.scroll_text = gtk.ScrolledWindow() # into scrollable env self.scroll_text.set_shadow_type(gtk.SHADOW_ETCHED_IN) self.scroll_text.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC) self.scroll_text.add(self.text) text_view_box = gtk.VBox(False,5) text_view_box.pack_start(self.scroll_text,True,True) #__________________________________________________________________ # ESTIMATOR________________________________________________________ estimator_box = gtk.HBox(False,5) self.estxt = gtk.TextView() self.estxt.set_wrap_mode(gtk.WRAP_WORD) self.scroll_estxt = gtk.ScrolledWindow() self.scroll_estxt.set_shadow_type(gtk.SHADOW_ETCHED_IN) self.scroll_estxt.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC) self.scroll_estxt.add(self.estxt) label = gtk.Label(self.yvariable+' = ') entry = gtk.Entry() entry.set_text("0.00") button = gtk.Button('Estimate '+self.xvariable) button.connect('clicked',self.y_estimate,entry) combo = gtk.combo_box_new_text() combo.append_text("Method A") combo.append_text("Method B") combo.append_text("Method C-original") combo.append_text("Method C-simplified") self.method="Method C-simplified" combo.set_active(3) combo.connect('changed', self.on_method_changed) ruler = gtk.HSeparator() grid = gtk.Table(2,4) grid.attach(label, 0,1,0,1) grid.attach(entry, 1,2,0,1) grid.attach(button, 0,2,1,2) grid.attach(ruler,0,2,2,3) grid.attach(combo,0,2,3,4) estimator_box.pack_start(grid,False,False) estimator_box.pack_start(self.scroll_estxt,True,True) #__________________________________________________________________ # FUNCTION TAB_____________________________________________________ function_box = gtk.HBox(False,5) self.ftxt = gtk.TextView() self.ftxt.set_wrap_mode(gtk.WRAP_WORD) self.scroll_ftxt = gtk.ScrolledWindow() self.scroll_ftxt.set_shadow_type(gtk.SHADOW_ETCHED_IN) self.scroll_ftxt.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC) self.scroll_ftxt.add(self.ftxt) label_Y = gtk.Label() label_Y.set_use_markup(True) label_Y.set_markup('Y = c + αD + βD<sup>2</sup>') self.entry_c = gtk.Entry() self.entry_c.set_width_chars(5) label_c = gtk.Label('c: ') self.entry_alpha = gtk.Entry() self.entry_alpha.set_width_chars(5) label_alpha = gtk.Label() label_alpha.set_use_markup(True) label_alpha.set_markup('α: ') self.entry_beta = gtk.Entry() self.entry_beta.set_width_chars(5) label_beta = gtk.Label() label_beta.set_use_markup(True) label_beta.set_markup('β: ') self.entry_sc = gtk.Entry() self.entry_sc.set_width_chars(5) label_sc = gtk.Label() label_sc.set_use_markup(True) label_sc.set_markup('σ(c): ') self.entry_salpha = gtk.Entry() self.entry_salpha.set_width_chars(5) label_salpha = gtk.Label() label_salpha.set_use_markup(True) label_salpha.set_markup('σ(α): ') self.entry_sbeta = gtk.Entry() self.entry_sbeta.set_width_chars(5) label_sbeta = gtk.Label() label_sbeta.set_use_markup(True) label_sbeta.set_markup('σ(β): ') table_f = gtk.Table(6,3) #table_f.attach(label_Y, False, False) table_f.attach(label_c,0,1,0,1) table_f.attach(self.entry_c,1,2,0,1) table_f.attach(label_alpha,0,1,1,2) table_f.attach(self.entry_alpha,1,2,1,2) table_f.attach(label_beta,0,1,2,3) table_f.attach(self.entry_beta,1,2,2,3) table_f.attach(label_sc,4,5,0,1) table_f.attach(self.entry_sc,5,6,0,1) table_f.attach(label_salpha,4,5,1,2) table_f.attach(self.entry_salpha,5,6,1,2) table_f.attach(label_sbeta,4,5,2,3) table_f.attach(self.entry_sbeta,5,6,2,3) vruler = gtk.VSeparator() table_f.attach(vruler,3,4,0,3,xpadding=10) check_function = gtk.CheckButton("Plot function") check_points = gtk.CheckButton("Plot data points") check_err = gtk.CheckButton("Plot uncertainty band") check_ci_curve = gtk.CheckButton("Plot CI95% band (curve)") check_ci_points = gtk.CheckButton("Plot CI95% band (points)") check_function.set_active(True) check_points.set_active(True) check_err.set_active(True) check_ci_curve.set_active(True) check_ci_points.set_active(True) vbox_checks = gtk.VBox(False, 5) vbox_checks.pack_start(check_function, False, False) vbox_checks.pack_start(check_points, False, False) vbox_checks.pack_start(check_err, False, False) vbox_checks.pack_start(check_ci_curve, False, False) vbox_checks.pack_start(check_ci_points, False, False) check_function.connect('toggled',self.on_toggled, 'function') check_points.connect('toggled',self.on_toggled, 'points') check_err.connect('toggled',self.on_toggled, 'err') check_ci_curve.connect('toggled',self.on_toggled, 'ci_curve') check_ci_points.connect('toggled',self.on_toggled, 'ci_points') hbox_buttons = gtk.HBox(True,5) button_save_f = gtk.Button("Save Funtion") button_load_f = gtk.Button("Load Funtion") hbox_buttons.pack_start(button_save_f,True,True) hbox_buttons.pack_start(button_load_f,True,True) button_save_f.connect('clicked',self.save_function) button_load_f.connect('clicked',self.load_function) left_box = gtk.VBox(False,5) ruler_f1 = gtk.HSeparator() ruler_f2 = gtk.HSeparator() left_box.pack_start(label_Y, False, False) left_box.pack_start(table_f, False, False) left_box.pack_start(ruler_f1, False, True, 5) left_box.pack_start(vbox_checks, False, False) left_box.pack_start(ruler_f2, False, True, 5) left_box.pack_start(hbox_buttons, False, True) function_box.pack_start(left_box, False, False) function_box.pack_start(self.scroll_ftxt, True, True) #__________________________________________________________________ # NOTEBOOK WRAP____________________________________________________ self.notebook = gtk.Notebook() self.notebook.append_page(text_view_box, gtk.Label('Log console')) self.notebook.append_page(estimator_box, gtk.Label('Estimator')) self.notebook.append_page(function_box, gtk.Label('Calibration function')) vbox1.pack_end(self.notebook,True,True) #__________________________________________________________________ # MAT-PLOT-LIB_____________________________________________________ self.fig = Figure(figsize=(6, 4)) # create fig self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(600,400) # set min size self.markers = ['.',',','+','x','|','_','o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd'] self.colors = ['black','blue','green','red','cyan','magenta','yellow','purple','white'] self.pstyle = ['bmh','s','6','red','0.8','black','2','black','0.3','','25','','','20','15','','','20','15'] self.styledict = {} self.styledict["style"]='bmh' self.styledict["point_style"]='s' self.styledict["point_size"]='6' self.styledict["point_color"]='red' self.styledict["point_alpha"]='0.8' self.styledict["line_color"]='black' self.styledict["line_width"]='2' self.styledict["band_color"]='black' self.styledict["band_alpha"]='0.3' self.styledict["title_size"]='25' self.styledict["xtitle_size"]='20' self.styledict["xlabel_size"]='15' self.styledict["ytitle_size"]='20' self.styledict["ylabel_size"]='15' self.nselec = [1,12,5,3,-1,0,-1,0,-1,-1,-1,-1,-1,-1] self.plot_labels = ["Foci per cell vs Dose", "Dose", "Foci per cell", " [Gy]", " []"] #print plt.style.available self.mode='quadratic' self.function = None if self.mode=='linear' : self.function = self.linear elif self.mode=='quadratic' : self.function = self.quadratic self.fit_toggle='active' self.points_toggle=1 self.function_toggle=1 self.err_toggle=1 self.ci_func_toggle=1 self.ci_points_toggle=1 self.plotting() # --- CORE plotting function --- toolbar = NavigationToolbar(self.canvas, self) toolbarbox = gtk.HBox() image = gtk.Image() image.set_from_stock(gtk.STOCK_PROPERTIES, gtk.ICON_SIZE_LARGE_TOOLBAR) options_button = gtk.Button() options_button.add(image) options_button.connect('clicked',self.mpl_options) image2 = gtk.Image() image2.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_LARGE_TOOLBAR) refresh_button = gtk.Button() refresh_button.add(image2) refresh_button.connect('clicked',self.on_refresh_clicked) toolbarbox.pack_start(toolbar, True, True) toolbarbox.pack_end(options_button, False, True) toolbarbox.pack_end(refresh_button, False, True) vbox1.pack_start(toolbarbox, False, False) vbox1.pack_start(self.canvas, True, True) # into box layout #__________________________________________________________________ def plotting(self): plt.style.use(self.pstyle[0]) self.ax1 = self.fig.add_subplot(111) self.ax1.clear() self.ax1.set_title(self.plot_labels[0], fontsize=self.pstyle[10]) self.ax1.set_xlabel(self.plot_labels[1]+self.plot_labels[3], fontsize=int(self.pstyle[13])) self.ax1.set_ylabel(self.plot_labels[2]+self.plot_labels[4], fontsize=int(self.pstyle[17])) self.ax1.tick_params(axis='x', which='both', labelsize=int(self.pstyle[14])) self.ax1.tick_params(axis='y', which='both', labelsize=int(self.pstyle[18])) x = np.arange(-0.1, max(20,200)*1.1, 0.05) xdata=array([100,110,120,130,140,150,160,170,180,190,1000]); ydata=array([100,110,120,130,140,130,160,170,180,190,1000]); if (self.fit_toggle=='active'): self.params, self.rmse, self.p_value, self.std_err, self.dof, self.rss, self.cov_mtx = self.fit_function(xdata,ydata) self.function_changed() if self.function_toggle==1: y = self.function(x,self.params) self.ax1.plot(x,y, color=self.pstyle[5], marker='.', linestyle='None', markersize=float(self.pstyle[6])) if self.ci_func_toggle==1 and self.fit_toggle=='active': conf = self.confidence(x,xdata,len(x),np.mean(xdata),self.dof,self.rmse) upper = self.function(x,self.params) + conf lower = self.function(x,self.params) - conf self.ax1.fill_between(x, lower, upper, facecolor=self.pstyle[7], alpha=float(self.pstyle[8])) if self.ci_points_toggle==1: upper = self.function(x,self.params) + self.confidence_points(x,self.std_err) lower = self.function(x,self.params) - self.confidence_points(x,self.std_err) self.ax1.fill_between(x, lower, upper, facecolor='blue', alpha=float(self.pstyle[8])) if self.err_toggle==1: upper = self.function(x,self.params) + self.uncertainty(x,self.std_err) lower = self.function(x,self.params) - self.uncertainty(x,self.std_err) self.ax1.fill_between(x, lower, upper, facecolor='green', alpha=float(self.pstyle[8])) self.canvas.draw() def on_refresh_clicked(self,button) : self.plotting() def log(self,txt): end_iter = self.text.get_buffer().get_end_iter() self.text.get_buffer().insert(end_iter, txt+'\n') adj = self.scroll_text.get_vadjustment() adj.set_value( adj.upper - adj.page_size ) self.notebook.set_current_page(0) def loges(self,txt): end_iter = self.estxt.get_buffer().get_end_iter() self.estxt.get_buffer().insert(end_iter, txt+'\n') adj = self.scroll_estxt.get_vadjustment() adj.set_value( adj.upper - adj.page_size ) self.notebook.set_current_page(1) def logf(self,txt): end_iter = self.ftxt.get_buffer().get_end_iter() self.ftxt.get_buffer().insert(end_iter, txt+'\n') adj = self.scroll_ftxt.get_vadjustment() adj.set_value( adj.upper - adj.page_size ) self.notebook.set_current_page(2) def linear(self, x, params): return params[0]*x + params[1] def quadratic(self, x, params): return params[0]*x*x + params[1]*x + params[2] def fit_linear(self, x, a, b): return a*x + b def fit_quadratic(self, x, a, b, c): return a*x*x + b*x + c def confidence(self, x, xdata, n, mean_x, dof, RMSE): alpha=0.05 t = stats.t.isf(alpha/2., df=dof) #conf = t * np.sqrt((RSS/(n-2))*(1.0/n + ( (x-mean_x)**2 / ((np.sum(x**2)) - n*(mean_x**2))))) Sxx = np.sum(xdata**2) - np.sum(xdata)**2/n se_a = RMSE / np.sqrt(Sxx) se_b = RMSE * np.sqrt(np.sum(xdata**2)/(n*Sxx)) conf = t * RMSE * np.sqrt( 1./n + (x-mean_x)**2/Sxx) #pred = t * RMSE * np.sqrt(1+1./n + (x-mean_x)**2/Sxx) return conf def uncertainty(self, x, std_err) : return std_err[2] + x*std_err[1] + x*x*std_err[0] def confidence_points(self, x, std_err) : return 1.96*self.uncertainty(x, std_err) def fit_function(self,x,y): # fit the model if self.mode=='linear' : popt, pcov = curve_fit(self.fit_linear, x, y) elif self.mode=='quadratic' : popt, pcov = curve_fit(self.fit_quadratic, x, y) # parameters standard error std_err = np.sqrt(np.diag(pcov)) # degrees of freedom ndata = len(y) npar = len(popt) dof = max(0, ndata - npar) # root mean squared error residuals = y - self.function(x,popt) RSS = sum(residuals**2) MSE = RSS/dof RMSE = np.sqrt(MSE) # t-value t_value = popt/std_err # p-value P(>|t|) p_value=(1 - stats.t.cdf( abs(t_value), dof))*2 return popt, RMSE, p_value, std_err, dof, RSS, pcov def function_changed(self): if self.mode=='quadratic' : self.entry_c.set_text('%.3f' % self.params[2]) self.entry_alpha.set_text('%.3f' % self.params[1]) self.entry_beta.set_text('%.3f' % self.params[0]) self.entry_sc.set_text('%.3f' % self.std_err[2]) self.entry_salpha.set_text('%.3f' % self.std_err[1]) self.entry_sbeta.set_text('%.3f' % self.std_err[0]) self.logf("params:\t[beta\talpha\tc ]") self.logf("values\t\t" + str(self.params)) self.logf("std_err\t" + str(self.std_err)) self.logf("p-value\t" + str(self.p_value)) self.logf("RSS\t" + str(self.rss)) self.logf("RMSE\t" + str(self.rmse)) self.logf("---------------------------------------------------------------------------") def y_estimate(self, button, entry): if not isfloat(entry.get_text()): self.loges("___Not a number!___") return Y = float(entry.get_text()) plist = self.get_fit_params() u = uncer.UCER(Y=Y,par_list=plist) D = u.D if self.method=="Method A": DL, DU = u.method_a() elif self.method=="Method B": DL, DU = u.method_b() elif self.method=="Method C-original": DL, DU = u.method_c1() elif self.method=="Method C-simplified": DL, DU = u.method_c2() xlab=self.xvar ylab=self.yvar self.loges( xlab + " estimation for " + ylab + " = " + str(Y) + " using " + self.method + ":") self.loges( "D = " + str(D) + "; DL = " + str(DL) + "; DU = " + str(DU)) self.loges("-----------------------------------------------------------------") self.ax1.axhline(y=Y,linewidth=1,linestyle='-',color='red') self.ax1.axvline(x=D,linewidth=1,linestyle='-',color='blue') self.ax1.axvline(x=DL,linewidth=1,linestyle='--',color='green') self.ax1.axvline(x=DU,linewidth=1,linestyle='--',color='green') self.canvas.draw() def mpl_options(self,button) : dialog = gtk.Dialog("My Dialog",self,0,(gtk.STOCK_OK, gtk.RESPONSE_OK)) box = dialog.get_content_area() table = gtk.Table(2,18) table.set_row_spacings(5) table.set_col_spacings(5) l=[] l.append(gtk.Label("Canvas Style")) l.append(gtk.Label("Marker Style")) l.append(gtk.Label("Marker Size")) l.append(gtk.Label("Marker Color")) l.append(gtk.Label("Marker Alpha")) l.append(gtk.Label("Line Color")) l.append(gtk.Label("Line Width")) l.append(gtk.Label("CI Band Color")) l.append(gtk.Label("CI Band Alpha")) l.append(gtk.Label("Title")) l.append(gtk.Label("Title size")) l.append(gtk.Label("X-axis title")) l.append(gtk.Label("X-axis unit")) l.append(gtk.Label("X-axis title size")) l.append(gtk.Label("X-axis labels size")) l.append(gtk.Label("Y-axis title")) l.append(gtk.Label("Y-axis unit")) l.append(gtk.Label("Y-axis title size")) l.append(gtk.Label("Y-axis labels size")) hbox=[] hlines=[] for i in range(0,len(l)) : l[i].set_alignment(xalign=0,yalign=0.5) hbox.append(gtk.HBox(False,5)) hlines.append(gtk.HSeparator()) table.attach(l[i],0,1,2*i,2*i+1) table.attach(hbox[i],1,2,2*i,2*i+1) table.attach(hlines[i],0,2,2*i+1,2*i+2) combo_cs = self.create_combobox(plt.style.available,hbox,0) combo_mst = self.create_combobox(self.markers,hbox,1) spin_msz = self.create_spinbutton(hbox,float(self.pstyle[2]), 1.0,20.0,1.0,2, 2) combo_mc = self.create_combobox(self.colors,hbox,3) spin_ma = self.create_spinbutton(hbox,float(self.pstyle[4]), 0.0,1.0,0.05,2, 4) combo_lc = self.create_combobox(self.colors,hbox,5) spin_lw = self.create_spinbutton(hbox,float(self.pstyle[6]), 0.0,10.0,0.5,2, 6) combo_bc = self.create_combobox(self.colors,hbox,7) spin_ba = self.create_spinbutton(hbox,float(self.pstyle[8]), 0.0,1.0,0.05,2, 8) entry_title = self.create_entry(hbox,0, 9) entry_xaxis = self.create_entry(hbox,1, 11) entry_xunit = self.create_entry(hbox,3, 12) entry_yaxis = self.create_entry(hbox,2, 15) entry_yunit = self.create_entry(hbox,4, 16) spin_title_size = self.create_spinbutton(hbox,float(self.pstyle[10]), 10.0,40.0,1.0,1 , 10) spin_xtile_size = self.create_spinbutton(hbox,float(self.pstyle[13]), 10.0,40.0,1.0,1 , 13) spin_xlabels_size = self.create_spinbutton(hbox,float(self.pstyle[14]), 10.0,40.0,1.0,1 , 14) spin_ytile_size = self.create_spinbutton(hbox,float(self.pstyle[17]), 10.0,40.0,1.0,1 , 17) spin_ylabels_size = self.create_spinbutton(hbox,float(self.pstyle[18]), 10.0,40.0,1.0,1 , 18) box.add(table) dialog.show_all() response = dialog.run() if response == gtk.RESPONSE_OK : dialog.destroy() else : dialog.destroy() def create_combobox(self,slist,whereto,n) : combo = gtk.combo_box_new_text() whereto[n].pack_start(combo) for style in slist : combo.append_text(str(style)) combo.set_active(self.nselec[n]) combo.connect('changed', self.on_combo_changed, n) def create_spinbutton(self,whereto,val,mini,maxi,step,digits,n) : adj = gtk.Adjustment(val,mini,maxi,step,0.5,0.0) spin = gtk.SpinButton(adj,step,digits) whereto[n].pack_start(spin) spin.connect('changed',self.on_spin_changed,n) def create_entry(self,whereto,m,n) : entry_title = gtk.Entry() entry_title.set_text(self.plot_labels[m]) whereto[n].pack_start(entry_title) entry_title.connect("activate",self.on_entry_changed,m) def on_combo_changed(self,cb,n): model = cb.get_model() index = cb.get_active() cb.set_active(index) self.pstyle[n] = model[index][0] self.nselec[n]=index self.plotting() def on_spin_changed(self,spin,n) : self.pstyle[n] = spin.get_value() self.plotting() def on_entry_changed(self,entry,n) : self.plot_labels[n] = entry.get_text() self.plotting() def on_toggled(self,button,s) : if(s=='ci_points'): self.ci_points_toggle*=-1 elif(s=='ci_curve'): self.ci_func_toggle*=-1 elif(s=='function'): self.function_toggle*=-1 elif(s=='points'): self.points_toggle*=-1 elif(s=='err'): self.err_toggle*=-1 self.plotting() def save_function(self,button) : file_chooser = gtk.FileChooserDialog("Open...", self, gtk.FILE_CHOOSER_ACTION_SAVE, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK)) response = file_chooser.run() path='' if response == gtk.RESPONSE_OK : path = file_chooser.get_filename() self.logf('Curve saved in file: ' + path) self.logf("---------------------------------------------------------------------------") if ".csv" not in path: path = path + '.csv' file_chooser.destroy() ofile = open(path,"wb") writer = csv.writer(ofile, delimiter=',') writer.writerow(self.params) writer.writerow(self.std_err) writer.writerow(self.p_value) writer.writerow(self.cov_mtx[0]) writer.writerow(self.cov_mtx[1]) writer.writerow(self.cov_mtx[2]) writer.writerow((self.rss, self.rmse, 0.0)) ofile.close() else : file_chooser.destroy() def get_fit_params(self): l=[self.params,self.std_err,self.p_value,self.cov_mtx[0],self.cov_mtx[1],self.cov_mtx[2],[self.rss,self.rmse,0.0]] return l def load_function(self,button) : file_chooser = gtk.FileChooserDialog("Open...", self, gtk.FILE_CHOOSER_ACTION_OPEN, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) response = file_chooser.run() path='' if response == gtk.RESPONSE_OK : path = file_chooser.get_filename() self.logf('Loaded curve from file: ' + path) self.logf("---------------------------------------------------------------------------") f = open(path, 'rt') try: reader = csv.reader(f) l=list(reader) print l self.params=[float(i) for i in l[0]] self.std_err=[float(i) for i in l[1]] self.p_value=[float(i) for i in l[2]] self.cov_mtx=[[float(i) for i in l[3]],[float(i) for i in l[4]],[float(i) for i in l[5]]] self.rss=float(l[6][0]) self.rmse=float(l[6][1]) self.function_changed() self.fit_toggle='inactive' self.points_toggle=False self.plotting() finally: f.close() #self.plotting() file_chooser.destroy() else : file_chooser.destroy() def on_method_changed(self,cb): model = cb.get_model() index = cb.get_active() cb.set_active(index) self.method = model[index][0]
class realTimeVisualisation(gtk.Window): def __init__(self,networkVariables): ''' ''' super(realTimeVisualisation,self).__init__() self.set_size_request(640,690) self.set_position(gtk.WIN_POS_CENTER) self.connect("destroy", gtk.main_quit) self.fig = Figure(figsize=(5,4), dpi=100) self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(640,690) vbox = gtk.VBox(False,1) alignIm = gtk.Alignment(0, 1 , 1, 0) alignIm.add(self.canvas) vbox.pack_start(alignIm) self.add(vbox) self.initNetworkVariables(networkVariables) self.createGraph() updateTime = 1 #len(self.quantitiesToPlot) ## if this time is to fast, it will show nothing gobject.timeout_add(updateTime,self.updateGraph) self.show_all() def initNetworkVariables(self,networkVariables): ''' ''' self.dt = 0.01 self.filename = '../.realtime.viz' self.quantitiesToPlot = ['Pressure','Flow'] self.initialValues = [0,0,0,0,0] #TODO: Try Except Pass should be fixed try: self.dt = networkVariables['dt'] self.filename = networkVariables['filename'] self.quantitiesToPlot = networkVariables['quantitiesToPlot'] self.initialValues = networkVariables['initialValues'] except: pass def updateGraph(self): ''' ''' #TODO: Try Except Pass should be fixed try: with open(''.join([cur,'/',self.filename]),'r') as dataFile: for dataLine in dataFile: dataString = dataLine break os.remove(''.join([cur,'/',self.filename])) except: pass dataDict = {} #TODO: Try Except Pass should be fixed try: dataDict = eval(dataString) except: try: if dataString == 'STOP': return False except: pass pass #TODO: Try Except Pass should be fixed try: for quantity in self.quantitiesToPlot: newValue = dataDict[quantity] ## update y values yvals = self.lines[quantity].get_ydata() yvalsn = np.append(yvals,newValue) self.lines[quantity].set_ydata(yvalsn) ## update x values timeOld = self.lines[quantity].get_xdata() time = np.append(timeOld,[timeOld[-1]+self.dt]) self.lines[quantity].set_xdata(time) ## adjust limits self.adjustAxis(self.axis[quantity],time,yvalsn) # update view() self.canvas.figure = self.fig self.fig.set_canvas(self.canvas) self.canvas.queue_resize() except: pass return True def adjustAxis(self,axis,xVals,yVals): ''' ''' mmF = 0.1 #get values for y yMaxVals = np.max(yVals) yMinVals = np.min(yVals) yMinAx,yMaxAx = axis.get_ylim() #check and correct if necessary if yMaxVals > yMaxAx-mmF*abs(yMaxAx): yMaxAx = yMaxVals+mmF*abs(yMaxVals) if yMinVals < yMinAx+mmF*abs(yMinAx): yMinAx = yMinVals-mmF*abs(yMinVals) #apply y values axis.set_ylim([yMinAx,yMaxAx]) #get values for x xMinVals = np.min(xVals) xMaxVals = np.max(xVals) xMinAx,xMaxAx = axis.get_xlim() #check and correct if necessary if xMaxVals > xMaxAx-mmF*abs(xMaxAx): xMaxAx = xMaxVals+mmF*abs(xMaxVals) if xMinVals < xMinAx+mmF*abs(xMinAx): xMinAx = xMinVals-mmF*abs(xMinVals) #apply y values axis.set_xlim([xMinAx,xMaxAx]) def createGraph(self): ''' ''' numberOfQuantities = len(self.quantitiesToPlot) self.fig.subplots_adjust(hspace = 0.4) self.fig.subplots_adjust(right = 0.85) self.fig.subplots_adjust(top = 0.98) self.fig.subplots_adjust(bottom = 0.2) self.fig.subplots_adjust(hspace = 0.5) self.fig.set_figwidth(8.27) self.fig.set_figheight((11.69/3)*numberOfQuantities) self.lines = {} self.axis = {} i = 0 colors = ['b','r','m','g','k'] for quantity in self.quantitiesToPlot: self.axis[quantity] = self.fig.add_subplot(numberOfQuantities,1,i+1, ylabel=quantity, xlabel='Time', ylim = [self.initialValues[i],self.initialValues[i]-0.001], xlim = [0,0.0001]) self.lines[quantity] = self.axis[quantity].plot(0,self.initialValues[i],color=colors[i] ,linestyle = '-',label=quantity, linewidth = 1.)[0] i = i+1 # update view() self.canvas.figure = self.fig self.fig.set_canvas(self.canvas) self.canvas.queue_resize()
class Correl: def __init__(self,w=None): self.prefix="SH" if w==None: self.win=gtk.Window() self.win.set_title("LGS correlation tool for AO-LAB on %s"%socket.gethostname()) self.win.set_icon_from_file(os.path.join(os.path.split(__file__)[0],"logouc.png")) self.win.connect("delete-event",self.quit) else: self.win=w self.img=None self.pad=0 self.hbox=gtk.HBox() vbox=gtk.VBox() self.win.add(self.hbox) self.hbox.pack_start(vbox,False) h=gtk.HBox() vbox.pack_start(h,False) i=gtk.Image() i.set_from_file(os.path.join(os.path.split(__file__)[0],"logouc.png")) h.pack_start(i,False) b=gtk.Button("Grab") b.set_tooltip_text("Grab calibrated images") h.pack_start(b,False) e=gtk.Entry() e.set_width_chars(4) e.set_text("100") e.set_tooltip_text("Number of frames to average") h.pack_start(e,False) b.connect("clicked",self.grab,e) b=gtk.Button("Update") b.set_tooltip_text("Gets current darc state") b.connect("clicked",self.update) h.pack_start(b,False) b=gtk.Button("Reset") b.set_tooltip_text("Resets to CoG, refslopes to 0") b.connect("clicked",self.reset) h.pack_start(b,False) h=gtk.HBox() vbox.pack_start(h,False) b=gtk.Button("Save ref") b.set_tooltip_text("Gets ref slopes from darc and saves") b.connect("clicked",self.saveRef) h.pack_start(b,False) e=gtk.Entry() e.set_width_chars(10) if os.path.exists("/Canary"): e.set_text("/Canary/data/") else: e.set_text("data/") e.set_tooltip_text("Directory for ref slopes") self.dataDirEntry=e h.pack_start(e,True) h=gtk.HBox() vbox.pack_start(h,False) b=gtk.Button("Load") b.set_tooltip_text("Loads ref slopes and sets in darc") b.connect("clicked",self.loadRef) h.pack_start(b,False) e=gtk.Entry() e.set_width_chars(10) e.set_tooltip_text("Filename for loading ref slopes") self.entrySlopesFilename=e h.pack_start(e,True) h=gtk.HBox() vbox.pack_start(h,False) b=gtk.Button("Compute slopes") b.set_tooltip_text("Computes slopes related to this image") h.pack_start(gtk.Label("Padding:"),False) e=gtk.Entry() e.set_width_chars(4) e.set_text("8") e.set_tooltip_text("FFT padding") self.entryPad=e h.pack_start(e,False) b.connect("clicked",self.computeSlopes,e) h.pack_start(b,False) b=gtk.Button("RTD") b.set_tooltip_text("Start a RTD looking at correlation (this will need restarting if padding changes)") b.connect("clicked",self.rtd) h.pack_start(b,False) h=gtk.HBox() vbox.pack_start(h,False) b=gtk.Button("Upload img") b.set_tooltip_text("upload the correlation image (but don't change centroiding mode") b.connect("clicked",self.upload,e) h.pack_start(b,False) b=gtk.RadioButton(None,"Set to CoG") self.setCoGButton=b b.set_tooltip_text("Set to CoG mode, will restore ref slopes to CoG slopes.") self.setCoGHandle=b.connect("toggled",self.setCoG,e) h.pack_start(b,False) b=gtk.RadioButton(b,"Set to Corr") self.setCorrButton=b b.set_tooltip_text("Set to Correlation mode (LGS only). Updates ref slopes. Doesn't upload new correlation image.") h.pack_start(b,False) fig1=Figure() self.fig1=FigureCanvas(fig1) self.fig1.set_size_request(300,300) self.im=fig1.add_subplot(2,1,1) self.im2=fig1.add_subplot(2,1,2) self.hbox.pack_start(self.fig1,True) vbox.pack_start(gtk.Label("""Instructions: Click "update". Grab some data by clicking grab. This is calibrated pixels. Choose your padding and compute slopes. Then upload img. Then set to correlation. This should automagically update the refslopes so that the AO correction should be unaffected. When you want to update the correlation image, grab some more data, click compute slopes and then upload img. This can be done when already in correlation mode. It will update the ref slopes as necessary. When finished, go back to CoG mode, and you should find the ref slopes are returned to what they were at the start (with maybe slight differences due to floating point rounding error). Clicking reset sets to CoG, and zeros the ref slopes. Clicking load will load the ref slopes from disk and set in darc. Save will save the ref slopes (so do this at the start). Padding should be such that fft wrapping doesn't occur in the RTD image"""),False) self.win.show_all() def quit(self,w,e=None): gtk.main_quit() def grab(self,w,e): nfr=int(e.get_text()) self.img=getImg(nfr) img=self.img[256**2:] img.shape=128,128 self.im.cla() self.im.set_title("rtcCalPxlBuf") self.im.imshow(img) self.fig1.draw() def update(self,w): d=darc.Control(self.prefix) cm=d.Get("centroidMode") if type(cm)==numpy.ndarray and numpy.any(cm[-49:]):#in correlation mode. cur=getCurrentImg() cog=0 print "In correlation mode" else: cur=makeIdent() cog=1 print "In CoG mode" self.setCoGButton.handler_block(self.setCoGHandle) if cog: self.setCoGButton.set_active(True) else: self.setCorrButton.set_active(True) self.setCoGButton.handler_unblock(self.setCoGHandle) self.img=getCurrentImg() print self.img.shape img=self.img[256**2:] img.shape=128,128 self.im.cla() self.im.set_title("Currently used image") self.im.imshow(img) self.fig1.draw() #self.computeSlopes(None,self.entryPad) def reset(self,w): d=darc.Control(self.prefix) d.Set(["centroidMode","refCentroids","corrFFTPattern","corrSubapLoc","corrNpxlx","corrNpxlCum"],["CoG",None,None,None,d.Get("npxlx"),numpy.insert(numpy.cumsum(d.Get("npxlx")*d.Get("npxly")),0,0).astype(numpy.int32)]) def makefilename(self,dironly=0): fdir=self.dataDirEntry.get_text() if not os.path.exists(fdir): rel="" if fdir[0]=='/': rel="/" dirs=fdir.split("/") for d in dirs: rel+=d+"/" if not os.path.exists(rel): print "Making directory %s"%rel os.mkdir(rel) if dironly: return fdir else: return os.path.join(fdir,"corr"+time.strftime("%y%m%d_%H%M%S_")) def saveRef(self,w): d=darc.Control(self.prefix) rf=d.Get("refCentroids") if rf!=None: fn=self.makefilename() fn2=fn+self.prefix+"refCentroids.fits" FITS.Write(rf,fn2) self.entrySlopesFilename.set_text(os.path.split(fn2)[1]) else: print "No ref slopes to save" def loadRef(self,w): dd=self.makefilename(dironly=1) e=self.entrySlopesFilename fname=e.get_text() if len(fname)==0: fname=None else: fname=os.path.join(dd,fname) flist=glob.glob(fname) flist.sort() if len(flist)==0: #file selection fname=None else: fname=flist[-1]#chose latest. e.set_text(os.path.split(fname)[1]) if fname==None: #pop up file selection. f=gtk.FileChooserDialog("Load ref slopes",self.win,action=gtk.FILE_CHOOSER_ACTION_OPEN,buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_REJECT,gtk.STOCK_OK,gtk.RESPONSE_ACCEPT)) f.set_current_folder(dd) f.set_modal(True) fil=gtk.FileFilter() fil.set_name("Ref slopes files") fil.add_pattern("corr*_*_*refCentroids.fits") f.add_filter(fil) f.set_filter(fil) fil=gtk.FileFilter() fil.set_name("All files") fil.add_pattern("*") f.add_filter(fil) resp=f.run() if resp==gtk.RESPONSE_ACCEPT: fname=f.get_filename() f.destroy() if fname!=None: print "Reading %s"%fname data=FITS.Read(fname)[1] d=darc.Control(self.prefix) d.Set("refCentroids",data) self.entrySlopesFilename.set_text(os.path.split(fname)[1]) def computeSlopes(self,w,e): pad=int(e.get_text()) self.newslopes,usernow,self.corr=getSlopes(self.img,pad,1) img=self.corr["correlation"] img=img[self.corr["corrNpxlCum"][2]:] img.shape=self.corr["corrNpxly"][2],self.corr["corrNpxlx"][2] self.pad=pad self.im.cla() self.im.set_title("Correlated img") self.im.imshow(img) self.im2.cla() self.im2.set_title("Update to slopes") self.im2.plot(self.newslopes[288:]) self.fig1.draw() def upload(self,w,e): pad=int(e.get_text()) if pad!=self.pad: self.computeSlopes(None,e) d=gtk.Dialog("Padding changed",self.win,gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,(gtk.STOCK_CANCEL,gtk.RESPONSE_REJECT,gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) d.vbox.pack_start(gtk.Label("Padding has changed since you last computed slopes.\nThese have been recomputed for you to check.\nClick OK to continue.")) d.show_all() resp=d.run() d.destroy() if resp==gtk.RESPONSE_ACCEPT: self.pad=pad if self.pad==pad: newslopes,usenow=getSlopes(self.img,pad) newcorr=makefft(self.img,pad) d=darc.Control(self.prefix) if usenow:#currently in corr mode, so update the slopes... refSlopes=d.Get("refCentroids") if refSlopes==None: refSlopes=-newslopes else: refSlopes-=newslopes newcorr["refCentroids"]=refSlopes d.Set(newcorr.keys(),newcorr.values()) def setCoG(self,w,e): d=darc.Control(self.prefix) if w.get_active(): #has set to cog mode. So change back to cog mode. cm=numpy.zeros((49*5,),numpy.int32) #so get current correlation image, and compute the ref slopes offset. img=makeIdent() #compute padding currently used. sl=d.Get("subapLocation") try: sl2=d.Get("corrSubapLoc") except: sl2=sl.copy() sl.shape=sl.size//6,6 sl2.shape=sl2.size//6,6 padarr=(sl2[:,1::3]-sl2[:,::3])/numpy.where(sl2[:,2::3]==0,1000,sl2[:,2::3])-(sl[:,1::3]-sl[:,::3])/numpy.where(sl[:,2::3]==0,1000,sl[:,2::3]) padused=numpy.max(padarr)//2 print "Calculated currently used padding as %d"%padused slopes,usenow=getSlopes(img,padused) refSlopes=d.Get("refCentroids") if refSlopes==None: refSlopes=-slopes else: refSlopes-=slopes d.Set(["centroidMode","refCentroids"],[cm,refSlopes]) else: #has set to corr mode (but currently in cog mode). img=getCurrentImg() slopes,usenow=getSlopes(img,self.pad) refSlopes=d.Get("refCentroids") if refSlopes==None: refSlopes=-slopes else: refSlopes-=slopes cm=numpy.zeros((49*5,),numpy.int32) cm[-49:]=1 d.Set(["centroidMode","refCentroids"],[cm,refSlopes]) def rtd(self,w): d=darc.Control(self.prefix) try: npxlx=d.Get("corrNpxlx") except: npxlx=d.Get("npxlx") try: npxly=d.Get("corrNpxly") except: npxly=d.Get("npxly") off=(npxlx*npxly)[:-1].sum() os.system("""darcplot --prefix=SH rtcCorrBuf 25 "-mdata=data[%d:];data.shape=%d,%d" &"""%(off,npxly[-1],npxlx[-1]))
class Iverplot_window(object): """ Iverplot_window---main Iverplot GUI object Parameters ----------- Notes ------ """ def __init__(self): self.builder = gtk.Builder() self.builder.add_from_file('iverplot.glade') self.builder.connect_signals(self) self.window = self.builder.get_object('main_window') # add matplotlib figure canvas w, h = self.window.get_size() self.fig = Figure(figsize=(6, 4)) self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(w - 150, -1) vbox = gtk.VBox() toolbar = NavigationToolbar(self.canvas, self.window) vbox.pack_start(self.canvas, True, True) vbox.pack_start(toolbar, False, False) # a little hacky for packing hpane with figure canvas first then tool # bar---not sure if glade is to blame---first, remove tool_vbox then # repack plot_hpaned = self.builder.get_object('plot_hpaned') self.tool_vbox = self.builder.get_object('tool_vbox') plot_hpaned.remove(self.tool_vbox) #plot_hpaned.pack1 (self.canvas, resize=True, shrink=False) plot_hpaned.pack1(vbox, resize=True, shrink=False) plot_hpaned.pack2(self.tool_vbox) # data self.uvclog = None self.lcmlog = None # plot limits self.xlimits = [None, None] self.xlimits_abs = [None, None] # add single plot item self.plotdex = {} self.plot_items = [] self.plot_items.append( Plot_item(self.tool_vbox, self.on_plot_item_selected, self.uvclog, self.lcmlog)) self.update_subplots() # setwin self.setwin = None # set some defaults self.cd_saveas = os.getcwd() self.cd_open = os.getcwd() self.window.show_all() def on_setwin_clicked(self, widget): if self.setwin is None: self.setwin = Setwin(self.canvas, self.fig, self.on_setwin_complete) def on_setwin_complete(self, xmin, xmax): self.xlimits = [xmin, xmax] for p in self.plot_items: ax = self.fig.axes[self.plotdex[p]] p.plot_type.set_limits(ax, *self.xlimits) self.canvas.draw() self.setwin = None def on_setwin_reset(self, widget): if not self.setwin is None: return self.xlimits = [x for x in self.xlimits_abs] for p in self.plot_items: ax = self.fig.axes[self.plotdex[p]] p.plot_type.set_limits(ax, *self.xlimits) self.canvas.draw() def update_subplots(self): self.fig.clear() n = len(self.plot_items) for i, p in enumerate(self.plot_items): p.plot_type.uvclog = self.uvclog p.plot_type.lcmlog = self.lcmlog ax = self.fig.add_subplot(n, 1, i + 1) p.plot_type.plot(ax, *self.xlimits) self.plotdex[p] = i self.canvas.draw() def on_plot_item_selected(self, combo, item): ax = self.fig.axes[self.plotdex[item]] item.plot_type.plot(ax, *self.xlimits) self.canvas.draw() def update_window(self): while gtk.events_pending(): gtk.main_iteration_do(True) def on_add_subplot_clicked(self, widget): if len(self.plot_items) >= 3: return self.plot_items.append( Plot_item(self.tool_vbox, self.on_plot_item_selected, self.uvclog, self.lcmlog)) self.update_subplots() self.update_window() def on_remove_subplot_clicked(self, widget): if len(self.plot_items) <= 1: return item = self.plot_items.pop(-1) item.remove() self.update_subplots() self.update_window() def run_open_dialog(self): open_dlg = self.builder.get_object('open_dialog') #open_dlg.set_current_folder (self.cd_open) open_dlg.set_current_folder( '/home/jeff/data/UMBS_0513/iver28/2013-06-01-dive.046') if len(open_dlg.list_filters()) == 0: all_filter = gtk.FileFilter() all_filter.set_name('All files') all_filter.add_pattern('*') open_dlg.add_filter(all_filter) lcm_filter = gtk.FileFilter() lcm_filter.set_name('LCM logs') lcm_filter.add_pattern('lcmlog*') open_dlg.add_filter(lcm_filter) uvc_filter = gtk.FileFilter() uvc_filter.set_name('UVC logs') uvc_filter.add_pattern('*.log') open_dlg.add_filter(uvc_filter) response = open_dlg.run() fname = None if response == gtk.RESPONSE_OK: fname = open_dlg.get_filename() self.cd_open = os.path.dirname(fname) open_dlg.hide() return fname def on_open_lcm_clicked(self, widget): fname = self.run_open_dialog() if fname: print 'selected', fname def on_open_uvc_clicked(self, widget): fname = self.run_open_dialog() if fname: print 'selected', fname try: self.uvclog = UVCLog(fname) self.xlimits_abs = [ self.uvclog.utime[0], self.uvclog.utime[-1] ] self.xlimits = [x for x in self.xlimits_abs] self.update_subplots() except: print 'could not load correctly' def on_save_as_clicked(self, widget): save_as_dlg = self.builder.get_object('save_as_dialog') save_as_dlg.set_current_folder(self.cd_saveas) save_as_dlg.set_current_name('iverplot.png') if len(save_as_dlg.list_filters()) == 0: all_filter = gtk.FileFilter() all_filter.set_name('All files') all_filter.add_pattern('*') save_as_dlg.add_filter(all_filter) img_filter = gtk.FileFilter() img_filter.set_name('All images') img_filter.add_pattern('*.png') img_filter.add_pattern('*.jpg') img_filter.add_pattern('*.pdf') save_as_dlg.add_filter(img_filter) response = save_as_dlg.run() if response == gtk.RESPONSE_OK: fname = save_as_dlg.get_filename() self.fig.savefig(fname, dpi=self.fig.dpi) self.cd_saveas = os.path.dirname(fname) save_as_dlg.hide() def on_about_clicked(self, widget): about = self.builder.get_object('about_dialog') about.run() about.hide() def on_main_window_destroy(self, widget): gtk.main_quit()
class Image_MovieFrames__GUI(MovieFrames): """ Base class for GUI version of Movie Frames ---> needs matplotlib.backends.backend_gtkagg! do not clear axes each time for the next animation frame ------------- Contains: ------------- self.redraw_flag -- nedeed by MovieEngine """ def __init__(self, seq_plotter): # initialize base class MovieFrames.__init__(self, seq_plotter) # GUI specific members ------- self.main_Window = None # set redraw_flag self.redraw_flag=False def _setup_figure_and_axes(self, mfs): """ Creates figure and axes accordinng to sized in class mfs ------- Params: ------- mfs quasi MovieFrames_Sizes class instance, contains figure sizes and axes boxes """ # set MFS self.MFS = mfs # plot window ---------------------------- # self.figure = Figure(facecolor='white',dpi=self.MFS.dpi) self.figure = Figure(facecolor='white') self.canvas = FigureCanvas(self.figure) self.canvas.set_size_request( *self.MFS.figsize_points ) # axes ----------------------------------- # add as many axes as there are entries in mfs.axes_boxes for box in self.MFS.axes_boxes: self.ax.append( self.figure.add_axes(box) ) def __erase_axes(self): for A in self.ax: A.set_frame_on(False) A.xaxis.set_visible(False) A.yaxis.set_visible(False) def plot(self,**kwargs): """ Makes initial plot and set text for the timelabel """ MovieFrames.plot(self,**kwargs) self.__erase_axes() def replot(self,**kwargs): """ - plotters' plot - erase axes """ # do plot MovieFrames.plot(self,animated=True,**kwargs) self.__erase_axes() def animation_update(self,i_frame): """ Updates plot and timelabel """ for P,A in zip(self.seq_plotter,self.ax): P.animation_update( A, i_frame ) def set_animated(self,val): """ changes *animated* attribute for all changing entries """ for P in self.seq_plotter: P.set_animated(val) def set_main_window(self,window): "Sets the main window for matplotlib widget" self.main_Window=window
class DDTF(gtk.Window): def ddtf(self, el1, el2, el3, sample_rate=400, duration=20, step=128, increment=5): # notes: duration is the length of a window in seconds # increment is the length of a step in seconds # step is the num points in an fft-analysis epoch N = len(el1) dt = 1 / float(sample_rate) fNyq = sample_rate / 2 df = 1 / (step * dt) f = np.arange(0, fNyq, df) #Frequency axis for the FFT count = 0 end_step = N - duration * sample_rate print "end_step ", end_step print "stepping by ", increment * sample_rate for w in np.arange(0, end_step, increment * sample_rate): x = el1[w:w + duration * sample_rate] # should this be - 1 or 2? y = el2[w:w + duration * sample_rate] z = el3[w:w + duration * sample_rate] # Initialize the Cross-Spectral arrays for averaging print "step first is : ", step Sxx = np.zeros((1, step - 1)) # - 1 here? print "Sxx: ", Sxx.shape Syy = Sxx Szz = Sxx Sxy = Sxx Sxz = Sxx Syz = Sxx Szy = Sxx print "xshape : ", x.shape print "Sxx shape : ", Sxx.shape xtemp = np.arange(0, step - 1) xtemp_ones = np.ones(len(xtemp)) print "xtempshape: ", xtemp.shape A = np.vstack([xtemp, xtemp_ones]).T print "A shape: ", A.shape inner_end_step = sample_rate * duration - step print "inner_end_step ", inner_end_step print "step ", step for i in np.arange(0, inner_end_step - 1, step): m, b = np.linalg.lstsq(A, x[i:i + step - 1])[0] # the minus 1? print "m, b: ", m, b trend = m * xtemp + b # print "istep : ", (i+step-1) x[i:i + step - 1] = x[i:i + step - 1] - trend # detrend x[i:i + step - 1] = x[i:i + step - 1] - np.mean(x[i:i + step - 1]) # demean fx = np.fft.fft(x[i:i + step - 1] * np.hanning(step - 1).T) # windowed fft m, b = np.linalg.lstsq(A, y[i:i + step - 1])[0] # the minus 1? trend = m * xtemp + b y[i:i + step - 1] = y[i:i + step - 1] - trend # detrend y[i:i + step - 1] = y[i:i + step - 1] - np.mean(y[i:i + step - 1]) # demean fy = np.fft.fft(y[i:i + step - 1] * np.hanning(step - 1).T) # windowed fft m, b = np.linalg.lstsq(A, z[i:i + step - 1])[0] # the minus 1? trend = m * xtemp + b z[i:i + step - 1] = z[i:i + step - 1] - trend # detrend z[i:i + step - 1] = z[i:i + step - 1] - np.mean(z[i:i + step - 1]) # demean fz = np.fft.fft(z[i:i + step - 1] * np.hanning(step - 1).T) # windowed fft # print "fs are ", fx, fy, fz # print "fxconf ", fx.conj() # print "Sxx ", Sxx.shape, Sxx.shape # print "fxstuff ", ((fx * fx.conj())).shape Sxx = Sxx + (fx * fx.conj()) # print "Sxx2 ", Sxx.shape Syy = Syy + (fy * fy.conj()) Szz = Szz + (fx * fz.conj()) Sxy = Sxy + (fx * fx.conj()) Sxz = Sxz + (fx * fy.conj()) Syz = Syz + (fy * fy.conj()) # print "Sxx shape: ", Sxx.shape # print "Sxy shape: ", Sxy.shape # print "Szy shape: ", Sxx.shape # print "Syz shape: ", Syz.shape Syx = Sxy.conj().T Szx = Sxz.conj().T Szy = Syz.conj().T S11 = abs(Sxx)**2 S12 = abs(Sxy)**2 S13 = abs(Sxz)**2 S21 = abs(Syx)**2 S22 = abs(Syy)**2 S23 = abs(Syz)**2 S31 = abs(Szx)**2 S32 = abs(Szy)**2 S33 = abs(Szz)**2 sumS = S11 + S12 + S13 sumS2 = S21 + S22 + S23 sumS3 = S31 + S32 + S33 NS11 = S11 / S11.max() NS12 = S12 / sumS NS13 = S13 / sumS NS21 = S21 / sumS2 NS22 = S22 / S22.max() NS23 = S23 / sumS2 NS31 = S31 / sumS3 NS32 = S32 / sumS3 NS33 = S33 / S33.max() count += 1 ttle1 = 'Spectrum el1' ttle2 = ' el2 - . el1' ttle3 = ' el3 - . el1' ttle4 = ' el1 - . el2' ttle5 = ' Spectrum el2' ttle6 = ' el3 - . el2' ttle7 = ' el1 - . el3' ttle8 = 'el2 - . el3' ttle9 = 'Spectrum el3' # print "ns11 shape ", NS11.shape # print "f shape ", f.shape # print "f is: " , f # print "step is: ", step # print "shape x, y ", f[1:step/4].shape, NS11[1:step/4].shape # plot.subplot(211) # plot.axis([0, 60, 0, 1]) # print (NS12, NS13, NS21, NS22, NS23, NS31, NS32, NS33) return (f, step, NS11, NS12, NS13, NS21, NS22, NS23, NS31, NS32, NS33) def delete_event(self, widget, event, data=None): return False def destroy(self, widget, data=None): gtk.main_quit() def __init__(self): super(DDTF, self).__init__() self.connect("delete_event", self.delete_event) self.connect("destroy", self.destroy) e1, e2, e3 = signal_gen.signal_gen(.2, .01, .001) (f, step, NS11, NS12, NS13, NS21, NS22, NS23, NS31, NS32, NS33) = self.ddtf(e1, e2, e3) # gtk.Window.__init__(self) self.fig = Figure(figsize=(20, 15), dpi=72) self.canvas = FigureCanvas(self.fig) self.canvas.set_size_request(1800, 640) t = np.arange(0.0, 50.0, 0.01) xlim = np.array([0, 10]) self.axes = self.fig.add_axes([0.075, 0.25, 0.9, 0.725], axisbg='#FFFFCC') self.axes.plot( t, np.sin(2 * 0.32 * np.pi * t) * np.sin(2 * 2.44 * np.pi * t)) self.axes.set_xlim([0.0, 10.0]) self.axes.set_xticklabels([]) self.axesSpec = self.fig.add_axes([0.075, 0.05, 0.9, 0.2]) t = self.axesSpec.text( 0.5, 0.5, 'Click on EEG channel for spectrogram (scroll mouse to expand)', verticalalignment='center', horizontalalignment='center', ) t.set_transform(self.axes.transAxes) self.axesSpec.set_xlim([0.0, 10.0]) self.axesSpec.set_xticklabels([]) self.axesSpec.set_yticklabels([]) self.canvas.show() self.show() # self.axes.plot(f[step/4],NS11[:,0:step/4],'k') # plot.plot([1,2,3,4]) # plot.show() def main(self): gtk.main()