def __init__(self): Gtk.Window.__init__(self, title="GtkListStore demo") self.connect("delete-event", Gtk.main_quit) # self.connect("destroy", Gtk.main_quit) # no difference? xpix, ypix, dpi = 600, 600, 100 self.set_default_size(xpix, ypix) self.set_border_width(8) # -- overall window box # docs recommend we switch this Gtk.Box to a Gtk.Grid # https://lazka.github.io/pgi-docs/#Gtk-3.0/classes/VBox.html#Gtk.VBox vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.add(vbox) label = Gtk.Label(label='Double click a row to plot the data') vbox.pack_start(label, False, False, 0) # -- ScrolledWindow to hold our data table self.sw = Gtk.ScrolledWindow() self.sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN) self.sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) vbox.pack_start(self.sw, True, True, 0) # set data self.nrows, self.ncols = 20, 10 self.data = np.random.random((self.nrows, self.ncols)) # declare the model (a Gtk.ListStore) and TreeView for our data table model = self.create_table() self.treeview = Gtk.TreeView(model=model) # -- Figure for the plot of each row fig = Figure(figsize=(xpix / dpi, ypix / dpi), dpi=dpi) self.set_default_size(xpix, ypix) self.canvas = FigureCanvas(fig) vbox.pack_start(self.canvas, True, True, 0) ax = fig.add_subplot(111) self.line, = ax.plot(self.data[0, :], 'go') # plot first row # -- set an action: update plot when you dblclick a row self.treeview.connect('row-activated', self.plot_row) self.sw.add(self.treeview) self.add_columns() # load our data self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.KEY_PRESS_MASK | Gdk.EventMask.KEY_RELEASE_MASK)
def attach_Figs(self, grid): for i in range(4): en_d_vbox_name = "en_d{:d}_vbox".format(i) en_d_vbox = self.builder.get_object(en_d_vbox_name) en_d_vbox.pack_start(FigureCanvas(self.en_fig[i]), True, True, 0) col, row = 0, 1 for i in range(6): grid.attach(FigureCanvas(self.t_fig[2 * i]), col, row, 1, 1) col += 1 col, row = 0, 2 for i in range(6): grid.attach(FigureCanvas(self.t_fig[2 * i + 1]), col, row, 1, 1) col += 1
def main(): window = gtk.Window() window.set_default_size(800, 600) # matplotlib x_vec = np.arange(-10, 10, 0.01) y_vec = np.sin(2 * 2 * np.pi * x_vec) * 1 / np.sqrt(2 * np.pi) * np.exp( -(x_vec**2) / 2) #fig = plt.figure(figsize=(8.0, 6.0), dpi=100) fig = plt.figure() ax = fig.add_subplot(111) ax.plot(x_vec, y_vec) # add the image to the window scrolled_window = gtk.ScrolledWindow() window.add(scrolled_window) canvas = FigureCanvas(fig) canvas.set_size_request(800, 600) # optional... scrolled_window.add_with_viewport(canvas) # main window.connect( "delete-event", gtk.main_quit ) # ask to quit the application when the close button is clicked window.show_all() # display the window gtk.main() # GTK+ main loop
def __init__(self, data_source): years = mdates.YearLocator(2) # every year months = mdates.MonthLocator() # every month yearsFmt = mdates.DateFormatter('%y') dt_list, ssn_list = data_source.get_plotting_data() self.figure = Figure(figsize=(12, 8), dpi=72) self.figure.patch.set_facecolor('white') self.figure.subplots_adjust(bottom=0.2) self.axis = self.figure.add_subplot(111) self.axis.plot_date(dt_list, ssn_list, '-', lw=2) self.axis.axvline(date.today(), color='r') # format the ticks self.axis.xaxis.set_major_locator(years) self.axis.xaxis.set_major_formatter(yearsFmt) self.axis.grid(True) # rotates and right aligns the x labels, and moves the bottom of the # axes up to make room for them # The following line currently breaks voacapgui if the thumbnail is # inserted into a panel # self.figure.autofmt_xdate(rotation=90) self.canvas = FigureCanvas(self.figure) # a Gtk.DrawingArea
def graph_c(funcion, initial_value, last_value): function = Fun(funcion) win = Gtk.Window() win.connect("destroy", lambda x: Gtk.main_quit()) win.set_default_size(640, 480) win.set_title("Embedding in GTK") vbox = Gtk.VBox() win.add(vbox) fig = Figure(figsize=(5, 4), dpi=100) ax = fig.add_subplot(111) x = np.arange(initial_value, last_value) y = [function.evaluate2(i) for i in x] ax.plot(x, y) dev = Fun(derivate_function(funcion)) derivada = [dev.evaluate2(i) for i in x] ax.plot(x, derivada) canvas = FigureCanvas(fig) # a Gtk.DrawingArea vbox.pack_start(canvas, True, True, 0) toolbar = NavigationToolbar(canvas, win) vbox.pack_start(toolbar, False, False, 0) win.show_all() Gtk.main()
def __init__(self, *args, **kwds): super().__init__(*args, **kwds) self.set_label("Image Plot") self.connect("node_func_clicked", self.remove) # create input socket lbl = Gtk.Label.new("Input") lbl.set_xalign(0.0) node_socket_input = self.item_add(lbl, GtkNodes.NodeSocketIO.SINK) node_socket_input.connect("socket_incoming", self.node_socket_incoming) # the compatibility key node_socket_input.set_key(1234) node_socket_input.set_rgba(get_rgba('darkturquoise')) f = Figure(figsize=(5, 4), dpi=100) self.a = f.add_subplot(111) sw = Gtk.ScrolledWindow() sw.set_border_width(10) self.canvas = FigureCanvas(f) sw.add(self.canvas) sw.set_size_request(200, 200) self.item_add(sw, GtkNodes.NodeSocketIO.DISABLE) self.set_child_packing(sw, True, True, 0, Gtk.PackType.END)
def final_clicked(self, widget): self.grid.remove(self.label7) self.grid.remove(self.label8) self.grid.remove(self.canvas) f = Figure() ax = f.add_subplot(111) ax.scatter(np.arange(1, len(self.gensel.scores_best) + 1, 1), self.gensel.scores_best, label='Best') ax.plot(np.arange(1, len(self.gensel.scores_best) + 1, 1), self.gensel.scores_avg, label='Average') self.canvas = FigureCanvas(f) # a Gtk.DrawingArea self.canvas.set_size_request(800, 600) self.grid.attach(self.canvas, 4, 0, 4, 4) self.gensel.scores_best.sort(reverse=True) self.label7 = Gtk.Label() self.label7.set_text("Accuracy after feature selection: {0}".format( self.gensel.scores_best[0])) self.grid.attach(self.label7, 4, 4, 4, 1) self.label8 = Gtk.Label() self.label8.set_text("Feature Subset selected: {0}".format( self.gensel.chromosomes_best[0])) self.grid.attach(self.label8, 4, 5, 4, 1) self.show_all()
def __init__(self, yrange=(0, 1), xrange=10, update_interval=50): super(Graph, self).__init__(hexpand=True, vexpand=True) self.range = xrange self.interval = update_interval self.last_velocidad = 0 self.last_torque = 0 self.last_vel_deseada = 0 self.last_time = 0 self.fig = plt.figure() self.ax = self.fig.subplots() self.xdata, self.ydata_velocidad = [], [] self.ydata_torque = [] self.ydata_vel_deseada = [] self.ln_velocidad, = self.ax.plot([], [], label='Velocidad') self.ln_torque, = self.ax.plot([], [], label='Torque') self.ln_vel_deseada, = self.ax.plot([], [], 'r', label='Velocidad deseada') self.ax.legend() self.ax.grid(True) self.on_frame_callback = [] self.ax.set_xlim(-self.range, 0) self.ax.set_ylabel('Velocidad / Torque') self.ax.set_ylim(yrange[0], yrange[1]) self.ax.set_xlabel('Segundos') self.canvas = FigureCanvas(self.fig) self.add(self.canvas)
def __init__(self, **kw): super(PlotterWindow, self).__init__(**kw) self.set_title("Real-time plotting") self.set_default_size(600, 400) # self.grid = Gtk.Grid() # self.add(self.grid) self.i = 0 self.before = self.prepare_cpu_usage() self.fig = Figure() ax = self.fig.add_subplot(111) ax.set_xlim(0, 30) ax.set_ylim([0, 100]) ax.set_autoscale_on(False) self.user, self.nice, self.sys, self.idle = [], [], [], [] self.l_user, = ax.plot([], self.user, label='User %') self.l_nice, = ax.plot([], self.nice, label='Nice %') self.l_sys, = ax.plot([], self.sys, label='Sys %') self.l_idle, = ax.plot([], self.idle, label='Idle %') ax.legend() self.canvas = FigureCanvas(self.fig) self.add(self.canvas) self.update_draw() GLib.idle_add(self.update_draw)
def create_window_using_tuple(self, tupl, title): window = Gtk.Window() box = Gtk.VBox() window.add(box) figure = Figure(figsize=(4, 4), dpi=100) canvas = FigureCanvas(figure) box.pack_start(canvas, True, True, 0) toolbar = NavigationToolbar(canvas, window) box.pack_start(toolbar, False, False, 0) subplot = figure.add_subplot(111) amounts = list() dates = list() for row in tupl: amounts.append(row[0]) dates.append(row[1]) subplot.bar(dates, amounts, width=10) subplot.set_xticks(dates) subplot.set_xticklabels(dates) for index, data in enumerate(amounts): subplot.text(x=dates[index], y=data, s=f"{data}", ha='center') figure.autofmt_xdate() subplot.set_title(title) window.set_size_request(400, 300) window.set_title(title) window.set_icon_name('pygtk-posting') window.show_all()
def draw_piechart(self): labels = [] sizes = [] colors = [ '#ffffff', '#eeeeee', '#dddddd', '#cccccc', '#bbbbbb', '#aaaaaa', '#999999', '#888888' ] i = 0 other_percent = 0 for item in self.portfolio["items"]: if i < 7: labels.append(" " + item['ticker'] + " ") sizes.append(item['percent']) else: other_percent += item['percent'] i += 1 if other_percent > 0: labels.append(" другие ") sizes.append(other_percent) fig, ax = plt.subplots() fig.patch.set_facecolor('white') fig.patch.set_alpha(0) wedges, text, autotext = ax.pie(sizes, colors=colors, labels=labels, autopct='%1.1f%%', startangle=0) plt.setp(wedges, width=0.25) #plt.setp( wedges, ) for w in wedges: w.set_linewidth(1) w.set_linestyle('-') w.set_edgecolor('#555555') w.set_capstyle('projecting') fig = plt.gcf() ax.axis('equal') for t in text: t.set_color("#999999") #t.set_backgroundcolor("white") t.set_fontname("Play") t.set_fontsize(8) for t in autotext: t.set_color("#888888") t.set_fontname("Play") t.set_fontsize(7) canvas = FigureCanvas(fig) canvas.set_size_request(300, 300) self.box.pack_start(canvas, expand=False, fill=True, padding=0)
def __init__(self, parent, simulation, colormap, statBar, z_lims=None, y_lims=None, binary_colors=False): self.parent = parent self.simulation = simulation self.colormap = colormap self.format = '%.2E' self.statBar = statBar self.builder = Gtk.Builder() self.builder.add_from_file(resource_dir + "/toolbar.glade") wnd = self.builder.get_object("wndToolBar") self.toolbar = self.builder.get_object("boxToolBar") self.boxLimits = self.builder.get_object("boxLimits") wnd.remove(self.toolbar) self.btnApplyLimits = self.builder.get_object("btnApplyLimits") self.txtMinLimit = self.builder.get_object("txtMinLimit") self.txtMaxLimit = self.builder.get_object("txtMaxLimit") self.lblBmin = self.builder.get_object("lblBmin") self.lblBmax = self.builder.get_object("lblBmax") self.btnRestore = self.builder.get_object("btnRestore") self.btnSave = self.builder.get_object("btnSave") self.btnHideShowCoils = self.builder.get_object("btnHideShowCoils") self.lblHideShowCoils = self.builder.get_object("lblHideShowCoils") self.txtMaxLimit.connect("key-press-event", self.on_key_press_event) self.txtMinLimit.connect("key-press-event", self.on_key_press_event) self.boxPlot = Gtk.Box(spacing=6, orientation=Gtk.Orientation.VERTICAL) self.fig = Figure(figsize=(10, 10), dpi=80) self.fig.patch.set_facecolor((242 / 255, 241 / 255, 240 / 255)) self.canvas = FigureCanvas(self.fig) self.fig.canvas.mpl_connect("button_press_event", self.on_click) self.boxPlot.pack_start(self.canvas, True, True, 0) self.boxPlot.pack_start(self.toolbar, False, True, 0) self.btnRestore.connect("clicked", self.on_initial_plot) self.btnApplyLimits.connect("clicked", self.on_apply_limits) self.btnSave.connect("clicked", self.on_save) self.btnHideShowCoils.connect("clicked", self.on_hide_show_coils) self.z_lims = (self.simulation.z_min, self.simulation.z_max) self.y_lims = (self.simulation.y_min, self.simulation.y_max) if z_lims: self.z_lims = z_lims if y_lims: self.y_lims = y_lims self.initial_norm = self.simulation.norm.copy() self.binary_colors = binary_colors self.selected_point = [[], []] self.rect = None self.plot_coils = False self.on_initial_plot(None)
def __init__(self, app): Gtk.Window.__init__(self, application=app) self.set_default_size(800, 600) # ------------------------------------------------------------------ # Functions to plot x = np.linspace(0, 5, 11) y = x**2 # Figure as wrapper for plots fig = plt.figure() axes = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # add description of axes axes.set_xlabel("X") axes.set_ylabel("Y") # add title of plot axes.set_title("Title") # Plot1 axes.plot(x, y) # ------------------------------------------------------------------ canvas = FigureCanvas(fig) canvas.set_size_request(400, 300) self.add(canvas)
def best_fit(self, temp_data, dimension): f = Figure(figsize=(5, 4), dpi=100) a = f.add_subplot(111) s = temp_data t = range(1, len(temp_data) + 1) fit = np.poly1d(np.polyfit(t, s, dimension)) format_fit = str(fit).replace('\n', '') win = Gtk.Window() win.set_default_size(1000, 1000) title = self.questions[ self.active_question].get_question() + "(y = %s)" % format_fit win.set_title(title) a.plot(s) a.plot(fit(t)) a.set_xlabel("Time(x)") a.set_ylabel("Input(y)") sw = Gtk.ScrolledWindow() win.add(sw) # A scrolled window border goes outside the scrollbars and viewport sw.set_border_width(10) canvas = FigureCanvas(f) # a Gtk.DrawingArea canvas.set_size_request(800, 600) sw.add_with_viewport(canvas) win.show_all()
def show_fourier(fr, armonicas, xl, xu): #cantidad de armonicas al numero de armonica a calcular cant_armo = armonicas + (armonicas - 1) #preparar ventana para mostrar resultado win = Gtk.Window() win.connect("delete-event", Gtk.main_quit) win.set_default_size(800, 600) win.set_title("Embedding in GTK") f = Figure(figsize=(800 / 96, 800 / 96), dpi=96) a = f.add_subplot(111) #algoritmo para generar series de fourier xs = np.arange(xl, xu, 0.001) generar = generador_armonicas(fr) ys = [generar(cant_armo, x) for x in xs] a.plot(xs, ys) #mostrar resultados sw = Gtk.ScrolledWindow() win.add(sw) sw.set_border_width(10) canvas = FigureCanvas(f) # a Gtk.DrawingArea canvas.set_size_request(800, 600) sw.add_with_viewport(canvas) win.show_all() Gtk.main()
def _createPlot(self): self.fig = plt.Figure(figsize=(5, 4), dpi=100) self.ax = self.fig.add_subplot() self.canvas = FigureCanvas(self.fig) # a Gtk.DrawingArea self.canvas.set_size_request(800, 600) self.left.add(self.canvas)
def graphic(funcion, initial_value, iterations): function = Function(funcion) win = Gtk.Window() win.connect("destroy", lambda x: Gtk.main_quit()) win.set_default_size(640, 480) win.set_title("Embedding in GTK") vbox = Gtk.VBox() win.add(vbox) increment = 0.01 final_value = math.fabs(initial_value+math.fabs(increment*100)) fig = Figure(figsize=(5, 4), dpi=100) ax = fig.add_subplot(111) x = np.arange(-50, 3, 0.01) y = [function.evaluate2(i) for i in x] ax.plot(x, y) canvas = FigureCanvas(fig) # a Gtk.DrawingArea vbox.pack_start(canvas, True, True, 0) toolbar = NavigationToolbar(canvas, win) vbox.pack_start(toolbar, False, False, 0) win.show_all() Gtk.main()
def __init__(self, app): Gtk.Window.__init__(self, application=app) self.set_default_size(800, 600) # ------------------------------------------------------------------ # Functions to plot x = np.linspace(0, 5, 11) y = x**2 # Figure and axes fig, axes = plt.subplots(nrows=1, ncols=2) # Plot1 axes[0].plot(x, y) # Plot2 axes[1].plot(y, x) # ------------------------------------------------------------------ canvas = FigureCanvas(fig) canvas.set_size_request(400, 300) self.add(canvas)
def drawPlot(filename=""): if sw.get_child() != None: sw.remove(sw.get_child()) figure = Figure(figsize=(8, 8), dpi=80) axis = figure.add_subplot(111) x, y = calculateValues() axis.plot(x, y) if plot["zoom"]: last = y[0] for i in range(len(y)): if y[i] > last: break last = y[i] axis.set_ylim(top=y[i:].max() + abs(y[i:].max() * 0.075), bottom=y[i:].min() - abs(y[i:].min() * 0.075)) else: axis.set_ylim(top=y.max() + abs(y.max() * 0.075), bottom=y.min() - abs(y.min() * 0.075)) if plot["lambda"]: axis.set_xlabel("Wellenlänge in m") else: axis.set_xlabel("Glanzinkel in °") if plot["persecond"]: axis.set_ylabel("Zählrahte in 1/s") else: axis.set_ylabel("Zählrahte in 1/" + str(time) + "s") axis.set_title("Röntgenspektrum") canvas = FigureCanvas(figure) sw.add(canvas) sw.show_all() if filename != "": figure.savefig(filename)
def __init__(self, lat, lon, alt, data, name): fig = Figure() self.ax = fig.gca(projection='3d') s = False for i in range(len(sys.argv)): if (sys.argv[i] == "-l"): try: self.ax.plot3D(latitude, longitude, altitude, sys.argv[i+1]) except ValueError: print("Colour not recognized") except IndexError: print("Please input a colour") elif (sys.argv[i] == "-s"): s = True; try: self.ax.scatter(latitude, longitude, altitude, c=data, s=int(sys.argv[i+1])) except IndexError: print("Please input a point size") if (s != True): self.ax.scatter(latitude, longitude, altitude, c=data, s=1) self.ax.set_title("%s Heatmap" %name) self.ax.set_xlabel("x (m)") self.ax.set_ylabel("y (m)") self.ax.set_zlabel("altitude (m)") self.ax.view_init(30, 45) self.canvas = FigureCanvas(fig) self.canvas.set_size_request(800, 800)
def __init__(self): #Readers should find it familiar, as we are creating a matplotlib figure here with a dpi(resolution) 100 self.fig = Figure(figsize=(5, 5), dpi=100) #The axes element, here we indicate we are creating 1x1 grid and putting the subplot in the only cell #Also we are creating a polar plot, therefore we set projection as 'polar self.ax = self.fig.add_subplot(111, projection='polar') #Here, we borrow one example shown in the matplotlib gtk3 cookbook #and show a beautiful bar plot on a circular coordinate system self.theta = linspace(0.0, 2 * pi, 30, endpoint=False) self.radii = 10 * random.rand(30) self.width = pi / 4 * random.rand(30) self.bars = self.ax.bar(self.theta, self.radii, width=self.width, bottom=0.0) #Here defines the color of the bar, as well as setting it to be transparent for r, bar in zip(self.radii, self.bars): bar.set_facecolor(cm.jet(r / 10.)) bar.set_alpha(0.5) #Here we generate the figure self.ax.plot() #Creating Canvas which store the matplotlib figure self.canvas = FigureCanvas(self.fig) # a Gtk.DrawingArea
def __init__(self, profile): self.profile = profile self.builder = Gtk.Builder() prog_path = Path(__file__).parent self.builder.add_from_file(str(prog_path / 'ui.glade')) self.builder.connect_signals(self) for obj in self.builder.get_objects(): try: setattr(self, Gtk.Buildable.get_name(obj), obj) except: pass self.f = Figure() self.canvas = FigureCanvas(self.f) self.figure_holder.pack_start(self.canvas, True, True, 5) self.profile_data_x = [0] self.profile_data_y = [25] for (rate, target, time) in self.profile: t = (target - self.profile_data_y[-1]) / rate self.profile_data_x.append(self.profile_data_x[-1] + t) self.profile_data_y.append(target) self.profile_data_x.append(self.profile_data_x[-1] + time) self.profile_data_y.append(target) self.recorded_data_x = [0] self.recorded_data_y = [25] self.replot() self.stop_button.set_sensitive(False) self.start_button.set_sensitive(False) print(self.connect_button.get_label()) self.main_window.show_all() self.oven = None self.running = False self.start_t = None GLib.idle_add(lambda: self.idle())
def __init__(self): builder = Gtk.Builder() builder.add_from_file('app_perceptron_lib/main_gui.glade') builder.connect_signals(self) self.generator = DatasetGenerator() self.perceptron = Perceptron(run_perceptron) self.train_plotter = DataPlotter() self.train_canvas = FigureCanvas(self.train_plotter.fig) self.dataset_size_entry = builder.get_object('dataset_size_entry') self.max_epochs_entry = builder.get_object('max_epochs_entry') self.test_size_entry = builder.get_object('test_r_size_entry') self.learning_rate_entry = builder.get_object('learning_r_entry') self.epoch_output = builder.get_object('epoch_output') self.train_errors_output = builder.get_object('train_errors_output') self.test_errors_output = builder.get_object('test_errors_output') self.model_output = builder.get_object('model_output') self.gen_data_button = builder.get_object('gen_data_button') self.train_button = builder.get_object('train_button') self.test_button = builder.get_object('test_button') box = builder.get_object('graph_box') box.pack_start(self.train_canvas, True, True, 0) self.on_gen_data_button_clicked() window = builder.get_object('main_window') window.set_default_size(700, 550) window.show_all()
def __init__(self, app): Gtk.Window.__init__(self, application=app) self.set_default_size(800, 600) # ------------------------------------------------------------------ # Functions to plot x = np.linspace(0, 5, 11) y = x**2 # Figure as wrapper for plots fig = plt.figure() # Axes 1 axes = fig.add_axes([0.1, 0.1, 0.8, 0.8]) axes.set_title("Bigger plot") # Plot1 axes.plot(x, y) # Plot2 axes.plot(y, x) # ------------------------------------------------------------------ canvas = FigureCanvas(fig) canvas.set_size_request(400, 300) self.add(canvas)
def __init__(self): self.win = Gtk.Window() self.win.connect("delete-event", Gtk.main_quit) self.win.set_default_size(720, 480) self.fig = Figure(figsize=(10, 10), dpi=100) self.ax = self.fig.add_subplot() self.canvas = FigureCanvas(self.fig) sw = Gtk.ScrolledWindow() sw.set_border_width(10) sw.add(self.canvas) upperside = Gtk.ButtonBox(orientation=Gtk.Orientation.VERTICAL) self.fill_btnbox(upperside, TIMINGS) lowerside = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.spin = Gtk.SpinButton() self.spin.set_range(1, 2**16) #TODO: find out how to remove upper bound self.spin.set_increments(1, 10) self.spin.set_value(self.iterc) self.spin.connect("value-changed", self._on_spin) lowerside.pack_end(self.spin, False, True, 0) lowerside.pack_end(Gtk.Label.new("↓Iterations↓"), False, True, 0) self.progr2 = Gtk.ProgressBar() lowerside.pack_end(self.progr2, False, True, 2) self.progr1 = Gtk.ProgressBar() lowerside.pack_end(self.progr1, False, True, 2) sidebar = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) sidebar.pack_start(upperside, False, True, 10) sidebar.pack_start(lowerside, True, True, 2) self.box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) self.box.pack_start(sidebar, False, True, 2) self.box.pack_start(sw, True, True, 0) self.win.add(self.box) self.win.show_all() self.progr1.set_opacity(0) self.progr2.set_opacity(0)
def __init__(self): super(PlotWindow, self).__init__() self.connect('destroy', Gtk.main_quit) self.box = Gtk.Box(spacing=6, orientation=Gtk.Orientation(1)) self.add(self.box) self.switch = Gtk.Switch() self.switch.connect("notify::active", self.on_switch_toggled) self.switch.set_active(False) self.box.pack_start(self.switch, True, True, 0) self.progress = Gtk.ProgressBar(show_text=True) self.box.pack_start(self.progress, True, True, 0) # global line, ax, canvas self.fig = Figure() self.ax = self.fig.add_subplot(111) self.ax.set_xlim(0, 30) self.ax.set_ylim([0, 255]) self.ax.set_autoscale_on(False) self.data = [] self.l_data, = self.ax.plot([], self.data, label='MagY') self.ax.legend() self.canvas = FigureCanvas(self.fig) self.canvas.set_size_request(800, 600) self.canvas.show() self.box.pack_start(self.canvas, True, True, 0) # self.line, = self.ax.plot([1, 2, 3], [1, 2, 10]) port = '/dev/ttyACM0' baud = 9600 self.arduino = ArdTest(self, port, baud)
def __init__(self, viewport): self._viewport = viewport figure = Figure() self._canvas = FigureCanvas(figure) self._viewport.add(self._canvas) self._viewport.show_all()
def main(): builder = Gtk.Builder() builder.add_objects_from_file( str(Path(__file__).parent / "mpl_with_glade3.glade"), ("window1", "")) builder.connect_signals(Window1Signals()) window = builder.get_object("window1") sw = builder.get_object("scrolledwindow1") # Start of Matplotlib specific code figure = Figure(figsize=(8, 6), dpi=71) axis = figure.add_subplot(111) t = np.arange(0.0, 3.0, 0.01) s = np.sin(2 * np.pi * t) axis.plot(t, s) axis.set_xlabel('time [s]') axis.set_ylabel('voltage [V]') canvas = FigureCanvas(figure) # a Gtk.DrawingArea canvas.set_size_request(800, 600) sw.add(canvas) # End of Matplotlib specific code window.show_all() Gtk.main()
def invoice_chart_clicked (self, button): global Figure if Figure == None: from matplotlib.figure import Figure from matplotlib.backends.backend_gtk3agg import FigureCanvasGTK3Agg as FigureCanvas from matplotlib.pyplot import pie self.figure = Figure(figsize=(4, 4), dpi=100) canvas = FigureCanvas(self.figure) # a Gtk.DrawingArea canvas.set_size_request(800, 500) overlay = self.builder.get_object('overlay1') overlay.add (canvas) a = self.figure.add_subplot(111) labels = list() fractions = list() unpaid = 0 self.cursor.execute("SELECT SUM(amount_due), c.name FROM invoices " "JOIN contacts AS c ON c.id = invoices.customer_id " "WHERE (canceled, paid, posted) = " "(False, False, True) GROUP BY customer_id, c.name " "ORDER BY SUM(amount_due)") for row in self.cursor.fetchall(): customer_total = row[0] customer_name = row[1] fractions.append(customer_total) labels.append(customer_name) unpaid += 1 if unpaid == 0: labels.append("None") fractions.append(1.00) a.pie(fractions, labels=labels, autopct='%1.f%%', radius=0.7) window = self.builder.get_object('window1') window.show_all()
def makePlot(x_axis, y_axes, axis_update_callback, is_polar): if len(y_axes) < 1: raise Exception("Plot needs at least one y-axis") if is_polar and len(y_axes) != 1: displayError("Polar plots can't have more than one y-axis") y_axes = [y_axes[0]] fig = Figure(figsize=(5, 4), dpi=100) subplot = None if is_polar: subplot = fig.add_subplot(1, 1, 1, projection='polar') else: subplot = fig.add_subplot(1, 1, 1) #we need to adjust the plot so that we have enough space for extra labels if len(y_axes) > 2: fig.subplots_adjust(right=0.75) #generate all axes subplots = [subplot] for axis in y_axes[1:]: subplots.append(subplot.twinx()) #set labels, etc i = -1 for axis, plot in zip(y_axes, subplots): axis.setUpdateCallback(axis_update_callback) if not is_polar: plot.set_ylabel("%s [%s]" % (axis.name, str(axis.unit))) else: label_position = plot.get_rlabel_position() plot.text(np.radians(label_position + 10), plot.get_rmax() / 2.0, "%s [%s]" % (axis.name, str(axis.unit)), rotation=label_position, ha='center', va='center') if axis.min_val is None and axis.max_val is None: plot.set_ylim(auto=True) else: plot.set_ylim(axis.min_val, axis.max_val) if i >= 0: plot.spines['right'].set_position(('outward', i * 60)) i += 1 subplot.set_xlabel("%s [%s]" % (x_axis.name, str(x_axis.unit))) if x_axis.min_val is None and x_axis.max_val is None: subplot.set_xlim(auto=True) else: subplot.set_xlim(x_axis.min_val, x_axis.max_val) subplot.grid(True) canvas = FigureCanvas(fig) canvas.set_size_request(600, 600) box = Gtk.VBox() toolbar = NavigationToolbar(canvas, box) box.pack_start(canvas, False, False, 0) box.pack_start(toolbar, False, False, 0) return box, canvas, subplots
def __init__(self): Gtk.Window.__init__(self) self.set_default_size(600, 600) self.connect('destroy', lambda win: Gtk.main_quit()) self.set_title('GtkListStore demo') self.set_border_width(8) vbox = Gtk.VBox(False, 8) self.add(vbox) label = Gtk.Label('Double click a row to plot the data') vbox.pack_start(label, False, False, 0) sw = Gtk.ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN) sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) vbox.pack_start(sw, True, True, 0) model = self.create_model() self.treeview = Gtk.TreeView(model) self.treeview.set_rules_hint(True) # matplotlib stuff fig = Figure(figsize=(6, 4)) self.canvas = FigureCanvas(fig) # a Gtk.DrawingArea vbox.pack_start(self.canvas, True, True, 0) ax = fig.add_subplot(111) self.line, = ax.plot(self.data[0, :], 'go') # plot the first row self.treeview.connect('row-activated', self.plot_row) sw.add(self.treeview) self.add_columns() self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.KEY_PRESS_MASK | Gdk.EventMask.KEY_RELEASE_MASK)
class DataManager(Gtk.Window): numRows, numCols = 20, 10 data = random((numRows, numCols)) def __init__(self): Gtk.Window.__init__(self) self.set_default_size(600, 600) self.connect('destroy', lambda win: Gtk.main_quit()) self.set_title('GtkListStore demo') self.set_border_width(8) vbox = Gtk.VBox(False, 8) self.add(vbox) label = Gtk.Label('Double click a row to plot the data') vbox.pack_start(label, False, False, 0) sw = Gtk.ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN) sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) vbox.pack_start(sw, True, True, 0) model = self.create_model() self.treeview = Gtk.TreeView(model) self.treeview.set_rules_hint(True) # matplotlib stuff fig = Figure(figsize=(6, 4)) self.canvas = FigureCanvas(fig) # a Gtk.DrawingArea vbox.pack_start(self.canvas, True, True, 0) ax = fig.add_subplot(111) self.line, = ax.plot(self.data[0, :], 'go') # plot the first row self.treeview.connect('row-activated', self.plot_row) sw.add(self.treeview) self.add_columns() self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.KEY_PRESS_MASK | Gdk.EventMask.KEY_RELEASE_MASK) def plot_row(self, treeview, path, view_column): ind, = path # get the index into data points = self.data[ind, :] self.line.set_ydata(points) self.canvas.draw() def add_columns(self): for i in range(self.numCols): column = Gtk.TreeViewColumn(str(i), Gtk.CellRendererText(), text=i) self.treeview.append_column(column) def create_model(self): types = [float]*self.numCols store = Gtk.ListStore(*types) for row in self.data: store.append(tuple(row)) return store