def __init__(self): self.data_x = [] self.data_y = [] self.data_i = [] self.data_v = [] self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_default_size(550, 700) self.window.connect("delete_event", self.destroy) self.window.connect("destroy", self.destroy) self.vbox = gtk.VBox(False, 0) self.window.add(self.vbox) self.plotfig_i = Figure(figsize=(100, 100), dpi=75) self.plotfig_v = Figure(figsize=(100, 100), dpi=75) self.plotax_i = self.plotfig_i.add_subplot(111) self.plotax_v = self.plotfig_v.add_subplot(111) self.plotlines_i = self.plotax_i.plot(self.data_x, self.data_i, '.') self.plotlines_v = self.plotax_v.plot(self.data_x, self.data_v, '.') self.plotax_i.set_ylim(-15, 15) self.plotax_v.set_ylim(0, 178) self.plotcanvas_i = FigureCanvasGTK(self.plotfig_i) self.plotcanvas_v = FigureCanvasGTK(self.plotfig_v) self.plotcanvas_i.show() self.plotcanvas_v.show() self.vbox.pack_start(self.plotcanvas_i, True, True, 0) self.vbox.pack_end(self.plotcanvas_v, True, True, 0) self.vbox.show()
def __init__(self): self.data_x = [] self.data_y = [] self.data_i = [] self.data_v = [] self.data_x.append([0]) self.data_y.append([0]) self.data_i.append([0]) self.data_v.append([0]) self.colors = ['r', 'b', 'c', 'm', 'g', 'y'] self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_default_size(550, 700) self.window.connect("delete_event", self.destroy) self.window.connect("destroy", self.destroy) self.vbox = [] self.vbox.append(gtk.VBox(False, 0)) self.hbox = gtk.HBox(False, 0) self.hbox.pack_start(self.vbox[0], True, True, 0) self.window.add(self.hbox) self.plotfig_i = Figure(figsize=(100, 100), dpi=75) self.plotfig_v = Figure(figsize=(100, 100), dpi=75) self.plotax_i = [] self.plotax_v = [] self.plotax_i.append(self.plotfig_i.add_subplot(111)) self.plotax_v.append(self.plotfig_v.add_subplot(111)) self.plotlines_i = [] self.plotlines_v = [] self.plotlines_i.append(self.plotax_i[0].plot(self.data_x[0], self.data_i[0], '.')) self.plotlines_v.append(self.plotax_v[0].plot(self.data_x[0], self.data_v[0], '.')) self.plotax_i[0].set_ylim(-10, 10) self.plotax_v[0].set_ylim(0, 178) self.plotcanvas_i = [] self.plotcanvas_v = [] self.plotcanvas_i.append(FigureCanvasGTK(self.plotfig_i)) self.plotcanvas_v.append(FigureCanvasGTK(self.plotfig_v)) self.plotcanvas_i[0].show() self.plotcanvas_v[0].show() self.vbox[0].pack_start(self.plotcanvas_i[0], True, True, 0) self.vbox[0].pack_end(self.plotcanvas_v[0], True, True, 0) self.vbox[0].show() self.hbox.show()
def drawDefault(self): logging.debug('>>') self.axis = self.figure.add_subplot(111) self.axis.set_xlabel('Yepper') self.axis.set_ylabel('Flabber') self.axis.set_title('An Empty Graph') self.axis.grid(True) self.canvas.destroy() self.canvas = FigureCanvasGTK(self.figure) # a gtk.DrawingArea self.canvas.show() self.vbox.pack_start(self.canvas, True, True) logging.debug('<<')
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 create_ui(self): self.widget = gtk.Assistant() self.widget.connect("prepare", self.assistant_prepared) self.widget.connect("cancel", self.cancel_button_clicked) self.widget.connect("close", self.close_button_clicked) self.widget.connect("apply", self.apply_button_clicked) # # Introduction # box = gtk.HBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_INTRO) self.widget.set_page_title(box, "Introduction") content = ('This wizard will guide you through the process of ' 'testing the channels of a single switching board.') label = gtk.Label(content) label.set_use_markup(True) label.set_line_wrap(True) image = gtk.Image() img_path = pkg_resources.resource_filename( 'dmf_control_board_firmware', 'gui/channels_intro.png') image.set_from_file(str(img_path)) box.pack_start(label, True, False, padding=15) box.pack_start(image, True, True, padding=5) self.widget.set_page_complete(box, True) # # Connect hardware # box = gtk.HBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONTENT) self.widget.set_page_title(box, "Connect hardware") label = gtk.Label( ' - Connect DropBot "<tt>Out to Amp</tt>" to amplifier input.\n' ' - Connect amplifier output to DropBot "<tt>In from Amp</tt>".\n' ' - Connect a bank of DropBot channels to test board.') image = gtk.Image() img_path = pkg_resources.resource_filename( 'dmf_control_board_firmware', 'gui/impedance_feedback_setup.png') image.set_from_file(str(img_path)) label.set_line_wrap(True) label.set_use_markup(True) box.pack_start(label, True, False, padding=15) box.pack_start(image, True, True, padding=5) self.widget.set_page_complete(box, True) # # Select frequencies # self.radio_buttons = [ gtk.RadioButton(label='Channels %d-%d' % (c, c + self.channels_per_board - 1)) for c in xrange(0, self.channel_count, self.channels_per_board) ] for b in self.radio_buttons[1:]: b.set_group(self.radio_buttons[0]) box = gtk.VBox() for b in self.radio_buttons: box.pack_start(b, expand=False, fill=False, padding=20) self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONTENT) self.widget.set_page_title(box, "Select bank of test channels") self.widget.set_page_complete(box, True) ## # Record measurements # box1 = gtk.VBox() self.widget.append_page(box1) self.widget.set_page_type(box1, gtk.ASSISTANT_PAGE_PROGRESS) self.widget.set_page_title(box1, "Record measurements") self.measurements_label = gtk.Label('Ready.') self.measurements_label.set_line_wrap(True) self.measure_progress = gtk.ProgressBar() box1.pack_start(self.measurements_label, True, True, 0) box1.pack_start(self.measure_progress, expand=False, fill=False, padding=15) self.box1 = box1 ## # Display readings # box = gtk.VBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONFIRM) self.widget.set_page_title(box, "Channel readings") self.figure = Figure(dpi=72) self.canvas = FigureCanvasGTK(self.figure) toolbar = NavigationToolbar(self.canvas, self.widget) box.pack_start(self.canvas) box.pack_start(toolbar, False, False) self.widget.set_page_complete(box, True) ### # Summary # box = gtk.VBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_SUMMARY) self.widget.set_page_title(box, "Summary") label = gtk.Label('Testing of selected channels complete.') label.set_line_wrap(True) box.pack_start(label, True, True, 0) self.widget.set_page_complete(box, True)
def draw(self, datalist=None, box=None, figure=None, title=None, y2=False, xgrid=False, ygrid=False): ''' Draw a graph using supplied information into supplied gtk.box datalist = populated graphdata class (required) box = gtk.box object (required) figure = matplotlib figure (optional) if supplied will add graph to this figure title = y2 = return = figure ''' logging.debug('>>') if box is None: logging.error("Must supply a vbox or hbox to display the graph") return #Check if have a graph object if figure is None: #No figure, so create figure figure = plt.figure() self.ax1 = plt.axes() #Reset second axis self.ax2 = None #Remove any existing plots for child in box.get_children(): logging.debug('Removing box child: ' + str(child)) box.remove(child) if datalist is None: logging.debug("drawPlot called with no data") return figure if y2 and self.ax2 is None: self.ax2 = plt.twinx() #Create canvas canvas = FigureCanvasGTK(figure) # a gtk.DrawingArea canvas.show() #Display title etc if datalist.xlabel is not None: plt.xlabel(datalist.xlabel) if title is not None: plt.title(title) #Display grid if y2 and ygrid: self.ax2.grid(True) elif self.ax1 and ygrid: self.ax1.grid(True) plt.gca().xaxis.grid(xgrid) #Removed as now in legend #plt.ylabel(datalist.ylabel) #Determine graph type.... #print "Got graphtype: %s" % datalist.graphType #print datalist.x_values #print datalist.y_values #print datalist.linewidth #print datalist.linecolor #print datalist.ylabel if datalist.graphType == "plot": #Plot data if not y2: #plt.plot(datalist.x_values, datalist.y_values, linewidth=datalist.linewidth, color=datalist.linecolor, label=datalist.ylabel ) self.ax1.plot(datalist.x_values, datalist.y_values, linewidth=datalist.linewidth, color=datalist.linecolor, label=datalist.ylabel) else: self.ax2.plot(datalist.x_values, datalist.y_values, linewidth=datalist.linewidth, color=datalist.y2linecolor, label=datalist.ylabel) elif datalist.graphType == "bar": if not y2: self.ax1.bar(datalist.x_values, datalist.y_values, datalist.bar_widths, datalist.bar_bottoms, color=datalist.linecolor, label=datalist.ylabel, alpha=0.5) else: self.ax2.bar(datalist.x_values, datalist.y_values, datalist.bar_widths, datalist.bar_bottoms, color=datalist.y2linecolor, label=datalist.ylabel, alpha=0.5) elif datalist.graphType == "vspan": i = 0 while i < len(datalist.x_values): #print datalist.x_values[i] , datalist.bar_widths[i] if not y2: self.ax1.axvspan(datalist.x_values[i], datalist.x_values[i] + datalist.bar_widths[i], alpha=0.15, facecolor=datalist.linecolor) else: self.ax2.axvspan(datalist.x_values[i], datalist.x_values[i] + datalist.bar_widths[i], alpha=0.15, facecolor=datalist.y2linecolor) i += 1 elif datalist.graphType == "hspan": i = 0 while i < len(datalist.x_values): #print datalist.x_values[i] , datalist.y_values[i], datalist.labels[i], datalist.colors[i] if not y2: self.ax1.axhspan(datalist.x_values[i], datalist.y_values[i], alpha=0.25, facecolor=datalist.colors[i], label=datalist.labels[i]) else: self.ax2.axhspan(datalist.x_values[i], datalist.y_values[i], alpha=0.25, facecolor=datalist.colors[i], label=datalist.labels[i]) i += 1 elif datalist.graphType == "date": if not y2: self.ax1.plot_date(datalist.x_values, datalist.y_values, color=datalist.linecolor, label=datalist.ylabel, alpha=0.5) else: self.ax2.plot_date(datalist.x_values, datalist.y_values, color=datalist.y2linecolor, label=datalist.ylabel, alpha=0.5) else: print "Unknown/unimplemented graph type: %s" % datalist.graphType return figure #Set axis limits #plt.axis([datalist.min_x_value, datalist.max_x_value, datalist.min_y_value, datalist.max_y_value]) if self.ax1 is not None: self.ax1.legend(loc='upper left', bbox_to_anchor=(0, 1)) if self.ax2 is not None: self.ax2.legend(loc='upper right', bbox_to_anchor=(1, 1)) #axis.set_xlim(0, data.max_x_value) #axis.set_ylim(0, data.max_y_value) #Display plot box.pack_start(canvas, True, True) logging.debug("<<") return figure
def create_ui(self): self.widget = gtk.Assistant() self.widget.connect("prepare", self.assistant_prepared) self.widget.connect("cancel", self.cancel_button_clicked) self.widget.connect("close", self.close_button_clicked) self.widget.connect("apply", self.apply_button_clicked) # # Introduction # box = gtk.HBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_INTRO) self.widget.set_page_title(box, "Introduction") content = ('This wizard will guide you through the process of ' 'calibrating the high-voltage reference load feedback ' 'measurement circuit. This feedback circuit is used to ' 'measure the output voltage of the amplifier on the control' 'board.\n\nSee ' r'<a href="http://microfluidics.utoronto.ca/trac/dropbot/wiki/Control board calibration#high-voltage-attenuation-calibration">' 'here</a> for more details.') label = gtk.Label(content) label.set_use_markup(True) label.set_line_wrap(True) image = gtk.Image() img_path = pkg_resources.resource_filename( 'dmf_control_board_firmware', 'gui/reference_feedback_intro.png') image.set_from_file(str(img_path)) box.pack_start(label, True, False, padding=15) box.pack_start(image, True, True, padding=5) self.widget.set_page_complete(box, True) # # Connect hardware # box = gtk.HBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONTENT) self.widget.set_page_title(box, "Connect hardware") label = gtk.Label(' - Connect DropBot "<tt>Out to Amp</tt>" to amplifier input.\n' ' - Use T-splitter to connect amplifier output to:\n' ' 1) DropBot "<tt>In from Amp</tt>".\n' ' 2) Oscilloscope input.') image = gtk.Image() img_path = pkg_resources.resource_filename( 'dmf_control_board_firmware', 'gui/reference_feedback_setup.png') image.set_from_file(str(img_path)) label.set_line_wrap(True) label.set_use_markup(True) box.pack_start(label, True, False, padding=15) box.pack_start(image, True, True, padding=5) self.widget.set_page_complete(box, True) # # Select frequencies # minimum = self.control_board.min_waveform_frequency maximum = self.control_board.max_waveform_frequency form = Form.of( Integer.named('start_frequency').using( default=minimum, optional=True, validators=[ValueAtLeast(minimum=minimum), ]), Integer.named('end_frequency').using( default=maximum, optional=True, validators=[ValueAtLeast(minimum=minimum), ]), Integer.named('number_of_steps').using( default=10, optional=True, validators=[ValueAtLeast(minimum=2), ]), ) box = gtk.HBox() self.form_view = create_form_view(form) self.form_view.form.proxies.connect('changed', display) box.pack_start(self.form_view.widget, fill=False, padding=40) self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONTENT) self.widget.set_page_title(box, "Select calibration frequencies") self.widget.set_page_complete(box, True) # # Record measurements # box1 = gtk.VBox() self.widget.append_page(box1) self.widget.set_page_type(box1, gtk.ASSISTANT_PAGE_PROGRESS) self.widget.set_page_title(box1, "Record measurements") self.measurements_label = gtk.Label('Ready') self.measurements_label.set_line_wrap(True) self.measure_progress = gtk.ProgressBar() self.measure_progress.set_size_request(300, 40) box1.pack_start(self.measurements_label, True, True, 0) box1.pack_start(self.measure_progress, expand=False, fill=False, padding=15) self.box1 = box1 # # Confirm fitted parameters # box = gtk.VBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONFIRM) self.widget.set_page_title(box, "Confirm fitted parameters") figure = Figure(figsize=(14, 8), dpi=60) self.canvas = FigureCanvasGTK(figure) toolbar = NavigationToolbar(self.canvas, self.widget) self.axis = figure.add_subplot(111) box.pack_start(self.canvas) box.pack_start(toolbar, False, False) self.widget.set_page_complete(box, True) # # Summary # box = gtk.VBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_SUMMARY) self.widget.set_page_title(box, "Summary") label = gtk.Label('Calibration of reference load feedback circuit is ' 'complete. The high-voltage output from amplifier ' 'should now be measured accurately by the control ' 'board.') label.set_line_wrap(True) box.pack_start(label, True, True, 0) self.widget.set_page_complete(box, True)
def setup_canvas(self): self._canvas = FigureCanvasGTK(self.figure)
def drawBars(self, xvalues, yvalues, xlabel, ylabel, title, color): logging.debug('>>') logging.debug("Type: bars | title: " + str(title) + " | col: " + str(color) + " | xlabel: " + str(xlabel) + " | ylabel: " + str(ylabel)) self.removeVboxChildren() #figure = Figure(figsize=(6,4), dpi=72) figure = plt.figure() logging.debug("Figure: %s" % str(figure)) numCols = len(xvalues[0]) xmod = 0.4 self.showGraph = False axis = figure.add_subplot(111) logging.debug("Axis: %s" % str(axis)) if len(xvalues) == 1: #One axis barWidth = 0.8 barOffset = 0.1 logging.debug("One axis, barWidth %f, barOffset %f" % (barWidth, barOffset)) elif len(xvalues) == 2: #Twin axes barWidth = 0.4 barOffset = 0.1 logging.debug("Twin axes, barWidth %f, barOffset %f" % (barWidth, barOffset)) else: #Error logging.debug("Error: invalid number of axes") return axis.set_xlabel(xlabel[0]) axis.set_ylabel(ylabel[0]) logging.debug("Labels set x: %s, y: %s" % (xlabel[0], ylabel[0])) xvals = [x + barOffset for x in range(0, numCols)] yvals = [0] * numCols for i in range(0, numCols): yval = yvalues[0][i] if float(yval) > 0.0: self.showGraph = True else: yval = self.NEARLY_ZERO yvals[i] = yval if self.showGraph: logging.debug("Drawing bars") axis.bar(xvals, yvals, barWidth, color=color[0], align='edge') else: #Only zero results logging.debug("No results to draw") pass axis.grid(True) axis.set_title("%s" % (title[0])) logging.debug("Setting title to: %s" % title[0]) for tl in axis.get_yticklabels(): logging.debug("Setting ticklabel color %s" % color[0]) tl.set_color('%s' % color[0]) if len(xvalues) == 2: #Display twin axis ax2 = axis.twinx() logging.debug("Axis 2: Twin axis: %s " % str(ax2)) xvals = [x + barOffset + barWidth for x in range(0, numCols)] for i in range(0, numCols): yval = yvalues[1][i] if float(yval) > 0.0: self.showGraph = True else: yval = self.NEARLY_ZERO yvals[i] = yval if self.showGraph: logging.debug("Axis 2: Drawing bars") ax2.bar(xvals, yvals, barWidth, color=color[1], align='edge') logging.debug("Axis 2: Label set y: %s" % (ylabel[1])) ax2.set_ylabel(ylabel[1]) else: #Only zero results logging.debug("Axis 2: No results to draw") pass for tl in ax2.get_yticklabels(): tl.set_color('%s' % color[1]) logging.debug("Axis 2: Setting ticklabel color %s" % color[1]) _title = "%s vs %s" % (title[0], title[1]) logging.debug("Axis 2: Setting title to: %s" % _title) axis.set_title(_title) logging.debug("Setting x ticks") tickLocations = [x + 0.5 for x in xrange(0, numCols)] axis.set_xticks(tickLocations) axis.set_xticklabels(xvalues[0]) logging.debug("Setting x limits") axis.set_xlim(0, numCols) canvas = FigureCanvasGTK(figure) # a gtk.DrawingArea logging.debug("Got canvas: %s" % (str(canvas))) canvas.show() logging.debug("Adding canvas to vbox") self.vbox.pack_start(canvas, True, True) #toolbar = NavigationToolbar(canvas, self.window) #self.vbox.pack_start(toolbar, False, False) for child in self.vbox.get_children(): logging.debug('Child available: ' + str(child)) logging.debug('<<')
def drawPie(self, xvalues, yvalues, xlabel, ylabel, title, color, zones=None): logging.debug('>>') logging.debug("Type: pie | title: " + str(title) + " | col: " + str(color) + " | xlabel: " + str(xlabel) + " | ylabel: " + str(ylabel)) self.removeVboxChildren() #figure = Figure(figsize=(6,4), dpi=72) figure = Figure() logging.debug("Figure: %s" % str(figure)) axis = figure.add_subplot(111) labels = [] colors = [] frac0 = 0 frac1 = 0 frac2 = 0 frac3 = 0 frac4 = 0 frac5 = 0 for zone in zones: labels.insert(0, zone[3]) colors.insert(0, zone[2]) labels.insert(0, _("rest")) colors.insert(0, "#ffffff") for value in yvalues[0]: if value <= zones[4][0]: frac0 += 1 elif value > zones[4][0] and value <= zones[4][1]: frac1 += 1 elif value > zones[3][0] and value <= zones[3][1]: frac2 += 1 elif value > zones[2][0] and value <= zones[2][1]: frac3 += 1 elif value > zones[1][0] and value <= zones[1][1]: frac4 += 1 elif value > zones[0][0] and value <= zones[0][1]: frac5 += 1 fracs = [] explode = [] if frac5 == 0: labels.pop(5) colors.pop(5) else: fracs.insert(0, frac5) explode.insert(0, 0) if frac4 == 0: labels.pop(4) colors.pop(4) else: fracs.insert(0, frac4) explode.insert(0, 0) if frac3 == 0: labels.pop(3) colors.pop(3) else: fracs.insert(0, frac3) explode.insert(0, 0) if frac2 == 0: labels.pop(2) colors.pop(2) else: fracs.insert(0, frac2) explode.insert(0, 0) if frac1 == 0: labels.pop(1) colors.pop(1) else: fracs.insert(0, frac1) explode.insert(0, 0) if frac0 == 0: labels.pop(0) colors.pop(0) else: fracs.insert(0, frac0) explode.insert(0, 0) axis.pie(fracs, explode=explode, labels=labels, colors=colors, autopct='%1.1f%%', shadow=True) canvas = FigureCanvasGTK(figure) # a gtk.DrawingArea canvas.show() for child in self.vbox.get_children(): logging.debug('Child available: ' + str(child)) self.vbox.pack_start(canvas, True, True) logging.debug('<<')
def drawPlot(self, xvalues, yvalues, xlabel, ylabel, title, color, zones=None, xzones=None, ylimits=None, y1_linewidth=None): logging.debug('>>') logging.debug("Type: plot | title: " + str(title) + " | col: " + str(color) + " | xlabel: " + str(xlabel) + " | ylabel: " + str(ylabel)) logging.debug('xlabel: ' + str(xlabel) + ' | ylabel: ' + str(ylabel) + ' | title: ' + str(title)) self.removeVboxChildren() figure = plt.Figure() logging.debug("Figure: %s" % str(figure)) #figure.clf() i = 0 for value in xvalues: if i < 1: logging.debug("i: %d, value: (%s) %s %s" % (i, str(value), str(xvalues), str(yvalues))) axis = figure.add_subplot(111) logging.debug("Axis: %s" % str(axis)) line = axis.plot(xvalues[i], yvalues[i], color=color[i]) logging.debug("Axis plotted, Line: %s" % str(line)) if y1_linewidth is not None: line[0].set_linewidth(y1_linewidth) linewidth = line[0].get_linewidth() axis.grid(True) logging.debug("Axis grid on") for tl in axis.get_yticklabels(): tl.set_color('%s' % color[i]) logging.debug("Ticklabels color set") #Draw zones on graph, eg for each lap if xzones is not None: logging.debug("Setting xzones") for xzone in xzones: if xzones.index(xzone) % 2: zonecolor = 'b' else: zonecolor = 'g' axis.axvspan(xzone[0], xzone[1], alpha=0.25, facecolor=zonecolor) maxX = max(xvalues[i]) if i >= 1: ax2 = axis.twinx() logging.debug("Axis2: Axis: %s" % str(ax2)) ax2.plot(xvalues[i], yvalues[i], color=color[i]) logging.debug("Axis2: plotted") for tl in ax2.get_yticklabels(): tl.set_color('%s' % color[i]) logging.debug("Axis2: Ticklabels color set") maxXt = max(xvalues[i]) if maxXt > maxX: maxX = maxXt axis.set_xlabel(xlabel[i]) logging.debug("X label set") i += 1 axis.set_xlim(0, maxX) if (len(xvalues) > 1): axis.set_title("%s vs %s" % (ylabel[0], ylabel[1])) else: axis.set_title("%s" % (ylabel[0])) ylim_min, ylim_max = axis.get_ylim() if ylimits is not None: logging.debug("Using ylimits: %s" % str(ylimits)) if ylimits[0] is not None: ylim_min = ylimits[0] if ylimits[1] is not None: ylim_max = ylimits[1] axis.set_ylim(ylim_min, ylim_max) canvas = FigureCanvasGTK(figure) # a gtk.DrawingArea logging.debug("Canvas: %s" % str(canvas)) canvas.show() self.vbox.pack_start(canvas, True, True) toolbar = NavigationToolbar(canvas, self.window) self.vbox.pack_start(toolbar, False, False) for child in self.vbox.get_children(): logging.debug('Child available: ' + str(child)) logging.debug('<<') return { 'y1_min': ylim_min, 'y1_max': ylim_max, 'y1_linewidth': linewidth }
def drawStackedBars(self, xvalues, yvalues, ylabel, title, valuesAreTime=False, colors={}): '''function to draw stacked bars xvalues needs to be a list of lists of strings, e.g. [0]["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] yvalues needs to be a list of dicts e.g. [0]{'Kayak': {'Tue': 10.08, 'Fri': 17.579999999999998, 'Thu': 15.66, 'Sat': 30.619999999999997}, {'Run': {'Mon': 9.65, 'Sun': 15.59}} ''' #TODO tidy logging.debug('>>') logging.debug("Title: %s", (title, )) logging.debug("X values received: %s", str(xvalues)) logging.debug("Y values received: %s", str(yvalues)) self.removeVboxChildren() #Check how many axes to draw if len(xvalues) == 1: #One axis barWidth = 0.8 barOffset = 0.1 elif len(xvalues) == 2: #Twin axes barWidth = 0.4 barOffset = 0.1 else: #Error return keys = yvalues[0].keys() # days of the week numRows = len(keys) numCols = len(xvalues[0]) if numRows == 0: return width = .8 #figure = plt.figure(figsize=(6,4), dpi=72) figure = plt.figure() logging.debug("Figure: %s" % str(figure)) axis = plt.subplot(111) ybottoms = [0] * numCols yheights = [0] * numCols inds = xrange(0, numCols) xvals = [x + barOffset for x in range(0, numCols)] cellText = [] self.showGraph = False for k in colors: if colors[k] == None: colors[k] = '' #Display first axis xticks = [] for key in keys: logging.debug("Day of the week: %s", str(key)) for ind in inds: ybottoms[ind] += yheights[ind] yheights[ind] = 0 #Zero heights color = "#" + colors.get(key, '') if len(color) < 2: color = self.getColor(keys.index(key)) for xvalue in xvalues[0]: index = xvalues[0].index(xvalue) if xvalue in yvalues[0][key]: height = yvalues[0][key][xvalue] if float(height) > 0.0: self.showGraph = True else: height = self.NEARLY_ZERO yheights[index] = height cellText.append( [self.fmtTableText(x, valuesAreTime[0]) for x in yheights]) if self.showGraph: axis.bar(xvals, yheights, bottom=ybottoms, width=barWidth, color=color, align='edge', label=key) else: #Only zero results pass axis.set_xticklabels('' * len(xvalues[0])) axis.set_ylabel(ylabel[0]) if len(xvalues) == 1: plt.title(title[0]) axis.legend(loc=0) axis.set_xlim(0, numCols) logging.debug("X values first axis: %s", str(xvals)) logging.debug("Y values first axis: %s", str(yheights)) #Display twin axis if len(xvalues) == 2: self.showGraph = False ax2 = axis.twinx() keys = yvalues[1].keys() ybottoms = [0] * numCols yheights = [self.NEARLY_ZERO] * numCols for key in keys: for ind in inds: ybottoms[ind] += yheights[ind] yheights[ind] = 0.0 #Zero heights color = "#" + colors.get(key, '') if len(color) < 2: color = self.getColor(keys.index(key)) for xvalue in xvalues[0]: index = xvalues[0].index(xvalue) if xvalue in yvalues[1][key]: height = yvalues[1][key][xvalue] if float(height) > 0.0: self.showGraph = True else: height = self.NEARLY_ZERO yheights[index] = height textToAdd = self.fmtTableText(height, valuesAreTime[1]) if textToAdd is not ' ': row = keys.index(key) col = index cellText[row][col] += " | %s" % (self.fmtTableText( height, valuesAreTime[1])) #print "Would add %s to %s %s" % (self.fmtTableText(height, valuesAreTime[1]), index, keys.index(key)) if self.showGraph: xvals = [ x + barOffset + barWidth for x in range(0, numCols) ] #print "ax2", xvals, yheights, ybottoms ax2.bar(xvals, yheights, bottom=ybottoms, width=barWidth, color=color, align='edge', label=key) else: #Only zero results ax2.bar(xvals, [0] * numCols, bottom=[0] * numCols, width=barWidth, color=color, align='edge', label=key) pass ax2.set_xticklabels('' * len(xvalues[1])) ax2.set_xlim(0, numCols) ax2.set_ylabel(ylabel[1]) ax2.legend(loc=0) plt.title("%s vs %s" % (title[0], title[1])) ## try to do some table stuff colLabels = xvalues[0] rowLabels = keys axis.table(cellText=cellText, cellLoc='center', rowLabels=rowLabels, colLabels=colLabels, loc='bottom') plt.subplots_adjust(left=0.15, bottom=0.08 + (0.03 * numRows)) axis.grid(True) canvas = FigureCanvasGTK(figure) # a gtk.DrawingArea canvas.show() self.vbox.pack_start(canvas, True, True) #toolbar = NavigationToolbar(canvas, self.window) #self.vbox.pack_start(toolbar, False, False) for child in self.vbox.get_children(): logging.debug('Child available: ' + str(child)) logging.debug('<<')
def create_ui(self): self.widget = gtk.Assistant() self.widget.connect("prepare", self.assistant_prepared) self.widget.connect("cancel", self.cancel_button_clicked) self.widget.connect("close", self.close_button_clicked) self.widget.connect("apply", self.apply_button_clicked) # # Introduction # box = gtk.HBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_INTRO) self.widget.set_page_title(box, "Introduction") content = ( 'This wizard will guide you through the process of ' 'calibrating the device load feedback measurement circuit. ' 'This feedback circuit is used to measure the impedance ' 'between the actuated area and ground. This impedance is ' 'related to the volume of liquid between the actuated area' '\n\nSee ' r'<a href="http://microfluidics.utoronto.ca/trac/dropbot/wiki/Control board calibration#device-load-impedance-calibration">' 'here</a> for more details.') label = gtk.Label(content) label.set_use_markup(True) label.set_line_wrap(True) image = gtk.Image() img_path = pkg_resources.resource_filename( 'dmf_control_board_firmware', 'gui/impedance_feedback_intro.png') image.set_from_file(str(img_path)) box.pack_start(label, True, False, padding=15) box.pack_start(image, True, True, padding=5) self.widget.set_page_complete(box, True) # # Connect hardware # box = gtk.HBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONTENT) self.widget.set_page_title(box, "Connect hardware") label = gtk.Label( ' - Connect DropBot "<tt>Out to Amp</tt>" to amplifier input.\n' ' - Connect amplifier output to DropBot "<tt>In from Amp</tt>".\n' ' - Connect DropBot "<tt>0-39</tt>" to test board.') image = gtk.Image() img_path = pkg_resources.resource_filename( 'dmf_control_board_firmware', 'gui/impedance_feedback_setup.png') image.set_from_file(str(img_path)) label.set_line_wrap(True) label.set_use_markup(True) box.pack_start(label, True, False, padding=15) box.pack_start(image, True, True, padding=5) self.widget.set_page_complete(box, True) # # Select frequencies # form = Form.of( Integer.named('start_frequency').using( default=self.control_board.min_waveform_frequency, optional=True, validators=[ ValueAtLeast( minimum=self.control_board.min_waveform_frequency), ValueAtMost( maximum=self.control_board.max_waveform_frequency) ]), Integer.named('end_frequency').using( default=self.control_board.max_waveform_frequency, optional=True, validators=[ ValueAtLeast( minimum=self.control_board.min_waveform_frequency), ValueAtMost( maximum=self.control_board.max_waveform_frequency) ]), Integer.named('number_of_steps').using(default=10, optional=True, validators=[ ValueAtLeast(minimum=2), ]), Integer.named('RMS_voltage').using( default=min(100, self.control_board.max_waveform_voltage), optional=True, validators=[ ValueAtLeast(minimum=10), ValueAtMost( maximum=self.control_board.max_waveform_voltage) ])) box = gtk.HBox() self.form_view = create_form_view(form) box.pack_start(self.form_view.widget, fill=False, padding=40) self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONTENT) self.widget.set_page_title(box, "Select calibration frequencies") self.widget.set_page_complete(box, True) ## # Record measurements # box1 = gtk.VBox() self.widget.append_page(box1) self.widget.set_page_type(box1, gtk.ASSISTANT_PAGE_PROGRESS) self.widget.set_page_title(box1, "Record measurements") self.measurements_label = gtk.Label('Ready.') self.measurements_label.set_line_wrap(True) self.measure_progress = gtk.ProgressBar() box1.pack_start(self.measurements_label, True, True, 0) box1.pack_start(self.measure_progress, expand=False, fill=False, padding=15) self.box1 = box1 # # Confirm fitted parameters # box = gtk.VBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONFIRM) self.widget.set_page_title(box, "Confirm fitted parameters") self.figure = Figure(dpi=72) self.canvas = FigureCanvasGTK(self.figure) toolbar = NavigationToolbar(self.canvas, self.widget) #self.axis = figure.add_subplot(111) box.pack_start(self.canvas) box.pack_start(toolbar, False, False) self.widget.set_page_complete(box, True) ## # Summary # box = gtk.VBox() self.widget.append_page(box) self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_SUMMARY) self.widget.set_page_title(box, "Summary") label = gtk.Label('Calibration of device load feedback circuit is ' 'complete. The impedance between actuated device ' 'area and ground should now be measured accurately ' 'by the control board.') label.set_line_wrap(True) box.pack_start(label, True, True, 0) self.widget.set_page_complete(box, True)
def replot(self): if (dataLog.new_data > 0): cindex = dataLog.new_data - 1 # If this is a new meter, add it to our data / plotline arrays while (dataLog.new_data > len(self.data_x)): newMemberID = len(self.data_x) #print "new member!" self.data_x.append([0]) self.data_y.append([0]) self.data_i.append([0]) self.data_v.append([0]) self.vbox.append(gtk.VBox(False, 0)) pi = Figure(figsize=(100, 100), dpi=75) pv = Figure(figsize=(100, 100), dpi=75) self.plotax_i.append(pi.add_subplot(111)) self.plotax_v.append(pv.add_subplot(111)) self.plotlines_i.append(self.plotax_i[newMemberID].plot( self.data_x[newMemberID], self.data_i[newMemberID], '.')) self.plotlines_v.append(self.plotax_v[newMemberID].plot( self.data_x[newMemberID], self.data_v[newMemberID], '.')) self.plotax_i[newMemberID].set_ylim(-10, 10) self.plotax_v[newMemberID].set_ylim(0, 178) self.plotcanvas_i.append(FigureCanvasGTK(pi)) self.plotcanvas_v.append(FigureCanvasGTK(pv)) self.plotcanvas_i[newMemberID].show() self.plotcanvas_v[newMemberID].show() self.vbox[newMemberID].pack_start( self.plotcanvas_i[newMemberID], True, True, 0) self.vbox[newMemberID].pack_end(self.plotcanvas_v[newMemberID], True, True, 0) self.vbox[newMemberID].show() self.hbox.pack_end(self.vbox[newMemberID], True, True, 0) self.hbox.show() powers.append([]) self.data_x[cindex] = dataLog.back_axis_time[cindex][:] self.data_y[cindex] = dataLog.back_axis_voltage[cindex][:] if (len(self.data_x[cindex]) % 2 != 0 or len(self.data_y[cindex]) % 2 != 0): dataLog.new_data = 0 return True #print "index: %d len x: %d len y: %d" % (cindex, len(self.data_x[cindex]), len(self.data_y[cindex])) self.data_adjust(cindex) for i in range(len(self.plotlines_i)): self.plotlines_i[i][0].set_xdata(self.data_x[i]) self.plotlines_v[i][0].set_xdata(self.data_x[i]) self.plotlines_i[i][0].set_ydata(self.data_i[i]) self.plotlines_v[i][0].set_ydata(self.data_v[i]) self.plotlines_i[i][0].set_color(self.colors[i]) self.plotlines_v[i][0].set_color(self.colors[i]) self.plotax_i[cindex].set_xlim(self.data_x[cindex][0], self.data_x[cindex][-1]) self.plotax_v[cindex].set_xlim(self.data_x[cindex][0], self.data_x[cindex][-1]) dataLog.new_data = 0 for i in range(len(self.plotcanvas_i)): self.plotcanvas_i[i].draw_idle() self.plotcanvas_v[i].draw_idle() return True