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')