class WidgetsWrapper(object): def __init__(self): self.widgets = gtk.glade.XML('mpl_with_glade.glade') self.widgets.signal_autoconnect(GladeHandlers.__dict__) self['windowMain'].connect('destroy', lambda x: gtk.main_quit()) self['windowMain'].move(10, 10) self.figure = Figure(figsize=(8, 6), dpi=72) self.axis = self.figure.add_subplot(111) t = arange(0.0, 3.0, 0.01) s = sin(2 * pi * t) self.axis.plot(t, s) self.axis.set_xlabel('time (s)') self.axis.set_ylabel('voltage') self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea self.canvas.show() self.canvas.set_size_request(600, 400) self.canvas.set_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK) self.canvas.set_flags(gtk.HAS_FOCUS | gtk.CAN_FOCUS) self.canvas.grab_focus() def keypress(widget, event): print('key press') def buttonpress(widget, event): print('button press') self.canvas.connect('key_press_event', keypress) self.canvas.connect('button_press_event', buttonpress) def onselect(xmin, xmax): print(xmin, xmax) span = SpanSelector(self.axis, onselect, 'horizontal', useblit=False, rectprops=dict(alpha=0.5, facecolor='red')) self['vboxMain'].pack_start(self.canvas, True, True) self['vboxMain'].show() # below is optional if you want the navigation toolbar self.navToolbar = NavigationToolbar(self.canvas, self['windowMain']) self.navToolbar.lastDir = '/var/tmp/' self['vboxMain'].pack_start(self.navToolbar) self.navToolbar.show() sep = gtk.HSeparator() sep.show() self['vboxMain'].pack_start(sep, True, True) self['vboxMain'].reorder_child(self['buttonClickMe'], -1) def __getitem__(self, key): return self.widgets.get_widget(key)
class WidgetsWrapper(object): def __init__(self): self.widgets = gtk.glade.XML('mpl_with_glade.glade') self.widgets.signal_autoconnect(GladeHandlers.__dict__) self['windowMain'].connect('destroy', lambda x: gtk.main_quit()) self['windowMain'].move(10, 10) self.figure = Figure(figsize=(8, 6), dpi=72) self.axis = self.figure.add_subplot(111) t = arange(0.0, 3.0, 0.01) s = sin(2*pi*t) self.axis.plot(t, s) self.axis.set_xlabel('time (s)') self.axis.set_ylabel('voltage') self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea self.canvas.show() self.canvas.set_size_request(600, 400) self.canvas.set_events( gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK ) self.canvas.set_flags(gtk.HAS_FOCUS | gtk.CAN_FOCUS) self.canvas.grab_focus() def keypress(widget, event): print('key press') def buttonpress(widget, event): print('button press') self.canvas.connect('key_press_event', keypress) self.canvas.connect('button_press_event', buttonpress) def onselect(xmin, xmax): print(xmin, xmax) span = SpanSelector(self.axis, onselect, 'horizontal', useblit=False, rectprops=dict(alpha=0.5, facecolor='red')) self['vboxMain'].pack_start(self.canvas, True, True) self['vboxMain'].show() # below is optional if you want the navigation toolbar self.navToolbar = NavigationToolbar(self.canvas, self['windowMain']) self.navToolbar.lastDir = '/var/tmp/' self['vboxMain'].pack_start(self.navToolbar) self.navToolbar.show() sep = gtk.HSeparator() sep.show() self['vboxMain'].pack_start(sep, True, True) self['vboxMain'].reorder_child(self['buttonClickMe'], -1) def __getitem__(self, key): return self.widgets.get_widget(key)
class 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 add_figure_canvas(self, w=700, h=500): """Note: this method assumed self.main_hbox is already defined. A figure canvas with a toolbar at the bottom is added to self.main_hbox.""" self.fig = Figure(figsize=(8,6), dpi=100) self.ax = self.fig.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.fig) # a gtk.DrawingArea self.figcanvas.show() self.canvas_vbox = gtk.VBox() toolbar = NavigationToolbar(self.figcanvas, self.window) #toolbar.set_size_request(-1,50) self.figcanvas.set_size_request(w,h) toolbar.set_size_request(w,50) toolbar.show() self.canvas_vbox.pack_start(self.figcanvas)#, expand=True, \ #fill=True, padding=5) self.canvas_vbox.pack_start(toolbar, False)#, False)#, padding=5) self.main_hbox.pack_start(self.canvas_vbox)#, expand=True, \
class HurricaneUI: def __init__(self): gladefile = "HurricaneUI.glade" builder = gtk.Builder() builder.add_from_file(gladefile) self.window = builder.get_object("mainWindow") builder.connect_signals(self) self.figure = Figure(figsize=(10, 10), dpi=75) self.axis = self.figure.add_subplot(111) self.lat = 50 self.lon = -100 self.globe = globDisp.GlobeMap(self.axis, self.lat, self.lon) self.canvas = FigureCanvasGTK(self.figure) self.canvas.show() self.canvas.set_size_request(500, 500) self.globeview = builder.get_object("map") self.globeview.pack_start(self.canvas, True, True) self.navToolbar = NavigationToolbar(self.canvas, self.globeview) self.navToolbar.lastDir = '/var/tmp' self.globeview.pack_start(self.navToolbar) self.navToolbar.show() self.gridcombo = builder.get_object("gridsize") cell = gtk.CellRendererText() self.gridcombo.pack_start(cell, True) self.gridcombo.add_attribute(cell, 'text', 0) #self.gridcombo.set_active(2) # read menu configuration self.gridopt = builder.get_object("gridopt").get_active() self.chkDetected = builder.get_object("detectedopt") self.detectedopt = self.chkDetected.get_active() self.chkHurricane = builder.get_object("hurricaneopt") self.hurricaneopt = self.chkHurricane.get_active() model = builder.get_object("liststore1") index = self.gridcombo.get_active() self.gridsize = model[index][0] radio = [ r for r in builder.get_object("classifieropt1").get_group() if r.get_active() ][0] self.sClassifier = radio.get_label() self.start = builder.get_object("startdate") self.end = builder.get_object("enddate") self.chkUndersample = builder.get_object("undersample") self.chkGenKey = builder.get_object("genKey") # disable unimplemented classifier selection builder.get_object("classifieropt2").set_sensitive(False) builder.get_object("classifieropt3").set_sensitive(False) builder.get_object("classifieropt4").set_sensitive(False) self.btnStore = builder.get_object("store") self.datapath = 'GFSdat' self.trackpath = 'tracks' builder.get_object("btnDatapath").set_current_folder(self.datapath) builder.get_object("btnTrackpath").set_current_folder(self.trackpath) self.btnDetect = builder.get_object("detect") # current operation status self.stormlocs = None self.detected = None self.clssfr = None # for test drawing functions if os.path.exists('demo.detected'): with open('demo.detected', 'r') as f: self.detected = pickle.load(f) self.stormlocs = pickle.load(f) self.chkHurricane.set_label( str(self.stormlocs.shape[0]) + " Hurricanes") self.chkDetected.set_label( str(self.detected.shape[0]) + " Detected") self.setDisabledBtns() # draw Globe self.drawGlobe() def setDisabledBtns(self): self.chkDetected.set_sensitive(self.detected != None) self.chkHurricane.set_sensitive(self.stormlocs != None) self.btnStore.set_sensitive(self.clssfr != None) self.btnDetect.set_sensitive(self.clssfr != None) def drawGlobe(self): self.globe.drawGlobe(self.gridsize, self.gridopt) if self.hurricaneopt: self.globe.drawHurricanes(self.stormlocs) if self.detectedopt: self.globe.fillGrids(self.detected) def main(self): self.window.show_all() gtk.main() def redraw(self): self.axis.cla() self.drawGlobe() self.canvas.draw_idle() def gtk_main_quit(self, widget): gtk.main_quit() ############################################################################### # # utility functions (dialogs) # def getFilenameToRead(self, stitle, save=False, filter='all'): chooser = gtk.FileChooserDialog( title=stitle, parent=self.window, action=gtk.FILE_CHOOSER_ACTION_OPEN if not save else gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN if not save else gtk.STOCK_SAVE, gtk.RESPONSE_OK)) chooser.set_default_response(gtk.RESPONSE_OK) if filter == 'mat' or filter == 'mdat': filter = gtk.FileFilter() filter.set_name("Matrix files") filter.add_pattern("*.mat") chooser.add_filter(filter) if filter == 'svm': filter = gtk.FileFilter() filter.set_name("SVM") filter.add_pattern("*.svm") chooser.add_filter(filter) if filter == 'dat' or filter == 'mdat': filter = gtk.FileFilter() filter.set_name("Data") filter.add_pattern("*.dat") chooser.add_filter(filter) filter = gtk.FileFilter() filter.set_name("All files") filter.add_pattern("*") chooser.add_filter(filter) chooser.set_current_folder(os.getcwd()) response = chooser.run() if response == gtk.RESPONSE_OK: filen = chooser.get_filename() else: filen = None chooser.destroy() return filen def showMessage(self, msg): md = gtk.MessageDialog(self.window, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_INFO, gtk.BUTTONS_CLOSE, msg) md.run() md.destroy() ############################################################################### # # read data files and convert into a training matrix input # def on_btnTrackpath_current_folder_changed(self, widget): self.trackpath = widget.get_current_folder() def on_btnDatapath_current_folder_changed(self, widget): self.datapath = widget.get_current_folder() def on_createMat_clicked(self, widget): filen = self.getFilenameToRead("Save converted matrix for training", True, filter='mat') if filen is not None: start = self.start.get_text() end = self.end.get_text() bundersmpl = self.chkUndersample.get_active() bgenkey = self.chkGenKey.get_active() ### FIX ME: currently gridsize for classification is fixed 1 (no clustering of grids - 2x2) if os.path.exists(filen): os.unlink( filen ) # createMat append existing file, so delete it if exist gdtool.createMat(self.datapath, self.trackpath, start, end, store=filen, undersample=bundersmpl, genkeyf=bgenkey) self.showMessage("Matrix has been stored to " + filen) ############################################################################### # # train the selected classifier # def on_train_clicked(self, widget): # FOR NOW, only SVM is supported if self.sClassifier == "SVM": filen = self.getFilenameToRead("Open training data", filter='mat') if filen is not None: data = ml.VectorDataSet(filen, labelsColumn=0) self.clssfr = ml.SVM() self.clssfr.train(data) # train finished. need to update button status self.setDisabledBtns() self.showMessage("Training SVM is done.") else: self.showMessage("The classifier is not supported yet!") def on_classifieropt_toggled(self, widget, data=None): self.sClassifier = widget.get_label() ############################################################################### # # Classify on test data # def on_detect_clicked(self, widget): if self.clssfr is not None: filen = self.getFilenameToRead("Open hurricane data", filter='mdat') if filen is not None: fname = os.path.basename(filen) key, ext = os.path.splitext(fname) if ext == '.dat': key = key[1:] # take 'g' out #testData = gdtool.createMat(self.datapath, self.trackpath, key, key) #result = self.clssfr.test(ml.VectorDataSet(testData,labelsColumn=0)) tmpfn = 'f__tmpDetected__' if os.path.exists(tmpfn): os.unlink(tmpfn) # for DEMO, undersampled the normal data -- without undersampling there are too many candidates gdtool.createMat(self.datapath, self.trackpath, key, key, store=tmpfn, undersample=True, genkeyf=True) bneedDel = True else: tmpfn = fname bneedDel = False result = self.clssfr.test( ml.VectorDataSet(tmpfn, labelsColumn=0)) gdkeyfilen = ''.join([tmpfn, '.keys']) with open(gdkeyfilen, 'r') as f: gridkeys = pickle.load(f) self.stormlocs = pickle.load(f) predicted = result.getPredictedLabels() predicted = np.array(map(float, predicted)) self.detected = np.array(gridkeys)[predicted == 1] if bneedDel: os.unlink(tmpfn) os.unlink(gdkeyfilen) snstroms = str(self.stormlocs.shape[0]) sndetected = str(self.detected.shape[0]) self.chkHurricane.set_label(snstroms + " Hurricanes") self.chkDetected.set_label(sndetected + " Detected") self.showMessage(''.join([ sndetected, "/", snstroms, " grids are predicted to have hurricane." ])) if False: with open('demo.detected', 'w') as f: pickle.dump(self.detected, f) pickle.dump(self.stormlocs, f) # test data tested. update buttons self.setDisabledBtns() self.redraw() else: self.showMessage("There is no trained classifier!") ############################################################################### # # load and store trained classifier # def on_load_clicked(self, widget): filen = self.getFilenameToRead("Load Classifier", filter='svm') if filen is not None: #db = shelve.open(filen) #if db.has_key('clssfr'): # self.clssfr = db['clssfr'] #else: # self.showMessage("Cannot find a classifier!") #db.close() #with open(filen, 'wb') as f: # self.clssfr = pickle.load(f) datfn = self.getFilenameToRead("Open Training Data", filter='mat') if datfn is not None: data = ml.VectorDataSet(datfn, labelsColumn=0) self.clssfr = loadSVM(filen, data) ## Why do I need to feed data ??? #self.clssfr = loadSVM(filen,None) ## edited PyML for this # classifier has been loaded. need to update button status self.setDisabledBtns() self.showMessage("The classifier has been loaded!") def on_store_clicked(self, widget): if self.clssfr is not None: filen = self.getFilenameToRead("Store Classifier", True, filter='svm') if filen is not None: #with open(filen, 'wb') as f: # pickle.dump(self.clssfr,f) #db = shelve.open(filen) #db['clssfr'] = self.clssfr #db.close() self.clssfr.save(filen) self.showMessage("The classifier has been saved!") else: self.showMessage("There is no trained classifier!") ############################################################################### # # Display Globe # def on_right_clicked(self, widget): self.lon += 10 # rotate Globe def on_left_clicked(self, widget): self.lon -= 10 # rotate Globe def gridsize_changed_cb(self, widget): model = widget.get_model() index = widget.get_active() if index > -1: self.gridsize = model[index][0] self.redraw() def on_gridopt_toggled(self, widget): self.gridopt = not self.gridopt self.redraw() def on_Hurricane_toggled(self, widget): self.hurricaneopt = not self.hurricaneopt self.redraw() def on_detected_toggled(self, widget): self.detectedopt = not self.detectedopt self.redraw()
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): 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)
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,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()
class MainWindow: OPTICAL_FLOW_BLOCK_WIDTH = 8 OPTICAL_FLOW_BLOCK_HEIGHT = 8 OPTICAL_FLOW_RANGE_WIDTH = 8 # Range to look outside of a block for motion OPTICAL_FLOW_RANGE_HEIGHT = 8 PROCESSED_FRAME_DIFF = 1 # Classes of pixel in GrabCut algorithm GC_BGD = 0 # background GC_FGD = 1 # foreground GC_PR_BGD = 2 # most probably background GC_PR_FGD = 3 # most probably foreground # GrabCut algorithm flags GC_INIT_WITH_RECT = 0 GC_INIT_WITH_MASK = 1 GC_EVAL = 2 #--------------------------------------------------------------------------- def __init__( self, options, bagFilename = None ): self.options = options self.scriptPath = os.path.dirname( __file__ ) self.image = None self.frameIdx = 0 self.workerThread = None self.numFramesProcessed = 0 self.graphCanvas = None self.graphNavToolbar = None self.PROCESSED_FRAME_DIFF = int( self.options.frameSkip ) # Setup the GUI builder = gtk.Builder() builder.add_from_file( self.scriptPath + "/GUI/ObjectDetectorExplorer.glade" ) self.window = builder.get_object( "winMain" ) self.comboOutput_1_Mode = builder.get_object( "comboOutput_1_Mode" ) self.comboOutput_2_Mode = builder.get_object( "comboOutput_2_Mode" ) self.vboxGraphs = builder.get_object( "vboxGraphs" ) dwgInput = builder.get_object( "dwgInput" ) dwgOutput_1 = builder.get_object( "dwgOutput_1" ) dwgOutput_2 = builder.get_object( "dwgOutput_2" ) self.dwgInputDisplay = Display( dwgInput ) self.dwgOutput_1_Display = Display( dwgOutput_1 ) self.dwgOutput_2_Display = Display( dwgOutput_2 ) self.sequenceControls = builder.get_object( "sequenceControls" ) self.sequenceControls.setNumFrames( 1 ) self.sequenceControls.setOnFrameIdxChangedCallback( self.onSequenceControlsFrameIdxChanged ) builder.connect_signals( self ) #updateLoop = self.update() #gobject.idle_add( updateLoop.next ) self.window.show() if bagFilename != None: self.tryToLoadBagFile( bagFilename ) #--------------------------------------------------------------------------- def onWinMainDestroy( self, widget, data = None ): gtk.main_quit() #--------------------------------------------------------------------------- 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.gdk.threads_init() gtk.main() #--------------------------------------------------------------------------- def isCurFrameReady( self ): return self.frameIdx < self.numFramesProcessed #--------------------------------------------------------------------------- def setFrameIdx( self, frameIdx ): frameReady = frameIdx < self.numFramesProcessed if frameReady or frameIdx == 0: self.frameIdx = frameIdx self.updateDisplay() else: # Try to reset to current frame index if self.isCurFrameReady(): self.sequenceControls.setFrameIdx( self.frameIdx ) else: self.sequenceControls.setFrameIdx( 0 ) #--------------------------------------------------------------------------- def updateDisplay( self ): if self.isCurFrameReady(): self.dwgInputDisplay.setImageFromOpenCVMatrix( self.inputImageList[ self.frameIdx ] ) output_1_Mode = self.comboOutput_1_Mode.get_active_text() if output_1_Mode == OutputMode.OPTICAL_FLOW: self.dwgOutput_1_Display.setImageFromOpenCVMatrix( self.inputImageList[ self.frameIdx ] ) elif output_1_Mode == OutputMode.DETECTED_MOTION: self.dwgOutput_1_Display.setImageFromNumpyArray( self.motionImageList[ self.frameIdx ] ) elif output_1_Mode == OutputMode.SEGMENTATION: self.dwgOutput_1_Display.setImageFromNumpyArray( self.segmentationList[ self.frameIdx ] ) elif output_1_Mode == OutputMode.SALIENCY: self.dwgOutput_1_Display.setImageFromNumpyArray( self.saliencyMapList[ self.frameIdx ] ) elif output_1_Mode == OutputMode.SEGMENTATION_MASK: self.dwgOutput_1_Display.setImageFromNumpyArray( self.segmentationMaskList[ self.frameIdx ] ) output_2_Mode = self.comboOutput_2_Mode.get_active_text() if output_2_Mode == OutputMode.OPTICAL_FLOW: self.dwgOutput_2_Display.setImageFromOpenCVMatrix( self.inputImageList[ self.frameIdx ] ) elif output_2_Mode == OutputMode.DETECTED_MOTION: self.dwgOutput_2_Display.setImageFromNumpyArray( self.motionImageList[ self.frameIdx ] ) elif output_2_Mode == OutputMode.SEGMENTATION: diffImage = np.array( self.motionImageList[ self.frameIdx ], dtype=np.int32 ) \ - np.array( self.imageFlowList[ self.frameIdx ][ 3 ], dtype=np.int32 ) diffImage = np.array( np.maximum( diffImage, 0 ), dtype=np.uint8 ) #self.dwgOutput_2_Display.setImageFromNumpyArray( diffImage ) self.dwgOutput_2_Display.setImageFromNumpyArray( self.segmentationList[ self.frameIdx ] ) elif output_2_Mode == OutputMode.SALIENCY: self.dwgOutput_2_Display.setImageFromNumpyArray( self.saliencyMapList[ self.frameIdx ] ) elif output_2_Mode == OutputMode.SEGMENTATION_MASK: self.dwgOutput_2_Display.setImageFromNumpyArray( self.segmentationMaskList[ self.frameIdx ] ) #--------------------------------------------------------------------------- def chooseBagFile( self ): result = None dialog = gtk.FileChooserDialog( title="Choose Bag File", action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT) ) dialog.set_current_folder( self.scriptPath + "/../../test_data/bags" ) filter = gtk.FileFilter() filter.add_pattern( "*.bag" ) filter.set_name( "Bag Files" ) dialog.add_filter( filter ) dialog.set_filter( filter ) result = dialog.run() if result == gtk.RESPONSE_ACCEPT: result = dialog.get_filename() dialog.destroy() return result #--------------------------------------------------------------------------- def onMenuItemOpenBagActivate( self, widget ): bagFilename = self.chooseBagFile() if bagFilename != None: self.tryToLoadBagFile( bagFilename ) #--------------------------------------------------------------------------- def onMenuItemQuitActivate( self, widget ): self.onWinMainDestroy( widget ) #--------------------------------------------------------------------------- def onSequenceControlsFrameIdxChanged( self, widget ): self.setFrameIdx( widget.frameIdx ) #--------------------------------------------------------------------------- def onComboOutput_1_ModeChanged( self, widget ): self.updateDisplay() #--------------------------------------------------------------------------- def onComboOutput_2_ModeChanged( self, widget ): self.updateDisplay() #--------------------------------------------------------------------------- def onDwgInputExposeEvent( self, widget, data ): self.dwgInputDisplay.drawPixBufToDrawingArea( data.area ) #--------------------------------------------------------------------------- def onDwgOutput_1_ExposeEvent( self, widget, data = None ): imgRect = self.dwgOutput_1_Display.drawPixBufToDrawingArea( data.area ) if imgRect != None: imgRect = imgRect.intersect( data.area ) outputMode = self.comboOutput_1_Mode.get_active_text() self.drawOutputOverlay( widget, imgRect, outputMode ) #--------------------------------------------------------------------------- def onDwgOutput_2_ExposeEvent( self, widget, data = None ): imgRect = self.dwgOutput_2_Display.drawPixBufToDrawingArea( data.area ) if imgRect != None: imgRect = imgRect.intersect( data.area ) outputMode = self.comboOutput_2_Mode.get_active_text() self.drawOutputOverlay( widget, imgRect, outputMode ) #--------------------------------------------------------------------------- def drawOutputOverlay( self, widget, imgRect, outputMode ): if outputMode == OutputMode.OPTICAL_FLOW: # Draw the optical flow if it's available opticalFlowX = self.opticalFlowListX[ self.frameIdx ] opticalFlowY = self.opticalFlowListY[ self.frameIdx ] if opticalFlowX != None and opticalFlowY != None: graphicsContext = widget.window.new_gc() graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 0, 65535, 0 ) ) blockCentreY = imgRect.y + self.OPTICAL_FLOW_BLOCK_HEIGHT / 2 for y in range( opticalFlowX.shape[ 0 ] ): blockCentreX = imgRect.x + self.OPTICAL_FLOW_BLOCK_WIDTH / 2 for x in range( opticalFlowX.shape[ 1 ] ): endX = blockCentreX + opticalFlowX[ y, x ] endY = blockCentreY + opticalFlowY[ y, x ] if endY < blockCentreY: # Up is red graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 65535, 0, 0 ) ) elif endY > blockCentreY: # Down is blue graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 0, 0, 65535 ) ) else: # Static is green graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 0, 65535, 0 ) ) widget.window.draw_line( graphicsContext, int( blockCentreX ), int( blockCentreY ), int( endX ), int( endY ) ) blockCentreX += self.OPTICAL_FLOW_BLOCK_WIDTH blockCentreY += self.OPTICAL_FLOW_BLOCK_HEIGHT elif outputMode == OutputMode.SALIENCY: graphicsContext = widget.window.new_gc() graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 0, 65535, 0 ) ) for cluster in self.saliencyClusterList[ self.frameIdx ]: mean = cluster[ 0 ] stdDev = cluster[ 1 ] arcX = int( imgRect.x + mean[ 0 ] ) arcY = int( imgRect.y + mean[ 1 ] ) # Draw a circle to represent the cluster arcWidth = arcHeight = int( stdDev * 2 ) drawFilledArc = False widget.window.draw_arc( graphicsContext, drawFilledArc, arcX, arcY, arcWidth, arcHeight, 0, 360 * 64 ) #--------------------------------------------------------------------------- def tryToLoadBagFile( self, bagFilename ): # Locate and open file try: bag = rosbag.Bag( bagFilename ) except: print "Error: Unable to load", bagFilename return # Count the number of frames in the bag file numFrames = 0 for topic, msg, t in bag.read_messages(): if msg._type == "sensor_msgs/Image": numFrames += 1 if numFrames == 0: print "Error: No frames in bag file" return numFrames = int( math.ceil( float( numFrames )/int( self.PROCESSED_FRAME_DIFF ) ) ) # Throw away existing data and prepare to process the bag file if self.workerThread != None and self.workerThread.is_alive(): self.workCancelled = True self.workerThread.join() self.inputImageList = [ None for i in range( numFrames ) ] self.grayScaleImageList = [ None for i in range( numFrames ) ] self.motionImageList = [ None for i in range( numFrames ) ] self.opticalFlowListX = [ None for i in range( numFrames ) ] self.opticalFlowListY = [ None for i in range( numFrames ) ] self.segmentationList = [ None for i in range( numFrames ) ] self.segmentationMaskList = [ None for i in range( numFrames ) ] self.imageFlowList = [ ( 0, 0, 0, None ) for i in range( numFrames ) ] self.maxMotionCounts = [ 0 for i in range( numFrames ) ] self.leftMostMotionList = [ 0 for i in range( numFrames ) ] self.saliencyMapList = [ None for i in range( numFrames ) ] self.saliencyClusterList = [ [] for i in range( numFrames ) ] self.numFramesProcessed = 0 # Kick off worker thread to process the bag file self.workCancelled = False self.workerThread = threading.Thread( target=self.processBag, args=( bag, ) ) self.workerThread.daemon = True self.workerThread.start() self.sequenceControls.setNumFrames( numFrames ) #--------------------------------------------------------------------------- def produceSegmentation( self, startFrame, impactMotionImage, preMotionImages, postMotionImages ): ROI_X = 0 ROI_Y = 76 ROI_WIDTH = 230 ROI_HEIGHT = 100 blankFrame = np.zeros( ( startFrame.height, startFrame.width ), dtype=np.uint8 ) imageFlowFilter = ImageFlowFilter() # Create the accumulator image accumulatorArray = np.copy( impactMotionImage ).astype( np.int32 ) # Take maximum values from motion images after the impact but # don't add them in to de-emphasise the manipulator imageNum = 1 for postMotionImage in postMotionImages: print "Aligning post impact image {0}...".format( imageNum ) imageNum += 1 ( transX, transY, rotationAngle, alignedImage ) = \ imageFlowFilter.calcImageFlow( impactMotionImage, postMotionImage ) accumulatorArray = np.maximum( accumulatorArray, alignedImage ) # Dilate and subtract motion images from before the impact imageNum = 1 for preMotionImage in preMotionImages: print "Aligning pre impact image {0}...".format( imageNum ) imageNum += 1 ( transX, transY, rotationAngle, alignedImage ) = \ imageFlowFilter.calcImageFlow( impactMotionImage, preMotionImage ) cv.Dilate( alignedImage, alignedImage ) cv.Dilate( alignedImage, alignedImage ) cv.Dilate( alignedImage, alignedImage ) accumulatorArray = accumulatorArray - alignedImage accumulatorImage = np.clip( accumulatorArray, 0, 255 ).astype( np.uint8 ) # Create the segmentation mask from the accumulator image startMask = np.copy( accumulatorImage ) cv.Dilate( startMask, startMask ) cv.Erode( startMask, startMask ) cv.Dilate( startMask, startMask ) cv.Erode( startMask, startMask ) startMask = scipy.ndimage.filters.gaussian_filter( startMask, 5.0, mode='constant' ) startMask[ startMask > 0 ] = 255 # Find the larget blob in the ROI # Label blobs startMask, numBlobs = PyBlobLib.labelBlobs( startMask ) # Find blobs in the region of interest testMap = np.copy( startMask ) testMap[ :ROI_Y, : ] = 0 # Mask out area above the ROI testMap[ :, :ROI_X ] = 0 # Mask out area to the left of the ROI testMap[ ROI_Y+ROI_HEIGHT: ] = 0 # Mask out area below the ROI testMap[ :, ROI_X+ROI_WIDTH: ] = 0 # Mask out area to the right of the ROI biggestBlobIdx = None biggestBlobSize = 0 for blobIdx in range( 1, numBlobs + 1 ): if testMap[ testMap == blobIdx ].size > 0: blobSize = startMask[ startMask == blobIdx ].size if blobSize > biggestBlobSize: biggestBlobSize = blobSize biggestBlobIdx = blobIdx # Isolate the largest blob if biggestBlobIdx != None: biggestBlobPixels = (startMask == biggestBlobIdx) startMask[ biggestBlobPixels ] = 255 startMask[ biggestBlobPixels == False ] = 0 else: print "No central blob" return blankFrame # Now expand it to get exclusion mask exclusionMask = np.copy( startMask ) for i in range( 10 ): cv.Dilate( exclusionMask, exclusionMask ) cv.Erode( exclusionMask, exclusionMask ) cv.Erode( exclusionMask, exclusionMask ) #---------------------------------------------------- maskArray = np.copy( startMask ) possiblyForeground = ( maskArray > 0 ) & ( accumulatorImage > 0 ) maskArray[ possiblyForeground ] = self.GC_PR_FGD maskArray[ possiblyForeground == False ] = self.GC_PR_BGD maskArray[ exclusionMask == 0 ] = self.GC_BGD definiteMask = np.copy( accumulatorImage ) definiteMask[ possiblyForeground ] = 255 definiteMask[ possiblyForeground == False ] = 0 cv.Erode( definiteMask, definiteMask ) cv.Erode( definiteMask, definiteMask ) maskArray[ definiteMask == 255 ] = self.GC_FGD # Now create the working mask and segment the image workingMask = np.copy( maskArray ) fgModel = cv.CreateMat( 1, 5*13, cv.CV_64FC1 ) cv.Set( fgModel, 0 ) bgModel = cv.CreateMat( 1, 5*13, cv.CV_64FC1 ) cv.Set( bgModel, 0 ) workingImage = np.copy( startFrame ) cv.GrabCut( workingImage, workingMask, (0,0,0,0), fgModel, bgModel, 6, self.GC_INIT_WITH_MASK ) cv.Set( fgModel, 0 ) cv.Set( bgModel, 0 ) bgdPixels = (workingMask != self.GC_PR_FGD) & (workingMask != self.GC_FGD) workingMask[ bgdPixels ] = 0 workingMask[ bgdPixels == False ] = 255 cv.Erode( workingMask, workingMask ) bgdPixels = workingMask == 0 workingMask[ bgdPixels ] = self.GC_PR_BGD workingMask[ bgdPixels == False ] = self.GC_PR_FGD workingMask[ exclusionMask == 0 ] = self.GC_BGD cv.GrabCut( workingImage, workingMask, (0,0,0,0), fgModel, bgModel, 6, self.GC_INIT_WITH_MASK ) segmentation = np.copy( startFrame ) segmentation[ (workingMask != self.GC_PR_FGD) & (workingMask != self.GC_FGD) ] = 0 # Remove everything apart from the biggest blob in the ROI graySeg = np.zeros( ( startFrame.height, startFrame.width ), dtype=np.uint8 ) cv.CvtColor( segmentation, graySeg, cv.CV_RGB2GRAY ) startMask = np.copy( graySeg ) startMask[ startMask > 0 ] = 255 # Find the larget blob in the ROI # Label blobs startMask, numBlobs = PyBlobLib.labelBlobs( startMask ) # Find blobs in the region of interest testMap = np.copy( startMask ) testMap[ :ROI_Y, : ] = 0 # Mask out area above the ROI testMap[ :, :ROI_X ] = 0 # Mask out area to the left of the ROI testMap[ ROI_Y+ROI_HEIGHT: ] = 0 # Mask out area below the ROI testMap[ :, ROI_X+ROI_WIDTH: ] = 0 # Mask out area to the right of the ROI biggestBlobIdx = None biggestBlobSize = 0 for blobIdx in range( 1, numBlobs + 1 ): if testMap[ testMap == blobIdx ].size > 0: blobSize = startMask[ startMask == blobIdx ].size if blobSize > biggestBlobSize: biggestBlobSize = blobSize biggestBlobIdx = blobIdx # Isolate the largest blob if biggestBlobIdx != None: biggestBlobPixels = (startMask == biggestBlobIdx) segmentation[ biggestBlobPixels == False, 0 ] = 255 segmentation[ biggestBlobPixels == False, 1 ] = 0 segmentation[ biggestBlobPixels == False, 2 ] = 255 else: print "No central blob after main segmentation" return blankFrame return segmentation #--------------------------------------------------------------------------- def processBag( self, bag ): FLIP_IMAGE = bool( self.options.frameFlip == "True" ) USING_OPTICAL_FLOW_FOR_MOTION = False print "frameFlip = ", FLIP_IMAGE bagFrameIdx = 0 frameIdx = 0 impactFrameIdx = None # Setup filters opticalFlowFilter = OpticalFlowFilter( self.OPTICAL_FLOW_BLOCK_WIDTH, self.OPTICAL_FLOW_BLOCK_HEIGHT, self.OPTICAL_FLOW_RANGE_WIDTH, self.OPTICAL_FLOW_RANGE_HEIGHT ) motionDetectionFilter = MotionDetectionFilter() imageFlowFilter = ImageFlowFilter() residualSaliencyFilter = ResidualSaliencyFilter() # Process bag file for topic, msg, t in bag.read_messages(): if self.workCancelled: # We've been given the signal to quit break if msg._type == "sensor_msgs/Image": bagFrameIdx += 1 if (bagFrameIdx-1)%self.PROCESSED_FRAME_DIFF != 0: continue print "Processing image", frameIdx # Get input image image = cv.CreateMatHeader( msg.height, msg.width, cv.CV_8UC3 ) cv.SetData( image, msg.data, msg.step ) if FLIP_IMAGE: cv.Flip( image, None, 1 ) # Convert to grayscale grayImage = cv.CreateMat( msg.height, msg.width, cv.CV_8UC1 ) cv.CvtColor( image, grayImage, cv.CV_BGR2GRAY ) grayImageNumpPy = np.array( grayImage ) # Calculate optical flow opticalFlowArrayX, opticalFlowArrayY = \ opticalFlowFilter.calcOpticalFlow( grayImage ) # Detect motion if USING_OPTICAL_FLOW_FOR_MOTION: if frameIdx == 0: motionImage = PyVarFlowLib.createMotionMask( grayImageNumpPy, grayImageNumpPy ) else: motionImage = PyVarFlowLib.createMotionMask( np.array( self.grayScaleImageList[ frameIdx - 1 ] ), grayImageNumpPy ) else: motionImage = motionDetectionFilter.calcMotion( grayImage ) # Work out the left most point in the image where motion appears motionTest = np.copy( motionImage ) cv.Erode( motionTest, motionTest ) if frameIdx == 0: leftMostMotion = motionImage.shape[ 1 ] else: leftMostMotion = self.leftMostMotionList[ frameIdx - 1 ] leftMostMotionDiff = 0 for i in range( leftMostMotion ): if motionTest[ :, i ].max() > 0: leftMostMotionDiff = abs( leftMostMotion - i ) leftMostMotion = i break segmentationMask = np.zeros( ( msg.height, msg.width ), dtype=np.uint8 ) FRAMES_BACK = 3 if impactFrameIdx == None: if leftMostMotionDiff > 18 and leftMostMotion < 0.75*msg.width: # Found impact frame impactFrameIdx = frameIdx else: PROCESS_IMPACT = False if PROCESS_IMPACT and frameIdx - impactFrameIdx == FRAMES_BACK: # Should now have enough info to segment object impactMotionImage = self.motionImageList[ impactFrameIdx ] print "Aligning" postImpactRealFarFlow = imageFlowFilter.calcImageFlow( impactMotionImage, motionImage ) print "Aligning" postImpactFarFlow = imageFlowFilter.calcImageFlow( impactMotionImage, self.motionImageList[ impactFrameIdx + 2 ] ) print "Aligning" postImpactNearFlow = imageFlowFilter.calcImageFlow( impactMotionImage, self.motionImageList[ impactFrameIdx + 1 ] ) segmentationMask = np.maximum( np.maximum( np.maximum( impactMotionImage, postImpactNearFlow[ 3 ] ), postImpactFarFlow[ 3 ] ), postImpactRealFarFlow[ 3 ] ) cv.Dilate( segmentationMask, segmentationMask ) print "Aligning" preImpactRealFarFlow = imageFlowFilter.calcImageFlow( impactMotionImage, self.motionImageList[ impactFrameIdx - 8 ] ) print "Aligning" preImpactFarFlow = imageFlowFilter.calcImageFlow( impactMotionImage, self.motionImageList[ impactFrameIdx - 6 ] ) print "Aligning" preImpactNearFlow = imageFlowFilter.calcImageFlow( impactMotionImage, self.motionImageList[ impactFrameIdx - 4 ] ) subMask = np.maximum( np.maximum( preImpactRealFarFlow[ 3 ], preImpactFarFlow[ 3 ] ), preImpactNearFlow[ 3 ] ) cv.Erode( subMask, subMask ) cv.Dilate( subMask, subMask ) cv.Dilate( subMask, subMask ) cv.Dilate( subMask, subMask ) subMask[ subMask > 0 ] = 255 diffImage = segmentationMask.astype( np.int32 ) - subMask.astype( np.int32 ) diffImage[ diffImage < 0 ] = 0 diffImage = diffImage.astype( np.uint8 ) cv.Erode( diffImage, diffImage ) #diffImage[ diffImage > 0 ] = 255 #segmentationMask = subMask segmentationMask = diffImage #segmentationMask = np.where( diffImage > 128, 255, 0 ).astype( np.uint8 ) # Calculate image flow #imageFlow = imageFlowFilter.calcImageFlow( motionImage ) ## Calculate saliency map #saliencyMap, largeSaliencyMap = residualSaliencyFilter.calcSaliencyMap( grayImageNumpPy ) #blobMap = np.where( largeSaliencyMap > 128, 255, 0 ).astype( np.uint8 ) #blobMap, numBlobs = PyBlobLib.labelBlobs( blobMap ) #print "found", numBlobs, "blobs" #largeSaliencyMap = np.where( largeSaliencyMap > 128, 255, 0 ).astype( np.uint8 ) # Threshold the saliency map #largeSaliencyMap = (largeSaliencyMap > 128).astype(np.uint8) * 255 #cv.AdaptiveThreshold( largeSaliencyMap, largeSaliencyMap, 255 ) # Detect clusters within the saliency map #NUM_CLUSTERS = 5 #numSamples = np.sum( saliencyMap ) #sampleList = np.ndarray( ( numSamples, 2 ), dtype=np.float32 ) #sampleListIdx = 0 #for y in range( saliencyMap.shape[ 0 ] ): #for x in range( saliencyMap.shape[ 1 ] ): #numNewSamples = saliencyMap[ y, x ] #if numNewSamples > 0: #sampleList[ sampleListIdx:sampleListIdx+numNewSamples, 0 ] = x #sampleList[ sampleListIdx:sampleListIdx+numNewSamples, 1 ] = y #sampleListIdx += numNewSamples #sampleList[ 0:numSamples/2 ] = ( 20, 20 ) #sampleList[ numSamples/2: ] = ( 200, 200 ) #labelList = np.ndarray( ( numSamples, 1 ), dtype=np.int32 ) #cv.KMeans2( sampleList, NUM_CLUSTERS, labelList, #(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 10, 0.01) ) #saliencyScaleX = float( largeSaliencyMap.shape[ 1 ] ) / saliencyMap.shape[ 1 ] #saliencyScaleY = float( largeSaliencyMap.shape[ 0 ] ) / saliencyMap.shape[ 0 ] clusterList = [] #for clusterIdx in range( NUM_CLUSTERS ): #clusterSamples = sampleList[ #np.where( labelList == clusterIdx )[ 0 ], : ] #if clusterSamples.size <= 0: #mean = ( 0.0, 0.0 ) #stdDev = 0.0 #else: #mean = clusterSamples.mean( axis=0 ) #mean = ( mean[ 0 ]*saliencyScaleX, mean[ 1 ]*saliencyScaleY ) #stdDev = clusterSamples.std()*saliencyScaleX #clusterList.append( ( mean, stdDev ) ) # Work out the maximum amount of motion we've seen in a single frame so far #motionCount = motionImage[ motionImage > 0 ].size #if frameIdx == 0: #lastMotionCount = 0 #else: #lastMotionCount = self.maxMotionCounts[ frameIdx - 1 ] #if motionCount < lastMotionCount: #motionCount = lastMotionCount ## Work out diffImage #diffImage = np.array( motionImage, dtype=np.int32 ) \ #- np.array( imageFlow[ 3 ], dtype=np.int32 ) #diffImage = np.array( np.maximum( diffImage, 0 ), dtype=np.uint8 ) # Segment the image #workingMask = np.copy( motionImage ) #workingMask = np.copy( diffImage ) workingMask = np.copy( segmentationMask ) kernel = cv.CreateStructuringElementEx( cols=3, rows=3, anchorX=1, anchorY=1, shape=cv.CV_SHAPE_CROSS ) cv.Erode( workingMask, workingMask, kernel ) cv.Dilate( workingMask, workingMask ) extraExtraMask = np.copy( workingMask ) cv.Dilate( extraExtraMask, extraExtraMask ) cv.Dilate( extraExtraMask, extraExtraMask ) cv.Dilate( extraExtraMask, extraExtraMask ) cv.Dilate( extraExtraMask, extraExtraMask ) cv.Dilate( extraExtraMask, extraExtraMask ) cv.Dilate( extraExtraMask, extraExtraMask ) allMask = np.copy( extraExtraMask ) cv.Dilate( allMask, allMask ) cv.Dilate( allMask, allMask ) cv.Dilate( allMask, allMask ) cv.Dilate( allMask, allMask ) cv.Dilate( allMask, allMask ) cv.Dilate( allMask, allMask ) possibleForeground = workingMask > 0 if workingMask[ possibleForeground ].size >= 100 \ and frameIdx >= 16: print "Msk size", workingMask[ possibleForeground ].size print workingMask[ 0, 0:10 ] fgModel = cv.CreateMat( 1, 5*13, cv.CV_64FC1 ) bgModel = cv.CreateMat( 1, 5*13, cv.CV_64FC1 ) #workingMask[ possibleForeground ] = self.GC_FGD #workingMask[ possibleForeground == False ] = self.GC_PR_BGD #workingMask[ : ] = self.GC_PR_BGD #workingMask[ possibleForeground ] = self.GC_FGD workingMask[ : ] = self.GC_BGD workingMask[ allMask > 0 ] = self.GC_PR_BGD workingMask[ extraExtraMask > 0 ] = self.GC_PR_FGD workingMask[ possibleForeground ] = self.GC_FGD if frameIdx == 16: # Save mask maskCopy = np.copy( workingMask ) maskCopy[ maskCopy == self.GC_BGD ] = 0 maskCopy[ maskCopy == self.GC_PR_BGD ] = 64 maskCopy[ maskCopy == self.GC_PR_FGD ] = 128 maskCopy[ maskCopy == self.GC_FGD ] = 255 print "Unused pixels", \ maskCopy[ (maskCopy != 255) & (maskCopy != 0) ].size outputImage = cv.CreateMat( msg.height, msg.width, cv.CV_8UC3 ) cv.CvtColor( maskCopy, outputImage, cv.CV_GRAY2BGR ) cv.SaveImage( "output.png", image ); cv.SaveImage( "outputMask.png", outputImage ); print "Saved images" #return #print "Set Msk size", workingMask[ workingMask == self.GC_PR_FGD ].size imageToSegment = image #self.inputImageList[ frameIdx - FRAMES_BACK ] imageCopy = np.copy( imageToSegment ) cv.CvtColor( imageCopy, imageCopy, cv.CV_BGR2RGB ) print "Start seg" cv.GrabCut( imageCopy, workingMask, (0,0,0,0), fgModel, bgModel, 12, self.GC_INIT_WITH_MASK ) print "Finish seg" segmentation = np.copy( imageToSegment ) segmentation[ (workingMask != self.GC_PR_FGD) & (workingMask != self.GC_FGD) ] = 0 black = (workingMask != self.GC_PR_FGD) & (workingMask != self.GC_FGD) #motionImage = np.where( black, 0, 255 ).astype( np.uint8 ) # Refine the segmentation REFINE_SEG = False if REFINE_SEG: motionImageCopy = np.copy( motionImage ) cv.Erode( motionImageCopy, motionImageCopy ) #cv.Erode( motionImageCopy, motionImageCopy ) #cv.Erode( motionImageCopy, motionImageCopy ) workingMask[ motionImageCopy > 0 ] = self.GC_PR_FGD workingMask[ motionImageCopy == 0 ] = self.GC_PR_BGD cv.Dilate( motionImageCopy, motionImageCopy ) cv.Dilate( motionImageCopy, motionImageCopy ) cv.Dilate( motionImageCopy, motionImageCopy ) cv.Dilate( motionImageCopy, motionImageCopy ) workingMask[ motionImageCopy == 0 ] = self.GC_BGD print "Other seg" cv.GrabCut( imageCopy, workingMask, (0,0,0,0), fgModel, bgModel, 12, self.GC_INIT_WITH_MASK ) print "Other seg done" segmentation = np.copy( imageToSegment ) segmentation[ (workingMask != self.GC_PR_FGD) & (workingMask != self.GC_FGD) ] = 0 black = (workingMask != self.GC_PR_FGD) & (workingMask != self.GC_FGD) motionImage = np.where( black, 0, 255 ).astype( np.uint8 ) else: segmentation = np.zeros( ( image.height, image.width ), dtype=np.uint8 ) # Save output data self.inputImageList[ frameIdx ] = image self.grayScaleImageList[ frameIdx ] = grayImage self.opticalFlowListX[ frameIdx ] = opticalFlowArrayX self.opticalFlowListY[ frameIdx ] = opticalFlowArrayY self.motionImageList[ frameIdx ] = motionImage self.segmentationList[ frameIdx ] = segmentation self.segmentationMaskList[ frameIdx ] = segmentationMask #self.maxMotionCounts[ frameIdx ] = motionCount #self.imageFlowList[ frameIdx ] = imageFlow #self.saliencyMapList[ frameIdx ] = largeSaliencyMap #self.saliencyClusterList[ frameIdx ] = clusterList self.leftMostMotionList[ frameIdx ] = leftMostMotion frameIdx += 1 self.numFramesProcessed += 1 if not self.workCancelled: SAVE_MOTION_IMAGES = True BASE_MOTION_IMAGE_NAME = self.scriptPath + "/../../test_data/motion_images/motion_{0:03}.png" if SAVE_MOTION_IMAGES and len( self.motionImageList ) > 0: width = self.motionImageList[ 0 ].shape[ 1 ] height = self.motionImageList[ 0 ].shape[ 0 ] colourImage = np.zeros( ( height, width, 3 ), dtype=np.uint8 ) for frameIdx, motionImage in enumerate( self.motionImageList ): colourImage[ :, :, 0 ] = motionImage colourImage[ :, :, 1 ] = motionImage colourImage[ :, :, 2 ] = motionImage outputName = BASE_MOTION_IMAGE_NAME.format( frameIdx + 1 ) cv.SaveImage( outputName, colourImage ) # Recalculate impactFrameIdx width = self.motionImageList[ 0 ].shape[ 1 ] totalMotionDiff = 0 maxMotionDiff = 0 impactFrameIdx = None for motionIdx in range( 1, len( self.leftMostMotionList ) ): motionDiff = abs( self.leftMostMotionList[ motionIdx ] \ - self.leftMostMotionList[ motionIdx - 1 ] ) totalMotionDiff += motionDiff if motionDiff > maxMotionDiff and totalMotionDiff > 0.5*width: maxMotionDiff = motionDiff impactFrameIdx = motionIdx if maxMotionDiff <= 18: impactFrameIdx = None if impactFrameIdx != None: preMotionImages = [] postMotionImages = [] impactMotionImage = None NUM_FRAMES_BEFORE = 3 prefix = self.options.outputPrefix if prefix != "": prefix += "_" BASE_MOTION_IMAGE_NAME = self.scriptPath + "/../../test_data/impact_images/" + prefix + "motion_{0:03}.png" START_MOTION_IMAGE_NAME = self.scriptPath + "/../../test_data/impact_images/" + prefix + "start_motion.png" START_IMAGE_NAME = self.scriptPath + "/../../test_data/impact_images/" + prefix + "start.png" IMPACT_IMAGE_NAME = self.scriptPath + "/../../test_data/impact_images/" + prefix + "impact.png" SEGMENTATION_IMAGE_NAME = self.scriptPath + "/../../test_data/impact_images/" + prefix + "segmentation.png" NUM_FRAMES_AFTER = 3 width = self.motionImageList[ 0 ].shape[ 1 ] height = self.motionImageList[ 0 ].shape[ 0 ] colourImage = np.zeros( ( height, width, 3 ), dtype=np.uint8 ) for frameIdx in range( impactFrameIdx - NUM_FRAMES_BEFORE, impactFrameIdx + NUM_FRAMES_AFTER + 1 ): motionImage = self.motionImageList[ frameIdx ] if frameIdx < impactFrameIdx: preMotionImages.append( motionImage ) elif frameIdx == impactFrameIdx: impactMotionImage = motionImage else: # frameIdx > impactFrameIdx postMotionImages.append( motionImage ) colourImage[ :, :, 0 ] = motionImage colourImage[ :, :, 1 ] = motionImage colourImage[ :, :, 2 ] = motionImage outputName = BASE_MOTION_IMAGE_NAME.format( frameIdx - impactFrameIdx ) cv.SaveImage( outputName, colourImage ) motionDetectionFilter.calcMotion( self.grayScaleImageList[ 0 ] ) startMotionImage = motionDetectionFilter.calcMotion( self.grayScaleImageList[ impactFrameIdx ] ) colourImage[ :, :, 0 ] = startMotionImage colourImage[ :, :, 1 ] = startMotionImage colourImage[ :, :, 2 ] = startMotionImage cv.SaveImage( START_MOTION_IMAGE_NAME, colourImage ) cv.CvtColor( self.inputImageList[ 0 ], colourImage, cv.CV_RGB2BGR ) cv.SaveImage( START_IMAGE_NAME, colourImage ) cv.CvtColor( self.inputImageList[ impactFrameIdx ], colourImage, cv.CV_RGB2BGR ) cv.SaveImage( IMPACT_IMAGE_NAME, colourImage ) print "Segmenting..." segmentation = self.produceSegmentation( self.inputImageList[ 0 ], impactMotionImage, preMotionImages, postMotionImages ) cv.CvtColor( segmentation, colourImage, cv.CV_RGB2BGR ) cv.SaveImage( SEGMENTATION_IMAGE_NAME, colourImage ) self.refreshGraphDisplay() print "Finished processing bag file" if bool( self.options.quitAfterFirstSegmentation == "True" ): print "Trying to quit" self.onWinMainDestroy( None ) else: print "Not trying to quit so neeah" #--------------------------------------------------------------------------- def refreshGraphDisplay( self ): # Remove existing graph items if self.graphCanvas != None: self.vboxGraphs.remove( self.graphCanvas ) self.graphCanvas.destroy() self.graphCanvas = None if self.graphNavToolbar != None: self.vboxGraphs.remove( self.graphNavToolbar ) self.graphNavToolbar.destroy() self.graphNavToolbar = None # Draw the graphs self.graphFigure = Figure( figsize=(8,6), dpi=72 ) self.graphAxis = self.graphFigure.add_subplot( 111 ) #self.graphAxis.plot( range( 1, len( self.maxMotionCounts )+1 ), self.maxMotionCounts ) diffs = [ 0 ] + [ self.leftMostMotionList[ i+1 ] - self.leftMostMotionList[ i ] for i in range( len( self.leftMostMotionList ) - 1 ) ] #self.graphAxis.plot( range( 1, len( self.leftMostMotionList )+1 ), self.leftMostMotionList ) self.graphAxis.plot( range( 1, len( self.leftMostMotionList )+1 ), diffs ) # Build the new graph display self.graphCanvas = FigureCanvas( self.graphFigure ) # a gtk.DrawingArea self.graphCanvas.show() self.graphNavToolbar = NavigationToolbar( self.graphCanvas, self.window ) self.graphNavToolbar.lastDir = '/var/tmp/' self.graphNavToolbar.show() # Show the graph self.vboxGraphs.pack_start( self.graphNavToolbar, expand=False, fill=False ) self.vboxGraphs.pack_start( self.graphCanvas, True, True ) self.vboxGraphs.show() self.vboxGraphs.show() #--------------------------------------------------------------------------- def update( self ): lastTime = time.clock() while 1: curTime = time.clock() #print "Processing image", framIdx yield True yield False
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()
class MainWindow: OPTICAL_FLOW_BLOCK_WIDTH = 16 OPTICAL_FLOW_BLOCK_HEIGHT = 16 OPTICAL_FLOW_RANGE_WIDTH = 16 # Range to look outside of a block for motion OPTICAL_FLOW_RANGE_HEIGHT = 16 OPTICAL_FLOW_METHOD = "BlockMatching" #OPTICAL_FLOW_METHOD = "LucasKanade" #OPTICAL_FLOW_METHOD = "HornSchunck" COMBINATION_METHOD = "NoChange" #GROUND_TRUTH_FILENAME = "/../../config/TopPosGripper.yaml" #GROUND_TRUTH_FILENAME = "/../../config/ExperimentPosGripper.yaml" #GROUND_TRUTH_FILENAME = "/../../config/OnTablePosGripper.yaml" GROUND_TRUTH_FILENAME = "/../../config/TightBasicWave_Gripper.yaml" CORRELATION_THRESHOLD = 0.52 MAX_TEST_POINT_X = (640 - OPTICAL_FLOW_BLOCK_WIDTH)/OPTICAL_FLOW_BLOCK_WIDTH - 1 MAX_TEST_POINT_Y = (480 - OPTICAL_FLOW_BLOCK_HEIGHT)/OPTICAL_FLOW_BLOCK_HEIGHT - 1 SAMPLES_PER_SECOND = 30.0 MAX_CORRELATION_LAG = 2.0 GRIPPER_WAVE_FREQUENCY = 1.0 # Waves per second GRIPPER_NUM_WAVES = 3.0 GRIPPER_WAVE_AMPLITUDE = math.radians( 20.0 ) #--------------------------------------------------------------------------- def __init__( self, bagFilename ): self.scriptPath = os.path.dirname( __file__ ) self.cameraImagePixBuf = None self.bagFilename = bagFilename self.lastImageGray = None # Read in sequence t1 = time.time() self.inputSequence = InputSequence( bagFilename ) distractors = [ Distractor( radius=24, startPos=( 25, 35 ), endPos=( 100, 100 ), frequency=2.0 ), Distractor( radius=24, startPos=( 200, 200 ), endPos=( 150, 50 ), frequency=0.25 ), Distractor( radius=24, startPos=( 188, 130 ), endPos=( 168, 258 ), frequency=0.6 ), Distractor( radius=24, startPos=( 63, 94 ), endPos=( 170, 81 ), frequency=1.5 ), Distractor( radius=24, startPos=( 40, 287 ), endPos=( 50, 197 ), frequency=3.0 ) ] #self.inputSequence.addDistractorObjects( distractors ) self.inputSequence.calculateOpticalFlow( self.OPTICAL_FLOW_BLOCK_WIDTH, self.OPTICAL_FLOW_BLOCK_HEIGHT, self.OPTICAL_FLOW_RANGE_WIDTH, self.OPTICAL_FLOW_RANGE_HEIGHT, self.OPTICAL_FLOW_METHOD ) t2 = time.time() print 'Processing sequence took %0.3f ms' % ((t2-t1)*1000.0) # Resample sequence t1 = time.time() self.regularisedInputSequence = RegularisedInputSequence( self.inputSequence, self.SAMPLES_PER_SECOND ) t2 = time.time() print 'Resampling took %0.3f ms' % ((t2-t1)*1000.0) t1 = time.time() self.crossCorrelatedSequence = CrossCorrelatedSequence( self.regularisedInputSequence, self.MAX_CORRELATION_LAG, self.COMBINATION_METHOD ) t2 = time.time() print 'Correlation took %0.3f ms' % ((t2-t1)*1000.0) # Detect the input signal based on the correlation in the x and y axis self.inputSignalDetectedArray = \ self.crossCorrelatedSequence.detectInputSequence( self.CORRELATION_THRESHOLD ) # Build a histogram for the gripper self.gripperHistogram = cv.CreateHist( [ 256/8, 256/8, 256/8 ], cv.CV_HIST_ARRAY, [ (0,255), (0,255), (0,255) ], 1 ) firstImage = self.inputSequence.cameraImages[ 0 ] imageRGB = cv.CreateImageHeader( ( firstImage.shape[ 1 ], firstImage.shape[ 0 ] ), cv.IPL_DEPTH_8U, 3 ) cv.SetData( imageRGB, firstImage.data, firstImage.shape[ 1 ]*3 ) r_plane = cv.CreateMat( imageRGB.height, imageRGB.width, cv.CV_8UC1 ) g_plane = cv.CreateMat( imageRGB.height, imageRGB.width, cv.CV_8UC1 ) b_plane = cv.CreateMat( imageRGB.height, imageRGB.width, cv.CV_8UC1 ) cv.Split( imageRGB, r_plane, g_plane, b_plane, None ) planes = [ r_plane, g_plane, b_plane ] maskArray = np.zeros(shape=( imageRGB.height, imageRGB.width ), dtype=np.uint8 ) for rowIdx in range( self.inputSignalDetectedArray.shape[ 0 ] ): for colIdx in range( self.inputSignalDetectedArray.shape[ 1 ] ): if self.inputSignalDetectedArray[ rowIdx, colIdx ]: rowStartIdx = rowIdx*self.OPTICAL_FLOW_BLOCK_HEIGHT rowEndIdx = rowStartIdx + self.OPTICAL_FLOW_BLOCK_HEIGHT colStartIdx = colIdx*self.OPTICAL_FLOW_BLOCK_WIDTH colEndIdx = colStartIdx + self.OPTICAL_FLOW_BLOCK_WIDTH maskArray[ rowStartIdx:rowEndIdx, colStartIdx:colEndIdx ] = 255 cv.CalcHist( [ cv.GetImage( i ) for i in planes ], self.gripperHistogram, 0, mask=cv.fromarray( maskArray ) ) markerBuffer = MarkerBuffer.loadMarkerBuffer( self.scriptPath + self.GROUND_TRUTH_FILENAME ) if markerBuffer == None: raise Exception( "Unable to load marker buffer" ) self.rocCurve = GripperDetectorROCCurve( self.crossCorrelatedSequence, markerBuffer ) # Create the matplotlib graph self.figure = Figure( figsize=(8,6), dpi=72 ) self.axisX = self.figure.add_subplot( 311 ) self.axisY = self.figure.add_subplot( 312 ) self.axisROC = self.figure.add_subplot( 313 ) self.canvas = None # Wait for GUI to be created before creating canvas self.navToolbar = None # Setup the GUI builder = gtk.Builder() builder.add_from_file( self.scriptPath + "/GUI/OpticalFlowExplorer.glade" ) self.dwgCameraImage = builder.get_object( "dwgCameraImage" ) self.window = builder.get_object( "winMain" ) self.vboxMain = builder.get_object( "vboxMain" ) self.hboxWorkArea = builder.get_object( "hboxWorkArea" ) self.adjTestPointX = builder.get_object( "adjTestPointX" ) self.adjTestPointY = builder.get_object( "adjTestPointY" ) self.adjTestPointX.set_upper( self.MAX_TEST_POINT_X ) self.adjTestPointY.set_upper( self.MAX_TEST_POINT_Y ) self.sequenceControls = builder.get_object( "sequenceControls" ) self.sequenceControls.setNumFrames( len( self.inputSequence.cameraImages ) ) self.sequenceControls.setOnFrameIdxChangedCallback( self.onSequenceControlsFrameIdxChanged ) self.setFrameIdx( 0 ) self.processOpticalFlowData() builder.connect_signals( self ) updateLoop = self.update() gobject.idle_add( updateLoop.next ) self.window.show() self.window.maximize() #--------------------------------------------------------------------------- def onWinMainDestroy( self, widget, data = None ): gtk.main_quit() #--------------------------------------------------------------------------- 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() #--------------------------------------------------------------------------- def processOpticalFlowData( self ): testX = int( self.adjTestPointX.get_value() ) testY = int( self.adjTestPointY.get_value() ) regSeq = self.regularisedInputSequence corSeq = self.crossCorrelatedSequence # Normalise the data ready for display normalisedServoAngleData = Utils.normaliseSequence( regSeq.regularServoAngleData ) normalisedOpticalFlowDataX = Utils.normaliseSequence( regSeq.regularOpticalFlowArrayX[ testY ][ testX ] ) normalisedOpticalFlowDataY = Utils.normaliseSequence( regSeq.regularOpticalFlowArrayY[ testY ][ testX ] ) numCorrelationChannels = len( corSeq.correlationChannels ) # Plot graphs self.axisX.clear() self.axisX.plot( regSeq.regularSampleTimes, normalisedServoAngleData ) self.axisX.plot( regSeq.regularSampleTimes, normalisedOpticalFlowDataX ) if numCorrelationChannels >= 1: correlationChannel = corSeq.correlationChannels[ 0 ][ testY ][ testX ] self.axisX.plot( regSeq.regularSampleTimes[:len(correlationChannel)], correlationChannel ) self.axisY.clear() self.axisY.plot( regSeq.regularSampleTimes, normalisedServoAngleData ) self.axisY.plot( regSeq.regularSampleTimes, normalisedOpticalFlowDataY ) inpSeq = self.inputSequence self.axisY.plot( inpSeq.imageTimes, Utils.normaliseSequence( inpSeq.opticalFlowArraysY[ testY ][ testX ] ) ) if numCorrelationChannels >= 2: correlationChannel = corSeq.correlationChannels[ 1 ][ testY ][ testX ] self.axisY.plot( regSeq.regularSampleTimes[:len(correlationChannel)], correlationChannel ) self.axisROC.clear() self.axisROC.plot( self.rocCurve.falsePositiveRates, self.rocCurve.truePositiveRates ) #self.axisROC.plot( self.rocCurve.thresholds, self.rocCurve.sensitivity ) #self.axisROC.plot( self.rocCurve.thresholds, self.rocCurve.specificity ) self.refreshGraphDisplay() outputFile = open( self.scriptPath + "/../../test_results/CrossCorrelation.csv", "w" ) numSamples = len( regSeq.regularSampleTimes ) correlationChannel = corSeq.correlationChannels[ 0 ][ testY ][ testX ] numCorrelationSamples = len( correlationChannel ) print >>outputFile, "Time,Input,Output,CrossCorrelation" for i in range( numSamples ): if i < numCorrelationSamples: correlationData = correlationChannel[ i ] else: correlationData = 0.0 print >>outputFile, "{0},{1},{2},{3}".format( regSeq.regularSampleTimes[ i ], normalisedServoAngleData[ i ], normalisedOpticalFlowDataX[ i ], correlationData ) outputFile.close() #--------------------------------------------------------------------------- def refreshGraphDisplay( self ): if self.canvas != None: self.hboxWorkArea.remove( self.canvas ) self.canvas.destroy() self.canvas = None if self.navToolbar != None: self.vboxMain.remove( self.navToolbar ) self.navToolbar.destroy() self.navToolbar = None self.canvas = FigureCanvas( self.figure ) # a gtk.DrawingArea self.canvas.show() self.hboxWorkArea.pack_start( self.canvas, True, True ) self.hboxWorkArea.show() # Navigation toolbar self.navToolbar = NavigationToolbar( self.canvas, self.window ) self.navToolbar.lastDir = '/var/tmp/' self.vboxMain.pack_start( self.navToolbar, expand=False, fill=False ) self.navToolbar.show() self.vboxMain.show() #--------------------------------------------------------------------------- def setFrameIdx( self, frameIdx ): self.frameIdx = frameIdx # Display the frame image = self.inputSequence.cameraImages[ frameIdx ] imageWidth = image.shape[ 1 ] imageHeight = image.shape[ 0 ] imageStep = imageWidth*3 self.cameraImagePixBuf = gtk.gdk.pixbuf_new_from_data( image.tostring(), gtk.gdk.COLORSPACE_RGB, False, 8, imageWidth, imageHeight, imageStep ) # Track gripper imageRGB = cv.CreateImageHeader( ( imageWidth, imageHeight ), cv.IPL_DEPTH_8U, 3 ) cv.SetData( imageRGB, image.data, imageStep ) imageRGB = cv.CloneImage( imageRGB ) r_plane = cv.CreateMat( imageRGB.height, imageRGB.width, cv.CV_8UC1 ) g_plane = cv.CreateMat( imageRGB.height, imageRGB.width, cv.CV_8UC1 ) b_plane = cv.CreateMat( imageRGB.height, imageRGB.width, cv.CV_8UC1 ) cv.Split( imageRGB, r_plane, g_plane, b_plane, None ) planes = [ r_plane, g_plane, b_plane ] backproject = cv.CreateImage(cv.GetSize(imageRGB), 8, 1) # Run the cam-shift cv.CalcArrBackProject( planes, backproject, self.gripperHistogram ) #cv.Threshold( backproject, backproject, 1, 255, cv.CV_THRESH_BINARY ) cv.CvtColor( backproject, imageRGB, cv.CV_GRAY2RGB ) #self.cameraImagePixBuf = gtk.gdk.pixbuf_new_from_data( #imageRGB.tostring(), #gtk.gdk.COLORSPACE_RGB, #False, #8, #imageRGB.width, #imageRGB.height, #imageRGB.width*3 ) # Resize the drawing area if necessary if self.dwgCameraImage.get_size_request() != ( imageWidth, imageHeight ): self.dwgCameraImage.set_size_request( imageWidth, imageHeight ) self.dwgCameraImage.queue_draw() #--------------------------------------------------------------------------- def onTestPointAdjustmentValueChanged( self, widget ): self.processOpticalFlowData() self.dwgCameraImage.queue_draw() #--------------------------------------------------------------------------- def onSequenceControlsFrameIdxChanged( self, widget ): self.setFrameIdx( widget.frameIdx ) #--------------------------------------------------------------------------- def onDwgCameraImageButtonPressEvent( self, widget, data ): if self.cameraImagePixBuf != None: imgRect = self.getImageRectangleInWidget( widget, self.cameraImagePixBuf.get_width(), self.cameraImagePixBuf.get_height() ) self.adjTestPointX.set_value( int( ( data.x - imgRect.x )/self.OPTICAL_FLOW_BLOCK_WIDTH ) ) self.adjTestPointY.set_value( int( ( data.y - imgRect.y )/self.OPTICAL_FLOW_BLOCK_HEIGHT ) ) #--------------------------------------------------------------------------- def onDwgCameraImageExposeEvent( self, widget, data = None ): if self.cameraImagePixBuf != None: imgRect = self.getImageRectangleInWidget( widget, self.cameraImagePixBuf.get_width(), self.cameraImagePixBuf.get_height() ) imgOffsetX = imgRect.x imgOffsetY = imgRect.y # Get the total area that needs to be redrawn imgRect = imgRect.intersect( data.area ) srcX = imgRect.x - imgOffsetX srcY = imgRect.y - imgOffsetY widget.window.draw_pixbuf( widget.get_style().fg_gc[ gtk.STATE_NORMAL ], self.cameraImagePixBuf, srcX, srcY, imgRect.x, imgRect.y, imgRect.width, imgRect.height ) #return # Draw an overlay to show places where the input motion has been detected if self.inputSignalDetectedArray != None: imageData = np.frombuffer( self.cameraImagePixBuf.get_pixels(), dtype=np.uint8 ) imageData.shape = ( self.cameraImagePixBuf.get_height(), self.cameraImagePixBuf.get_width(), 3 ) graphicsContext = widget.window.new_gc() graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 65535, 65535, 0 ) ) blockY = imgRect.y for y in range( self.inputSignalDetectedArray.shape[ 0 ] ): blockX = imgRect.x for x in range( self.inputSignalDetectedArray.shape[ 1 ] ): if self.inputSignalDetectedArray[ y, x ]: # Get source block as NumPy array srcX = blockX - imgRect.x srcY = blockY - imgRect.y srcData = imageData[ srcY:srcY+self.OPTICAL_FLOW_BLOCK_HEIGHT, srcX:srcX+self.OPTICAL_FLOW_BLOCK_WIDTH, : ] # Create a modified version of the block with a yellow layer # alpha blended over the top yellowLayer = np.ones( ( self.OPTICAL_FLOW_BLOCK_WIDTH, self.OPTICAL_FLOW_BLOCK_HEIGHT, 3 ) )*[255.0,255.0,0.0]*0.5 modifiedData = ( srcData.astype( np.float32 )*0.5 + yellowLayer ).astype( np.uint8 ) # Blit the modified version into the widget modifiedPixBuf = gtk.gdk.pixbuf_new_from_array( modifiedData, gtk.gdk.COLORSPACE_RGB, 8 ) widget.window.draw_pixbuf( widget.get_style().fg_gc[ gtk.STATE_NORMAL ], modifiedPixBuf, 0, 0, blockX, blockY, self.OPTICAL_FLOW_BLOCK_WIDTH, self.OPTICAL_FLOW_BLOCK_HEIGHT ) blockX += self.OPTICAL_FLOW_BLOCK_WIDTH blockY += self.OPTICAL_FLOW_BLOCK_HEIGHT return # Draw the optical flow if it's available opticalFlowX = self.inputSequence.opticalFlowArraysX[ :, :, self.frameIdx ] opticalFlowY = self.inputSequence.opticalFlowArraysY[ :, :, self.frameIdx ] if opticalFlowX != None and opticalFlowY != None: testX = int( self.adjTestPointX.get_value() ) testY = int( self.adjTestPointY.get_value() ) graphicsContext = widget.window.new_gc() graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 0, 65535, 0 ) ) blockCentreY = imgRect.y + self.OPTICAL_FLOW_BLOCK_HEIGHT / 2 for y in range( opticalFlowX.shape[ 0 ] ): blockCentreX = imgRect.x + self.OPTICAL_FLOW_BLOCK_WIDTH / 2 for x in range( opticalFlowX.shape[ 1 ] ): if testX == x and testY == y: # Highlight the current test point radius = 2 arcX = int( blockCentreX - radius ) arcY = int( blockCentreY - radius ) arcWidth = arcHeight = int( radius * 2 ) drawFilledArc = False graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 65535, 65535, 65535 ) ) widget.window.draw_arc( graphicsContext, drawFilledArc, arcX, arcY, arcWidth, arcHeight, 0, 360 * 64 ) endX = blockCentreX + opticalFlowX[ y, x ] endY = blockCentreY + opticalFlowY[ y, x ] if endY < blockCentreY: # Up is red graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 65535, 0, 0 ) ) elif endY > blockCentreY: # Down is blue graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 0, 0, 65535 ) ) else: # Static is green graphicsContext.set_rgb_fg_color( gtk.gdk.Color( 0, 65535, 0 ) ) widget.window.draw_line( graphicsContext, int( blockCentreX ), int( blockCentreY ), int( endX ), int( endY ) ) blockCentreX += self.OPTICAL_FLOW_BLOCK_WIDTH blockCentreY += self.OPTICAL_FLOW_BLOCK_HEIGHT #--------------------------------------------------------------------------- def getImageRectangleInWidget( self, widget, imageWidth, imageHeight ): # Centre the image inside the widget widgetX, widgetY, widgetWidth, widgetHeight = widget.get_allocation() imgRect = gtk.gdk.Rectangle( 0, 0, widgetWidth, widgetHeight ) if widgetWidth > imageWidth: imgRect.x = (widgetWidth - imageWidth) / 2 imgRect.width = imageWidth if widgetHeight > imageHeight: imgRect.y = (widgetHeight - imageHeight) / 2 imgRect.height = imageHeight return imgRect #--------------------------------------------------------------------------- def update( self ): UPDATE_FREQUENCY = 30.0 # Updates in Hz lastTime = time.clock() while 1: curTime = time.clock() if curTime - lastTime >= 1.0 / UPDATE_FREQUENCY: # Save the time lastTime = curTime yield True yield False
class MainWindow: OPTICAL_FLOW_BLOCK_WIDTH = 16 OPTICAL_FLOW_BLOCK_HEIGHT = 16 OPTICAL_FLOW_RANGE_WIDTH = 16 # Range to look outside of a block for motion OPTICAL_FLOW_RANGE_HEIGHT = 16 OPTICAL_FLOW_METHOD = "BlockMatching" #OPTICAL_FLOW_METHOD = "LucasKanade" #OPTICAL_FLOW_METHOD = "HornSchunck" COMBINATION_METHOD = "NoChange" #GROUND_TRUTH_FILENAME = "/../../config/TopPosGripper.yaml" #GROUND_TRUTH_FILENAME = "/../../config/ExperimentPosGripper.yaml" #GROUND_TRUTH_FILENAME = "/../../config/OnTablePosGripper.yaml" GROUND_TRUTH_FILENAME = "/../../config/TightBasicWave_Gripper.yaml" CORRELATION_THRESHOLD = 0.52 MAX_TEST_POINT_X = ( 640 - OPTICAL_FLOW_BLOCK_WIDTH) / OPTICAL_FLOW_BLOCK_WIDTH - 1 MAX_TEST_POINT_Y = ( 480 - OPTICAL_FLOW_BLOCK_HEIGHT) / OPTICAL_FLOW_BLOCK_HEIGHT - 1 SAMPLES_PER_SECOND = 30.0 MAX_CORRELATION_LAG = 2.0 GRIPPER_WAVE_FREQUENCY = 1.0 # Waves per second GRIPPER_NUM_WAVES = 3.0 GRIPPER_WAVE_AMPLITUDE = math.radians(20.0) #--------------------------------------------------------------------------- def __init__(self, bagFilename): self.scriptPath = os.path.dirname(__file__) self.cameraImagePixBuf = None self.bagFilename = bagFilename self.lastImageGray = None # Read in sequence t1 = time.time() self.inputSequence = InputSequence(bagFilename) distractors = [ Distractor(radius=24, startPos=(25, 35), endPos=(100, 100), frequency=2.0), Distractor(radius=24, startPos=(200, 200), endPos=(150, 50), frequency=0.25), Distractor(radius=24, startPos=(188, 130), endPos=(168, 258), frequency=0.6), Distractor(radius=24, startPos=(63, 94), endPos=(170, 81), frequency=1.5), Distractor(radius=24, startPos=(40, 287), endPos=(50, 197), frequency=3.0) ] #self.inputSequence.addDistractorObjects( distractors ) self.inputSequence.calculateOpticalFlow(self.OPTICAL_FLOW_BLOCK_WIDTH, self.OPTICAL_FLOW_BLOCK_HEIGHT, self.OPTICAL_FLOW_RANGE_WIDTH, self.OPTICAL_FLOW_RANGE_HEIGHT, self.OPTICAL_FLOW_METHOD) t2 = time.time() print 'Processing sequence took %0.3f ms' % ((t2 - t1) * 1000.0) # Resample sequence t1 = time.time() self.regularisedInputSequence = RegularisedInputSequence( self.inputSequence, self.SAMPLES_PER_SECOND) t2 = time.time() print 'Resampling took %0.3f ms' % ((t2 - t1) * 1000.0) t1 = time.time() self.crossCorrelatedSequence = CrossCorrelatedSequence( self.regularisedInputSequence, self.MAX_CORRELATION_LAG, self.COMBINATION_METHOD) t2 = time.time() print 'Correlation took %0.3f ms' % ((t2 - t1) * 1000.0) # Detect the input signal based on the correlation in the x and y axis self.inputSignalDetectedArray = \ self.crossCorrelatedSequence.detectInputSequence( self.CORRELATION_THRESHOLD ) # Build a histogram for the gripper self.gripperHistogram = cv.CreateHist([256 / 8, 256 / 8, 256 / 8], cv.CV_HIST_ARRAY, [(0, 255), (0, 255), (0, 255)], 1) firstImage = self.inputSequence.cameraImages[0] imageRGB = cv.CreateImageHeader( (firstImage.shape[1], firstImage.shape[0]), cv.IPL_DEPTH_8U, 3) cv.SetData(imageRGB, firstImage.data, firstImage.shape[1] * 3) r_plane = cv.CreateMat(imageRGB.height, imageRGB.width, cv.CV_8UC1) g_plane = cv.CreateMat(imageRGB.height, imageRGB.width, cv.CV_8UC1) b_plane = cv.CreateMat(imageRGB.height, imageRGB.width, cv.CV_8UC1) cv.Split(imageRGB, r_plane, g_plane, b_plane, None) planes = [r_plane, g_plane, b_plane] maskArray = np.zeros(shape=(imageRGB.height, imageRGB.width), dtype=np.uint8) for rowIdx in range(self.inputSignalDetectedArray.shape[0]): for colIdx in range(self.inputSignalDetectedArray.shape[1]): if self.inputSignalDetectedArray[rowIdx, colIdx]: rowStartIdx = rowIdx * self.OPTICAL_FLOW_BLOCK_HEIGHT rowEndIdx = rowStartIdx + self.OPTICAL_FLOW_BLOCK_HEIGHT colStartIdx = colIdx * self.OPTICAL_FLOW_BLOCK_WIDTH colEndIdx = colStartIdx + self.OPTICAL_FLOW_BLOCK_WIDTH maskArray[rowStartIdx:rowEndIdx, colStartIdx:colEndIdx] = 255 cv.CalcHist([cv.GetImage(i) for i in planes], self.gripperHistogram, 0, mask=cv.fromarray(maskArray)) markerBuffer = MarkerBuffer.loadMarkerBuffer( self.scriptPath + self.GROUND_TRUTH_FILENAME) if markerBuffer == None: raise Exception("Unable to load marker buffer") self.rocCurve = GripperDetectorROCCurve(self.crossCorrelatedSequence, markerBuffer) # Create the matplotlib graph self.figure = Figure(figsize=(8, 6), dpi=72) self.axisX = self.figure.add_subplot(311) self.axisY = self.figure.add_subplot(312) self.axisROC = self.figure.add_subplot(313) self.canvas = None # Wait for GUI to be created before creating canvas self.navToolbar = None # Setup the GUI builder = gtk.Builder() builder.add_from_file(self.scriptPath + "/GUI/OpticalFlowExplorer.glade") self.dwgCameraImage = builder.get_object("dwgCameraImage") self.window = builder.get_object("winMain") self.vboxMain = builder.get_object("vboxMain") self.hboxWorkArea = builder.get_object("hboxWorkArea") self.adjTestPointX = builder.get_object("adjTestPointX") self.adjTestPointY = builder.get_object("adjTestPointY") self.adjTestPointX.set_upper(self.MAX_TEST_POINT_X) self.adjTestPointY.set_upper(self.MAX_TEST_POINT_Y) self.sequenceControls = builder.get_object("sequenceControls") self.sequenceControls.setNumFrames(len( self.inputSequence.cameraImages)) self.sequenceControls.setOnFrameIdxChangedCallback( self.onSequenceControlsFrameIdxChanged) self.setFrameIdx(0) self.processOpticalFlowData() builder.connect_signals(self) updateLoop = self.update() gobject.idle_add(updateLoop.next) self.window.show() self.window.maximize() #--------------------------------------------------------------------------- def onWinMainDestroy(self, widget, data=None): gtk.main_quit() #--------------------------------------------------------------------------- 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() #--------------------------------------------------------------------------- def processOpticalFlowData(self): testX = int(self.adjTestPointX.get_value()) testY = int(self.adjTestPointY.get_value()) regSeq = self.regularisedInputSequence corSeq = self.crossCorrelatedSequence # Normalise the data ready for display normalisedServoAngleData = Utils.normaliseSequence( regSeq.regularServoAngleData) normalisedOpticalFlowDataX = Utils.normaliseSequence( regSeq.regularOpticalFlowArrayX[testY][testX]) normalisedOpticalFlowDataY = Utils.normaliseSequence( regSeq.regularOpticalFlowArrayY[testY][testX]) numCorrelationChannels = len(corSeq.correlationChannels) # Plot graphs self.axisX.clear() self.axisX.plot(regSeq.regularSampleTimes, normalisedServoAngleData) self.axisX.plot(regSeq.regularSampleTimes, normalisedOpticalFlowDataX) if numCorrelationChannels >= 1: correlationChannel = corSeq.correlationChannels[0][testY][testX] self.axisX.plot( regSeq.regularSampleTimes[:len(correlationChannel)], correlationChannel) self.axisY.clear() self.axisY.plot(regSeq.regularSampleTimes, normalisedServoAngleData) self.axisY.plot(regSeq.regularSampleTimes, normalisedOpticalFlowDataY) inpSeq = self.inputSequence self.axisY.plot( inpSeq.imageTimes, Utils.normaliseSequence(inpSeq.opticalFlowArraysY[testY][testX])) if numCorrelationChannels >= 2: correlationChannel = corSeq.correlationChannels[1][testY][testX] self.axisY.plot( regSeq.regularSampleTimes[:len(correlationChannel)], correlationChannel) self.axisROC.clear() self.axisROC.plot(self.rocCurve.falsePositiveRates, self.rocCurve.truePositiveRates) #self.axisROC.plot( self.rocCurve.thresholds, self.rocCurve.sensitivity ) #self.axisROC.plot( self.rocCurve.thresholds, self.rocCurve.specificity ) self.refreshGraphDisplay() outputFile = open( self.scriptPath + "/../../test_results/CrossCorrelation.csv", "w") numSamples = len(regSeq.regularSampleTimes) correlationChannel = corSeq.correlationChannels[0][testY][testX] numCorrelationSamples = len(correlationChannel) print >> outputFile, "Time,Input,Output,CrossCorrelation" for i in range(numSamples): if i < numCorrelationSamples: correlationData = correlationChannel[i] else: correlationData = 0.0 print >> outputFile, "{0},{1},{2},{3}".format( regSeq.regularSampleTimes[i], normalisedServoAngleData[i], normalisedOpticalFlowDataX[i], correlationData) outputFile.close() #--------------------------------------------------------------------------- def refreshGraphDisplay(self): if self.canvas != None: self.hboxWorkArea.remove(self.canvas) self.canvas.destroy() self.canvas = None if self.navToolbar != None: self.vboxMain.remove(self.navToolbar) self.navToolbar.destroy() self.navToolbar = None self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea self.canvas.show() self.hboxWorkArea.pack_start(self.canvas, True, True) self.hboxWorkArea.show() # Navigation toolbar self.navToolbar = NavigationToolbar(self.canvas, self.window) self.navToolbar.lastDir = '/var/tmp/' self.vboxMain.pack_start(self.navToolbar, expand=False, fill=False) self.navToolbar.show() self.vboxMain.show() #--------------------------------------------------------------------------- def setFrameIdx(self, frameIdx): self.frameIdx = frameIdx # Display the frame image = self.inputSequence.cameraImages[frameIdx] imageWidth = image.shape[1] imageHeight = image.shape[0] imageStep = imageWidth * 3 self.cameraImagePixBuf = gtk.gdk.pixbuf_new_from_data( image.tostring(), gtk.gdk.COLORSPACE_RGB, False, 8, imageWidth, imageHeight, imageStep) # Track gripper imageRGB = cv.CreateImageHeader((imageWidth, imageHeight), cv.IPL_DEPTH_8U, 3) cv.SetData(imageRGB, image.data, imageStep) imageRGB = cv.CloneImage(imageRGB) r_plane = cv.CreateMat(imageRGB.height, imageRGB.width, cv.CV_8UC1) g_plane = cv.CreateMat(imageRGB.height, imageRGB.width, cv.CV_8UC1) b_plane = cv.CreateMat(imageRGB.height, imageRGB.width, cv.CV_8UC1) cv.Split(imageRGB, r_plane, g_plane, b_plane, None) planes = [r_plane, g_plane, b_plane] backproject = cv.CreateImage(cv.GetSize(imageRGB), 8, 1) # Run the cam-shift cv.CalcArrBackProject(planes, backproject, self.gripperHistogram) #cv.Threshold( backproject, backproject, 1, 255, cv.CV_THRESH_BINARY ) cv.CvtColor(backproject, imageRGB, cv.CV_GRAY2RGB) #self.cameraImagePixBuf = gtk.gdk.pixbuf_new_from_data( #imageRGB.tostring(), #gtk.gdk.COLORSPACE_RGB, #False, #8, #imageRGB.width, #imageRGB.height, #imageRGB.width*3 ) # Resize the drawing area if necessary if self.dwgCameraImage.get_size_request() != (imageWidth, imageHeight): self.dwgCameraImage.set_size_request(imageWidth, imageHeight) self.dwgCameraImage.queue_draw() #--------------------------------------------------------------------------- def onTestPointAdjustmentValueChanged(self, widget): self.processOpticalFlowData() self.dwgCameraImage.queue_draw() #--------------------------------------------------------------------------- def onSequenceControlsFrameIdxChanged(self, widget): self.setFrameIdx(widget.frameIdx) #--------------------------------------------------------------------------- def onDwgCameraImageButtonPressEvent(self, widget, data): if self.cameraImagePixBuf != None: imgRect = self.getImageRectangleInWidget( widget, self.cameraImagePixBuf.get_width(), self.cameraImagePixBuf.get_height()) self.adjTestPointX.set_value( int((data.x - imgRect.x) / self.OPTICAL_FLOW_BLOCK_WIDTH)) self.adjTestPointY.set_value( int((data.y - imgRect.y) / self.OPTICAL_FLOW_BLOCK_HEIGHT)) #--------------------------------------------------------------------------- def onDwgCameraImageExposeEvent(self, widget, data=None): if self.cameraImagePixBuf != None: imgRect = self.getImageRectangleInWidget( widget, self.cameraImagePixBuf.get_width(), self.cameraImagePixBuf.get_height()) imgOffsetX = imgRect.x imgOffsetY = imgRect.y # Get the total area that needs to be redrawn imgRect = imgRect.intersect(data.area) srcX = imgRect.x - imgOffsetX srcY = imgRect.y - imgOffsetY widget.window.draw_pixbuf( widget.get_style().fg_gc[gtk.STATE_NORMAL], self.cameraImagePixBuf, srcX, srcY, imgRect.x, imgRect.y, imgRect.width, imgRect.height) #return # Draw an overlay to show places where the input motion has been detected if self.inputSignalDetectedArray != None: imageData = np.frombuffer(self.cameraImagePixBuf.get_pixels(), dtype=np.uint8) imageData.shape = (self.cameraImagePixBuf.get_height(), self.cameraImagePixBuf.get_width(), 3) graphicsContext = widget.window.new_gc() graphicsContext.set_rgb_fg_color(gtk.gdk.Color( 65535, 65535, 0)) blockY = imgRect.y for y in range(self.inputSignalDetectedArray.shape[0]): blockX = imgRect.x for x in range(self.inputSignalDetectedArray.shape[1]): if self.inputSignalDetectedArray[y, x]: # Get source block as NumPy array srcX = blockX - imgRect.x srcY = blockY - imgRect.y srcData = imageData[ srcY:srcY + self.OPTICAL_FLOW_BLOCK_HEIGHT, srcX:srcX + self.OPTICAL_FLOW_BLOCK_WIDTH, :] # Create a modified version of the block with a yellow layer # alpha blended over the top yellowLayer = np.ones( (self.OPTICAL_FLOW_BLOCK_WIDTH, self.OPTICAL_FLOW_BLOCK_HEIGHT, 3)) * [255.0, 255.0, 0.0] * 0.5 modifiedData = (srcData.astype(np.float32) * 0.5 + yellowLayer).astype(np.uint8) # Blit the modified version into the widget modifiedPixBuf = gtk.gdk.pixbuf_new_from_array( modifiedData, gtk.gdk.COLORSPACE_RGB, 8) widget.window.draw_pixbuf( widget.get_style().fg_gc[gtk.STATE_NORMAL], modifiedPixBuf, 0, 0, blockX, blockY, self.OPTICAL_FLOW_BLOCK_WIDTH, self.OPTICAL_FLOW_BLOCK_HEIGHT) blockX += self.OPTICAL_FLOW_BLOCK_WIDTH blockY += self.OPTICAL_FLOW_BLOCK_HEIGHT return # Draw the optical flow if it's available opticalFlowX = self.inputSequence.opticalFlowArraysX[:, :, self.frameIdx] opticalFlowY = self.inputSequence.opticalFlowArraysY[:, :, self.frameIdx] if opticalFlowX != None and opticalFlowY != None: testX = int(self.adjTestPointX.get_value()) testY = int(self.adjTestPointY.get_value()) graphicsContext = widget.window.new_gc() graphicsContext.set_rgb_fg_color(gtk.gdk.Color(0, 65535, 0)) blockCentreY = imgRect.y + self.OPTICAL_FLOW_BLOCK_HEIGHT / 2 for y in range(opticalFlowX.shape[0]): blockCentreX = imgRect.x + self.OPTICAL_FLOW_BLOCK_WIDTH / 2 for x in range(opticalFlowX.shape[1]): if testX == x and testY == y: # Highlight the current test point radius = 2 arcX = int(blockCentreX - radius) arcY = int(blockCentreY - radius) arcWidth = arcHeight = int(radius * 2) drawFilledArc = False graphicsContext.set_rgb_fg_color( gtk.gdk.Color(65535, 65535, 65535)) widget.window.draw_arc(graphicsContext, drawFilledArc, arcX, arcY, arcWidth, arcHeight, 0, 360 * 64) endX = blockCentreX + opticalFlowX[y, x] endY = blockCentreY + opticalFlowY[y, x] if endY < blockCentreY: # Up is red graphicsContext.set_rgb_fg_color( gtk.gdk.Color(65535, 0, 0)) elif endY > blockCentreY: # Down is blue graphicsContext.set_rgb_fg_color( gtk.gdk.Color(0, 0, 65535)) else: # Static is green graphicsContext.set_rgb_fg_color( gtk.gdk.Color(0, 65535, 0)) widget.window.draw_line(graphicsContext, int(blockCentreX), int(blockCentreY), int(endX), int(endY)) blockCentreX += self.OPTICAL_FLOW_BLOCK_WIDTH blockCentreY += self.OPTICAL_FLOW_BLOCK_HEIGHT #--------------------------------------------------------------------------- def getImageRectangleInWidget(self, widget, imageWidth, imageHeight): # Centre the image inside the widget widgetX, widgetY, widgetWidth, widgetHeight = widget.get_allocation() imgRect = gtk.gdk.Rectangle(0, 0, widgetWidth, widgetHeight) if widgetWidth > imageWidth: imgRect.x = (widgetWidth - imageWidth) / 2 imgRect.width = imageWidth if widgetHeight > imageHeight: imgRect.y = (widgetHeight - imageHeight) / 2 imgRect.height = imageHeight return imgRect #--------------------------------------------------------------------------- def update(self): UPDATE_FREQUENCY = 30.0 # Updates in Hz lastTime = time.clock() while 1: curTime = time.clock() if curTime - lastTime >= 1.0 / UPDATE_FREQUENCY: # Save the time lastTime = curTime yield True yield False
class HurricaneUI: def __init__(self): gladefile = "HurricaneUI.glade" builder = gtk.Builder() builder.add_from_file(gladefile) self.window = builder.get_object("mainWindow") builder.connect_signals(self) self.figure = Figure(figsize=(10,10), dpi=75) self.axis = self.figure.add_subplot(111) self.lat = 50 self.lon = -100 self.globe= globDisp.GlobeMap(self.axis, self.lat, self.lon) self.canvas = FigureCanvasGTK(self.figure) self.canvas.show() self.canvas.set_size_request(500,500) self.globeview = builder.get_object("map") self.globeview.pack_start(self.canvas, True, True) self.navToolbar = NavigationToolbar(self.canvas, self.globeview) self.navToolbar.lastDir = '/var/tmp' self.globeview.pack_start(self.navToolbar) self.navToolbar.show() self.gridcombo = builder.get_object("gridsize") cell=gtk.CellRendererText() self.gridcombo.pack_start(cell,True) self.gridcombo.add_attribute(cell, 'text', 0) #self.gridcombo.set_active(2) # read menu configuration self.gridopt = builder.get_object("gridopt").get_active() self.chkDetected = builder.get_object("detectedopt") self.detectedopt = self.chkDetected.get_active() self.chkHurricane = builder.get_object("hurricaneopt") self.hurricaneopt = self.chkHurricane.get_active() model = builder.get_object("liststore1") index = self.gridcombo.get_active() self.gridsize = model[index][0] radio = [ r for r in builder.get_object("classifieropt1").get_group() if r.get_active() ][0] self.sClassifier = radio.get_label() self.start = builder.get_object("startdate") self.end = builder.get_object("enddate") self.chkUndersample = builder.get_object("undersample") self.chkGenKey = builder.get_object("genKey") # disable unimplemented classifier selection builder.get_object("classifieropt2").set_sensitive(False) builder.get_object("classifieropt3").set_sensitive(False) builder.get_object("classifieropt4").set_sensitive(False) self.btnStore = builder.get_object("store") self.datapath = 'GFSdat' self.trackpath = 'tracks' builder.get_object("btnDatapath").set_current_folder(self.datapath) builder.get_object("btnTrackpath").set_current_folder(self.trackpath) self.btnDetect = builder.get_object("detect") # current operation status self.stormlocs = None self.detected = None self.clssfr = None # for test drawing functions if os.path.exists('demo.detected'): with open('demo.detected','r') as f: self.detected = pickle.load(f) self.stormlocs = pickle.load(f) self.chkHurricane.set_label(str(self.stormlocs.shape[0])+" Hurricanes") self.chkDetected.set_label(str(self.detected.shape[0])+" Detected") self.setDisabledBtns() # draw Globe self.drawGlobe() def setDisabledBtns(self): self.chkDetected.set_sensitive(self.detected!=None) self.chkHurricane.set_sensitive(self.stormlocs!=None) self.btnStore.set_sensitive(self.clssfr!=None) self.btnDetect.set_sensitive(self.clssfr!=None) def drawGlobe(self): self.globe.drawGlobe(self.gridsize, self.gridopt) if self.hurricaneopt : self.globe.drawHurricanes(self.stormlocs) if self.detectedopt : self.globe.fillGrids(self.detected) def main(self): self.window.show_all() gtk.main() def redraw(self): self.axis.cla() self.drawGlobe() self.canvas.draw_idle() def gtk_main_quit(self,widget): gtk.main_quit() ############################################################################### # # utility functions (dialogs) # def getFilenameToRead(self, stitle, save=False, filter='all'): chooser = gtk.FileChooserDialog(title=stitle, parent=self.window, action=gtk.FILE_CHOOSER_ACTION_OPEN if not save else gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN if not save else gtk.STOCK_SAVE,gtk.RESPONSE_OK)) chooser.set_default_response(gtk.RESPONSE_OK) if filter=='mat' or filter=='mdat': filter = gtk.FileFilter() filter.set_name("Matrix files") filter.add_pattern("*.mat") chooser.add_filter(filter) if filter=='svm': filter = gtk.FileFilter() filter.set_name("SVM") filter.add_pattern("*.svm") chooser.add_filter(filter) if filter=='dat' or filter=='mdat': filter = gtk.FileFilter() filter.set_name("Data") filter.add_pattern("*.dat") chooser.add_filter(filter) filter = gtk.FileFilter() filter.set_name("All files") filter.add_pattern("*") chooser.add_filter(filter) chooser.set_current_folder(os.getcwd()) response = chooser.run() if response == gtk.RESPONSE_OK: filen = chooser.get_filename() else: filen = None chooser.destroy() return filen def showMessage(self,msg): md = gtk.MessageDialog(self.window, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_INFO, gtk.BUTTONS_CLOSE, msg) md.run() md.destroy() ############################################################################### # # read data files and convert into a training matrix input # def on_btnTrackpath_current_folder_changed(self,widget): self.trackpath = widget.get_current_folder() def on_btnDatapath_current_folder_changed(self,widget): self.datapath = widget.get_current_folder() def on_createMat_clicked(self,widget): filen = self.getFilenameToRead("Save converted matrix for training", True, filter='mat') if filen is not None: start = self.start.get_text() end = self.end.get_text() bundersmpl = self.chkUndersample.get_active() bgenkey = self.chkGenKey.get_active() ### FIX ME: currently gridsize for classification is fixed 1 (no clustering of grids - 2x2) if os.path.exists(filen): os.unlink(filen) # createMat append existing file, so delete it if exist gdtool.createMat(self.datapath, self.trackpath, start, end, store=filen, undersample=bundersmpl, genkeyf=bgenkey) self.showMessage("Matrix has been stored to "+filen) ############################################################################### # # train the selected classifier # def on_train_clicked(self, widget): # FOR NOW, only SVM is supported if self.sClassifier == "SVM": filen = self.getFilenameToRead("Open training data",filter='mat') if filen is not None: data = ml.VectorDataSet(filen,labelsColumn=0) self.clssfr = ml.SVM() self.clssfr.train(data) # train finished. need to update button status self.setDisabledBtns() self.showMessage("Training SVM is done.") else : self.showMessage("The classifier is not supported yet!") def on_classifieropt_toggled(self,widget, data=None): self.sClassifier = widget.get_label() ############################################################################### # # Classify on test data # def on_detect_clicked(self, widget): if self.clssfr is not None: filen = self.getFilenameToRead("Open hurricane data", filter='mdat') if filen is not None: fname = os.path.basename(filen) key, ext = os.path.splitext(fname) if ext == '.dat': key = key[1:] # take 'g' out #testData = gdtool.createMat(self.datapath, self.trackpath, key, key) #result = self.clssfr.test(ml.VectorDataSet(testData,labelsColumn=0)) tmpfn = 'f__tmpDetected__' if os.path.exists(tmpfn): os.unlink(tmpfn) # for DEMO, undersampled the normal data -- without undersampling there are too many candidates gdtool.createMat(self.datapath, self.trackpath, key, key, store=tmpfn, undersample=True, genkeyf=True) bneedDel = True else: tmpfn = fname bneedDel = False result = self.clssfr.test(ml.VectorDataSet(tmpfn,labelsColumn=0)) gdkeyfilen = ''.join([tmpfn,'.keys']) with open(gdkeyfilen, 'r') as f: gridkeys = pickle.load(f) self.stormlocs = pickle.load(f) predicted = result.getPredictedLabels() predicted = np.array(map(float,predicted)) self.detected = np.array(gridkeys)[predicted==1] if bneedDel: os.unlink(tmpfn) os.unlink(gdkeyfilen) snstroms = str(self.stormlocs.shape[0]) sndetected = str(self.detected.shape[0]) self.chkHurricane.set_label(snstroms+" Hurricanes") self.chkDetected.set_label(sndetected+" Detected") self.showMessage(''.join([sndetected,"/",snstroms," grids are predicted to have hurricane."])) if False: with open('demo.detected','w') as f: pickle.dump(self.detected,f) pickle.dump(self.stormlocs,f) # test data tested. update buttons self.setDisabledBtns() self.redraw() else: self.showMessage("There is no trained classifier!") ############################################################################### # # load and store trained classifier # def on_load_clicked(self, widget): filen = self.getFilenameToRead("Load Classifier",filter='svm') if filen is not None: #db = shelve.open(filen) #if db.has_key('clssfr'): # self.clssfr = db['clssfr'] #else: # self.showMessage("Cannot find a classifier!") #db.close() #with open(filen, 'wb') as f: # self.clssfr = pickle.load(f) datfn = self.getFilenameToRead("Open Training Data",filter='mat') if datfn is not None: data = ml.VectorDataSet(datfn,labelsColumn=0) self.clssfr = loadSVM(filen,data) ## Why do I need to feed data ??? #self.clssfr = loadSVM(filen,None) ## edited PyML for this # classifier has been loaded. need to update button status self.setDisabledBtns() self.showMessage("The classifier has been loaded!") def on_store_clicked(self, widget): if self.clssfr is not None: filen = self.getFilenameToRead("Store Classifier", True, filter='svm') if filen is not None: #with open(filen, 'wb') as f: # pickle.dump(self.clssfr,f) #db = shelve.open(filen) #db['clssfr'] = self.clssfr #db.close() self.clssfr.save(filen) self.showMessage("The classifier has been saved!") else: self.showMessage("There is no trained classifier!") ############################################################################### # # Display Globe # def on_right_clicked(self,widget): self.lon += 10 # rotate Globe def on_left_clicked(self,widget): self.lon -= 10 # rotate Globe def gridsize_changed_cb(self, widget): model = widget.get_model() index = widget.get_active() if index > -1: self.gridsize = model[index][0] self.redraw() def on_gridopt_toggled(self, widget): self.gridopt = not self.gridopt self.redraw() def on_Hurricane_toggled(self, widget): self.hurricaneopt = not self.hurricaneopt self.redraw() def on_detected_toggled(self, widget): self.detectedopt = not self.detectedopt self.redraw()
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()