def __init__(self,gtkWindow,eventPipe): self.objects = {} self.window = gtkWindow self.eventPipe = eventPipe fileName = 'funo.brd' print "Loading PCB %s"%(fileName,) self.table = gtk.Table(rows=12, columns=1, homogeneous=True) window.add(self.table) self.table.show() self.pcb = PCB(fileName,usingMouse=noTracking,multimeter=multimeterObj, x=pcb_x, y=pcb_y, modeupdate=self.set_status_mode) self.table.attach(self.pcb, left_attach = 0, right_attach = 1, top_attach = 0, bottom_attach = 6, xpadding=0, ypadding=0) self.pcb.show( ) f = Figure(figsize=(5,4), dpi=100, facecolor='white') a = f.add_subplot(211) b = f.add_subplot(212) #t1 = arange(0.0, 3.0, 0.01) #t2 = arange(0.0, 5.0, 0.01) #s1 = sin(2*pi*t1) #s2 = sin(2*pi*t2) #a.plot(t1, s1) f.tight_layout() self.plot_figure = f self.top_plot = a self.bottom_plot = b canvas = FigureCanvas(f) self.table.attach(canvas, left_attach = 0, right_attach = 1, top_attach = 6, bottom_attach = 11, xpadding=0, ypadding=0) canvas.show() self.canvas = canvas self.status_bar = gtk.Statusbar() self.table.attach(self.status_bar, left_attach = 0, right_attach = 1, top_attach = 11, bottom_attach = 12, xpadding=0, ypadding=0) self.status_bar.show() self.cid = self.status_bar.get_context_id('') self.status_bar.push(self.cid,'Operation Mode: select')
class Plot(Callback.Callbacks): def __init__(self, logger): Callback.Callbacks.__init__(self) self.logger = logger # For callbacks for name in ('close', ): self.enable_callback(name) self.fig = matplotlib.figure.Figure() self.ax = self.fig.add_subplot(111) self.ax.set_xlabel('X values') self.ax.set_ylabel('Y values') self.ax.set_title('') self.ax.grid(True) self.canvas = FigureCanvas(self.fig) self.canvas.show_all() def get_widget(self): return self.canvas def getAxis(self): return self.ax def _sanity_check_window(self): pass def set_titles(self, xtitle=None, ytitle=None, title=None, rtitle=None): self._sanity_check_window() if xtitle != None: self.ax.set_xlabel(xtitle) if ytitle != None: self.ax.set_ylabel(ytitle) if title != None: self.ax.set_title(title) if rtitle != None: pass def clear(self): self._sanity_check_window() self.logger.debug('clearing canvas...') self.ax.cla() def show(self): self._sanity_check_window() self.logger.debug('raising window...') self.canvas.show() def hide(self): self._sanity_check_window() self.logger.debug('hiding window...') pass def close(self): self.logger.debug('closing window....') self.canvas.destroy() self.make_callback('close') return False def _draw(self): self.fig.canvas.draw() def plot(self, xarr, yarr, xtitle=None, ytitle=None, title=None, rtitle=None, **kwdargs): self.set_titles(xtitle=xtitle, ytitle=ytitle, title=title, rtitle=rtitle) self.ax.plot(xarr, yarr, **kwdargs) self.ax.grid(True) self._draw()
class ColViewer: def __init__(self, coldir=None): self.equalize = False self.equalize_cutoff = 20 self.data_binary = True self.n_values = 2 self.n_bins = 10 self.n_bins_desired = self.n_bins self.tgt2color = {} builder = gtk.Builder() xmlfile = os.path.join(os.path.split(sys.argv[0])[0], "colviewer_main_window.xml") builder.add_from_file(xmlfile) self.window = builder.get_object("window") print builder.connect_signals(self) self.logbuffer = builder.get_object("textbuffer_info") # GtkTextBuffer self.append_to_log("initialized") self.coldir = coldir if not self.coldir: self.coldir = os.getcwd() self.filelist = builder.get_object("list_files") # GtkListStore self.fill_filelist() # scale and spinbutton to set number of bins self.n_bins_scale = builder.get_object("hscale_nbins") # GtkHScale self.n_bins_spinb = builder.get_object("spinbutton_nbins") # GtkSpinButton self.set_nbins_sensible() # label showing target filename self.target_label = builder.get_object("label_target_filename") self.barchart_box = builder.get_object("box_barchart") # GtkVBox self.init_barchart() ### GUI Tools ### def set_target_filename(self, filename): self.target_label.set_text(os.path.split(filename)[-1]) self.target_label.set_tooltip_text(filename) def update_barchart(self): self.histogram() self.plot_barchart() self.plot_errorbars() self.bar_canvas.draw() def fill_filelist(self): files = os.listdir(self.coldir) for filename in sorted(files): if filename.startswith("."): continue self.filelist.append([filename]) def append_to_log(self, text): self.logbuffer.insert(self.logbuffer.get_end_iter(),'# ' + text + "\n") def set_nbins_sensible(self): """ activate or deactivate interface elements that only make sense for data with binary / non-binary values """ self.n_bins_scale.set_sensitive(not self.data_binary) self.n_bins_spinb.set_sensitive(not self.data_binary) def show(self): self.window.show() ### Plotting ### def init_barchart(self): fig = Figure(facecolor='w') ax = fig.add_subplot(211,axisbg=NiceColors.lightgrey) self.bar_ax = ax self.err_ax = fig.add_subplot(212,axisbg=NiceColors.lightgrey) self.bar_canvas = FigureCanvas(fig) # a gtk.DrawingArea self.bar_canvas.show() self.barchart_box.pack_start(self.bar_canvas) def get_layers(self): " return one layer for each target in sorted order " for tgt in sorted(self.data.keys()): cnt = Counter(bin_id for val, bin_id in self.data[tgt]) layer = [cnt[b] for b in range(self.n_bins)] if self.equalize: mult = self.get_equalize_multiplicator() assert len(mult) == len(layer) layer = [c*f for c, f in zip(layer, mult)] yield (tgt, layer) def get_locations(self, limits): " locations of bars are in the middle between lower and upper bound" return [(u+l)/2.0 for l,u in izip(limits[:-1], limits[1:])] def get_width(self, locations=None, gap_factor=1.0): if locations == None: locations = self.get_locations(self.limits) if len(locations) < 3: return 1.0 return gap_factor * min( (l2-l1) for l1, l2 in zip(locations[:-1], locations[1:]) ) def get_equalize_multiplicator(self): return [1./float(c) if c > self.equalize_cutoff else 0. for c in self.col_counts] def plot_errorbars(self): #print len(locations) , len(self.cols) self.err_ax.cla() assert len(self.locations) == len(self.cols) err = [np.std(c) for c in self.cols] means = [np.mean(c) for c in self.cols] self.err_ax.errorbar(self.locations, means, yerr=err, ecolor="black") self.err_ax.set_xbound( self.bar_ax.get_xbound() ) self.err_ax.yaxis.grid(True) #for l,m,e in izip(self.locations, means, err): # self.err_ax.errorbar(l, m, yerr=e, ecolor="black") def plot_barchart(self): self.bar_ax.cla() assert len(self.limits) == self.n_bins + 1, "mismatch n_bins and limits" self.locations = self.get_locations(self.limits) width = self.get_width(self.locations, 0.8) colormap = NiceColors.cmap bottom = [0] * self.n_bins for tgt, layer in self.get_layers(): assert len(layer) == len(bottom) color = colormap(self.normalize(tgt, self.min_tgt, self.max_tgt)) self.bar_ax.bar(self.locations, layer, width, color=color, bottom=bottom, linewidth=0, align='center') bottom = [b+c for b,c in zip(bottom, layer)] #ax.set_xticks((0.0,1.0)) #ax.set_yticks([0,25,50,75,100],minor=False) #ax.yaxis.grid(True) #ax.set_xticklabels(('0', '1')) if self.equalize: self.bar_ax.set_ybound(lower=0.0, upper=1.05) ### Signal Handling ### def on_window_destroy(self, widget, data=None): gtk.main_quit() def on_treeview_filenames_cursor_changed(self, treeview): treeselection = treeview.get_selection() (treemodel, treeiter) = treeselection.get_selected() col = 0 filename = treemodel.get_value(treeiter, col) self.load_col(filename) def on_adjustment_nbins_value_changed(self, adjustment): self.n_bins_desired = int(adjustment.get_value()) self.update_barchart() def on_check_equal_toggled(self, checkbutton): self.equalize = checkbutton.get_active() self.update_barchart() ### Data Handling ### def load_bincol(self, filename): self.data = map(int, map(float,open(filename))) def load_col(self, filename): fname = os.path.join(self.coldir, filename) self.raw_data = [float(l) for l in open(fname) if l.strip()] if len(self.raw_data) > len(self.target): sys.stdout.write("WARN: more data than targets (%s vs %s)\n" %(len(self.raw_data), len(self.target))) self.raw_data = self.raw_data[:len(self.target)] self.n_values = len(set(self.raw_data)) self.data_binary = self.n_values == 2 self.set_nbins_sensible() self.append_to_log("loaded %s lines containing %s uniq values" %(len(self.raw_data), self.n_values)) if self.data_binary: self.append_to_log("%s zeros, %s ones" %(self.raw_data.count(0.0), self.raw_data.count(1.0))) self.update_barchart() def read_target(self, filename): # self.target = map(int, map(float, open(filename))) self.target = map(float, open(filename)) self.n_classes = len(set(self.target)) self.append_to_log("loaded target: %s lines containing %s classes" %(len(self.target), self.n_classes)) self.set_target_filename(filename) self.min_tgt = min(self.target) self.max_tgt = max(self.target) # redo histogram if data already read def reset_data(self): self.data = dict( (tgt, []) for tgt in set(self.target) ) ### Histogram ### def find_bin(self, val, bins): """ bins are given as bins=[x1 x2 x3 x4] returns largest i such that val <= bins[i+1] """ nbins = len(bins) assert nbins >= 2, "%s does not specify proper intervals" %(bins) assert val <= bins[-1], "value larger than end of last interval" assert val >= bins[0], "value smaller than start of first interval" for i in range(nbins-1): if val < bins[i+1]: assert val >= bins[i] return i return nbins - 2 def histogram(self): """ make histogram and update self.data with bin infos """ self.reset_data() self.n_bins = min(self.n_values, self.n_bins_desired) n, bins, patches = self.bar_ax.hist(self.raw_data, self.n_bins) self.col_counts = n self.cols = [[] for c in range(self.n_bins)] for val, tgt in izip(self.raw_data, self.target): bin_id = self.find_bin(val, bins) assert bin_id <= self.n_bins, "%s > %s" %(bin_id, self.n_bins) self.data[tgt].append((val, bin_id)) self.cols[bin_id].append(tgt) self.limits = bins def normalize(self, value, min_val=0.0, max_val=1.0): return float(value-min_val)/(max_val-min_val)
class Backend( backend.Backend ): def init(self): self.layer_to_axes = {} self.axes_to_layer = {} self.layers_cache = [] # copy of self.plot.layers self.layer_cblists = {} self.line_caches = {} self.omaps = {} def connect(self): logger.debug("Opening matplotlib session.") self.figure = Figure(dpi=100), facecolor="white") # figsize=(5,4), dpi=100) self.canvas = FigureCanvas(self.figure) self.canvas.show() self.line_caches = {} self.layer_to_axes.clear() self.axes_to_layer.clear() backend.Backend.connect(self) logger.debug("Init finished") def set(self, project,plot): backend.Backend.set(self, project, plot) if self.project is not None: # TODO: connect to update::layers of Plot pass def disconnect(self): logger.debug("Closing matplotlib session.") if not self.canvas is None: self.canvas.destroy() self.canvas = None if not self.figure is None: self.figure = None backend.Backend.disconnect(self) #---------------------------------------------------------------------- def arrange(self, rows=1, cols=1): layers = self.plot.layers n = len(layers) if n > (rows*cols): rows = int((rows*cols) / n) + 1 cols = rows * n #raise ValueError("Not enough rows and cols for all layers!") self.figure.clear() self.figure.axes = [] self.layer_to_axes.clear() self.axes_to_layer.clear() self.layers_cache = [] for cblist in self.layer_cblists.itervalues(): for cb in cblist: cb.disconnect() self.layer_cblists = {} j = 1 for layer in layers: print "Setting up layer", layer axes = self.figure.add_subplot("%d%d%d" % (rows,cols,j)) self.layer_to_axes[layer] = axes self.axes_to_layer[axes] = layer self.layers_cache.append(layer) print "Connecting to update of ", layer self.layer_cblists[layer] = \ [layer.sig_connect('update', self.on_update_layer), layer.sig_connect('update::labels', self.on_update_labels) ] j += 1
class Backend( backend.Backend ): def init(self): self.layer_to_axes = {} self.axes_to_layer = {} self.layers_cache = [] # copy of self.plot.layers self.layer_cblists = {} self.line_caches = {} self.omaps = {} def connect(self): logger.debug("Opening matplotlib session.") self.figure = Figure(dpi=100, facecolor="white") # figsize=(5,4), dpi=100) self.canvas = FigureCanvas(self.figure) self.canvas.show() self.line_caches = {} self.layer_to_axes.clear() self.axes_to_layer.clear() backend.Backend.connect(self) logger.debug("Init finished") def set(self, project,plot): backend.Backend.set(self, project, plot) if self.project is not None: # TODO: connect to notify::layers of Plot pass def disconnect(self): logger.debug("Closing matplotlib session.") if not self.canvas is None: self.canvas.destroy() self.canvas = None if not self.figure is None: self.figure = None backend.Backend.disconnect(self) #---------------------------------------------------------------------- def arrange(self, rows=1, cols=1): layers = self.plot.layers n = len(layers) if n > (rows*cols): rows = int((rows*cols) / n) + 1 cols = rows * n #raise ValueError("Not enough rows and cols for all layers!") self.figure.clear() self.figure.axes = [] self.layer_to_axes.clear() self.axes_to_layer.clear() self.layers_cache = [] for cblist in self.layer_cblists.itervalues(): for cb in cblist: cb.disconnect() self.layer_cblists = {} j = 1 for layer in layers: print "Setting up layer", layer axes = self.figure.add_subplot("%d%d%d" % (rows,cols,j)) self.layer_to_axes[layer] = axes self.axes_to_layer[axes] = layer self.layers_cache.append(layer) print "Connecting to notify of ", layer self.layer_cblists[layer] = \ [layer.sig_connect('notify', self.on_update_layer), layer.sig_connect('notify::labels', self.on_update_labels) ] j += 1 def draw(self): self.check_connection() logger.debug("Matplotlib: draw()") if self.plot.layers != self.layers_cache: self.arrange() self.omaps = {} for layer in self.plot.layers: self.update_layer(layer) self.draw_canvas() def draw_canvas(self): self.canvas.draw() #---------------------------------------------------------------------- # Layer # def on_update_layer(self, sender, updateinfo={}): # updateinfo is ignored self.update_layer(sender) self.canvas.draw() def update_layer(self, layer, updateinfo={}): # updateinfo is ignored self.omaps[layer] = {} self.line_caches[layer] = {} axes = self.layer_to_axes[layer] axes.lines = [] line_cache = self.line_caches[layer] = [] #:layer.lines:OK for line in layer.lines: self.update_line(line, layer, axes=axes) #:layer.axes for (key, axis) in layer.axes.iteritems(): #:axis.label #:axis.scale #:axis.start #:axis.end label = axis.label scale = axis.scale start = axis.start end = axis.end #logger.debug("start = %s; end = %s" % (start, end)) if key == 'x': set_label = axes.set_xlabel set_scale = axes.set_xscale set_start = (lambda l: axes.set_xlim(xmin=l)) set_end = (lambda l: axes.set_xlim(xmax=l)) elif key == 'y': set_label = axes.set_ylabel set_scale = axes.set_yscale set_start = (lambda l: axes.set_ylim(ymin=l)) set_end = (lambda l: axes.set_ylim(ymax=l)) else: raise RuntimeError("Invalid axis key '%s'" % key) if label is not None: set_label(label) if scale is not None: set_scale(scale) if start is not None: set_start(start) if end is not None: set_end(end) #:layer.visible if layer.visible is False: return # TODO #:layer.title title = layer.title if title is not None: axes.set_title(title) #:layer.grid axes.grid(layer.grid) #:layer.legend:OK self.update_legend(layer) #:layer.labels:OK axes.texts = [] for label in layer.labels: self.update_textlabel(label, layer) #---------------------------------------------------------------------- # Line # def update_line(self, line, layer, axes=None, updateinfo={}): # updateinfo is ignored axes = axes or self.layer_to_axes[layer] omap = self.omaps[layer] line_cache = self.line_caches[layer] data_to_plot = [] #:line.visible if line.visible is False: if line in axes.lines: axes.lines.remove(line) line_cache.remove(line) omap[line] = None return ds = self.get_line_source(line) cx, cy = self.get_column_indices(line) try: xdata, ydata = self.get_dataset_data(ds, cx, cy) except backend.BackendError, msg: logger.error(msg) omap[line] = None return #:line.row_first #:line.row_last start, end = line.row_first, line.row_last try: xdata = self.limit_data(xdata, start, end) ydata = self.limit_data(ydata, start, end) except BackendError, msg: logger.error("Error when plotting line #%d: %s" % (line_index, msg)) omap[line] = None return
class Plot(Callback.Callbacks): def __init__(self, logger): Callback.Callbacks.__init__(self) self.logger = logger # For callbacks for name in ('close', ): self.enable_callback(name) self.fig = matplotlib.figure.Figure() self.ax = self.fig.add_subplot(111) self.ax.set_xlabel('X values') self.ax.set_ylabel('Y values') self.ax.set_title('') self.ax.grid(True) self.canvas = FigureCanvas(self.fig) self.canvas.show_all() def get_widget(self): return self.canvas def getAxis(self): return self.ax def _sanity_check_window(self): pass def set_titles(self, xtitle=None, ytitle=None, title=None, rtitle=None): self._sanity_check_window() if xtitle != None: self.ax.set_xlabel(xtitle) if ytitle != None: self.ax.set_ylabel(ytitle) if title != None: self.ax.set_title(title) if rtitle != None: pass def clear(self): self._sanity_check_window() self.logger.debug('clearing canvas...') self.ax.cla() def show(self): self._sanity_check_window() self.logger.debug('raising window...') self.canvas.show() def hide(self): self._sanity_check_window() self.logger.debug('hiding window...') pass def close(self): self.logger.debug('closing window....') self.canvas.destroy() self.make_callback('close') return False def _draw(self): self.fig.canvas.draw() def plot(self, xarr, yarr, xtitle=None, ytitle=None, title=None, rtitle=None, color=None, alpha=1.0): self.set_titles(xtitle=xtitle, ytitle=ytitle, title=title, rtitle=rtitle) if not color: self.ax.plot(xarr, yarr, linewidth=1.0, alpha=alpha, linestyle='-') else: self.ax.plot(xarr, yarr, linewidth=1.0, color=color, alpha=alpha, linestyle='-') self.ax.grid(True) self._draw()
def __init__(self, gtkWindow, eventPipe): self.objects = {} self.window = gtkWindow self.eventPipe = eventPipe fileName = 'funo.brd' print "Loading PCB %s" % (fileName, ) self.table = gtk.Table(rows=12, columns=1, homogeneous=True) window.add(self.table) self.table.show() self.pcb = PCB(fileName, usingMouse=noTracking, multimeter=multimeterObj, x=pcb_x, y=pcb_y, modeupdate=self.set_status_mode) self.table.attach(self.pcb, left_attach=0, right_attach=1, top_attach=0, bottom_attach=4, xpadding=0, ypadding=0) self.pcb.show() f = Figure(figsize=(5, 4), dpi=100, facecolor='white') a = f.add_subplot(211) b = f.add_subplot(212) t1 = arange(0.0, 3.0, 0.01) t2 = arange(0.0, 5.0, 0.01) s1 = sin(2 * pi * t1) s2 = sin(2 * pi * t2) a.plot(t1, s1) a.set_title('Channel 1', fontsize=10) a.tick_params(labelsize=8) a.grid(True, which='both') b.plot(t2, s2) b.tick_params(labelsize=8) b.grid(True, which='both') b.set_title('Channel 2', fontsize=10) f.tight_layout() canvas = FigureCanvas(f) self.table.attach(canvas, left_attach=0, right_attach=1, top_attach=4, bottom_attach=11, xpadding=0, ypadding=0) canvas.show() self.status_bar = gtk.Statusbar() self.table.attach(self.status_bar, left_attach=0, right_attach=1, top_attach=11, bottom_attach=12, xpadding=0, ypadding=0) self.status_bar.show() self.cid = self.status_bar.get_context_id('') self.status_bar.push(self.cid, 'Operation Mode: select')