class Plotter: def __init__(self, master): self.master = master self.x = [0 for i in range(10)] self.y = [i for i in range(10)] self.fig = Figure(figsize=(3, 3)) self.ax = self.fig.add_subplot(111) self.ax.set(xlim=[0, 1], yticks=[i for i in range(10)], title='Predicted Probability') self.bar_plot = self.ax.barh(self.y, self.x) self.fig_canvas = FigureCanvasTkAgg(self.fig, master=master) self.fig_canvas.draw() self.fig_canvas.get_tk_widget().pack(pady=20) def update_plot(self, y): for bar, y_val in zip(self.bar_plot, y): bar.set_width(y_val) self.fig_canvas.draw() self.fig_canvas.flush_events() def reset_plot(self): y = [0 for i in range(10)] for bar, y_val in zip(self.bar_plot, y): bar.set_width(y_val) self.fig_canvas.draw() self.fig_canvas.flush_events()
class BarChart: def __init__(self, algorithm, data, frame): n = len(data) m = max(data) self.algorithm = algorithm self.data = data self.frame = frame self.sorting_algorithm_ref = Algorithms.reference(algorithm, data) self.figure, self.ax = plt.subplots() self.rectangles = self.ax.bar(range(n), self.data, align="edge") self.ax.set_xlim(0, n) self.ax.set_ylim(0, m + 10) self.ax.set_yticklabels([]) self.ax.set_xticklabels([]) self.ax.set_title(self.algorithm.value) self.text = self.ax.text(0.01, 0.97, "", transform=self.ax.transAxes) self.iteration = [0] self.canvas = FigureCanvasTkAgg(self.figure, master=self.frame) self.anim = None def start_animation(self): if self.anim is None: self.anim = FuncAnimation(self.figure, func=self.__animate_ref__, frames=self.sorting_algorithm_ref, interval=50, repeat=False) else: self.anim.event_source.start() self.canvas.draw() def stop_animation(self): if self.anim is not None: self.anim.event_source.stop() def pack(self): self.canvas.get_tk_widget().pack(side=LEFT, fill=BOTH) def pack_forget(self): self.canvas.get_tk_widget().pack_forget() def reset_data(self, new_data): self.data = new_data self.iteration = [0] self.anim = None self.ax.clear() self.figure, self.ax = plt.subplots() self.rectangles = self.ax.bar(range(len(new_data)), self.data, align="edge") self.canvas = FigureCanvasTkAgg(self.figure, master=self.frame) self.canvas.draw() self.canvas.flush_events() def __animate_ref__(self, A): for rect, val in zip(self.rectangles, A): rect.set_height(val) self.iteration[0] += 1 self.text.set_text("Broj iteracija: {}".format(self.iteration[0]))
class Graph: def __init__(self): self._ind = 111 def create_figure(self,data,info="input parameters",fl=False,xw=9,yh=6): try : if not fl: self.fig.delaxes(self.fig.axes[0]) self.fig except AttributeError: self.fig = Figure(figsize=(xw,yh), dpi=100) figure = self.fig.add_subplot(self._ind) figure.grid(True) m = (lambda: "-" if fl else "--")() figure.plot(data[0],data[1],m,label = info) figure.legend(loc='upper left') def create_canvas(self,wh=False): try: self.fig except AttributeError: if wh: self.create_figure([1,1],"input parameters",False,wh[0],wh[1]) else: self.create_figure([1,1]) self.canvas = FigureCanvasTkAgg(self.fig, master=self.frame) self.canvas.get_tk_widget().grid(row=0,column=0) self.canvas.draw() self.canvas.flush_events() def enable_toolbar(self): try: toolbarFrame = tkinter.Frame(master=self.frame) toolbarFrame.grid(row=1,column=0) toolbar = NavigationToolbar2Tk(self.canvas,toolbarFrame) toolbar.config(bg=back) toolbar._message_label.config(bg=back) toolbar.update() except AttributeError: print("error: crate figure first") def create_graph(self,**opt): self.frame = tkinter.Frame(master=opt["mas"],bg=back) self.frame.grid(row=opt["row"],column=opt["col"]) if "wh" in opt.keys(): self.create_canvas(opt["wh"]) else: self.create_canvas() if(opt['toolbar']): self.enable_toolbar()
def plot_domain_gui(result, original, file): test = np.asarray(result) orig = np.asarray(original) plots: Tk = Tk() plots.wm_title("Ring Locations in the Cluster:\t" + file) fig = Figure(figsize=(10, 10), dpi=100) canvas = FigureCanvasTkAgg(fig, master=plots) canvas.draw() ax1 = fig.add_subplot(111, projection='3d') # Hide grid lines ax1.grid(False) # Hide axes ticks ax1.set_xticks([]) ax1.set_yticks([]) ax1.set_zticks([]) ax1.axis('off') x = orig[:, 0] y = orig[:, 1] z = orig[:, 2] # for i in range(len(orig)): # for j in range(len(orig)): # if 2 >= np.linalg.norm(orig[i] - orig[j]) >= 1.2: # p = [orig[i, 0], orig[j, 0]] # q = [orig[i, 1], orig[j, 1]] # r = [orig[i, 2], orig[j, 2]] # ax1.plot(p, q, r, color='r', marker='o', linewidth=2) x = test[:, 0] y = test[:, 1] z = test[:, 2] for i in range(len(test)): for j in range(len(test)): if 2 >= np.linalg.norm(test[i] - test[j]) >= 1.2: p = [test[i, 0], test[j, 0]] q = [test[i, 1], test[j, 1]] r = [test[i, 2], test[j, 2]] ax1.plot(p, q, r, color='b', marker='o', linewidth=2) toolbar = NavigationToolbar2Tk(canvas, plots) toolbar.update() canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1) canvas.flush_events()
def plot_model_activation(self, model_activations, frame): """Plots the current model activations in a given frame (in a prediction context)""" fig = Figure(figsize=(4, 4)) fig.clf() fig.add_subplot(111).plot(range(10), model_activations) fig.suptitle("corresponding model activations") axes = fig.gca() axes.set_xlabel("digit") axes.set_ylabel("activation") axes.set_ylim([0, 1]) axes.set_xticks(range(10)) axes.set_yticks(np.array(range(11)) / 10) canvas = FigureCanvasTkAgg(fig, master=frame) canvas.draw() canvas.flush_events() canvas.get_tk_widget().grid(row=0, column=1) self.annot_max(range(10), model_activations, axes)
class Graph: def __init__(self, start_x, end_x, frame=None): self.start_x = start_x self.end_x = end_x self.__frame = frame self.__figure = Figure(figsize=(10, 6), dpi=100) self.__plot = self.__figure.add_subplot(111) self.__plot.grid(True) self.__plot.legend(loc='upper left') self.__canvas = FigureCanvasTkAgg(self.__figure, master=self.__frame) self.__canvas.get_tk_widget().pack() self.__canvas.draw() self.__canvas.flush_events() # Shows function range with red dots def show_interval(self): self.__plot.plot(self.start_x, 0, 'ro') self.__plot(self.end_x, 0, 'ro') def show_function(self, x, y, color, label=None): self.__plot.plot(x, y, color, label=label) self.refresh() def refresh(self): self.__plot.legend(loc='upper left') self.__canvas.draw() def set_frame(self, frame): self.__frame = frame def add_toolbar(self): Toolbar(frame=self.__frame, canvas=self.__canvas) def get_plot(self): return self.__plot def get_canvas(self): return self.__canvas def clear_graph(self): self.__plot.clear()
class myLinePlotter: def __init__(self): root = Tkinter.Tk() # Create a container frame = Tkinter.Frame(root) # create a figure fig = plt.figure(figsize=(12, 6), dpi=96, facecolor='w', edgecolor='k') self.ax = fig.add_axes([.1, .1, .8, .8]) #initialize left plot #self.plot = ax.plot(np) #plt.ion() self.plot, = self.ax.plot(np.zeros(400), np.zeros(400)) #self.ax.axis('off') self.ax.get_xaxis().set_visible(False) self.ax.get_yaxis().set_visible(False) #self.plot.set_clim(0,1) #builds the gui self.canvas = FigureCanvasTkAgg(fig, master=root) self.canvas.show() self.canvas.get_tk_widget().pack(side='top', fill='both', expand=1) frame.pack() def set_data(self, X_in, Y_in): self.plot.set_xdata(X_in) self.plot.set_ydata(Y_in) #self.plot.draw() self.canvas.draw() self.canvas.flush_events() def set_xlim(self, lowerlim, upperlim): self.ax.set_xlim([lowerlim, upperlim]) def set_ylim(self, lowerlim, upperlim): self.ax.set_ylim([lowerlim, upperlim])
class TkFigure(ttk.Frame): DEFAULT_FONT_SIZE = 23 DEFAULT_TITLE_SIZE = 25 def __init__(self, root, subplots, title=''): ttk.Frame.__init__(self, root) self.signal_mouse_press = Signal() self.signal_mouse_release = Signal() self._fig = Figure() self._subplots = [] self._canvas = FigureCanvas(self._fig, self) self._canvas.get_tk_widget().pack(expand=tk.YES, fill=tk.BOTH) self._canvas.mpl_connect('button_press_event', self.signal_mouse_press) self._canvas.mpl_connect('button_release_event', self.signal_mouse_release) toolbar = NavigationToolbar2Tk(self._canvas, self) toolbar.update() num_rows = len(subplots) num_columns = max(len(graphs) for graphs in subplots) for i in range(num_rows): for j in range(num_columns): subplot = subplots[i][j] if subplot is not None: index = (i * num_columns) + j + 1 ax = self._fig.add_subplot(num_rows, num_columns, index) subplot.set_axis(ax) self._subplots.append(subplot) self._fig.suptitle(title, fontweight='bold', fontsize=self.DEFAULT_TITLE_SIZE) self._fig.subplots_adjust(hspace=.6, wspace=.3) def draw(self): for subplot in self._subplots: subplot.draw() def update_plot(self): self._canvas.draw() self._canvas.flush_events()
class FragmentDisplayer: def __init__(self, frame): figure_fragment = plt.Figure(figsize=(3, 3), dpi=100) self._ax = figure_fragment.add_subplot(111) self._canvas = FigureCanvasTkAgg(figure_fragment, frame) self._canvas.get_tk_widget().pack(side=tk.RIGHT, fill=tk.BOTH) self._data = None def get_data(self): return self._data def draw_data(self, data): self._data = data if settings.is_visualisation(): self._ax.imshow(self._data, cmap='gray') force_aspect(self._ax, aspect=1) self._canvas.draw() plt.pause(0.01) def _redraw(self): self._canvas.draw() self._canvas.flush_events()
def __init__(self, master): tk.Frame.__init__(self, master) self.grid_rowconfigure(0, weight=1) self.grid_columnconfigure(0, weight=1) canvas = FigureCanvasTkAgg(f, self) canvas.get_tk_widget().grid(row=0, column=0, columnspan=10, rowspan=5, sticky=N + S + E + W) canvas.draw() toolbarframe = tk.Frame(self) toolbarframe.grid(row=6, column=0, columnspan=10, sticky=W) toolbar = CustomToolbar(canvas, toolbarframe) ani = animation.FuncAnimation(f, animate, interval=10000) canvas.draw() canvas.flush_events()
class VisualizationFrame(SynthFrame): def __init__(self, master, data, name="Visualization"): super().__init__(master, name) self.data = data self._init_plot_components() def _init_plot_components(self): fig = Figure((2, 1)) self.ax = fig.add_subplot(111) self.line, = self.ax.plot(0) self.canvas = FigureCanvasTkAgg(fig, master=self) self.ax.set_xlim((0, 1)) self.ax.set_ylim((-1, 1)) self.ax.set_xticks([]) self.ax.set_yticks([]) self.canvas.get_tk_widget().pack() def plot(self): data = self.data() if callable(self.data) else self.data if data is not None: data_size = len(data) time_axis = np.arange(data_size) xlimits = (0, data_size) self.line.set_data(time_axis, data) self.ax.set_xlim(xlimits) def update_canvas(self): try: self.canvas.draw() self.canvas.flush_events() except tk.TclError: pass
class gui(object): """choose_palette(\\**kwargs) Graphical user interface to choose custom HCL-basec color palettes. Parameters ---------- kwargs : ... Optional, can be used to change the defaults when starting the GUI. Currently a parameter called ``palette`` is allowed to specify the initial color palette. If not set, ``palette = "Blue-Red"`` is used. Example ------- >>> colorspace.choose_palette() """ WIDTH = 400 HEIGHT = 700 FRAMEHEIGHT = 100 FRAMEWIDTH = WIDTH - 20 # Slider settings _slider_settings = { "h1" : {"type": "int", "from": -360, "to": 360, "resolution": 1}, "h2" : {"type": "int", "from": -360, "to": 360, "resolution": 1}, "c1" : {"type": "int", "from": 0, "to": 100, "resolution": 1}, "cmax" : {"type": "int", "from": 0, "to": 180, "resolution": 1}, "c2" : {"type": "int", "from": 0, "to": 100, "resolution": 1}, "l1" : {"type": "int", "from": 0, "to": 100, "resolution": 1}, "l2" : {"type": "int", "from": 0, "to": 100, "resolution": 1}, "p1" : {"type": "float", "from": 0, "to": 3, "resolution": .1}, "p2" : {"type": "float", "from": 0, "to": 3, "resolution": .1}, "n" : {"type": "int", "from": 2, "to": 30, "resolution": 1} } _sliders = [] # Canvas for the current palette _currentpalette = None # Dropdown menu (Dropdown) _Dropdown = None # Frame taking up the default palettes _palframe = None # Tkiter object for the demo _demoTk = None # Used to store the control buttons (desaturate, reversed, ...) _control = None # Initialize defaults _setting_names = ["h1","h2","c1","cmax","c2","l1","l2","p1","p2","n"] _settings = {} for key in _setting_names: _settings[key] = 7 if key == "n" else None def __init__(self, **kwargs): # Initialization arguments, if any init_args = {} # Default if no inputs are set if not "palette" in kwargs.keys(): palette = "Blue-Red" else: palette = kwargs["palette"] # Find initial values from . import hclpalettes self._palettes = hclpalettes() pal = self._palettes.get_palette(palette) # Store palette name and palette type to select # the correct dropdown entries init_args["name"] = pal.name() init_args["type"] = pal.type() for key,val in pal.get_settings().items(): init_args[key] = val # Save palette settings self.settings(**pal.get_settings()) # Initialize gui self._master = self._init_master() # The different palette types self._Dropdown = self._add_paltype_dropdown(pal.type()) # Adding current palette has to be before the sliders # as they need the current palette canvas for the # to be able to be reactive. self._sliders = self._add_sliders() # Adding dropdown menu and select color map # Add the frame with the default palettes # on top of the GUI self._palframe = self._add_palframe(pal.type()) ## Add the horizontal color map for current colors. self._currentpalette = self._add_currentpalettecanvas() self._draw_currentpalette() self._DEMO = self._add_demo_options() self._add_return_button() # Adding control checkboxes and radio buttons self._control = self._add_control() # Initialize interface mainloop() def _add_paltype_dropdown(self, type_): """_add_paltype_dropdown() Adds a drop down menu to the GUI which allowes to switch between the different types of the default palettes (see also :py:class:`palettes.hclpalettes`). Parameters ---------- type_ : str the default selected palette type on GUI initialization. """ opts = self.palettes().get_palette_types() paltypevar = StringVar(self.master()) paltypevar.set(type_) # default value # Option menu menu = OptionMenu(self.master(), paltypevar, *opts, command = self.OnPaltypeChange) #obj.selected) menu.config(width = 40, pady = 5, padx = 5) menu.grid(column = 1, row = len(opts)) menu.place(x = 10, y = 30) return paltypevar def OnPaltypeChange(self, *args, **kwargs): """OnPaltypeChange(*args, **kwargs) The callback function of the drop down element. Triggered every time the drop down element changes. """ # Updating the palette-frame. self._palframe = self._add_palframe(args[0]) # Take first palette p = self.palettes().get_palettes(args[0])[0] # Enable/disable/set sliders settings = p.get_settings() for elem in self.sliders(): # Setting value, ensable slider if elem.name() == "n": continue elif elem.name() in settings.keys(): elem.set(settings[elem.name()]) elem.enable() # Disable slider else: elem.disable() def _add_control(self): """_add_control() Adds the check buttons (``Tk.Checkbutton``) and radio button (``Tk.Radiobutton``) elements. Color fixup, revert colors, and CVD options. """ control = {} frame = Frame(self.master(), height = 30, width = self.WIDTH - 20) frame.grid() frame.place(x = 10, y = self.HEIGHT - 140) col = 0; row = 0 # Fixup colors fixupvar = BooleanVar() fixupbutton = Checkbutton(frame, text="Fixup colors", variable = fixupvar, command = self.OnChange) fixupbutton.grid(column = col, row = row, sticky = "w"); row += 1 fixupbutton.select() control["fixup"] = fixupvar # Reverse colors revvar = BooleanVar() revbutton = Checkbutton(frame, text="Reverse colors", variable = revvar, command = self.OnChange) revbutton.grid(column = col, row = row, sticky = "w"); row += 1 control["reverse"] = revvar # Butons for Desaturation/CVD ypos = self.HEIGHT - 40 desatvar = BooleanVar() desatbutton = Checkbutton(frame, text="Desaturation", command = self.OnChange, variable = desatvar) desatbutton.grid(column = col, row = row, sticky = "w"); row += 1 control["desaturate"] = desatvar cvdvar = BooleanVar() cvdbutton = Checkbutton(frame, text="Color blindness", command = self.OnChange, variable = cvdvar) cvdbutton.grid(column = col, row = row, sticky = "w"); col += 1 control["cvd"] = cvdvar # Radio buttons for CVD ypos = self.HEIGHT - 20 cvdtypevar = StringVar() radio_deutan = Radiobutton(frame, text = "deutan", command = self.OnChange, variable = cvdtypevar, value = "deutan") radio_protan = Radiobutton(frame, text = "protan", command = self.OnChange, variable = cvdtypevar, value = "protan") radio_tritan = Radiobutton(frame, text = "tritan", command = self.OnChange, variable = cvdtypevar, value = "tritan") radio_deutan.grid(column = col, row = row, sticky = "w"); col += 1 radio_protan.grid(column = col, row = row, sticky = "w"); col += 1 radio_tritan.grid(column = col, row = row, sticky = "w"); col += 1 cvdtypevar.set("deutan") control["cvdtype"] = cvdtypevar return control def control(self): """control() Returns ------- dict Returns a dictionary with the current control options (see :py:func:`_add_control`). """ if not self._control: return {"reverse" : False, "desaturate" : False, "cvd" : False, "cvdtype" : "deutan", "fixup": True} else: res = {} res["reverse"] = self._control["reverse"].get() res["desaturate"] = self._control["desaturate"].get() res["cvd"] = self._control["cvd"].get() res["cvdtype"] = self._control["cvdtype"].get() res["fixup"] = self._control["fixup"].get() return res def settings(self, *args, **kwargs): """settings( *args, **kwargs) Used to load/store current palette settings (gui settings). Parameters ---------- args : ... strings to load one/several parameters. kwargs : ... named arguments, used to store values. Returns ------- dict Returns a dictionary with the current slider settings. """ # Return current settings if len(args) == 0 and len(kwargs) == 0: return self._settings # Return some settings elif len(args): res = {} for key in args: if not isinstance(key, str): continue # Loading setting if key in self._setting_names: res[key] = self._settings[key] if len(res) == 1: return res[list(res.keys())[0]] else: return reskk # Store values, if possible. else: for key,val in kwargs.items(): if key in self._setting_names: self._settings[key] = val def _init_master(self): """_init_master() Initializes the ``Tk`` GUI window. """ # initialize mater TK interface master = Tk() master.wm_title("Colorspace - Choose Color Palette") master.configure() master.resizable(width=False, height=False) master.geometry("{:d}x{:d}".format(self.WIDTH, self.HEIGHT)) master.bind("<Return>", self._return_to_python) master.bind("<Escape>", self._return_to_python) return master def master(self): """master() Returns ------- ``Tk`` Returns the ``Tk`` GUI object. """ return self._master def palettes(self): """palettes() Returns ------- :py:class:`palettes.hclpalettes` Returns the default palettes available. """ return self._palettes def sliders(self): """sliders() Returns ------- list List of :py:class:`Slider` objects. """ return self._sliders def palframe(self): """palframe() Returns ------- ``Tk.Frame`` Returns the palette frame (``Tk.Frame`` object, see :py:func:`_add_palframe`). """ return self._palframe def _add_palframe(self, type_): """_add_palframe() Adds a ``Tk.Frame`` to the ``Tk`` element (see :py:func:`_init_master`). This frame is used to take up the default palettes. """ ##scroll dev### if hasattr(self, "_palframe"): ##scroll dev### if not self._palframe is None: self._palframe.destroy() ##scroll dev### frame = Frame(self.master()) ##scroll dev### frame.place(x = 10, y = 80) ##scroll dev### # Loading palettes of currently selected palette type ##scroll dev### from numpy import min ##scroll dev### pals = self.palettes().get_palettes(type_) ###self.dd_type.get()) ##scroll dev### for child in frame.winfo_children(): child.destroy() ##scroll dev### canvas = Canvas(frame, bg = "#ffffff", ##scroll dev### scrollregion = (0,0,2000,0), ##scroll dev### height = self.FRAMEHEIGHT, width = self.FRAMEWIDTH) ##scroll dev### scroll = Scrollbar(frame, orient = HORIZONTAL) ##scroll dev### scroll.pack(side = BOTTOM,fill = X) ##scroll dev### scroll.config(command = canvas.xview) ##scroll dev### canvas.config(xscrollcommand = scroll.set) ##scroll dev### canvas.pack(fill = BOTH, expand = True) if hasattr(self, "_palframe"): if not self._palframe is None: self._palframe.destroy() frame = Frame(self.master(), bg = "#ffffff", height = self.FRAMEHEIGHT, width = self.FRAMEWIDTH) frame.place(x = 10, y = 80) # Loading palettes of currently selected palette type from numpy import min, sum pals = self.palettes().get_palettes(type_) ###self.dd_type.get()) for child in frame.winfo_children(): child.destroy() # Number of palettes to be drawn (where gui = 1 in palette config) npals = sum([x.get("gui") for x in pals]) # Adding new canvas figwidth = min([30, self.FRAMEWIDTH / npals]) xpos = 0 for pal in pals: if pal.get("gui") <= 0: continue defaultpalettecanvas(frame, self.sliders(), pal, 5, xpos, figwidth, self.FRAMEHEIGHT) xpos += figwidth return frame def _add_currentpalettecanvas(self): """_add_currentpalettecanvas() Adds a ``Tk.Canvas`` object to the GUI to display the current color palette as specified by the GUI settings. Returns ------- ``Tk.Canvas`` Returns the canvas. """ canvas = currentpalettecanvas(self.master(), x = 20, y = 500, width = self.WIDTH - 40, height = 30) return canvas def _draw_currentpalette(self): """_draw_currentpalette() Shows the colors in the current palette frame. """ # Re-draw the canvas. self._currentpalette._draw_canvas(self.get_colors()) def get_colors(self): """get_colors() Returns ------- list Returns a list of hex colors and ``nan`` given the current settings on the GUI. ``numpy.nan`` will be returned if ``fixup`` is set to False but some colors lie outside the RGB color space. """ # Getting current arguments params = {} for elem in self.sliders(): if elem.is_active(): params[elem.name()] = float(elem.get()) # Manipulate params from re import match for dim in ["h", "c", "l","p"]: dim1 = "{:s}1".format(dim) dim2 = "{:s}2".format(dim) dim3 = "{:s}max".format(dim) dim = "power" if dim == "p" else dim # Boolean vector check = [dim1 in params.keys(), dim2 in params.keys(), dim3 in params.keys()] if check[0] and check[1] and check[2]: params[dim] = [params[dim1], params[dim2], params[dim3]] del params[dim1]; del params[dim2]; del params[dim3] elif check[0] and check[2]: # Diverging chemes: only [c1, cmax] allowed, for # others [c1, c2, cmax] (sequential) if match(".*[Dd]iverging.*", self._Dropdown.get()) and dim == "c": params[dim] = [params[dim1], params[dim3]] else: params[dim] = [params[dim1], params[dim1], params[dim3]] del params[dim1]; del params[dim3] elif check[0] and check[1]: params[dim] = [params[dim1], params[dim2]] del params[dim1] del params[dim2] elif check[0]: params[dim] = params[dim1] del params[dim1] for elem in self.sliders(): if elem.name() == "n": n = elem.get() break # Check if we have to return the colors reversed. # and whether or not fixup is set to True/False control = self.control() if not "h" in params.keys(): sys.exit("whoops, lost h") if "n" in params: del params["n"] params["fixup"] = control["fixup"] # Craw colors from current color map from . import palettes type_ = self._Dropdown.get() colorfun = self.palettes().get_palettes(type_)[0].method() fun = getattr(palettes, colorfun) # Return colors colors = fun(**params)(n, rev = control["reverse"]) # Do we have to desaturate the colors? if control["desaturate"]: from .CVD import desaturate colors = desaturate(colors) # Do we have to apply CVD simulation? if control["cvd"]: from . import CVD fun = getattr(CVD, control["cvdtype"]) colors = fun(colors) return colors def method(self): """method() Returns ------- str Returns the name of the object which has to be called to get the colors. The name of the object is defined in the palconfig config files. For "Diverging" palettes this will be :py:class:`palettes.diverging_hcl`, for "Qualitative" :py:class:`palettes.qualitative_hcl`, and for "Sequential" palettes :py:class:`palettes.sequential_hcl`. """ type_ = self._Dropdown.get() colorfun = self.palettes().get_palettes(type_)[0].method() return colorfun def _add_sliders(self): """_add_sliders() Adds a set of sliders to the GUI. Returns ------- list a list of :py:class:`Slider` objects. """ sliders = [] # For each key in self._setting_names add a Slider object # (a Slider is a combined Tkinter.Scale, Tkinter.Entry, and # Tkinter.Label element with bindings). for idx,key in enumerate(self._setting_names): # Initialize with default 0 if nothing yet specified. s = Slider(self.master(), key, # name 10, 100 + idx * 30 + self.FRAMEHEIGHT, # x, y self.WIDTH - 20, 30, # width, height False if self.settings()[key] is None else True, # active type_ = self._slider_settings[key]["type"], from_ = self._slider_settings[key]["from"], to = self._slider_settings[key]["to"], resolution = self._slider_settings[key]["resolution"]) if not self.settings(key): s.set("0") else: s.set(str(self.settings(key))) # Append slider to list sliders.append(s) # Add the trace element to make them interactive # (an observer, call OnChange whenever the Scale changes). for x in sliders: x.trace("w", self.OnChange) return sliders # Callback when an item is getting changed def OnChange(self, *args, **kwargs): """OnChange(*args, **kwargs) Triggered any time the slider values or control arguments change. Draws new current palette (see :py:func:`_draw_currentpalette`). """ self._draw_currentpalette() # Is the demo running? if self._demoTk: self._show_demo(True) def _add_demo_options(self): """_add_demo_options() Adds a ``Tk.Button`` to open the demo plot window. .. todo:: Currently not enabled (have had some problems with the interaction/update). """ but = Button(self.master(), text = "Demo", command = self._show_demo, pady = 5, padx = 5) but.place(x = self.WIDTH - 70, y = self.HEIGHT - 40) # Variable to store current selection opts = ["Bar", "Heatmap", "Pie", "Spine", "Matrix", "Lines", "Spectrum"] demovar = StringVar(self.master()) demovar.set(opts[0]) # default value # Demo plot option menu. No callback menu = OptionMenu(self.master(), demovar, *opts, command = self.OnChange) menu.config(width = 10, pady = 5, padx = 5) menu.grid(column = 1, row = len(opts)) menu.place(x = 180, y = self.HEIGHT - 40) return demovar def _add_return_button(self): """_add_return_button() Adds the button to return to python, a ``Tk.Button`` element. When clicked :py:func:`_return_to_python` is triggered (callback function for this button). """ but = Button(self.master(), text = "Return to python", command = self._return_to_python, pady = 5, padx = 5) but.place(x = 10, y = self.HEIGHT - 40) def _return_to_python(self, *args): """_return_to_python() Returns to :py:func:`choose_palette`. Destroys the ``Tk`` interface but not the object such that :py:func:`choose_palette` can read the settings of the sliders and control elements. Used to create the palette which will then be returned to the console/user console. """ # Destroy the demo figure if not already closed try: import matplotlib.pyplot as plt plt.close(self._demo_Figure) except: pass # Close demo window if not already closed try: self._demoTk.destroy() except: pass self.master().destroy() self.master().quit() def _show_demo(self, update = False): """_show_demo(update = False) Show demo. .. todo:: Implement and test. .. note:: Requires matplotlib. Will show a message if matplotlib is not installed on the machine. """ try: from matplotlib.backends.backend_tkagg import FigureCanvasAgg import matplotlib.backends.tkagg as tkagg from matplotlib.figure import Figure hasmatplotlib = True except: hasmatplotlib = False # If has matplotlib: plot if hasmatplotlib: def draw_figure(canvas, figure, loc=(0, 0)): """ Draw a matplotlib figure onto a Tk canvas loc: location of top-left corner of figure on canvas in pixels. Inspired by matplotlib source: lib/matplotlib/backends/backend_tkagg.py """ figure_canvas_agg = FigureCanvasAgg(figure) figure_canvas_agg.draw() figure_x, figure_y, figure_w, figure_h = figure.bbox.bounds figure_w, figure_h = int(figure_w), int(figure_h) photo = PhotoImage(master=canvas, width=figure_w, height=figure_h) # Position: convert from top-left anchor to center anchor canvas.create_image(loc[0] + figure_w/2, loc[1] + figure_h/2, image=photo) # Unfortunately, there's no accessor for the pointer to the native renderer tkagg.blit(photo, figure_canvas_agg.get_renderer()._renderer, colormode=2) # Return a handle which contains a reference to the photo object # which must be kept live or else the picture disappears return photo import matplotlib matplotlib.use("TkAgg") from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg import matplotlib.pyplot as plt # Initialize plot if not hasattr(self, "_demo_Figure"): self._demo_Figure = plt.figure() if not update: self._demoTk = Tk() self._demoTk.protocol("WM_DELETE_WINDOW", self._close_demo) #demoTk.destroy) self._demoTk.wm_title("colorspace demoplot") self._demo_Axis = self._demo_Figure.add_subplot(211) self._demo_Canvas = FigureCanvasTkAgg(self._demo_Figure, master=self._demoTk) self._demo_Canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1) # Getting demo function from . import demos fun = getattr(demos, self._DEMO.get()) # Update plot fun(self.get_colors(), fig = self._demo_Figure) self._demo_Canvas.draw() self._demo_Canvas.flush_events() else: info = [""] info.append("To be able to run the demo plots") info.append("the python matplotlib package has to be") info.append("installed.") info.append("") info.append("Install matplotlib and try again!") txt = Text(self._demowindow_, height=10, width=45) txt.pack() txt.insert(END, "\n".join(info)) def _close_demo(self): import matplotlib.pyplot as plt self._demoTk.destroy(); self._demoTk = None
class KittelPlotter: def __init__(self, parent): self.tl = tk.Toplevel(parent) self.parent = parent self.dane = [] # "Wyłącza" okno root. Nie można go kontrolować self.tl.grab_set() self.tl.wm_title("Window Kittel") # l = tk.Label(tl, text="This is window #%s" % self.counter) l = tk.Label(self.tl, text="Prepare measurement points") # l.pack(side="top", fill="both", expand=True, padx=100, pady=100) l.pack() containerLeft = tk.Frame(self.tl) containerLeft.pack(side="left") containerRight = tk.Frame(self.tl) containerRight.pack(side="left") PlotButton = tk.Button(containerLeft, text="Plot", command=self.plotKittel) PlotButton.pack(side="top") # l1 = tk.Label(containerLeft, text="MagnEntry") # l1.pack(side="top", fill="both", expand=True) # self.MagnEntry=tk.Entry(containerLeft) # self.MagnEntry.insert(0,"1000") # self.MagnEntry.pack() # l2 = tk.Label(containerLeft, text="gEntry") # l2.pack(side="top", fill="both", expand=True) # self.gEntry=tk.Entry(containerLeft) # self.gEntry.insert(0,"2") # self.gEntry.pack() self.labels = {} self.entries = {} for key, value in EntriesDict.items(): l = tk.Label(containerLeft, text=key) l.pack(side="top", fill="both", expand=True) self.labels[key] = l ent = tk.Entry(containerLeft) ent.insert(0, value) ent.pack() self.entries[key] = ent self.fig = Figure(figsize=(5, 4), dpi=100) self.canvas = FigureCanvasTkAgg( self.fig, master=containerRight) # A tk.DrawingArea. self.graph1 = self.fig.add_subplot(111) self.canvas.draw() self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1) toolbar = NavigationToolbar2Tk(self.canvas, containerRight) toolbar.update() self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1) # self.tl.protocol("WM_DELETE_WINDOW", self.close_window) # def close_window(self): # self.parent.show() # self.tl.destroy() def plotKittel(self): H = np.arange(float(self.entries["Start field"].get()), float(self.entries["End field"].get()), float(self.entries["Field step"].get())) f = float(self.entries["g-factor"].get()) * np.sqrt( (H + 4 * np.pi * float(self.entries["Effective magnetization"].get())) + H) self.dane.append(H) self.dane.append(f) # print(self.MagnEntry.get()) self.graph1.clear() self.graph1.scatter(H, f) self.canvas.draw() self.canvas.flush_events()
class generic_scan(): def __init__(self, main_window, gemroc_handler, tab_control): self.title = "Generic scan" self.tabControl = tab_control self.main_window = main_window self.scan_matrixs = {} self.efine_average = {} self.efine_stdv = {} self.total_events = {} self.GEMROC_reading_dict = gemroc_handler self.error_window = Frame(self.main_window) def _init_windows(self): Label(self.error_window, text=self.title, font=("Courier", 25)).grid(row=0, column=2, sticky=S, pady=4, columnspan=10) tot = len(self.GEMROC_reading_dict) self.TD_scan_result = {} number_list = [] i = 0 self.first_row = Frame(self.error_window) self.first_row.grid(row=1, column=1, sticky=S, pady=4, columnspan=10) self.plotting_gemroc = 0 self.plotting_TIGER = 0 self.plotting_Channel = 0 self.second_row_frame = Frame(self.error_window) self.second_row_frame.grid(row=2, column=1, sticky=S, pady=4, columnspan=10) self.GEMROC_num = StringVar(self.error_window) self.scan_key = StringVar(self.error_window) self.TIGER_num_first = IntVar(self.error_window) self.TIGER_num_last = IntVar(self.error_window) self.CHANNEL_num_first = IntVar(self.error_window) self.CHANNEL_num_last = IntVar(self.error_window) self.param_first = IntVar(self.error_window) self.param_last = IntVar(self.error_window) Label(self.second_row_frame, text='First TIGER ').pack(side=LEFT) Entry(self.second_row_frame, width=4, textvariable=self.TIGER_num_first).pack(side=LEFT) Label(self.second_row_frame, text='Last TIGER ').pack(side=LEFT) Entry(self.second_row_frame, width=4, textvariable=self.TIGER_num_last).pack(side=LEFT) Label(self.second_row_frame, text='First Channel ').pack(side=LEFT) Entry(self.second_row_frame, width=4, textvariable=self.CHANNEL_num_first).pack(side=LEFT) Label(self.second_row_frame, text='Last Channel ').pack(side=LEFT) Entry(self.second_row_frame, width=4, textvariable=self.CHANNEL_num_last).pack(side=LEFT) Label(self.second_row_frame, text='Start ').pack(side=LEFT) Entry(self.second_row_frame, width=4, textvariable=self.param_first).pack(side=LEFT) Label(self.second_row_frame, text='End ').pack(side=LEFT) Entry(self.second_row_frame, width=4, textvariable=self.param_last).pack(side=LEFT) fields_optionsG = self.GEMROC_reading_dict.keys() # fields_optionsG.append("All") Add again all lter OptionMenu( self.first_row, self.GEMROC_num, *fields_optionsG, ).pack(side=LEFT) self.third_row = Frame(self.error_window) self.third_row.grid(row=3, column=1, sticky=S, pady=4, columnspan=10) self.fields_optionspar_c, self.fields_optionspar_g = self.acquire_keys( ) fields_optionspar = self.fields_optionspar_c + self.fields_optionspar_g self.scan_key.set("TP_Vcal_ref") Combobox(self.third_row, textvariable=self.scan_key, values=fields_optionspar).pack(side=LEFT) self.strart_button = Button(self.third_row, text='Launch scan', command=self.launch_scan) self.strart_button.pack(side=LEFT, padx=2) Button(self.third_row, text="Save", command=self.SAVE).pack(side=LEFT, padx=2) Button(self.third_row, text="Load", command=self.LOAD).pack(side=LEFT, padx=2) self.Activate_TP = BooleanVar(self.main_window) Checkbutton(self.third_row, text="Activate TP on channels (one by one)", variable=self.Activate_TP).pack(side=LEFT, padx=2) Button(self.third_row, text="Dump on txt", command=self.DUMP).pack(side=LEFT, padx=2) self.corn0 = Frame(self.error_window) self.corn0.grid(row=4, column=0, sticky=S, pady=4, columnspan=10) self.LBOCC = Label(self.corn0, text='Threshold scan', font=("Times", 18)) self.LBOCC.grid(row=0, column=1, sticky=S, pady=4) self.butleftG = Button( self.corn0, text='<', command=lambda: self.change_G_or_T(-1, "G")).grid(row=1, column=0, sticky=S, pady=4) self.LBGEM = Label(self.corn0, text='GEMROC {}'.format(self.plotting_gemroc), font=("Courier", 12)) self.LBGEM.grid(row=1, column=1, sticky=S, pady=4) self.butrightG = Button( self.corn0, text='>', command=lambda: self.change_G_or_T(1, "G")).grid(row=1, column=2, sticky=S, pady=4) self.butleftT = Button( self.corn0, text='<', command=lambda: self.change_G_or_T(-1, "T")).grid(row=2, column=0, sticky=S, pady=4) self.LBTIG = Label(self.corn0, text='TIGER {}'.format(self.plotting_TIGER), font=("Courier", 12)) self.LBTIG.grid(row=2, column=1, sticky=S, pady=4) self.butrightT = Button( self.corn0, text='>', command=lambda: self.change_G_or_T(1, "T")).grid(row=2, column=2, sticky=S, pady=4) self.usefullframe = Frame(self.corn0) self.usefullframe.grid(row=3, column=1, sticky=S, pady=4) Button(self.usefullframe, text='<', command=lambda: self.change_G_or_T(-1, "C")).grid(row=0, column=0, sticky=S, pady=4) self.LBCH = Label(self.usefullframe, text='CHANNEL ', font=("Courier", 12)) self.LBCH.grid(row=0, column=1, sticky=S, pady=4) self.CHentry = Entry(self.usefullframe, textvariable=self.plotting_Channel, width=4) self.CHentry.grid(row=0, column=2, sticky=S, pady=4) Button(self.usefullframe, text='Go', command=lambda: self.change_G_or_T(1, "GO")).grid(row=0, column=3, sticky=S, pady=4) Button(self.usefullframe, text='>', command=lambda: self.change_G_or_T(1, "C")).grid(row=0, column=4, sticky=S, pady=4) self.corn1 = Frame(self.error_window) self.corn1.grid(row=12, column=1, sticky=S, pady=8, padx=8, columnspan=100) # Plot x = np.arange(0, 1) v = np.zeros((1)) self.fig = Figure(figsize=(5, 5)) self.plot_rate = self.fig.add_subplot() self.scatter, = self.plot_rate.plot(x, v, 'r+', label="data") self.plot_rate.set_title("TIGER {}, GEMROC {}".format( self.plotting_TIGER, self.plotting_gemroc)) self.plot_rate.set_ylabel("Efine") self.plot_rate.set_xlabel("Step") self.plot_rate.ticklabel_format(style='sci', scilimits=(-3, 4), axis='both') self.canvas = FigureCanvasTkAgg(self.fig, master=self.corn1) self.canvas.get_tk_widget().pack(side=BOTTOM) self.canvas.draw() self.canvas.flush_events() self.toolbar = NavigationToolbar2Tk(self.canvas, self.corn1) self.toolbar.canvas.draw_idle() self.line_list = [] # for number, GEMROC_number in self.GEMROC_reading_dict.items(): # print number for i in range(0, 21): number = "GEMROC {}".format(i) self.scan_matrixs[number] = np.zeros((8, 64, 64)) self.TP_settings = {} self.total_events[number] = {} self.efine_average[number] = {} self.efine_stdv[number] = {} for T in range(0, 8): self.TP_settings["TIG{}".format(T)] = {} self.total_events[number]["TIG{}".format(T)] = {} self.efine_average[number]["TIG{}".format(T)] = {} self.efine_stdv[number]["TIG{}".format(T)] = {} for ch in range(0, 64): # self.gaussians[number]["TIG{}".format(T)]["CH{}".format(ch)]=(0,0,0,0) self.efine_average[number]["TIG{}".format(T)][ "CH{}".format(ch)] = [] self.efine_stdv[number]["TIG{}".format(T)]["CH{}".format( ch)] = [] self.total_events[number]["TIG{}".format(T)]["CH{}".format( ch)] = [] def _insert(self, name): self.tabControl.add(self.error_window, text=name) # Add the tab def launch_scan(self): """ Launch the scna procedure :return: """ self.sampling_scan = True if self.Activate_TP.get(): self.start_TP() GEMROC = self.GEMROC_reading_dict["{}".format(self.GEMROC_num.get())] GEM_COM = GEMROC.GEM_COM c_inst = GEMROC.c_inst g_inst = GEMROC.g_inst test_r = AN_CLASS.analisys_read(GEM_COM, c_inst) first = self.TIGER_num_first.get() last = self.TIGER_num_last.get() + 1 firstch = self.CHANNEL_num_first.get() lastch = self.CHANNEL_num_last.get() + 1 GEMROC_ID = GEM_COM.GEMROC_ID for T in range(first, last): # TIGER for J in range(firstch, lastch): # Channel self.efine_average["GEMROC {}".format(GEMROC_ID)][ "TIG{}".format(T)]["CH{}".format(J)] = [] self.efine_average["GEMROC {}".format(GEMROC_ID)][ "TIG{}".format(T)]["CH{}".format(J)] = [] self.total_events["GEMROC {}".format(GEMROC_ID)][ "TIG{}".format(T)]["CH{}".format(J)] = [] for i in range(int(self.param_first.get()), int(self.param_last.get())): print("{} set {}".format(self.scan_key.get(), i)) if self.Activate_TP.get(): GEM_COM.Set_param_dict_channel(c_inst, "TP_disable_FE", T, J, 0) GEM_COM.Set_param_dict_global(g_inst, "FE_TPEnable", T, 1) GEM_COM.Set_param_dict_channel(c_inst, "TriggerMode", T, J, 0) if self.scan_key.get() in self.fields_optionspar_c: GEM_COM.Set_param_dict_channel(c_inst, self.scan_key.get(), T, J, i) if self.scan_key.get() in self.fields_optionspar_g: GEM_COM.Set_param_dict_global(g_inst, self.scan_key.get(), T, i) GEM_COM.SynchReset_to_TgtFEB() average, stdv, total = test_r.acquire_Efine(J, T, 0.5) self.efine_average["GEMROC {}".format(GEMROC_ID)][ "TIG{}".format(T)]["CH{}".format(J)].append(average) self.efine_stdv["GEMROC {}".format(GEMROC_ID)][ "TIG{}".format(T)]["CH{}".format(J)].append(stdv) self.total_events["GEMROC {}".format(GEMROC_ID)][ "TIG{}".format(T)]["CH{}".format(J)].append(total) GEM_COM.Set_param_dict_channel(c_inst, "TriggerMode", T, J, 3) if self.Activate_TP.get(): GEM_COM.Set_param_dict_channel(c_inst, "TP_disable_FE", T, J, 1) GEM_COM.Set_param_dict_global(g_inst, "FE_TPEnable", T, 0) def change_G_or_T(self, i, G_or_T): if G_or_T == "G": self.plotting_gemroc = self.plotting_gemroc + i if self.plotting_gemroc == -1: self.plotting_gemroc = 0 if self.plotting_gemroc == 20: self.plotting_gemroc = 19 if G_or_T == "T": self.plotting_TIGER = self.plotting_TIGER + i if self.plotting_TIGER == -1: self.plotting_TIGER = 0 if self.plotting_TIGER == 8: self.plotting_TIGER = 7 if G_or_T == "C": self.plotting_Channel = self.plotting_Channel + i if self.plotting_Channel < 0: self.plotting_Channel = 0 if self.plotting_Channel > 63: self.plotting_Channel = 63 if G_or_T == "GO": self.plotting_Channel = int(self.CHentry.get()) self.refresh_plot() def refresh_plot(self): self.LBGEM['text'] = 'GEMROC {}'.format(self.plotting_gemroc) self.LBTIG['text'] = 'TIGER {}'.format(self.plotting_TIGER) # self.LBCH['text'] = 'CHANNEL {}'.format(self.plotting_Channel) self.CHentry.delete(0, END) self.CHentry.insert(END, self.plotting_Channel) self.plotta() def start_TP(self): for number, GEMROC_number in self.GEMROC_reading_dict.items(): GEMROC_number.GEM_COM.Soft_TP_generate() GEMROC_number.GEM_COM.gemroc_DAQ_XX.DAQ_config_dict[ 'TL_nTM_ACQ'] = 1 GEMROC_number.GEM_COM.gemroc_DAQ_XX.DAQ_config_dict[ 'Periodic_TP_EN_pattern'] = 15 GEMROC_number.GEM_COM.gemroc_DAQ_XX.DAQ_config_dict[ 'number_of_repetitions'] = 512 + 1 GEMROC_number.GEM_COM.gemroc_DAQ_XX.DAQ_config_dict[ 'TP_width'] = 14 GEMROC_number.GEM_COM.DAQ_set_with_dict() def plotta(self): for number, GEMROC_number in self.GEMROC_reading_dict.items(): if int(number.split()[1]) == int(self.plotting_gemroc): GEMROC_ID = self.plotting_gemroc self.plot_rate.set_title("ROC {},TIG {}, CH {} ".format( self.plotting_gemroc, self.plotting_TIGER, self.plotting_Channel)) y = (self.efine_average["GEMROC {}".format(GEMROC_ID)][ "TIG{}".format(self.plotting_TIGER)]["CH{}".format( self.plotting_Channel)]) x = (range(self.param_first.get(), self.param_last.get())) y = np.nan_to_num(y) if len(y) > 0: self.scatter.set_ydata(y) self.scatter.set_xdata(x) self.plot_rate.set_xlim([x[0] - 1, x[-1] + 1]) self.plot_rate.set_ylim([ np.min(y) - 0.1 * np.max(y), np.max(y) + 0.1 * np.max(y) ]) self.plot_rate.set_xlabel(f"{self.scan_key.get()}", fontsize=14) self.canvas.draw() self.canvas.flush_events() break self.canvas.draw() self.canvas.flush_events() def SAVE(self): File_name = filedialog.asksaveasfilename( initialdir="." + sep + "noise_scan" + sep + "saves", title="Select file", filetypes=(("Noise scan files", "*.ns"), ("all files", "*.*"))) with open(File_name, 'wb') as f: pickle.dump(self.scan_matrixs, f) def LOAD(self): filename = filedialog.askopenfilename( initialdir="." + sep + "noise_scan" + sep + "saves", title="Select file", filetypes=(("Noise scan files", "*.ns"), ("all files", "*.*"))) with open(filename, 'rb') as f: self.scan_matrixs = pickle.load(f) def DUMP(self): """ Dump the matrix in a txt file :return: """ File_name = filedialog.asksaveasfilename(initialdir=".", title="Select file for dump", filetypes=(("txt", "*.txt"), ("all files", "*.*"))) with open(File_name, 'w+') as dumpfile: GEMROC_key = self.GEMROC_num.get() dumpfile.write( f"Scan of {self.scan_key.get()} from {self.param_first.get()} to {self.param_last.get()-1}\n" ) for TIGER_key in range(self.TIGER_num_first.get(), self.TIGER_num_last.get() + 1): for chkey in range(self.CHANNEL_num_first.get(), self.CHANNEL_num_last.get() + 1): dumpfile.write( f"{GEMROC_key} Tiger {TIGER_key} Channel {chkey}\n" ) dumpfile.write("Total event\t Efine\tSigma\n") for Efine, sigma, tota in zip( self.efine_average[GEMROC_key][f"TIG{TIGER_key}"] [f"CH{chkey}"], self.efine_stdv[GEMROC_key] [f"TIG{TIGER_key}"][f"CH{chkey}"], self.total_events[GEMROC_key][f"TIG{TIGER_key}"] [f"CH{chkey}"]): dumpfile.write(f"{tota}\t{Efine}\t{sigma}\n") def acquire_keys(self): """ Function to acquire all the keys for global and channel configuration :return: """ key_list_channel = [] with open("lib" + sep + "keys" + sep + "channel_conf_file_keys", 'r') as G: for line in G.readlines(): key_list_channel.append(line.strip()) key_list_global = [] with open("lib" + sep + "keys" + sep + "global_conf_file_keys", 'r') as C: for line in C.readlines(): key_list_global.append(line.strip()) return key_list_channel, key_list_global
class GUI(tkinter.Tk): def __str__(self): return ("OBSim v1.1") def __init__(self, **kwargs): tkinter.Tk.__init__(self, **kwargs) # ------------------------------- Parameters: self.backcolor = "black" self.forecolor = "white" self.font = ("Arial", "10") self.resol = { "x": 0.8 * self.winfo_screenwidth(), "y": 0.8 * self.winfo_screenheight() } # ------------------------------- Basics: self.title("OBSim v1.1") self.configure(background=self.backcolor) self.attributes("-fullscreen", False) self.resizable(False, False) self.geometry("%ix%i+0+0" % (self.resol["x"], self.resol["y"])) div_x = self.resol["x"] / 64 div_y = self.resol["y"] / 28 # ------------------------------- Variables: self.Ask = tkinter.IntVar() self.inputs = {} # ------------------------------- Radio button frame: inputs = {"Bn_Ask": ((1, 1), 0, "Sell"), "Bn_Bid": ((1, 2), 1, "Buy")} for key in inputs.keys(): self.inputs[key] = {} self.inputs[key] = tkinter.Radiobutton( master=self, font=self.font, bg=self.backcolor, fg=self.forecolor, value=inputs[key][1], text=inputs[key][2], variable=self.Ask, selectcolor=self.backcolor, activebackground=self.backcolor, highlightcolor=self.backcolor) self.inputs[key].place(x=inputs[key][0][0] * div_x, y=inputs[key][0][1] * div_y) self.inputs[key].select() # ------------------------------- Input frame: inputs = { "In_Vol": ((5, 1), (8, 1), "Volume", "w"), "In_Prc": ((5, 2), (8, 2), "Price", "w"), "In_Peg": ((12, 1), (12, 2), "Pegg", "center"), "In_Dsc": ((16, 1), (16, 2), "Disc", "center"), "In_Stp": ((20, 1), (20, 2), "Stop", "center") } self.Values = dict(zip(inputs.keys(), [0] * len(inputs.keys()))) for key in inputs.keys(): self.inputs[key] = {} self.inputs[key]["Input"] = tkinter.Entry(master=self, width=int(div_x / 2)) self.inputs[key]["Input"].place(x=inputs[key][0][0] * div_x, y=inputs[key][0][1] * div_y) self.inputs[key]["Label"] = tkinter.Label(master=self, font=self.font, bg=self.backcolor, fg=self.forecolor, anchor=inputs[key][3], text=inputs[key][2]) self.inputs[key]["Label"].place(x=inputs[key][1][0] * div_x, y=inputs[key][1][1] * div_y) # ------------------------------- Update: self.button = tkinter.Button(master=self, font=self.font, text="Update", command=self.Update) self.button.place(x=int(24 * div_x), y=int(1.5 * div_y)) # ------------------------------- Order book frame: start_csv = "B:\Stack\Trading\EPAT\OBsim\Start.csv" start_csv = [i for i in csv.reader(open(start_csv), delimiter=";")] start_csv = [ numpy.array(start_csv)[:, 0:3], # Bid numpy.array(start_csv)[:, 3:6] ] # Ask self.LOB = [ self.Table(x=30, y=1, w=16, h=12, indexes=["L%d" % L for L in range(11)], headers=["Iceberg", "Volume", "Bid"], data=list(start_csv[0])), self.Table(x=46, y=1, w=16, h=12, indexes=["L%d" % L for L in range(11)], headers=["Ask", "Volume", "Iceberg"], data=list(start_csv[1])) ] self.LOG = \ self.Table(x = 30, y = 14, w = 32, h = 13 ,indexes = ["%04d" % (L + 1) for L in range(0)] ,headers = ["Volume", "Price", "Pegg" , "Disc", "Level", "Type"]) # ------------------------------- Chart frame: a = [int(start_csv[1][0, 0])] b = [int(start_csv[0][0, 2])] s = a[0] - b[0] for t in range(99): an = a[t] * numpy.exp(random.gauss(0, 1 / a[0])) sn = s * numpy.exp(random.gauss(0, 0.1)) a.append(an) b.append(an - sn) self.Figure = Figure() self.Figure.set_facecolor(color=self.backcolor) self.Figure.set_figwidth(val=4.6) self.Figure.set_figheight(val=4.8) self.Plot = self.Figure.add_subplot(111) self.Plot.set_facecolor(color=self.backcolor) self.Plot.tick_params(colors=self.forecolor) xmax, ymax, ymin = 2 * len(a), max(a), 2 * b[-1] - max(a) self.Plot.hlines(y=0, xmin=0, xmax=200, colors=self.forecolor) self.Plot.vlines(x=0, ymin=0, ymax=200, colors=self.forecolor) self.Plot.set_xlim(xmin=0, xmax=xmax) self.Plot.set_ylim(ymin=ymin, ymax=ymax) self.Figure.tight_layout() self.APlot = self.Plot.plot(range(100), a[::-1], color="blue") self.BPlot = self.Plot.plot(range(100), b[::-1], color="red") self.Chart = TkPlot(self.Figure, master=self) self.Chart.get_tk_widget().place(x=0.5 * div_x, y=4 * div_y) self.Chart.draw() # ------------------------------- Update function: def Update(self): # If zero volume, don't carry on. if not (self.inputs["In_Vol"]["Input"].get().isdigit()): return # Retrieve each input value. Set to zero if not numeric. for key in list(self.Values.keys())[:-1]: Input = self.inputs[key]["Input"].get() self.Values[key] = int(Input) if Input.isdigit() else 0 # Get price relative difference. diff_price = self.price_rel_info()["p_diff"] # Order submission into history log. self.Order_Fill() # Check order type in terms of price difference. if (diff_price <= 0): self.Order_Market() else: self.Order_Limit() # Plot new values self.Order_Draw() return # ------------------------------- Get price diff., and spreadsheet columns: def price_rel_info(self): # See if best price is best ask or best bid based in op-type: p_col = 2 * (1 - self.Ask.get()) # Retrieve best price as level 1 (row = 0) of the spreadsheet. best_price = int(self.LOB[self.Ask.get()].get_cell_data(0, p_col)) best_volume = int(self.LOB[self.Ask.get()].get_cell_data(0, 1)) # Retrieve worst price as last filled price of the spreadsheet. w = len(self.LOB[self.Ask.get()].get_column_data(p_col)) - 1 worst_price = int(self.LOB[self.Ask.get()].get_cell_data(w, p_col)) # Market orders: "diff_price = 0" if (self.Values["In_Prc"] == 0): self.Values["In_Prc"] = worst_price # Limit orders: "diff_price > 0" diff_volume = (self.Values["In_Vol"] - best_volume) diff_price = (self.Values["In_Prc"] - best_price) * (-1)**self.Ask.get() # Return price relative diff., and price/column spreadsheet column. # print("%s | order_price = %d | diff_price = %d | diff_volume = %d" # % (self.Ask.get(), self.Values["In_Prc"], diff_price, diff_volume)) return ({"p_col": p_col, "p_diff": diff_price, "v_diff": diff_volume}) # ------------------------------- Order submission: def Order_Fill(self): # Add row at the end of order log, with new values. self.LOG.insert_row(values=list(self.Values.values())) # Write op-type, as it is on a separate property. r = self.LOG.total_rows() - 1 c = self.LOG.total_columns() - 1 o = "Buy" if self.Ask.get() else "Sell" self.LOG.set_cell_data(r, c, o) # Show changes. self.LOG.refresh() return # ------------------------------- Market order writer: MONKA def Order_Market(self): # Get price relative info. diff_volume = self.price_rel_info()["v_diff"] # In case there's more offer than demand, order is fully executed. if (diff_volume < 0): # Leave 1st level price. Only reduce offer volume. diff_volume = abs(diff_volume) self.LOB[self.Ask.get()].set_cell_data(0, 1, str(diff_volume)) self.LOB[self.Ask.get()].refresh() return # Order partially executed. Evaluate what's left. else: self.Values["In_Vol"] = abs(diff_volume) # Delete row of recently consumed level. self.LOB[self.Ask.get()].delete_row(0) self.LOB[self.Ask.get()].refresh() # Retrieve updated relative price difference. diff_price = self.price_rel_info()["p_diff"] if (diff_price <= 0): self.Order_Market() else: self.Order_Market() return # ------------------------------- Limit order writer: MONKA def Order_Limit(self): # Get price info: p_col = 2 - self.price_rel_info()["p_col"] prices = self.LOB[not (self.Ask.get())].get_column_data(p_col) prices = list(map(int, prices)) self.Values["In_Prc"] = self.Values["In_Prc"] prices.append(self.Values["In_Prc"]) prices = sorted(prices, reverse=self.Ask.get()) lvl = prices.index(self.Values["In_Prc"]) v = [0, self.Values["In_Vol"], self.Values["In_Prc"]] v = sorted(v, reverse=not (self.Ask.get())) if (prices.count(self.Values["In_Prc"]) <= 1): self.LOB[not (self.Ask.get())].insert_row(idx=lvl, values=v) self.LOB[not (self.Ask.get())].refresh() else: cell = self.LOB[not (self.Ask.get())].get_cell_data(lvl, 1) cell = str(self.Values["In_Vol"] + int(cell)) self.LOB[not (self.Ask.get())].set_cell_data(lvl, 1, cell) self.LOB[not (self.Ask.get())].refresh() return # ------------------------------- Draw new price and volume values: def Order_Draw(self): a = list(self.APlot[0].get_ydata()) b = list(self.BPlot[0].get_ydata()) a.append(int(self.LOB[1].get_cell_data(0, 0))) b.append(int(self.LOB[0].get_cell_data(0, 2))) self.APlot[0].set_data(range(len(a)), a) self.BPlot[0].set_data(range(len(b)), b) self.Chart.draw() self.Chart.flush_events() return # ------------------------------- Spreadsheet init: MONKA def Table(self, x=0, y=0, w=15, h=15, headers=[], indexes=[], data=[]): div_x = self.resol["x"] / 64 div_y = self.resol["y"] / 28 Table = tksheet.Sheet( self, row_index_foreground=self.forecolor, row_index_background="#222222", header_background="#222222", header_foreground=self.forecolor, table_background=self.backcolor, text_color=self.forecolor, grid_color=self.backcolor, outline_color=self.forecolor, outline_thickness=1, show_x_scrollbar=False, show_y_scrollbar=True, header_font=("Arial", 8, "bold", "underline"), font=("Arial", 8, "normal"), data=data, headers=headers, row_index=indexes, row_index_width=0.6 * w * div_x / (len(headers) + 0.4), column_width=0.8 * w * div_x / (len(headers) + 0.4), width=w * div_x, height=h * div_y) Table.place(x=x * div_x, y=y * div_y) return (Table)
class MainWindow(tkinter.Frame): def __init__(self, root, port): tkinter.Frame.__init__(self, root) self.root = root root.title("Noche de los Museos") root.geometry("1000x630") root.protocol('WM_DELETE_WINDOW', self.close_fn) self.bind('<Return>', self.updateGenerator) self.samples_1 = np.zeros(sample_len) self.samples_2 = np.zeros(sample_len) self.is_playing_1 = False self.is_playing_2 = False self.remote = False self.remote_port = port self.remote_offset = 0 self.remote_thread_runninng = False self.remote_queue = queue.Queue() self.p_audio = pyaudio.PyAudio() self.stream = self.p_audio.open(format=pyaudio.paFloat32, channels=2, rate=f_sampling, \ output=True, stream_callback=sound_callback) self.stream.start_stream() vcmd = (self.register(self.onFloatValidate), '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W') tkinter.Label(self, text='Vibración del Agua:').grid(row=0) self.button_toggle_1 = tkinter.Button( self, text='Activar', command=self.press_button_toggle_1) self.button_toggle_1.grid(row=1) tkinter.Label(self, text='Frecuencia (Hz):').grid(row=1, column=1) self.freq_1_entry_text = tkinter.StringVar() self.freq_1_entry = tkinter.Entry(self, validate='key', validatecommand=vcmd, \ textvariable=self.freq_1_entry_text) self.freq_1_entry.grid(row=1, column=2) self.freq_1_entry_text.set('25') self.freq_1_update = tkinter.Button(self, text='Aplicar', command=self.updateGenerator) self.freq_1_update.grid(row=1, column=3) self.freq_1_up = tkinter.Button(self, text='↑', command=self.freq_1_up_command) self.freq_1_up.grid(row=1, column=4) self.freq_1_down = tkinter.Button(self, text='↓', command=self.freq_1_down_command) self.freq_1_down.grid(row=1, column=5) tkinter.Label(self, text='Fase:').grid(row=1, column=6) self.phase_1_slider = tkinter.Scale(self, from_=0, to=2*np.pi, resolution=0.01, \ orient=tkinter.HORIZONTAL, command=self.updateGenerator) self.phase_1_slider.grid(row=1, column=7) tkinter.Label(self, text='Intensidad:').grid(row=1, column=8) self.intensity_1_slider = tkinter.Scale(self, from_=0, to=1, resolution=0.01, \ orient=tkinter.HORIZONTAL, command=self.updateGenerator) self.intensity_1_slider.grid(row=1, column=9) self.intensity_1_slider.set(1) tkinter.Label(self, text='Luz Estroboscópica:').grid(row=2) self.button_toggle_2 = tkinter.Button( self, text='Activar', command=self.press_button_toggle_2) self.button_toggle_2.grid(row=3) tkinter.Label(self, text='Frecuencia (Hz):').grid(row=3, column=1) self.freq_2_entry_text = tkinter.StringVar() self.freq_2_entry = tkinter.Entry(self, validate='key', validatecommand=vcmd, \ textvariable=self.freq_2_entry_text) self.freq_2_entry.grid(row=3, column=2) self.freq_2_entry_text.set('25') self.freq_1_update = tkinter.Button(self, text='Aplicar', command=self.updateGenerator) self.freq_1_update.grid(row=3, column=3) self.freq_2_up = tkinter.Button(self, text='↑', command=self.freq_2_up_command) self.freq_2_up.grid(row=3, column=4) self.freq_2_down = tkinter.Button(self, text='↓', command=self.freq_2_down_command) self.freq_2_down.grid(row=3, column=5) tkinter.Label(self, text='Fase:').grid(row=3, column=6) self.phase_2_slider = tkinter.Scale(self, from_=0, to=2*np.pi, resolution=0.01, \ orient=tkinter.HORIZONTAL, command=self.updateGenerator) self.phase_2_slider.grid(row=3, column=7) tkinter.Label(self, text='Intensidad:').grid(row=3, column=8) self.intensity_2_slider = tkinter.Scale(self, from_=0, to=1, resolution=0.01, \ orient=tkinter.HORIZONTAL, command=self.updateGenerator) self.intensity_2_slider.grid(row=3, column=9) self.intensity_2_slider.set(1) self.defaults_button_25 = tkinter.Button( self, text="Default 25Hz", command=self.default_config_25) self.defaults_button_25.grid(column=10, row=0, rowspan=2) self.defaults_button_30 = tkinter.Button( self, text="Default 30Hz", command=self.default_config_30) self.defaults_button_30.grid(column=10, row=2, rowspan=2) self.remote_control_button = tkinter.Button(self, text='Remoto', command=self.toggle_remote, relief="raised") self.remote_control_button.grid(row=2, column=11, rowspan=2) if self.remote_port is None: self.remote_control_button.config(state='disabled') self.remote_control_offset = tkinter.Label(self, text='25') self.remote_control_offset.grid(row=2, column=12, rowspan=2) self.plot_fig = plt.Figure(figsize=(10, 5), dpi=100) self.plot_ax1 = self.plot_fig.add_subplot(311) self.plot_samples_1 = self.plot_ax1.plot(t, self.samples_1)[0] self.plot_ax1.set_ylim(-1.1, 1.1) self.plot_ax1.set_xlim(0, t[-1] * 0.01) self.plot_ax1.xaxis.set_ticklabels([]) self.plot_ax1.set_ylabel('Agua') self.plot_ax2 = self.plot_fig.add_subplot(312) self.plot_samples_2 = self.plot_ax2.plot(t, self.samples_2)[0] self.plot_ax2.set_ylim(-0.1, 1.1) self.plot_ax2.set_xlim(0, t[-1] * 0.01) self.plot_ax2.xaxis.set_ticklabels([]) self.plot_ax2.set_ylabel('Luz') self.plot_ax3 = self.plot_fig.add_subplot(313) self.plot_samples_3 = self.plot_ax3.plot( t, self.samples_1 * self.samples_2)[0] self.plot_ax3.set_ylim(-1.1, 1.1) self.plot_ax3.set_xlim(0, t[-1] * 0.01) self.plot_ax3.set_ylabel('Superposición') self.plot_ax3.set_xlabel('t') self.plot_canvas = FigureCanvasTkAgg(self.plot_fig, master=self) self.plot_canvas.draw() self.plot_canvas.get_tk_widget().grid(row=5, columnspan=13) self.after(200, self.listen_for_result) if self.remote_port is not None: self.remote_thread = threading.Thread(target=self.read_remote_port) self.remote_port.reset_input_buffer() self.remote_thread_runninng = True self.remote_thread.start() def onFloatValidate(self, d, i, P, s, S, v, V, W): try: if P == '': return True float(P) return True except ValueError: self.bell() return False def freq_1_up_command(self): self.freq_1_entry_text.set( str(round(float(self.freq_1_entry_text.get()) + 0.1, 2))) self.updateGenerator() def freq_1_down_command(self): f = float(self.freq_1_entry_text.get()) if f >= 0.1: self.freq_1_entry_text.set(str(f - 0.1)) else: self.freq_1_entry_text.set(0) self.updateGenerator() def freq_2_up_command(self): self.freq_2_entry_text.set( str(round(float(self.freq_2_entry_text.get()) + 0.1, 2))) self.updateGenerator() def freq_2_down_command(self): f = float(self.freq_2_entry_text.get()) if f >= 0.1: self.freq_2_entry_text.set(str(f - 0.1)) else: self.freq_2_entry_text.set(0) self.updateGenerator() def updateGenerator(self, *argv): t1 = self.freq_1_entry_text.get() if t1 == '' or float(t1) < 0: self.freq_1_entry_text.set('0') t2 = self.freq_2_entry_text.get() if t2 == '' or float(t2) < 0: self.freq_2_entry_text.set('0') f2 = float(self.freq_2_entry_text.get()) if self.remote: f2 += self.remote_offset if f2 < 0: f2 = 0 self.remote_control_offset.config(text='%.2f' % round(f2, 2)) if self.is_playing_1: self.samples_1 = self.create_sin(float(self.freq_1_entry_text.get()), \ self.phase_1_slider.get(), \ self.intensity_1_slider.get()) else: self.samples_1 = np.zeros(sample_len) if self.is_playing_2: self.samples_2 = self.create_square(f2, \ self.phase_2_slider.get(), \ self.intensity_2_slider.get()) else: self.samples_2 = np.zeros(sample_len) stereo_signal[:, 0] = self.samples_1[:] #1 for right speaker, 0 for left stereo_signal[:, 1] = self.samples_2[:] #1 for right speaker, 0 for left self.plot_samples_1.set_ydata(self.samples_1) self.plot_samples_2.set_ydata(self.samples_2) self.plot_samples_3.set_ydata(self.samples_1 * self.samples_2) self.plot_canvas.draw() self.plot_canvas.flush_events() def create_sin(self, f=25, phase=0, v=1): return (np.sin(2 * np.pi * t * f / f_sampling + phase)).astype( np.float32) * v def create_square(self, f=25, phase=0, v=1): return (sp.signal.square(2 * np.pi * t * f / f_sampling + phase) + 1).astype(np.float32) * v / 2 def press_button_toggle_1(self): if self.is_playing_1: self.is_playing_1 = False self.button_toggle_1.config(text="Activar") else: self.is_playing_1 = True self.button_toggle_1.config(text="Desactivar") self.updateGenerator() def press_button_toggle_2(self): if self.is_playing_2: self.is_playing_2 = False self.button_toggle_2.config(text="Activar") else: self.is_playing_2 = True self.button_toggle_2.config(text="Desactivar") self.updateGenerator() def default_config_25(self): self.freq_1_entry_text.set(25) self.freq_2_entry_text.set(25) self.phase_1_slider.set(0) self.phase_2_slider.set(0) self.intensity_1_slider.set(1) self.intensity_2_slider.set(1) self.is_playing_1 = True self.button_toggle_1.config(text="Desactivar") self.is_playing_2 = True self.button_toggle_2.config(text="Desactivar") self.updateGenerator() def default_config_30(self): self.freq_1_entry_text.set(30) self.freq_2_entry_text.set(30) self.phase_1_slider.set(0) self.phase_2_slider.set(0) self.intensity_1_slider.set(1) self.intensity_2_slider.set(1) self.is_playing_1 = True self.button_toggle_1.config(text="Desactivar") self.is_playing_2 = True self.button_toggle_2.config(text="Desactivar") self.updateGenerator() def toggle_remote(self): if self.remote: self.remote_control_button.config(relief='raised') self.remote = False self.freq_2_entry.config(fg='black') else: self.remote_control_button.config(relief='sunken') with self.remote_queue.mutex: self.remote_queue.queue.clear() self.remote = True self.freq_2_entry.config(fg='red') self.updateGenerator() def read_remote_port(self): while self.remote_thread_runninng: self.remote_queue.put( float(self.remote_port.read_until()) / 1023 * 3 - 1.5) def listen_for_result(self): if self.remote: try: self.remote_offset = self.remote_queue.get(0) self.after(300, self.listen_for_result) self.updateGenerator() except queue.Empty: self.after(300, self.listen_for_result) else: self.after(300, self.listen_for_result) def close_fn(self): self.stream.stop_stream() self.stream.close() self.p_audio.terminate() self.root.destroy() if self.remote: self.remote = False if self.remote_port: self.remote_thread_runninng = False
class noise_rate_measure(): def __init__(self, main_window, gemroc_handler, tab_control, main_menu_istance): self.main_menu = main_menu_istance self.title = "Noise rate measure" self.tabControl = tab_control self.main_window = main_window self.sampling_scan = False self.GEMROC_reading_dict = gemroc_handler self.all_sys_window = Frame(self.main_window) self.start_frame = Frame(self.main_window) self.start_frame.pack() # self.queue = Queue.Queue() # self.getterino=Get_rate(self,self.queue) self.GMAX = int( max( int(key.split(" ")[1]) for key in self.GEMROC_reading_dict.keys())) self.count_matrix_channel = np.zeros((self.GMAX + 1, 8, 64)) self.count_matrix_TIGER = np.zeros((self.GMAX + 1, 8)) # self.rate_matrix_channel = np.zeros((GMAX+1, 8, 64)) # self.rate_matrix_TIGER = np.zeros((GMAX+1, 8)) self.GEMROC = StringVar(self.main_window) self.TIGER = StringVar(self.main_window) self.logscale = BooleanVar(self.main_window) # self.getterino.start() def _init_windows(self): Label(self.all_sys_window, text=self.title, font=("Courier", 25)).grid(row=0, column=2, sticky=S, pady=4, columnspan=10) self.first_lane_frame = Frame(self.start_frame) self.first_lane_frame.grid(row=1, column=2, sticky=S, pady=4, columnspan=10) self.start_button = Button(self.first_lane_frame, text="Acquire one cycle", command=self.start_acq) self.start_button.pack(side=LEFT) Button(self.first_lane_frame, text="Update plot", command=self.update_data).pack(side=LEFT) Button(self.first_lane_frame, text="Clear", command=self.clear).pack(side=LEFT) Label(self.first_lane_frame, text="Rate cap").pack(side=LEFT) self.cap = Entry(self.first_lane_frame, width=6) self.cap.pack(side=LEFT) Button(self.first_lane_frame, text="Lower (T) ch above cap", command=lambda: self.thr_equalizing("a")).pack(side=LEFT) Button(self.first_lane_frame, text="Rise (T) ch below cap", command=lambda: self.thr_equalizing("b")).pack(side=LEFT) # Button(self.first_lane_frame, text="Stop rate acquisition", command=self.stop_acq ).pack(side=LEFT) fields_optionsG = list(self.GEMROC_reading_dict.keys()) # fields_optionsG.append("All") OptionMenu(self.single_GEMROC, self.GEMROC, *fields_optionsG).grid(row=0, column=2, sticky=S, pady=4, columnspan=20) self.GEMROC.set(fields_optionsG[0]) # fields_optionsT = range (0,8) # # fields_optionsT.append("All") # OptionMenu(self.single_TIGER, self.TIGER, *fields_optionsT).grid(row=0, column=0, sticky=S, pady=4, columnspan=20) # OptionMenu(self.single_TIGER, self.GEMROC, *fields_optionsG).grid(row=0, column=1, sticky=S, pady=4, columnspan=20) # # self.GEMROC.trace("w", lambda name, index, mode, sv=self.GEMROC: self.change_plot_G(sv)) # self.TIGER.trace("w", lambda name, index, mode, sv=self.TIGER: self.change_plot_T(sv)) """ Create one plot for each tab mode """ self.plot_frame_total = Frame(self.all_sys_window) self.plot_frame_total.grid(row=2, column=2, sticky=S, pady=4, columnspan=20) self.fig_total = Figure(figsize=(10, 8)) self.axe_total = self.fig_total.add_subplot(111) self.heatmap_total, self.cbar_total = heatmap( self.count_matrix_TIGER, ["GEMROC {}".format(gem_num) for gem_num in range(0, 20)], ["TIGER {}".format(tig_num) for tig_num in range(0, 8)], ax=self.axe_total, cmap="winter", cbarlabel="Rate [hit/s]") self.canvas_total = FigureCanvasTkAgg(self.fig_total, master=self.plot_frame_total) self.canvas_total.get_tk_widget().pack(side=BOTTOM) self.canvas_total.draw() self.canvas_total.flush_events() self.toolbar_total = NavigationToolbar2Tk(self.canvas_total, self.plot_frame_total) self.toolbar_total.draw() self.plot_frame_GEMROC = Frame(self.single_GEMROC) Checkbutton(self.single_GEMROC, text="Log", variable=self.logscale).grid(row=0, column=1, sticky=NW, pady=4) self.plot_frame_GEMROC.grid(row=2, column=2, sticky=S, pady=4, columnspan=20) self.fig_GEMROC = Figure(figsize=(10, 8)) self.axe_GEMROC_A = self.fig_GEMROC.add_subplot(121) self.heatmap_GEMROC_A, self.cbar_GEMRORA = heatmap( np.transpose(self.count_matrix_channel[0])[:32], ["Ch {}".format(tig_num) for tig_num in range(0, 32)], ["T {}".format(tig_num) for tig_num in range(0, 8)], ax=self.axe_GEMROC_A, cmap="winter", cbarlabel="Rate [hit/s]", spawn_cb=True) self.axe_GEMROC_B = self.fig_GEMROC.add_subplot(122) self.heatmap_GEMROC_B, self.cbar_GEMRORB = heatmap( np.transpose(self.count_matrix_channel[0])[32:], ["Ch {}".format(tig_num) for tig_num in range(32, 64)], ["T {}".format(tig_num) for tig_num in range(0, 8)], ax=self.axe_GEMROC_B, cmap="winter", cbarlabel="Rate [hit/s]") self.canvas_GEMROC = FigureCanvasTkAgg(self.fig_GEMROC, master=self.plot_frame_GEMROC) self.canvas_GEMROC.get_tk_widget().pack(side=BOTTOM) self.canvas_GEMROC.draw() self.canvas_GEMROC.flush_events() self.toolbar_GEMROC = NavigationToolbar2Tk(self.canvas_GEMROC, self.plot_frame_GEMROC) self.toolbar_GEMROC.draw() self.acquire_thread = Acquire_rate(self, self.GEMROC_reading_dict) Button(self.first_lane_frame, text="Autotune thr", command=lambda: self.acquire_thread.procedural_scan_handler( self.GEMROC_reading_dict)).pack(side=LEFT) def change_plot_G(self, sv): # print sv.get() # if sv.get()=="All": # self.heatmap.remove() # self.heatmap, = heatmap(self.count_matrix_TIGER, ["GEMROC {}".format(gem_num) for gem_num in range(0, 20)], ["TIGER {}".format(tig_num) for tig_num in range(0, 11)], ax=self.axe, cmap="YlGn", cbarlabel="Rate [hits/s]") # else: # gem_num=int(sv.get().split(" ")[1]) # self.cbar.remov() # self.heatmap, = heatmap(self.count_matrix_channel[gem_num], ["TIGER {}".format(tig_num) for tig_num in range(0, 8)], ["Channel {}".format(ch_num) for ch_num in range(0, 64)], ax=self.axe, cmap="YlGn", cbarlabel="Rate [hits/s]") if sv.get() == "All": # self.heatmap.remove() self.axe_total.set_xticks( np.arange(self.count_matrix_TIGER.shape[1])) self.axe_total.set_yticks( np.arange(self.count_matrix_TIGER.shape[0])) self.axe_total.set_xticklabels( ["GEMROC {}".format(gem_num) for gem_num in range(0, 20)]) self.axe_total.set_yticklabels( ["TIGER {}".format(tig_num) for tig_num in range(0, 11)]) else: gem_num = int(sv.get().split(" ")[1]) print(gem_num) self.axe_total.set_xticks( np.arange(self.count_matrix_channel[gem_num].shape[0])) self.axe_total.set_yticks( np.arange(self.count_matrix_channel[gem_num].shape[1])) self.axe_total.set_xticklabels( ["TIGER {}".format(tig_num) for tig_num in range(0, 11)]) self.axe_total.set_yticklabels( ["Ch {}".format(tig_num) for tig_num in range(0, 64)]) self.canvas_total.draw() self.canvas_total.flush_events() def _insert(self, name): self.tabControl.add(self.all_sys_window, text=name) # Add the tab self.single_GEMROC = Frame(self.main_window) self.single_TIGER = Frame(self.main_window) self.tabControl.add(self.single_GEMROC, text="Single GEMROC") # Add the tab # self.tabControl.add(self.single_TIGER, text="Single TIGER") # Add the tab def start_acq(self): """ Start rate acquisition :return: """ self.start_button["state"] = "disabled" self.acquire_thread.acquire() self.start_button["state"] = "normal" # def stop_acq(self): # """ # Stop rate acquisition # :return: # """ # try: # if self.acquire_thread.running== True: # self.acquire_thread.running=False # self.start_button["state"]="normal" # except AttributeError: # pass def clear(self): """ clear the matrix :return: """ self.count_matrix_channel = np.zeros((self.GMAX + 1, 8, 64)) self.acquire_thread.number_of_cycles = 0 def thr_equalizing(self, mode): """ Lower all the channel threhsolds with the rate above/below a certain level. :return: """ if mode == "a": self.acquire_thread.lower_thr_above(self.cap.get(), "T") if mode == "b": self.acquire_thread.rise_thr_below(self.cap.get(), "T") def update_data(self): if self.tabControl.index("current") == 0: for key in self.GEMROC_reading_dict.keys(): for T in range(0, 8): G = key.split(" ")[1] self.count_matrix_TIGER[int(G)][T] = np.sum( self.count_matrix_channel[int(G)][T]) self.update_plot( self.count_matrix_TIGER / self.acquire_thread.number_of_cycles, "tot") if self.tabControl.index("current") == 1: self.update_plot(self.count_matrix_channel, "GEMROC") def update_plot(self, data, mode): if mode == "tot": # print "G0 : {}".format(data[0]) # print "G1 : {}".format(data[1]) self.heatmap_total.set_data(data) self.canvas_total.draw() self.canvas_total.flush_events() try: MIN_count = int(np.min(data)) MAX_count = int(np.max(data)) except ValueError: MIN_count = 1 MAX_count = 1 self.cbar_total.mappable.set_clim(vmin=MIN_count, vmax=MAX_count) cbar_ticks = np.linspace(MIN_count, MAX_count, num=11, endpoint=True) self.cbar_total.set_ticks(cbar_ticks) self.cbar_total.draw_all() if mode == "GEMROC": G = int(self.GEMROC.get().split(" ")[1]) data = data / self.acquire_thread.number_of_cycles MIN_count = int(np.min(np.transpose(data[G]))) MAX_count = int(np.max(np.transpose(data[G]))) if self.logscale.get(): data = np.ma.log10(data) data = data.filled(0) MIN_count = int(np.min(np.transpose(data[G]))) MAX_count = int(np.max(np.transpose(data[G]))) self.heatmap_GEMROC_A.set_data(np.transpose(data[G])[:32]) self.heatmap_GEMROC_B.set_data(np.transpose(data[G])[32:]) if self.logscale.get(): # cbar_ticks = np. ma.log10(np.linspace(MIN_count, MAX_count, num=11, endpoint=True)) # cbar_ticks = cbar_ticks.filled(0) cbar_ticks = np.linspace(MIN_count, MAX_count, num=11, endpoint=True) self.cbar_GEMRORB.ax.set_ylabel("Log(Rate [hit/s])", rotation=-90, va="bottom") self.cbar_GEMRORA.ax.set_ylabel("Log(Rate [hit/s])", rotation=-90, va="bottom") else: cbar_ticks = np.linspace(MIN_count, MAX_count, num=11, endpoint=True) self.cbar_GEMRORB.ax.set_ylabel("Rate [hit/s]", rotation=-90, va="bottom") self.cbar_GEMRORA.ax.set_ylabel("Rate [hit/s]", rotation=-90, va="bottom") self.cbar_GEMRORB.mappable.set_clim(vmin=MIN_count, vmax=MAX_count) self.cbar_GEMRORA.mappable.set_clim(vmin=MIN_count, vmax=MAX_count) self.cbar_GEMRORB.set_ticks(cbar_ticks) self.cbar_GEMRORB.draw_all() self.cbar_GEMRORA.set_ticks(cbar_ticks) self.cbar_GEMRORA.draw_all() self.canvas_GEMROC.draw() self.canvas_GEMROC.flush_events() def close_stopping(self): """ Handle the closing protocol stopping the acquisition """ # self.stop_acq() self.main_window.destroy() def rework_window(self): self.plot_frame_total.destroy() self.first_lane_frame.destroy() self.start_frame.destroy() self.main_window.update()
class TestFrame(ttk.Frame): def __init__(self, master, settings, machine): self.settings = settings self.machine = machine self.master = master ttk.Frame.__init__(self, master, width=780, height=400) self.columnconfigure(1, weight=1) self.columnconfigure(0, weight=0) self.rowconfigure(0, weight=0) self.grid(row=0, column=0, sticky="nsew") self.runLabel = ttk.Label(self, text="Run Program:", font=('Helvetica', 16), width="20", anchor=tk.E) self.runBtn = ttk.Button(self, text="Stab", command=self.runTest) self.runLabel.grid(row=0, column=0, sticky="e") self.runBtn.grid(row=0, column=1, sticky="w") self.runNumVar = tk.StringVar() self.runNumVar.set("Run Number: " + str(int(self.settings.getValue("runNumber")))) self.runNumberLabel = ttk.Label(self, textvariable=self.runNumVar, font=('Helvetica', 16), width="20", anchor=tk.E) self.runNumberLabel.grid(row=0, column=2, sticky="e") self.figure = Figure() self.figure.set_figheight(3.7) self.figure.set_figwidth(7.8) self.axis = self.figure.add_subplot(111) self.axis.plot([], [], lw=2) self.canvas = FigureCanvasTkAgg(self.figure, self) self.canvas.draw() self.canvas.get_tk_widget().grid(row=1, column=0, columnspan=4, sticky="nsew") self.clearGraphBtn = ttk.Button(self, text="Clear", command=self.clearResults) self.clearGraphBtn.grid(row=0, column=3, sticky="e") def clearResults(self): self.axis.clear() self.canvas.draw() self.canvas.flush_events() self.canvas.draw() def syncTab(self, active): if (not self.settings.getValue("homed")): self.runBtn.configure(state='disable') else: self.runBtn.configure(state='normal') def runTest(self): runNum = int(self.settings.getValue("runNumber")) runNum = runNum + 1 self.settings.setValue("runNumber", runNum) self.settings.save() self.runNumVar.set("Run Number: " + str(runNum)) self.runNumberLabel.update() penetration = self.settings.getValue("targetPen") thrustmove = self.settings.getValue("targetZero") + penetration if (thrustmove > self.settings.getValue("maxDistance")): return #if the thrust move is to far we quit distance = self.machine.Motor.AxisLocation() * -1 if (distance != 0): self.moveHome() thrustspeed = int(self.settings.getValue("Speed")) retractmove = (penetration * 2) * -1 #start reading self.machine.startSensor() #thrust at target self.machine.moveTo(thrustmove, int(thrustspeed)) finished = False while (not finished): time.sleep(.001) finished = self.machine.Motor.commandDone() time.sleep(.25) self.machine.stopSensor() forceresults = self.machine.getForceReadings() moveresults = self.machine.getMovementReadings() self.axis.plot(forceresults[0], forceresults[1], lw=2) self.canvas.draw() self.canvas.flush_events() self.canvas.draw() self.moveHome() filenametime = time.time() acceleration = int(self.settings.getValue("acceleration")) f = open("run-measurements-" + str(runNum) + ".csv", "a") f.write('run,speed,distance,penetration,acceleration\r\n') f.write( str(runNum) + ',' + str(thrustspeed) + ',' + str(thrustmove) + ',' + str(penetration) + ',' + str(acceleration) + '\r\n') f.write('\r\n') f.write('\r\n') f.write('\r\n') f.write('microsecond,rawmeasurement\r\n') count = len(forceresults[0]) for i in range(0, count): f.write( str(forceresults[0][i]) + "," + str(forceresults[1][i]) + '\r\n') f.close() f = open("run-movement-log-" + str(runNum) + ".csv", "a") f.write('run,speed,distance,penetration,acceleration\r\n') f.write( str(runNum) + ',' + str(thrustspeed) + ',' + str(thrustmove) + ',' + str(penetration) + ',' + str(acceleration) + '\r\n') f.write('\r\n') f.write('\r\n') f.write('\r\n') f.write('microsecond,location\r\n') count = len(moveresults[0]) for i in range(0, count): f.write( str(moveresults[0][i]) + "," + str(moveresults[1][i]) + '\r\n') f.close() def moveHome(self): homed = False self.machine.watchSwitch(self.machine.stopMove) self.machine.moveTo( self.settings.getValue("maxDistance") * -1, int(self.settings.getValue("homeSpeed"))) while (not homed): time.sleep(.1) homed = self.machine.Motor.commandDone() self.machine.stopSwitch() self.machine.moveTo(5, int(self.settings.getValue("homeSpeed"))) homed = False while (not homed): time.sleep(.1) homed = self.machine.Motor.commandDone() self.machine.Motor.PulseLocation = 0 self.settings.setValue("homed", True)
class AreaView: """View of signal on serial port. Attributes: master Item to show in. fig MatPlotLib figure. subplt Subplot to plot in. canvas Connection of TKinter and MatPlotLib. getData Callback for getting data. record Callback to control recording. afterId TKinter ID of planned call. """ log = logging.getLogger(__name__) def __init__(self, master=None, reader=lambda:np.array([[0,0],[0,0]])): """Constructs object. Arguments: master Item to show in. reader Callback for getting data. recorder Callback to control recording. """ # create variables self.master = master if master == None: self.master = tk.Frame() self.reader = reader self.afterId = None # initiate MatPlotLib view self.fig = Figure(figsize=(6,4)) self.subplt = self.fig.add_subplot(111) self.subplt.set_xlabel("Orientation") self.subplt.set_ylabel("Distance") self.subplt.set_ylim(0, 12) self.canvas = FigureCanvasTkAgg(self.fig, master=self.master) self.canvas.draw() self.y,self.x = np.mgrid[slice(0,13,6),slice(0,13,6)] # set border self.canvas.get_tk_widget().config(highlightcolor='black', highlightbackground='black', highlightthickness=3, bd=0) # set mouse handlers self.canvas.get_tk_widget().bind('<ButtonRelease-1>', self.manualUpdate) #self.canvas.get_tk_widget().bind('<ButtonRelease-3>', self.showMenu) # create right-click menu #self.menu = RightMenu(self.master, self.manualUpdate, self.recordMenuHandler) # run update in separate thread self.update() def __del__(self): """Destructs object.""" if self.afterId: self.master.after_cancel(self.afterId) def show(self, data): """Actualizes view with new data. Arguments: data New data to show. """ # clear view self.subplt.cla() # set view self.subplt.set_xlabel("Orientation") self.subplt.set_ylabel("Distance") self.subplt.set_ylim(0, 12) # plot data self.subplt.pcolormesh(self.x, self.y, data, vmin=0, vmax=1, cmap='hot') # paint self.canvas.draw() self.canvas.flush_events() def update(self): """Updates view. Runs in separated thread.""" # show new data self.show( self.reader() ) # plan next update after 300 ms self.afterId = self.master.after(conf.Config.period(), self.update) self.log.debug("update area view") def manualUpdate(self, event): """Updates view. Handler for mouse events. Arguments: event Event descriptor. """ # cancel updater thread if self.afterId: self.master.after_cancel(self.afterId) # run new thread self.update()
class menu(): def __init__(self): self.main_win = Tk() # self.client = InfluxDBClient(host='localhost', port=8086) self.client = InfluxDBClient(host='192.168.38.191', port=8086) self.client.switch_database('GUFI_DB') if OS == 'linux2' or OS == 'linux': self.main_win.wm_iconbitmap('@' + "." + sep + 'icons' + sep + 'GUFO_ICON.xbm') self.main_win.wm_title("Online data monitoring") self.GEM_to_config = np.zeros((22)) Title_frame = Frame(self.main_win) Title_frame.pack(side=TOP) Label(Title_frame, text="GUFI Online Monitor", font=("Times", 25)).pack(side=LEFT) self.tabControl = Notebook(self.main_win) # Create Tab Control self.tabControl.pack(side=TOP) self.select_frame = Frame(self.main_win) self.tabControl.add(self.select_frame, text="Selection") self.icon_on = PhotoImage(file="." + sep + 'icons' + sep + 'on.gif') self.icon_off = PhotoImage(file="." + sep + 'icons' + sep + 'off.gif') self.icon_bad = PhotoImage(file="." + sep + 'icons' + sep + 'bad.gif') self.icon_blink = PhotoImage(file="." + sep + 'icons' + sep + 'blinky.gif') self.icon_GUFI1 = PhotoImage(file="." + sep + 'icons' + sep + 'gufi3.gif') self.icon_GUFI2 = PhotoImage(file="." + sep + 'icons' + sep + 'gufi4.gif') self.handler_list = [] self.GEMROC_acquiring_dict = {} self.grid_frame = Frame(self.select_frame) self.grid_frame.pack() self.LED = [] self.button = [] for i in range(0, len(self.GEM_to_config)): if i < 11: riga = 0 else: riga = 1 colonna = ((i) % 11) * 2 + 1 self.LED.append(Label(self.grid_frame, image=self.icon_off)) self.LED[i].grid(row=riga, column=colonna) self.button.append( Button(self.grid_frame, text='ROC {}'.format(i), command=lambda c=i: self.toggle(c))) self.button[i].grid(row=riga, column=colonna - 1) self.error_frame = Frame(self.main_win) self.error_frame.pack(side=TOP) self.Launch_error_check = Label(self.error_frame, text='-', background='white') self.Launch_error_check.grid(row=0, column=2, sticky=NW, pady=4) self.activate_frame = Frame(self.main_win) self.activate_frame.pack(side=TOP) self.conn_but = Button(self.activate_frame, text="Connect", command=self.connect_to_acquisition) self.conn_but.pack() self.start_but = Button(self.activate_frame, text="Start", command=self.start) self.start_but.pack() self.start_but.config(state='disabled') self.get_event_flag = False ##Control tab for buffer self.buffers_frame = Frame(self.main_win) self.tabControl.add( self.buffers_frame, text="Buffer control", ) self.buffer_label_list = [] for i in range(0, len(self.GEM_to_config)): if i < 11: riga = 0 else: riga = 1 colonna = ((i) % 11) * 2 + 1 self.buffer_label_list.append( Label(self.buffers_frame, text=" ---- ", width=6)) self.buffer_label_list[i].grid(row=riga, column=colonna) Label(self.buffers_frame, text='ROC {}'.format(i), width=6, font=(12)).grid(row=riga, column=colonna - 1) ## FIRST status FRAME self.Status_frame = Frame(self.main_win) self.tabControl.add(self.Status_frame, text="Status 1") Label(self.Status_frame, text="Missing UDP packets in current subrun", font=("Courier", 25)).pack() self.UDP_frame = Frame(self.Status_frame) self.UDP_frame.pack() self.missing_UDP_label_list = [] for i in range(0, len(self.GEM_to_config)): if i < 11: riga = 0 else: riga = 1 colonna = ((i) % 11) * 2 + 1 self.missing_UDP_label_list.append( Label(self.UDP_frame, text=" ---- ", width=6)) self.missing_UDP_label_list[i].grid(row=riga, column=colonna) Label(self.UDP_frame, text='ROC {}'.format(i), width=6, font=(12)).grid(row=riga, column=colonna - 1) Label(self.Status_frame, text="TP efficency", font=("Courier", 25)).pack() self.TP_frame = Frame(self.Status_frame) self.TP_frame.pack() self.TP_label_list = [] self.TIG_list = [] for i in range(0, len(self.GEM_to_config) - 1): if i < 7: riga = 0 elif i < 14: riga = 1 else: riga = 2 colonna = ((i) % 7) * 2 + 1 self.TP_label_list.append(Frame(self.TP_frame, width=6)) self.TP_label_list[i].grid(row=riga, column=colonna) for TIG in range(0, 8): if TIG < 4: colonna2 = 0 else: colonna2 = 1 self.TIG_list.append( Label(self.TP_label_list[i], text=" -- ", width=3)) self.TIG_list[TIG + i * 8].grid(row=TIG - colonna2 * 4, column=colonna2 * 2 + 1) Label(self.TP_label_list[i], text="{}".format(TIG), fg="red").grid(row=TIG - colonna2 * 4, column=colonna2 * 2) Label(self.TP_frame, text='ROC {}'.format(i), width=6, font=(12)).grid(row=riga, column=colonna - 1) Label(self.Status_frame, text="Status bits", font=("Courier", 25)).pack() self.StatusBit_frame = Frame(self.Status_frame) self.StatusBit_frame.pack() self.status_bit_list_frame = [] self.single_status_bit = [] # TODO to solve one day for i in range(0, len(self.GEM_to_config) - 1): if i < 7: riga = 0 elif i < 14: riga = 1 else: riga = 2 colonna = ((i) % 7) * 2 + 1 self.status_bit_list_frame.append( Frame(self.StatusBit_frame, width=3)) self.status_bit_list_frame[i].grid(row=riga, column=colonna) for st_bit in range(0, 8): if st_bit < 4: colonna2 = 0 else: colonna2 = 1 self.single_status_bit.append( Label(self.status_bit_list_frame[i], text=" -- ", width=4)) self.single_status_bit[st_bit + i * 8].grid( row=st_bit - colonna2 * 4, column=colonna2 * 2 + 1) Label(self.status_bit_list_frame[i], text="{}".format(st_bit), fg="red").grid(row=st_bit - colonna2 * 4, column=colonna2 * 2) Label(self.StatusBit_frame, text='ROC {}'.format(i), width=6, font=(12)).grid(row=riga, column=colonna - 1) Label( self.Status_frame, text= "Bit 0:XCVR_rx_alignment_error, Bit 1 global_rx_error, Bit 2 top_daq_pll_unlocked_sticky_flag, Bit 3 enabled_FIFO_FULL_error, Bit 4 Header_Misalignment_across_FEBs_error, Bit 5 top_L1_chk_error", font=("Courier", 10)).pack() ## SECOND status frame self.Status_frame_2 = Frame(self.main_win) self.tabControl.add(self.Status_frame_2, text="Status 2") Label(self.Status_frame_2, text="Last UDP packet counter", font=("Courier", 25)).pack() self.UDP_frame_2 = Frame(self.Status_frame_2) self.UDP_frame_2.pack() self.last_UDP_list = [] for i in range(0, len(self.GEM_to_config)): if i < 11: riga = 0 else: riga = 1 colonna = ((i) % 11) * 2 + 1 self.last_UDP_list.append( Label(self.UDP_frame_2, text=" ---- ", width=6)) self.last_UDP_list[i].grid(row=riga, column=colonna) Label(self.UDP_frame_2, text='ROC {}'.format(i), width=6, font=(12)).grid(row=riga, column=colonna - 1) # Label(self.Status_frame, text="TP efficency", font=("Courier", 25)).pack() # self.TP_frame = Frame(self.Status_frame) # self.TP_frame.pack() # self.TP_label_list = [] # self.TIG_list = [] # for i in range(0, len(self.GEM_to_config) - 1): # if i < 7: # riga = 0 # elif i < 14: # riga = 1 # else: # riga = 2 # colonna = ((i) % 7) * 2 + 1 # self.TP_label_list.append(Frame(self.TP_frame, width=6)) # self.TP_label_list[i].grid(row=riga, column=colonna) # for TIG in range(0, 8): # if TIG < 4: # colonna2 = 0 # else: # colonna2 = 1 # self.TIG_list.append(Label(self.TP_label_list[i], text=" -- ", width=3)) # self.TIG_list[TIG + i * 8].grid(row=TIG - colonna2 * 4, column=colonna2 * 2 + 1) # Label(self.TP_label_list[i], text="{}".format(TIG)).grid(row=TIG - colonna2 * 4, column=colonna2 * 2) # Label(self.TP_frame, text='ROC {}'.format(i), width=6, font=(12)).grid(row=riga, column=colonna - 1) Label(self.Status_frame_2, text="Noise rate", font=("Courier", 25)).pack() self.Noise_frame = Frame(self.Status_frame_2) self.Noise_frame.pack() self.Noise_frame_list = [] self.noise_list = [] for i in range(0, len(self.GEM_to_config) - 1): if i < 7: riga = 0 elif i < 14: riga = 1 else: riga = 2 colonna = ((i) % 7) * 2 + 1 self.Noise_frame_list.append(Frame(self.Noise_frame, width=6)) self.Noise_frame_list[i].grid(row=riga, column=colonna) for TIG in range(0, 8): if TIG < 4: colonna2 = 0 else: colonna2 = 1 self.noise_list.append( Label(self.Noise_frame_list[i], text=" -- ", width=7)) self.noise_list[TIG + i * 8].grid(row=TIG - colonna2 * 4, column=colonna2 * 2 + 1) Label(self.Noise_frame_list[i], text="{}".format(TIG), fg="red").grid(row=TIG - colonna2 * 4, column=colonna2 * 2) Label(self.Noise_frame, text='ROC {}'.format(i), width=6, font=(12)).grid(row=riga, column=colonna - 1) ## Alarms self.Allarm_tab = Frame(self.main_win) self.tabControl.add(self.Allarm_tab, text="Allarms ") r = [1, 2] theta = [0, 3.14] self.Events_Vi = Frame(self.main_win) self.tabControl.add(self.Events_Vi, text="Events visualizer ") first_war = Frame(self.Events_Vi) first_war.pack() Button(first_war, command=self.get_event, text="Get next event").pack() second_fr = Frame(self.Events_Vi) second_fr.pack() self.fig = Figure(figsize=(7, 7)) self.plot_rate = self.fig.add_subplot(111, polar=True) self.plot_rate.set_rorigin(-1) self.scatter, = self.plot_rate.plot(theta, r, 'r+', alpha=0.75) self.plot_rate.set_title("Event {}") self.canvas = FigureCanvasTkAgg(self.fig, master=second_fr) self.canvas.get_tk_widget().pack(side=BOTTOM) self.canvas.draw() self.canvas.flush_events() self.toolbar = NavigationToolbar2Tk(self.canvas, second_fr) self.toolbar.draw() def get_event(self): """ Will get the next event for data visualizzation :return: """ udp_list_int = [] for elem in self.last_UDP_list[:]: try: udp_list_int.append(int(elem["text"])) except ValueError: pass self.UDP_trigger = np.max(udp_list_int) + 4 self.get_event_flag = True #This flag means that we will start to save the data from when the value in UDP hit_stack = [] running = True print(self.UDP_trigger) thread_for_plot = Plotter(self) thread_for_plot.start() def connect_to_acquisition(self): if np.count_nonzero(self.GEM_to_config) < 1: self.Launch_error_check['text'] = "Select at least one GEMROC" else: for button in self.button: button.config(state='disabled') self.Launch_error_check['text'] = "Connected" self.conn_but['text'] = "Disconnect" self.conn_but.config(command=self.disconnect) self.start_but.config(state='normal') def disconnect(self): for button in self.button: button.config(state='normal') self.Launch_error_check['text'] = "Disconnected" self.conn_but['text'] = "Connect" self.conn_but.config(command=self.connect_to_acquisition) self.start_but.config(state='disabled') def toggle(self, i): if self.GEM_to_config[i] == 0: self.GEM_to_config[i] = 1 else: self.GEM_to_config[i] = 0 del self.GEMROC_acquiring_dict["GEMROC {}".format(i)] self.convert0(i) def convert0(self, i): if self.GEM_to_config[i] == 1: try: self.handler_list.append(online_reader(i)) self.LED[i]["image"] = self.icon_on self.Launch_error_check[ 'text'] = "Listening for data from GEMROC {}".format(i) except Exception as error: self.Launch_error_check['text'] = "GEMROC {}: {}".format( i, error) self.LED[i]["image"] = self.icon_bad else: self.LED[i]["image"] = self.icon_off for j in range(0, len(self.handler_list)): if self.handler_list[j].GEMROC_ID == i: self.Launch_error_check[ 'text'] = "Stopped listening for data from GEMROC {}".format( i) break self.update_menu() def update_menu(self): for i in range(0, len(self.handler_list)): ID = self.handler_list[i].GEMROC_ID self.GEMROC_acquiring_dict["GEMROC {}".format( ID)] = self.handler_list[i] def start(self): for key in self.GEMROC_acquiring_dict: self.GEMROC_acquiring_dict[key].start_socket() self.runner = runner(self.GEMROC_acquiring_dict, self) self.runner.run() self.Launch_error_check['text'] = "Acquiring data" self.start_but['text'] = "Stop" self.start_but.config(command=self.stop) self.conn_but.config(state='disabled') def stop(self): self.runner.stop() self.Launch_error_check['text'] = "Stopping acquisition" self.start_but['text'] = "Start" self.start_but.config(command=self.start) for key in self.GEMROC_acquiring_dict: self.GEMROC_acquiring_dict[key].stop_socket() self.conn_but.config(state='normal') def blink(self, gemroc, update=1): self.LED[gemroc]["image"] = self.icon_blink if update == 1: self.main_win.after(100, lambda: self.blink(gemroc, 2)) if update == 2: self.LED[gemroc]["image"] = self.icon_on def bad_blink(self, gemroc, update=1): self.LED[gemroc]["image"] = self.icon_bad if update == 1: self.main_win.after(200, lambda: self.blink(gemroc, 2)) if update == 2: self.LED[gemroc]["image"] = self.icon_on def update_buffers(self, gemroc, lung): self.buffer_label_list[gemroc]["text"] = lung def send_to_db(self, json): try: self.client.write_points(json) except Exception as e: print("Unable to log in infludb: {}\n json: {}".format(e, json))
class Application(tk.Frame): def __init__(self, master=None): super().__init__(master) self.master = master self.f = Figure(figsize=(8, 6), dpi=100) self.mainPlot = self.f.add_subplot(111) self.canvas = FigureCanvasTkAgg(self.f, self.master) self.cid = self.canvas.mpl_connect("button_press_event", self.canvasClick) self.canvas.draw() self.canvas_tk = self.canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True) def canvasClick(self, event): global CONFIG_VRANGE, CONFIG_SAMPLERATE, CONFIG_SAMPLECOUNT, CONFIG_FPREFIX, CONFIG_THRESHOLD, CONFIG_CAPTURES, CONFIG_BACKOFF, CONFIG_DONOTSAVE, CONFIG_SPECGRAM, CONFIG_DISPLAY_SAMPLES try: ps = ps2000a.PS2000a() self.canvas.mpl_disconnect(self.cid) print("Committing capture...") except: print("Failed to commit scope") return ps.setChannel('A', 'DC', VRange=CONFIG_VRANGE, VOffset=0.0, enabled=True, BWLimited=False, probeAttenuation=10.0) (freq, maxSamples) = ps.setSamplingFrequency(CONFIG_SAMPLERATE, CONFIG_SAMPLECOUNT) print(" > Asked for %d Hz, got %d Hz" % (CONFIG_SAMPLERATE, freq)) if CONFIG_FPREFIX is not None: print(" > Configured in training mode with prefix %s" % CONFIG_FPREFIX) ps.setSimpleTrigger('A', CONFIG_THRESHOLD, 'Rising', enabled=True) i = 0 nCount = 0 nMax = CONFIG_CAPTURES print("Capture is committed...") while True: if nMax == nCount: break ps.runBlock(pretrig=0.2) ps.waitReady() dataA = ps.getDataV("A", CONFIG_SAMPLECOUNT, returnOverflow=False) # print(len(dataA)) SLICE_START = int(CONFIG_SAMPLECOUNT * 0.2) SLICE_END = SLICE_START + 500 if float(max( dataA[SLICE_START:SLICE_END])) < float(CONFIG_THRESHOLD): # print("failed capture") continue if CONFIG_DONOTSAVE is False: if CONFIG_FPREFIX is None: print("Saving training capture...") np.save("floss/%d.npy" % nCount, dataA) else: print("Saving real capture...") np.save("toothpicks/%s-%d.npy" % (CONFIG_FPREFIX, nCount), dataA) else: print("No save mode specified, discarding save") self.mainPlot.clear() data_DISPLAY = dataA[SLICE_START - 5000:SLICE_START + 5000] if CONFIG_SPECGRAM: self.mainPlot.specgram(data_DISPLAY, NFFT=1024, Fs=CONFIG_SAMPLERATE, noverlap=900) else: self.mainPlot.plot( support.block_preprocess_function(data_DISPLAY)) self.canvas.draw() self.canvas.flush_events() time.sleep(CONFIG_BACKOFF) nCount += 1 print("Captured %d slices" % nCount)
class SignalView: """View of signal on serial port. Attributes: master Item to show in. fig MatPlotLib figure. subplt Subplot to plot in. canvas Connection of TKinter and MatPlotLib. getData Callback for getting data. record Callback to control recording. afterId TKinter ID of planned call. """ log = logging.getLogger(__name__) def __init__(self, root, master, reader, recorder): """Constructs object. Arguments: root Root of view. master Item to show in. reader Callback for getting data. recorder Callback to control recording. """ # create variables self.master = master self.getData = reader self.record = recorder self.afterId = None # initiate MatPlotLib view self.fig = Figure(figsize=(6,4), dpi=100) self.subplt = self.fig.add_subplot(111) self.subplt.set_xlabel("Samples") self.subplt.set_ylabel("Signal value") self.subplt.set_ylim(0, 1027) self.canvas = FigureCanvasTkAgg(self.fig, master=self.master) self.canvas.draw() # set border self.canvas.get_tk_widget().config(highlightcolor='black', highlightbackground='black', highlightthickness=3, bd=0) # set mouse handlers self.canvas.get_tk_widget().bind('<ButtonRelease-1>', self.manualUpdate) self.canvas.get_tk_widget().bind('<ButtonRelease-3>', self.showMenu) # create right-click menu self.menu = RightMenu(self.master, self.manualUpdate, self.recordMenuHandler) # run update in separate thread self.update() def __del__(self): """Destructs object.""" if self.afterId: self.master.after_cancel(self.afterId) def show(self, data): """Actualizes view with new data. Arguments: data New data to show. """ # clear view self.subplt.cla() # set view self.subplt.set_xlabel("Samples") self.subplt.set_ylabel("Signal value") self.subplt.set_ylim(0, 1027) # plot data self.subplt.plot(data, color='magenta') # paint self.canvas.draw() self.canvas.flush_events() #print("SignalView: update") def update(self): """Updates view. Runs in separated thread.""" # show new data self.show( self.getData() ) # plan next update after 300 ms self.afterId = self.master.after(conf.Config.period(), self.update) self.log.debug("update signal view") def manualUpdate(self, event): """Updates view. Handler for mouse events. Arguments: event Event descriptor. """ # cancel updater thread if self.afterId: self.master.after_cancel(self.afterId) # run new thread self.update() def showMenu(self, event): """Shows menu. Handler for mouse event. Arguments: event Event descriptor. """ self.menu.show(event.x_root, event.y_root) def recordMenuHandler(self, filename, status): """Catches event from menu to recorder to indicate to user. Arguments: filename Filename to save recording to. status True if turning recording on. False if turning off. """ # indicate recording if status: self.canvas.get_tk_widget().config(highlightcolor='red', highlightbackground='red') else: self.canvas.get_tk_widget().config(highlightcolor='black', highlightbackground='black') # reemit signal self.record(filename)
class GraphFrame(tk.Frame): """Pestaña para mostrar la gráfica de los datos almacenados""" def __init__(self, parent, parameter_name, *args, **kwargs): tk.Frame.__init__(self, parent, *args, **kwargs) self.parent = parent self.parameter_name = parameter_name self.init_frame() def init_frame(self): """Creación de la gráfica""" # Posicionamiento label_x_pos, label_y_pos = 240.5, 100 # Header self.label_header = tk.Label(self, text="Tendencias", font=Style.HEADER_FONT) self.label_header.place(x=label_x_pos, y=label_y_pos) self.make_graph() self.graph.pack(side=tk.TOP, fill=tk.BOTH, expand=1) def make_graph(self): """Creación de la gráfica""" data = self.get_data() # Gráfica fig = Figure(figsize=(5, 4)) self.axe = fig.add_subplot(111, xlabel='FECHAS', ylabel=data['unidades']) self.axe.plot(data['fechas'], data['parameter_set']) # Título de la gráfica if self.parameter_name == 'ph': self.axe.set_title('pH') elif self.parameter_name == 'oxigeno': self.axe.set_title('Oxígeno Disuelto') elif self.parameter_name == 'conductividad': self.axe.set_title('Conductividad Eléctrica') else: self.axe.set_title(self.parameter_name.capitalize()) self.canvas = FigureCanvasTkAgg(fig, master=self) self.canvas.draw() self.graph = self.canvas.get_tk_widget() self.toolbar = NavigationToolbar2Tk(self.canvas, self) self.toolbar.update() def get_data(self): """Obtención de datos""" mediciones = Medicion.get_last() fechas = [ datetime.strptime(medicion[5], '%Y-%m-%d %H:%M:%S.%f') for medicion in mediciones ] if self.parameter_name == 'temperatura': idx = 1 unidades = '°C' elif self.parameter_name == 'ph': idx = 2 unidades = 'pH' elif self.parameter_name == 'oxigeno': idx = 3 unidades = 'mg/l' elif self.parameter_name == 'conductividad': idx = 4 unidades = 'S/m' else: return None parameter_set = [medicion[idx] for medicion in mediciones] datos = { 'fechas': fechas, 'parameter_set': parameter_set, 'unidades': unidades } return datos def update_graph(self): """Actualización la gráfica""" self.axe.clear() data = self.get_data() self.axe.plot(data['fechas'], data['parameter_set']) self.canvas.draw() self.canvas.flush_events()
class Visualizer: # queue: store the delivered time matrix def __init__(self, voxelQueue): self.queue = voxelQueue self.root = tkinter.Tk() self.root.wm_title("test") self.ax = None self.canvas = None self.toolbar = None self.can_stop = False def explode(self, data): size = np.array(data.shape) * 2 data_e = np.zeros(size - 1, dtype=data.dtype) data_e[::2, ::2, ::2] = data return data_e # start visualization def start(self): # root = tkinter.Tk() # root.wm_title("Embedding in Tk") plt.axis('off') fig = plt.figure() self.ax = fig.gca(projection='3d') self.ax.set_xticks([]) self.ax.set_yticks([]) self.ax.set_zticks([]) v_msg = self.queue.get() x, y, z, my_filled, my_fcolor, my_ecolor = self.get_data(v_msg.voxels) self.ax.voxels(x, y, z, my_filled, facecolors=my_fcolor, edgecolors=my_ecolor) self.canvas = FigureCanvasTkAgg(fig, master=self.root) # A tk.DrawingArea. self.canvas.draw_idle() self.canvas.get_tk_widget().pack(side=tkinter.TOP, fill=tkinter.BOTH, expand=1) self.toolbar = NavigationToolbar2Tk(self.canvas, self.root) self.toolbar.update() self.canvas.get_tk_widget().pack(side=tkinter.TOP, fill=tkinter.BOTH, expand=1) self.canvas.mpl_connect("key_press_event", self.on_key_press) timer = threading.Timer(1, self.refresh) timer.start() tkinter.mainloop() # refresh the canvas for next visualization def refresh(self): v_msg = self.queue.get() x, y, z, my_filled, my_fcolor, my_ecolor = self.get_data(v_msg.voxels) self.ax.clear() self.ax.set_xticks([]) self.ax.set_yticks([]) self.ax.set_zticks([]) self.ax.voxels(x, y, z, my_filled, facecolors=my_fcolor, edgecolors=my_ecolor) self.canvas.draw_idle() self.canvas.flush_events() if v_msg.msg == VMsgType.STOP: self.can_stop = True if not self.can_stop: timer = threading.Timer(1, self.refresh) timer.start() def on_key_press(self, event): print("you pressed {}".format(event.key)) key_press_handler(event, self.canvas, self.toolbar) # get the data for visualization def get_data(self, n_voxels): facecolors = np.where(n_voxels, '#0f15bf', '#bf0f15') # print(facecolors) edgecolors = np.where(n_voxels, '#BFAB6E', '#7D84A6') filled = np.ones(n_voxels.shape) # upscale the above voxel image, leaving gaps filled_2 = self.explode(filled) fcolors_2 = self.explode(facecolors) ecolors_2 = self.explode(edgecolors) # Shrink the gaps x, y, z = np.indices(np.array(filled_2.shape) + 1).astype(float) // 2 x[0::2, :, :] += 0.05 y[:, 0::2, :] += 0.05 z[:, :, 0::2] += 0.05 x[1::2, :, :] += 0.95 y[:, 1::2, :] += 0.95 z[:, :, 1::2] += 0.95 return x, y, z, filled_2, fcolors_2, ecolors_2
class ImageViewer(tk.Frame): def __init__(self, master, img_data, *args, **kwargs): tk.Frame.__init__(self, master, background='black') #*args, **kwargs) self.master = master ######################################## # ATTRIBUTES ######################################## # Whole image view binning factor self.img = img_data self.imgY, self.imgX = self.img.shape self.zoom_initX = self.zoom_initY = 100 self.main_img_scale = 4 self.binning_factor = self.main_img_scale # scale slider factors self.min_ydim = self.min_xdim = 20 self.init_ydim = self.init_xdim = 500 self.n_scale_factors = 15 self.min_scale_factor = self.min_xdim / float(self.init_ydim) self.scale_from_ = self.min_scale_factor self.scale_to = 1. #1. / self.min_scale_factor self.scale_increment = (self.scale_to - self.scale_from_) / self.n_scale_factors self.time_of_prev_call = np.inf self.attached = False self.showing_zoom_window = True self.showing_range_slider = True self.scale = 1 self.dragging_selector = True self.dragging_lower_right = True # load the image self.rectprops = dict(facecolor='none', edgecolor='#00fa32', fill=False) self.show_pixel_values = False self.ymin = None self.holding_zoom_master = False self.holding_rs = False self.holding_the_rect = False self.vmin = self.vmax = None self.time_since_last_call = time.time() self.min_redraw_time = .3 self.press_data = None ##################################### # WIDGETS ##################################### self._define_on_master_close() # MASTER FRAME IMAGE INITIALIZATION self._make_master_image_frame() self._create_master_frame_figure() self._setup_master_image_canvas() self._add_master_frame_image() self._draw_master_image() # ZOOM IMAGE self._setup_zoom_figure() self._pack_zoom_figure_into_canvas() self._load_zoom_image_into_figure() #self._initialize_crosshair() self._draw_zoom_image() # IMAGE INTERACTION self._setup_range_slider_frame() self._add_range_slider() self._add_zoom_scale_widget() # ######## self._setup_selector() # ####### self.RS.set_active(True) self.RS.extents = (0, self.zoom_initX, 0, self.zoom_initY) self._sync_zoomwindow_to_selector() self._set_key_bindings() self._menu_bar() ##################### # WIDGET WATCHER self._widget_watcher() def _show_zoom_window(self): if self.showing_zoom_window: return self.zoom_master.deiconify() self.RS.set_active(False) self.zoom_master.update() def _show_range_slider(self): if self.showing_range_slider: return self.slider_master.deiconify() self.slider_master.update() def _menu_bar(self): self.menu = tk.Menu(self.master) filemenu = tk.Menu(self.menu, tearoff=0) filemenu.add_command(label="Show zoom window", command=self._show_zoom_window) filemenu.add_command(label="Show colorscale slider", command=self._show_range_slider) filemenu.add_command(label="Show zoom slider", command=self._show_zoom_scale_widget) filemenu.add_separator() filemenu.add_command(label="Exit", command=self.master.quit) self.menu.add_cascade(label="Image", menu=filemenu) self.master.config(menu=self.menu) def _keyboard_quit(self, event): self.master.quit() def _set_key_bindings(self): #self.master.bind_all("<MouseWheel>", self._on_mousewheel) self.master.bind_all("<Command-z>", self._zoom_in) self.master.bind_all("<Command-Shift-z>", self._zoom_out) self.master.bind_all("<Command-w>", self._keyboard_quit) self.master.bind_all("<Shift-Left>", self._move_left) self.master.bind_all("<Shift-Right>", self._move_right) self.master.bind_all("<Shift-Up>", self._move_up) self.master.bind_all("<Shift-Down>", self._move_down) self.master.bind_all("<Command-Right>", self._expand_X) self.master.bind_all("<Command-Left>", self._compress_X) self.master.bind_all("<Command-Down>", self._expand_Y) self.master.bind_all("<Command-Up>", self._compress_Y) self.master.bind_all("<Left>", self._move_left_slow) self.master.bind_all("<Right>", self._move_right_slow) self.master.bind_all("<Up>", self._move_up_slow) self.master.bind_all("<Down>", self._move_down_slow) def _expand_X(self, event, inc=5): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1, x2 + inc, y1, y2) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _compress_X(self, event, inc=5): x1, x2, y1, y2 = self.RS.extents if x2 - inc < x1: return self.RS.extents = (x1, x2 - inc, y1, y2) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _expand_Y(self, event, inc=5): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1, x2, y1, y2 + inc) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _compress_Y(self, event, inc=5): x1, x2, y1, y2 = self.RS.extents if y2 - inc < y1: return self.RS.extents = (x1, x2, y1, y2 - inc) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _zoom_in(self, event): curr_val = self.scale if not self.showing_range_slider: next_val = max(curr_val - self.scale_increment / 2., self.min_scale_factor) self._set_zoom_scale(next_val) else: self.zoom_scale_slider.set(curr_val - self.scale_increment / 2.) def _zoom_out(self, event): curr_val = self.scale if not self.showing_range_slider: next_val = min(curr_val + self.scale_increment / 2., 1) self._set_zoom_scale(next_val) else: self.zoom_scale_slider.set(curr_val + self.scale_increment / 2.) def _move_left(self, event, inc=10): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1 - inc, x2 - inc, y1, y2) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _move_left_slow(self, event): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1 - 1, x2 - 1, y1, y2) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _move_down(self, event, inc=10): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1, x2, y1 + inc, y2 + inc) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _move_down_slow(self, event, inc=1): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1, x2, y1 + inc, y2 + inc) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _move_right(self, event, inc=10): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1 + inc, x2 + inc, y1, y2) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _move_right_slow(self, event, inc=1): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1 + inc, x2 + inc, y1, y2) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _move_up(self, event, inc=10): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1, x2, y1 - inc, y2 - inc) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _move_up_slow(self, event, inc=1): x1, x2, y1, y2 = self.RS.extents self.RS.extents = (x1, x2, y1 - inc, y2 - inc) self._sync_zoomwindow_to_selector() self.zoom_fig.canvas.draw() def _define_on_master_close(self): self.master.protocol("WM_DELETE_WINDOW", self._on_master_window_close) self.master.config(bg="black") def _make_master_image_frame(self): self.image_frame = tk.Frame(self.master, **fr) self.image_frame.pack(side=tk.TOP, expand=tk.YES, fill=tk.BOTH) def _on_master_window_close(self): self.master.destroy() print("\n\tBoo!!!\n") sys.exit() def _setup_range_slider_frame(self): self.slider_master = tk.Toplevel() self.slider_master.pack_propagate(True) self.slider_frame = tk.Frame(self.slider_master, **fr) self.slider_frame.pack(side=tk.LEFT, expand=tk.YES, fill=tk.BOTH) self.slider_master.protocol("WM_DELETE_WINDOW", self._on_range_slider_close) def _widget_watcher(self): new_vmin, new_vmax = self.color_slider.minval, self.color_slider.maxval if new_vmin != self.vmin or new_vmax != self.vmax: self.vmin = new_vmin self.vmax = new_vmax self._im.set_clim(vmin=self.vmin, vmax=self.vmax) self._zoom_im.set_clim(vmin=self.vmin, vmax=self.vmax) self._update_zoom_image() self._update_master_image() if self.holding_zoom_master: print("Holding zoomwind") self._update_zoom_image() self.master.after(150, self._widget_watcher) def _add_range_slider(self): self.color_slider_master = tk.Toplevel(self.master) self.color_slider = RangeSlider(self.color_slider_master, self.img.ravel(), color='#00fa32', length=700, height=50, background='black') self.color_slider.pack(side=tk.TOP, fill=tk.BOTH, expand=tk.YES) self.color_slider.pack_propagate() def _create_master_frame_figure(self): self.fig = plt.figure(figsize=(6, 6)) self.ax = self.fig.add_axes([0, 0, 1, 1]) self.fig.patch.set_visible(False) self.ax.axis('off') def _add_master_frame_image(self): self._im = self.ax.imshow( self.img[::self.binning_factor, ::self.binning_factor], interpolation='nearest', vmin=self.vmin, vmax=self.vmax, cmap='gist_gray') self.vmin, self.vmax = self._im.get_clim() def _set_zoom_scale(self, value): value = float(value) self.scale = value self._sync_selector_to_zoomwindow_on_rescale() self._update_zoom_image() def _launch_zoom_window(self): if self.showing_zoom_window: return self._setup_zoom_figure() self._pack_zoom_figure_into_canvas() self._load_zoom_image_into_figure() self._draw_zoom_image() def _show_zoom_scale_widget(self): self.zoom_scale_master.deiconify() self.zoom_scale_master.update() def _add_zoom_scale_widget(self): self.zoom_scale_master = tk.Toplevel(self.slider_frame) self.zoom_master.protocol("WM_DELETE_WINDOW", self._on_zoom_scale_close) self.zoom_scale_frame = tk.Frame(self.zoom_scale_master, bg="black") self.zoom_scale_frame.pack(side=tk.TOP) self.zoom_scale_frame.pack_propagate(True) self.zoom_scale_slider = tk.Scale(self.zoom_scale_frame, from_=self.scale_from_, to=self.scale_to, resolution=self.scale_increment / 2., fg="#00fa32", bg='black', length=200, highlightbackground="#00fa32", label="Zoom fraction", highlightthickness=0, orient=tk.HORIZONTAL, command=self._set_zoom_scale) self.zoom_scale_slider.pack(side=tk.TOP, expand=tk.NO) self.zoom_scale_slider.set(0.5) def _setup_master_image_canvas(self): self.canvas = FigureCanvasTkAgg(self.fig, master=self.image_frame) self.canvas.get_tk_widget().pack(side=tk.TOP, expand=tk.YES, fill=tk.BOTH) self.canvas.get_tk_widget().configure(bg='black', highlightbackground="black") def _setup_zoom_figure(self): self.zoom_fig = plt.figure(figsize=(3, 3)) self.zoom_ax = self.zoom_fig.add_axes([0.01, 0.01, .98, .98]) #self.zoom_fig.patch.set_visible(False) self.zoom_ax.axis('off') self.zoom_ax.spines['bottom'].set_color('#00fa32') self.zoom_ax.spines['right'].set_color('#00fa32') self.zoom_ax.spines['left'].set_color('#00fa32') self.zoom_ax.spines['top'].set_color('#00fa32') #self.zoom_ax.set_xticks([]) #self.zoom_ax.set_yticks([]) def _load_zoom_image_into_figure(self): self._zoom_im = self.zoom_ax.imshow( self.img[:self.zoom_initY, :self.zoom_initX], vmin=self.vmin, vmax=self.vmax, interpolation='nearest', aspect='auto', cmap='gist_gray') self.img_extent = (0, self.zoom_initX, 0, self.zoom_initY) def _initialize_crosshair(self): x1 = y1 = 0 y2, x2 = self.img.shape self.zoom_ax.set_xlim(x1, x2) self.zoom_ax.set_ylim(y2, y1) Xmid = .5 * (x1 + x2) Ymid = .5 * (y1 + y2) #self.zoom_crosshair_Hline = self.zoom_ax.plot( # [ Ymid, Ymid ], [x1, x2], # ls='--', color='#00fa32') #self.zoom_crosshair_Vline = self.zoom_ax.plot( # [ y1, y2 ], [Xmid, Xmid], # ls='--',color='#00fa32') def _on_zoom_master_close(self): self.showing_zoom_window = False self.RS.set_active(False) #for patch in self.RS_artists: # artist.set_visible(False) #self.ax.patches[0].set_visible(False) self.zoom_master.withdraw() def _on_zoom_scale_close(self): self.zoom_scale_master.withdraw() def _on_range_slider_close(self): self.showing_range_slider = False self.slider_master.withdraw() def _on_click_zoom_master(self, event): self.holding_zoom_master = True def _on_release_zoom_master(self, event): self.holding_zoom_master = False def _pack_zoom_figure_into_canvas(self): self.zoom_master = tk.Toplevel(self.master) self.zoom_master.protocol("WM_DELETE_WINDOW", self._on_zoom_master_close) self.zoom_master.bind("<Button-1>", self._on_click_zoom_master) self.zoom_master.bind("<ButtonRelease-1>", self._on_release_zoom_master) self.zoom_master.bind("<Configure>", self._on_mousemove_zoom_master) self.zoom_master.pack_propagate(True) self.zoom_canvas = FigureCanvasTkAgg(self.zoom_fig, master=self.zoom_master) self.zoom_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=tk.YES) self.zoom_canvas.get_tk_widget().configure(bg='black', highlightbackground="black", bd=1) #self.showing_zoom_window = True ############################# # DRAW AND UPDATE IMAGES! ############################# def _draw_master_image(self): self.canvas.draw_idle() self.canvas.flush_events() def _update_master_image(self): self.ax.draw_artist(self._im) for artist in self.RS_artists: self.ax.draw_artist(artist) self.fig.canvas.blit(self.ax.bbox) self.canvas.flush_events() def _draw_zoom_image(self): self.zoom_fig.canvas.draw_idle() self.zoom_fig.canvas.flush_events() def _update_zoom_image(self): self.zoom_ax.draw_artist(self._zoom_im) #self.zoom_ax.draw_artist( self.zoom_crosshair_Hline[0] ) #self.zoom_ax.draw_artist( self.zoom_crosshair_Vline[0] ) self.zoom_fig.canvas.blit(self.zoom_ax.bbox) self.zoom_fig.canvas.flush_events() def _update_zoom_image_data(self): self.zoom_ax.draw_artist(self._zoom_im) self.zoom_fig.canvas.blit(self.zoom_ax.bbox) self.zoom_fig.canvas.flush_events() ##################################### # DYNAMIC ZOOM IMAGE CALLBACKS ##################################### def _on_mousemove_zoom_master(self, event): if self.holding_zoom_master: self._sync_selector_to_zoomwindow() def _sync_selector_to_zoomwindow_on_rescale(self): cent_x, cent_y = self.RS.center zoom_window_height = self.zoom_master.winfo_height() zoom_window_width = self.zoom_master.winfo_width() if self.dragging_lower_right: new_x1 = cent_x - .5 * zoom_window_width / float( self.binning_factor) * self.scale new_y1 = cent_y - .5 * zoom_window_height / float( self.binning_factor) * self.scale new_x2 = cent_x + .5 * zoom_window_width / float( self.binning_factor) * self.scale new_y2 = cent_y + .5 * zoom_window_height / float( self.binning_factor) * self.scale self.RS.extents = (new_x1, new_x2, new_y1, new_y2) w = zoom_window_width * self.scale h = zoom_window_height * self.scale img_cent_x = (self.img_extent[0] + self.img_extent[1]) * .5 img_cent_y = (self.img_extent[2] + self.img_extent[3]) * .5 x1 = img_cent_x - w / 2. y1 = img_cent_y - h / 2. x2 = img_cent_x + w / 2. y2 = img_cent_y + h / 2. self.img_extent = (x1, x2, y1, y2) self._zoom_im.set_data(self.img[int(y1):int(y2), int(x1):int(x2)]) # axis limitation #self.zoom_ax.set_xlim(x1,x2) #self.zoom_ax.set_ylim(y2,y1) # cross hair #Ymid = (y1 +y2)*.5 #Xmid = (x1+x2)*.5 #self.zoom_crosshair_Hline[0].set_xdata( [Ymid, Ymid] ) #self.zoom_crosshair_Hline[0].set_ydata( [x1, x2]) #self.zoom_crosshair_Vline[0].set_xdata( [y1,y2]) #self.zoom_crosshair_Vline[0].set_ydata( [Xmid, Xmid]) def _sync_selector_to_zoomwindow(self): old_x1, old_x2, old_y1, old_y2 = self.RS.extents zoom_window_height = self.zoom_master.winfo_height() zoom_window_width = self.zoom_master.winfo_width() if self.dragging_lower_right: new_x1 = old_x1 new_y1 = old_y1 new_x2 = old_x1 + zoom_window_width / float( self.binning_factor) * self.scale new_y2 = old_y1 + zoom_window_height / float( self.binning_factor) * self.scale self.RS.extents = (new_x1, new_x2, new_y1, new_y2) x1 = self.img_extent[0] y1 = self.img_extent[2] x2 = zoom_window_width * self.scale + x1 y2 = zoom_window_height * self.scale + y1 self.img_extent = (x1, x2, y1, y2) self._zoom_im.set_data(self.img[int(y1):int(y2), int(x1):int(x2)]) # axis limitation #self.zoom_ax.set_xlim(x1,x2) #self.zoom_ax.set_ylim(y2,y1) # cross hair #Ymid = (y1 +y2)*.5 #Xmid = (x1+x2)*.5 #self.zoom_crosshair_Hline[0].set_xdata( [Ymid, Ymid] ) #self.zoom_crosshair_Hline[0].set_ydata( [x1, x2]) #self.zoom_crosshair_Vline[0].set_xdata( [y1,y2]) #self.zoom_crosshair_Vline[0].set_ydata( [Xmid, Xmid]) def _sync_zoomwindow_to_selector(self): # geometry x1, x2, y1, y2 = [i * self.binning_factor for i in self.RS.extents] if x1 < 0: x1 = 0 if y1 < 0: y1 = 0 width = (x2 - x1) height = (y2 - y1) Ymid = .5 * (y1 + y2) Xmid = .5 * (x1 + x2) #print( width, height) #print [ int(Ymid - height/2.), int(Ymid +height/2.), int(Xmid-width/2.), int(Xmid + width/2.)] # zoom image self.img_extent = (int(Xmid - width / 2.), int(Xmid + width / 2.), int(Ymid - height / 2.), int(Ymid + height / 2.)) self._zoom_im.set_data( self.img[int(Ymid - height / 2.):int(Ymid + height / 2.), int(Xmid - width / 2.):int(Xmid + width / 2.)]) # axis limitation #self.zoom_ax.set_xlim(x1,x2) #self.zoom_ax.set_ylim(y2,y1) # cross hair #self.zoom_crosshair_Hline[0].set_xdata( [Ymid, Ymid] ) #self.zoom_crosshair_Hline[0].set_ydata( [x1, x2]) #self.zoom_crosshair_Vline[0].set_xdata( [y1,y2]) #self.zoom_crosshair_Vline[0].set_ydata( [Xmid, Xmid]) # sync window size #self.zoom_canvas.xview_scroll(int( width), "units") #self.zoom_canvas.yview_scroll(int(height), "units") self.zoom_master.geometry( "%dx%d" % (int(width / self.scale), int(height / self.scale))) def _setup_selector(self): artists = self.ax.get_children() self.RS = RectangleSelector(self.ax, self._on_rectangle_selection, drawtype='box', useblit=False, button=[1, 3], minspanx=2, minspany=2, spancoords='data', interactive=True, rectprops=self.rectprops) self.RS_artists = [ a for a in self.ax.get_children() if a not in artists ] self.RS_rectangle = [ a for a in self.RS.artists if type(a) == mpl.patches.Rectangle ] assert (len(self.RS_rectangle) == 1) self.RS_rectangle = self.RS_rectangle[0] self.RS_rectangle.figure.canvas.mpl_connect('motion_notify_event', self.on_rs_motion) self.RS_rectangle.figure.canvas.mpl_connect('button_press_event', self.on_rs_press) self.RS_rectangle.figure.canvas.mpl_connect('button_release_event', self.on_rs_release) def _on_rectangle_selection(self, press, release): """ widget passes press and release to this callback """ self._sync_zoomwindow_to_selector() #self._update_zoom_image() def on_rs_press(self, event): self.holding_rs = True #self.zoom_master.lift() print("clicked rs") def on_rs_release(self, event): self.holding_rs = False print("released rs") def on_rs_motion(self, event): if self.holding_rs: self._sync_zoomwindow_to_selector() self._zoom_im.figure.canvas.draw()
class Placer(): """ Circuit Cell placement using Simulated Annealing Circuit: A representation of a circuit by Cells to be placed in rows and columns of Sites Cell: Circuit component represented as a Graph node with connections to other Cells as edges Node: Graph representation of a Cell Site: Possible location for a Cell (Is Free or is occupied by a Cell) Block: Graphic representation and data of a Site """ def __init__(self, master, T, seed, inputfile, quietMode): #=============Parse file to create cells graph===============# # Create Directed Graph and fill with input file self.G = nx.DiGraph() fin = open(inputfile, 'r') self.getGraph(fin) fin.close() #================Create Data Structures================# # Array of Line objects to draw connections self.connLines = [] # Array of Block objects drawing the rectangles for each site on the circuit, tracks occupancy self.sites = [] # Array of Text objects noting the name of the node assigned to a cell site self.tags = [] # Assign Initial Temperature self.T = T # Assign Initial Seed self.seed = seed #================Draw Buttons and plots================# self.master = master self.initialize_buttons() self.initialize_plots() # Quite Mode to run without graphics if quietMode: self.running = True self.start_timer = time.clock() # Simulated Annelaing Function self._startplacement(True) sys.exit() def getGraph(self, fin): """ Parse Input File to fill up Graph structure """ tmpList = fin.readline().split() # Number of Cells to be placed self.cells = int(tmpList[0]) # Number of Connections or Nets self.conns = int(tmpList[1]) # Number of Circuit Rows self.rows = int(tmpList[2]) # Number of Circuit Columns self.cols = int(tmpList[3]) # Number of available sites in the Circuit self.sitesNum = self.rows * self.cols # Annealing parameter is 10*N^(4/3). Where N is the number of cells to be placed self.k = pow(self.cells, (4 / 3)) self.winX = self.cols / 4 self.winY = self.rows / 4 # Add nodes from 0 to number of Cells to graph structure and initialize net array and net cost self.G.add_nodes_from(range(0, self.cells)) for node in self.G.nodes(): self.G.node[node]["nets"] = [] self.G.node[node]["cost"] = 0 # For every Net, add edges between corresponding nodes for net in range(0, self.conns): tmpList = fin.readline().split() numNodes = int(tmpList[0]) srcNode = int(tmpList[1]) self.G.node[srcNode]["nets"].append(srcNode) for conn in range(2, numNodes + 1): self.G.add_edge(srcNode, int(tmpList[conn])) self.G.node[int(tmpList[conn])]["nets"].append(srcNode) def initialize_buttons(self): """ Draw User Buttons on top of interface Start: Begin placement process Pause: Pause process. Allows continuing. Graph: Show Graph nodes to visualize connections Plot: Show Cost plot to see SA progress Draw: Show Circuit Cells """ self.start_button = tk.Button(self.master, text='Start', command=self.startRunning) self.start_button.grid(row=0, column=0) self.pause_button = tk.Button(self.master, text='Pause', command=self.pauseRunning) self.pause_button.grid(row=0, column=1) self.graph_button = tk.Button(self.master, text='Graph', command=self.showGraph) self.graph_button.grid(row=0, column=2) self.plot_button = tk.Button(self.master, text='Plot', command=self.showPlot) self.plot_button.grid(row=0, column=3) self.draw_button = tk.Button(self.master, text='Draw', command=self.drawCells) self.draw_button.grid(row=0, column=4) # Initialize Button States and Actions self.pause_button['state'] = 'disabled' # Boolean switch to control flow of placement process self.running = False # Boolean switch to plot placement connections and tags, turn off for faster processing self.plot = False self.drawing = False self.graph = False # Boolean switch to specify first run and allow stop/continue behavior that doesn't initialize program self.firstRun = True def initialize_plots(self): """ Draw all graphic components as Canvases Circuit Canvas: Drawing of the Circuit Sites Rows and Columns to overlay Cell Placement and Connections Graph Canvas: Drawing of the Graph structure used for the representation of the Cells Cost Plot Canvas: Plotting of the Cost Function used in the Annealing Process Plot Toolbar: Toolbar options to explore the Graph and Cost Canvases (Zoom, Save, Move...) """ #============================Draw circuit canvas=================================# # Draw Canvas with hardcoded width 600 and adjustable height to circuit input ckt_max_x = 600 ckt_max_y = (ckt_max_x * (self.rows)) / self.cols scale_x = round(ckt_max_x / self.cols) scale_y = round(ckt_max_y / self.rows) self.canvasCirkt = tk.Canvas(self.master, width=ckt_max_x, height=(ckt_max_y * 2) + int(scale_y)) self.canvasCirkt.grid(row=1, column=1, columnspan=4) # Draw border self.canvasCirkt.create_rectangle(1, 1, ckt_max_x, (ckt_max_y * 2) + int(scale_y)) # Draw cell rows spaced by routing channels blockIndex = 0 for cut in range(int(scale_y), int(ckt_max_y * 2), int(scale_y) * 2): for cut2 in range(1, int(ckt_max_x), int(scale_x)): # Coordinates for top and bottom points of rectangle points = (cut2, cut, cut2 + scale_x - 1, cut + scale_y) blockObj = placerGUI.Block(self.canvasCirkt, points, blockIndex, self.rows, self.cols) blockIndex += 1 self.sites.append(blockObj) #===================================Draw Plots================================# # Draw Figure for 2 subplots (Connections Graph and Cost Function) self.figure, self.axes = plt.subplots(2, facecolor="white") self.figure.set_figwidth(4) self.axGraph = self.axes[0] self.axCost = self.axes[1] # Initial condition for connection Graph self.axGraph.set_visible(False) # Select Cost Plot as current Axis. Get lines to use for plot updates plt.sca(self.axCost) self.lines, = self.axCost.plot([], []) self.axCost.set_xlabel("Time") self.axCost.set_title("Cost") # Draw Cost function Plot self.canvasPlot = FigureCanvasTkAgg(self.figure, master=self.master) self.canvasPlot.get_tk_widget().grid(row=1, column=0) # Draw Tool Bar self.toolbarFrame = tk.Frame(self.master) self.toolbarFrame.grid(row=2, column=0, columnspan=3, sticky="W") self.toolbarPlot = NavigationToolbar2TkAgg(self.canvasPlot, self.toolbarFrame) def showGraph(self): """ User selection to display graph """ self.graph_button['state'] = 'disabled' # Draw connection Graph self.axGraph.set_visible(True) nx.draw(self.G, ax=self.axGraph, with_labels=True) self.canvasPlot.draw() self.canvasPlot.flush_events() def showPlot(self): """ User selection to display Cost """ self.plot = not self.plot if self.plot: self.plot_button['text'] = "No Plot" else: self.plot_button['text'] = "Plot" def drawCells(self): """ User selection to display Circuit Cells """ self.drawing = not self.drawing if self.drawing: self.draw_button['text'] = "No Draw" else: self.draw_button['text'] = "Draw" def startRunning(self): """ User control for placement process """ self.start_button['state'] = 'disabled' self.pause_button['state'] = 'normal' self.running = True # If first run and not continuation from pause if (self.firstRun): self.start_timer = time.clock() # Simulated Annelaing Function self._startplacement(False) # Always display result at the end of the process self.updateDraw() self.updatePlot(self.totalCost) # Disable Buttons when finished self.pause_button['state'] = 'disabled' self.plot_button['state'] = 'disabled' self.draw_button['state'] = 'disabled' def pauseRunning(self): """ Pause process of SA by exiting loop """ self.start_button['state'] = 'normal' self.pause_button['state'] = 'disabled' self.running = False def _startplacement(self, quietMode): """ Start Simulated Annealing Process """ # On first run to random placement. This allows pausing and continuing the process if (self.firstRun == True): self.randPlace() self.cost() self.oldCost = self.totalCost self.firstRun = False # If user selects drawing circuit if not quietMode: self.drawConns() self.drawTags() self.updatePlot(self.oldCost) print "Inital Cost ", self.totalCost #========================Simulated Annealing========================# while (self.T > 0.1): if (not self.running): return self.k = self.k + 5 for i in range(0, self.k): swapCell, swapSite, swapTgtCell = self.swapWinRand() self.incrCost(swapCell, swapTgtCell) newCost = self.totalCost deltaNCost = (newCost - self.oldCost) if deltaNCost > 0: if (random.random() > math.exp(-deltaNCost / self.T)): # Revert move self.swap(swapCell, swapSite) # Revert Cost self.incrCost(swapCell, swapTgtCell) continue # Take move self.oldCost = newCost if not quietMode: if (self.drawing): self.updateDraw() if (self.plot): self.updatePlot(self.oldCost) self.T = 0.99 * self.T print "Final Cost ", self.totalCost # Append result to results file with open("results.txt", "a") as outputfile: outputfile.write(str(self.totalCost) + "\n") def swapWinRand(self): """ Select Random Cell and swap into Random Site """ # Pick Random Cell so the move is always from an occupied to a free/occupied cell randCell = random.randint(0, self.cells - 1) # Store Site of Cell to be swapped to use for Swap Back randCellSite = self.G.node[randCell]["site"].getIndex() # Pick random site near Cell randX, randY = self.G.node[randCell]["site"].getBlockXY( self.rows, self.cols) siteX = randX + int(random.uniform(-self.winX, self.winX)) siteY = randY + int(random.uniform(-self.winY, self.winY)) if siteX < 0: siteX = 0 if siteX >= self.cols: siteX = self.cols - 1 if siteY < 0: siteY = 0 if siteY >= self.rows: siteY = self.rows - 1 randSite = siteY * self.cols + siteX # Do swap. Returns Cell of target Site to use for incremental cost or none if target was free tgtSiteCell = self.swap(randCell, randSite) return randCell, randCellSite, tgtSiteCell def swap(self, swapCell, swapSite): """ Swap Cell(occupying site) to given Target Site(could be free) """ tgtSiteCell = None # Target Site can be empty if (self.sites[swapSite].isFree()): # Free Cell value of Random Cell self.G.node[swapCell]["site"].free() else: # Store Cell value of Target Site tgtSiteCell = self.sites[swapSite].getCell() # Write Cell value of Target Site into Swap Cell self.G.node[swapCell]["site"].setCell(tgtSiteCell) # Node of Target Site's Cell now points to Swap Cell's Site self.G.node[tgtSiteCell]["site"] = self.G.node[swapCell]["site"] # Write Cell value of Swap Cell into Target Site self.sites[swapSite].setCell(swapCell) # Node of Swap Cell now points to Target Site self.G.node[swapCell]["site"] = self.sites[swapSite] return tgtSiteCell def updateDraw(self): """ Draw circuit Connections and Cell Tags """ self.delConns() self.delTags() self.drawConns() self.drawTags() def updatePlot(self, cost): """ Cost plot gets updated on every new cost value """ timer = time.clock() - self.start_timer # Add new values to plot data set self.lines.set_xdata(np.append(self.lines.get_xdata(), timer)) self.lines.set_ydata(np.append(self.lines.get_ydata(), cost)) # Re-scale self.axCost.relim() self.axCost.autoscale_view() # Update plot self.axCost.set_title("Cost=" + str(cost)) self.canvasPlot.draw() self.canvasPlot.flush_events() def randPlace(self): """ Random placement, for every node a Site is assigned """ random.seed(self.seed) for node in self.G.nodes(): randSite = random.randint(0, self.sitesNum - 1) while (self.sites[randSite].isOcp()): randSite = random.randint(0, self.cells) self.sites[randSite].setCell(node) self.G.node[node]["site"] = self.sites[randSite] def drawConns(self): """ Extract center point from each node and draw connection to other nodes """ for node in self.G.nodes(): pX, pY = self.G.node[node]["site"].getCenter() for nb in self.G.neighbors(node): nbX, nbY = self.G.node[nb]["site"].getCenter() self.connLines.append( self.canvasCirkt.create_line(pX, pY, nbX, nbY)) self.canvasCirkt.update() def drawTags(self): """ Extract center point from each node and draw node Tag """ for node in self.G.nodes(): pX, pY = self.G.node[node]["site"].getCenter() self.tags.append(self.canvasCirkt.create_text(pX, pY, text=node)) self.canvasCirkt.update() def delConns(self): """ Delete Connections on Circuit using array of Line objects """ for line in self.connLines: self.canvasCirkt.delete(line) self.canvasCirkt.update() def delTags(self): """ Delete Tags on Circuit using array of Text objects """ for tag in self.tags: self.canvasCirkt.delete(tag) self.canvasCirkt.update() def cost(self): """ Seeing the circuit as a matrix the distance units between sites can be found as the difference between their axis locations. A=(0,0) B=(3,0) C=(0,3) v...........v >| A | | | B | Cell Sites Row :################# Routing Channel :| | | | | Cell Sites Row :################# Routing Channel :| | | | | Cell Sites Row :################# Routing Channel >| C | | | | Cell Sites Row Note: Y Distance between the center of A and C accounting for the Routing Channels DistY = (CX-AY)*2 """ # Accumulator for total Cost of half-perimeter of bounding box for all nets self.totalCost = 0 for node in self.G.nodes(): # Update Cost of net bbCost = self.boundBoxCost(node) self.G.node[node]["cost"] = bbCost # Accumulate cost as Half Perimeter of Bounding Box for every Net self.totalCost += bbCost def incrCost(self, swapCell, swapTgtCell): """ Incremental Cost function. From Cells inputs modify total cost by subtracting the cost of the nets connected to those cells, recalculating the cost of said Net and adding it to the total""" # Find Nets modified by swap. "nets" stores Net source nodes swapNets = set(self.G.node[swapCell]["nets"]) # Add nets from target to set if swapTgtCell: swapNets.update(self.G.node[swapTgtCell]["nets"]) for node in swapNets: # Decrement Total Cost by Cost of changed net self.totalCost -= self.G.node[node]["cost"] # Assign new Cost to net cost value self.G.node[node]["cost"] = self.boundBoxCost(node) # Increment Total Cost by Cost of changed net self.totalCost += self.G.node[node]["cost"] def boundBoxCost(self, node): """ Get Half Perimeter of Net of input Node """ # Initialize bounding box points on net source srcX, srcY = self.G.node[node]["site"].getBlockXY(self.cols, self.rows) minX, maxX = srcX, srcX minY, maxY = srcY, srcY # Find bounding box with min and max for X and Y for nb in self.G.neighbors(node): nbX, nbY = self.G.node[nb]["site"].getBlockXY(self.cols, self.rows) if (nbX > maxX): maxX = nbX elif (nbX < minX): minX = nbX if (nbY > maxY): maxY = nbY elif (nbY < minY): minY = nbY # Return Half-Perimeter of Bounding Box return (maxX - minX) + ((maxY - minY) * 2) def quitApp(self): """ Exit """ self.master.destroy() self.master.quit()
class Application(tk.Frame): def __init__(self, master=None): super().__init__(master) self.initialized = False self.master = master self.initVars() self.createWorkspace() def initVars(self): # Default padding for GUI elements self.defPad = 2 self.maxIterations = tk.IntVar() self.maxIterations.set(100) # Selection boxes self.functions = [ 'Sphere', 'Schwefel', 'Rosenbrock', 'Rastrigin', 'Griewank', 'Levy', 'Michalewicz', 'Zakharov', 'Ackley' ] self.selectedFunction = tk.StringVar() self.selectedFunction.set(self.functions[0]) self.defaultNotebookFrameWidth = 200 self.defaultNotebookFrameHeight = 200 self.renderDelay = tk.DoubleVar() self.renderDelay.set(0.05) def createWorkspace(self): # Frames mainFrame = ttk.Frame(self.master) mainFrame.grid(row=0, column=0, padx=self.defPad, pady=self.defPad) mainConfigFrame = ttk.LabelFrame(mainFrame, text="Config") mainConfigFrame.grid(row=0, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.NW + tk.NE) commonConfigFrame = ttk.LabelFrame(mainConfigFrame, text="Common") commonConfigFrame.grid(row=0, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.NW + tk.NE) algoConfigFrame = ttk.LabelFrame(mainConfigFrame, text="Algorithms") algoConfigFrame.grid(row=1, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.NW + tk.NE) controlsConfigFrame = ttk.LabelFrame(mainConfigFrame, text="Control") controlsConfigFrame.grid(row=2, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.NW + tk.NE) # # Common config # functionLabel = ttk.Label(commonConfigFrame, text="Function") functionLabel.grid(row=0, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.E) functionOption = ttk.OptionMenu(commonConfigFrame, self.selectedFunction, None, *self.functions) functionOption.grid(row=0, column=1, padx=self.defPad, pady=self.defPad, sticky=tk.W) functionOption.bind("<Configure>", self.onSelectFunction) iterationLabel = ttk.Label(commonConfigFrame, text="Iterations") iterationLabel.grid(row=1, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.E) iterationEntry = ttk.Entry(commonConfigFrame, textvariable=self.maxIterations) iterationEntry.grid(row=1, column=1, padx=self.defPad, pady=self.defPad, sticky=tk.W) renderDelayLabel = ttk.Label(commonConfigFrame, text="Render delay") renderDelayLabel.grid(row=2, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.E) renderDelaySlider = ttk.Scale(commonConfigFrame, from_=0.0, to=5.0, variable=self.renderDelay) renderDelaySlider.grid(row=2, column=1, padx=self.defPad, pady=self.defPad, sticky=tk.W + tk.E) renderDelayEntry = ttk.Entry(commonConfigFrame, textvariable=self.renderDelay) renderDelayEntry.grid(row=3, column=1, padx=self.defPad, pady=self.defPad, sticky=tk.W + tk.E) # style = ttk.Style(root) # style.configure('lefttab.TNotebook', tabposition='wn') # self.tabsFrame = ttk.Notebook(algoConfigFrame, style='lefttab.TNotebook') self.tabsFrame = ttk.Notebook(algoConfigFrame) blindFrame = self.createBlindFrame(self.tabsFrame) hillClimbFrame = self.createHillClimbFrame(self.tabsFrame) annealingFrame = self.createAnnealingFrame(self.tabsFrame) tspFrame = self.createTSPFrame(self.tabsFrame) dgaFrame = self.createDGAFrame(self.tabsFrame) somaFrame = self.createSomaFrame(self.tabsFrame) antFrame = self.createAntFrame(self.tabsFrame) fireflyFrame = self.createFireflyFrame(self.tabsFrame) tlbaFrame = self.createTLBAFrame(self.tabsFrame) self.tabsFrame.add(blindFrame, text='Blind') self.tabsFrame.add(hillClimbFrame, text='Hill Climb') self.tabsFrame.add(annealingFrame, text='Annealing') self.tabsFrame.add(tspFrame, text='TSP') self.tabsFrame.add(dgaFrame, text='Differential GA') self.tabsFrame.add(somaFrame, text='SOMA') self.tabsFrame.add(antFrame, text='Ants') self.tabsFrame.add(fireflyFrame, text='Firefly') self.tabsFrame.add(tlbaFrame, text='TLBA') self.tabsFrame.grid(row=0, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.NW + tk.NE) runButton = ttk.Button(controlsConfigFrame, text="Run", command=self.run) runButton.grid(row=0, column=1, padx=self.defPad, pady=self.defPad, sticky=tk.E) graph3dFrame = ttk.LabelFrame(mainFrame, text="3D plot") graph3dFrame.grid(row=0, column=1, padx=self.defPad, pady=self.defPad, sticky=tk.NW + tk.NE) self.fig3D = Figure(figsize=(5, 4), dpi=100) self.canvas3D = FigureCanvasTkAgg(self.fig3D, master=graph3dFrame) # self.canvas3D.draw() self.graph3Dax = self.fig3D.gca(projection="3d") t = np.arange(0, 3, .01) self.graph3Dax.plot(t, 2 * np.sin(2 * np.pi * t)) self.canvas3D.get_tk_widget().grid() graph2dFrame = ttk.LabelFrame(mainFrame, text="Fitness history") graph2dFrame.grid(row=0, column=2, padx=self.defPad, pady=self.defPad, sticky=tk.NW + tk.NE) # self.onSelectFunction(None) self.initialized = True def onSelectFunction(self, evt): if self.initialized is False: return try: func = fn.functionsMap[self.selectedFunction.get()] print(f"{func} selected") func.plot(axes=self.graph3Dax) self.canvas3D.draw() self.canvas3D.flush_events() except: print("Unable to update graph") traceback.print_exc() def quitApp(self): root.destroy() def createBlindFrame(self, master): frame = ttk.Frame(master, width=self.defaultNotebookFrameWidth, height=self.defaultNotebookFrameHeight) self.blindOptions = {"pointCloud": tk.IntVar()} self.blindOptions["pointCloud"].set(60) self.getFrameWithEntry(frame, text="Point cloud size", variable=self.blindOptions["pointCloud"]).grid( row=0, column=0, columnspan=2, sticky=tk.E) return frame def createHillClimbFrame(self, master): frame = ttk.Frame(master, width=self.defaultNotebookFrameWidth, height=self.defaultNotebookFrameHeight) self.hillClimbOptions = { "pointCloud": tk.IntVar(), "sigma": tk.DoubleVar() } self.hillClimbOptions["pointCloud"].set(60) self.hillClimbOptions["sigma"].set(0.05) self.getFrameWithEntry( master=frame, text="Point cloud size", variable=self.hillClimbOptions["pointCloud"]).grid(row=0, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Sigma", variable=self.hillClimbOptions["sigma"], from_=0, to=1).grid(row=1, column=0, columnspan=2, sticky=tk.E) return frame def createAnnealingFrame(self, master): frame = ttk.Frame(master, width=self.defaultNotebookFrameWidth, height=self.defaultNotebookFrameHeight) self.annealingOptions = { "pointCloud": tk.IntVar(), "temp": tk.DoubleVar(), "tempMin": tk.DoubleVar(), "alpha": tk.DoubleVar(), "sigma": tk.DoubleVar(), "elitism": tk.IntVar(), "repeats": tk.IntVar(), } self.annealingOptions["pointCloud"].set(10) self.annealingOptions["temp"].set(5000) self.annealingOptions["tempMin"].set(0.1) self.annealingOptions["alpha"].set(0.99) self.annealingOptions["sigma"].set(0.1) self.annealingOptions["elitism"].set(True) self.annealingOptions["repeats"].set(5) self.getFrameWithEntry( master=frame, text="Point cloud size", variable=self.annealingOptions["pointCloud"]).grid(row=0, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Sigma", variable=self.annealingOptions["sigma"], from_=0, to=1).grid(row=1, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry(master=frame, text="Temperature", variable=self.annealingOptions["temp"], from_=1, to=10000).grid(row=2, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Min temperature", variable=self.annealingOptions["tempMin"], from_=0.0, to=1).grid(row=3, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Alpha", variable=self.annealingOptions["alpha"], from_=0.01, to=0.99).grid(row=4, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Repeats for T", variable=self.annealingOptions["repeats"], from_=0.0, to=100).grid(row=5, column=0, columnspan=2, sticky=tk.E) return frame def createTSPFrame(self, master): frame = ttk.Frame(master, width=self.defaultNotebookFrameWidth, height=self.defaultNotebookFrameHeight) self.tspOptions = { 'citiesCount': tk.IntVar(), 'dimensions': tk.IntVar(), 'populationSize': tk.IntVar(), 'workspaceSize': [10000, 10000, 10000], 'mutationChance': tk.DoubleVar(), } self.tspOptions['citiesCount'].set(20) self.tspOptions['dimensions'].set(3) self.tspOptions['populationSize'].set(20) self.tspOptions['mutationChance'].set(0.5) self.getFrameWithSliderAndEntry( master=frame, text="Cities count", variable=self.tspOptions["citiesCount"], from_=4, to=100).grid(row=0, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Population", variable=self.tspOptions["populationSize"], from_=1, to=100).grid(row=1, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Mutation chance", variable=self.tspOptions["mutationChance"], from_=0, to=1).grid(row=2, column=0, columnspan=2, sticky=tk.E) return frame def createDGAFrame(self, master): frame = ttk.Frame(master, width=self.defaultNotebookFrameWidth, height=self.defaultNotebookFrameHeight) self.dgaOptions = { 'populationSize': tk.IntVar(), 'dimensions': tk.IntVar(), 'scalingFactorF': tk.DoubleVar(), 'crossoverCR': tk.DoubleVar(), } self.dgaOptions['populationSize'].set(20) self.dgaOptions['dimensions'].set(3) self.dgaOptions['scalingFactorF'].set(0.7) self.dgaOptions['crossoverCR'].set(0.7) self.getFrameWithSliderAndEntry( master=frame, text="Population size", variable=self.dgaOptions["populationSize"], from_=4, to=100).grid(row=0, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Scaling factor F", variable=self.dgaOptions["scalingFactorF"], from_=0.1, to=1.1).grid(row=1, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Crossover factor CR", variable=self.dgaOptions["crossoverCR"], from_=0.0, to=1.0).grid(row=2, column=0, columnspan=2, sticky=tk.E) return frame def createSomaFrame(self, master): frame = ttk.Frame(master, width=self.defaultNotebookFrameWidth, height=self.defaultNotebookFrameHeight) self.somaOptions = { 'populationSize': tk.IntVar(), 'dimensions': tk.IntVar(), 'pathLength': tk.DoubleVar(), 'step': tk.DoubleVar(), 'perturbation': tk.DoubleVar(), 'minDiv': tk.DoubleVar(), } self.somaOptions['populationSize'].set(20) self.somaOptions['dimensions'].set(3) self.somaOptions['pathLength'].set(3) self.somaOptions['step'].set(0.11) self.somaOptions['perturbation'].set(0.1) self.somaOptions['minDiv'].set(-0.1) self.getFrameWithSliderAndEntry( master=frame, text="Population size", variable=self.somaOptions["populationSize"], from_=10, to=100).grid(row=0, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Path length", variable=self.somaOptions["pathLength"], from_=1.1, to=10).grid(row=1, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Step", variable=self.somaOptions["step"], from_=0.11, to=self.somaOptions["pathLength"].get()).grid(row=2, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Perturbation", variable=self.somaOptions["perturbation"], from_=0, to=1).grid(row=3, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry(master=frame, text="Min Div", variable=self.somaOptions["minDiv"], from_=1, to=100).grid(row=4, column=0, columnspan=2, sticky=tk.E) return frame def createAntFrame(self, master): frame = ttk.Frame(master, width=self.defaultNotebookFrameWidth, height=self.defaultNotebookFrameHeight) self.antOptions = { 'dimensions': tk.IntVar(), 'citiesCount': tk.IntVar(), 'evaporization': tk.DoubleVar(), 'initialFeromone': tk.DoubleVar(), 'alpha': tk.DoubleVar(), 'beta': tk.DoubleVar(), 'workspaceSize': [100, 100, 100], } self.antOptions['dimensions'].set(3) self.antOptions['citiesCount'].set(20) self.antOptions['evaporization'].set(0.5) self.antOptions['initialFeromone'].set(1) self.antOptions['alpha'].set(1) self.antOptions['beta'].set(2) self.getFrameWithSliderAndEntry( master=frame, text="Cities count", variable=self.antOptions["citiesCount"], from_=4, to=100).grid(row=0, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Evaporization", variable=self.antOptions["evaporization"], from_=0.001, to=0.99).grid(row=1, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Initial pheromone", variable=self.antOptions["initialFeromone"], from_=0.1, to=10).grid(row=2, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry(master=frame, text="Pheromone importance", variable=self.antOptions["alpha"], from_=0, to=10).grid(row=3, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry(master=frame, text="Distance importance", variable=self.antOptions["beta"], from_=0, to=10).grid(row=4, column=0, columnspan=2, sticky=tk.E) return frame def createFireflyFrame(self, master): frame = ttk.Frame(master, width=self.defaultNotebookFrameWidth, height=self.defaultNotebookFrameHeight) self.fireflyOptions = { 'dimensions': tk.IntVar(), "populationSize": tk.IntVar(), 'alpha': tk.DoubleVar(), 'betaAtractivness': tk.DoubleVar(), } self.fireflyOptions['dimensions'].set(3) self.fireflyOptions['populationSize'].set(20) self.fireflyOptions['alpha'].set(0.6) self.fireflyOptions['betaAtractivness'].set(1.0) self.getFrameWithSliderAndEntry( master=frame, text="Number of fireflies", variable=self.fireflyOptions["populationSize"], from_=4, to=100).grid(row=0, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry(master=frame, text="Random factor (alpha)", variable=self.fireflyOptions["alpha"], from_=0, to=1).grid(row=1, column=0, columnspan=2, sticky=tk.E) self.getFrameWithSliderAndEntry( master=frame, text="Atractivness (beta)", variable=self.fireflyOptions["betaAtractivness"], from_=0, to=1).grid(row=2, column=0, columnspan=2, sticky=tk.E) return frame def createTLBAFrame(self, master): frame = ttk.Frame(master, width=self.defaultNotebookFrameWidth, height=self.defaultNotebookFrameHeight) self.tlbaOptions = { 'dimensions': tk.IntVar(value=3), "populationSize": tk.IntVar(value=20), } self.getFrameWithSliderAndEntry( master=frame, text="Population size", variable=self.tlbaOptions["populationSize"], from_=4, to=100).grid(row=0, column=0, columnspan=2, sticky=tk.E) return frame def getFrameWithEntry(self, master, text, variable): frame = ttk.Frame(master) valLabel = ttk.Label(frame, text=text) valLabel.grid(row=0, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.E) valEntry = ttk.Entry(frame, textvariable=variable) valEntry.grid(row=0, column=1, padx=self.defPad, pady=self.defPad, sticky=tk.W + tk.E) return frame def getFrameWithSliderAndEntry(self, master, text, variable, from_, to): frame = ttk.Frame(master) valLabel = ttk.Label(frame, text=text) valLabel.grid(row=0, column=0, padx=self.defPad, pady=self.defPad, sticky=tk.E) valSlider = ttk.Scale(frame, from_=from_, to=to, variable=variable) valSlider.grid(row=0, column=1, padx=self.defPad, pady=self.defPad, sticky=tk.W + tk.E) valEntry = ttk.Entry(frame, textvariable=variable) valEntry.grid(row=1, column=1, padx=self.defPad, pady=self.defPad, sticky=tk.W + tk.E) return frame def getAlgorithm(self): currentTabIdx = self.tabsFrame.index("current") func = fn.functionsMap[self.selectedFunction.get()] func.clearDict() algo = { 0: alg.BlindAlgorithm( function=func, pointCloudSize=self.blindOptions["pointCloud"].get()), 1: alg.HillClimbAlgorithm( function=func, pointCloudSize=self.hillClimbOptions["pointCloud"].get(), sigma=self.hillClimbOptions["sigma"].get()), 2: alg.AnnealingAlgorithm(function=func, options=self.annealingOptions), 3: alg.TravelingSalesmanGeneticAlgorithm(options=self.tspOptions), 4: alg.DifferentialGeneticAlgorithm(function=func, options=self.dgaOptions), 5: alg.SelfOrganizingMigrationAlgorithm(function=func, options=self.somaOptions), 6: alg.TravelingSalesmanAntColonyAlgorithm(options=self.antOptions), 7: alg.FireflyAlgorithm(function=func, options=self.fireflyOptions), 8: alg.TeachingLearningBasedAlgorithm(function=func, options=self.tlbaOptions), }.get(currentTabIdx, None) print(f"Func: {func}") print(f"Current index: {currentTabIdx}") print(f"Alg: {algo}") return algo def run(self): algo = self.getAlgorithm() algo.renderDelay = self.renderDelay.get() algo.solve(maxIterations=self.maxIterations.get(), ax3d=self.graph3Dax, canvas=self.canvas3D) tk.messagebox.showinfo( "Done", f"Best found value: {algo.fitness}. For more info check console output." ) algo.plotFitnessHistory()
line, = ax.plot(evo.time, evo.data) ax.set_ylim([0, 100]) ax.get_xaxis().set_animated(True) #ax.get_yaxis().set_animated(True) line.set_animated(True) canvas.draw() background = canvas.copy_from_bbox(fig.bbox) # now redraw and blit ax.draw_artist(ax.get_xaxis()) ax.draw_artist(line) canvas.blit(ax.clipbox) while True: evo.update() line.set_xdata(evo.time) line.set_ydata(evo.getData()) ax.set_xlim([evo.time[0], evo.time[-1]]) #ax.set_ylim([max(evo.data),min(evo.data)]) # restore the background, draw animation,blit canvas.restore_region(background) ax.draw_artist(ax.get_xaxis()) #ax.draw_artist(ax.get_yaxis()) ax.draw_artist(line) canvas.blit(ax.clipbox) canvas.flush_events()
class menu(): def __init__(self, std_alone=True, main_winz=None, GEMROC_reading_dict=None): self.restart = True self.PMT = True self.std_alone = std_alone self.GEM_to_read = np.zeros((20)) self.GEM_to_read_last = np.zeros((20)) self.errors_counters_810 = {} # for i in range (0,20): # self.errors_counters_810[i]=i*20 self.logfile = "." + sep + "log_folder" + sep + "ACQ_log_{}".format( datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")) self.mode = 'TL' self.LED = [] self.FIELD_TIGER = [] self.LED_UDP = [] self.plotting_gemroc = 0 self.plotting_TIGER = 0 self.time = 2 self.GEM = [] if std_alone: self.master_window = Tk() self.master_window.title("GEMROC acquisition") else: self.master_window = Toplevel(main_winz) self.main_winz = main_winz self.GEMROC_reading_dict = GEMROC_reading_dict self.simple_analysis = IntVar(self.master_window) Label(self.master_window, text='Acquisition setting', font=("Courier", 25)).pack() self.master = Frame(self.master_window) self.master.pack() self.icon_on = PhotoImage(file="." + sep + 'icons' + sep + 'on.gif') self.icon_off = PhotoImage(file="." + sep + 'icons' + sep + 'off.gif') self.icon_bad = PhotoImage(file="." + sep + 'icons' + sep + 'bad.gif') self.grid_frame = Frame(self.master_window) self.grid_frame.pack() Button(self.grid_frame, text='ROC 00', command=lambda: self.toggle(0)).grid(row=0, column=0, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 01', command=lambda: self.toggle(1)).grid(row=0, column=2, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 02', command=lambda: self.toggle(2)).grid(row=0, column=4, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 03', command=lambda: self.toggle(3)).grid(row=0, column=6, sticky=W, pady=4) Button(self.grid_frame, text='ROC 04', command=lambda: self.toggle(4)).grid(row=0, column=8, sticky=W, pady=4) Button(self.grid_frame, text='ROC 05', command=lambda: self.toggle(5)).grid(row=0, column=10, sticky=W, pady=4) Button(self.grid_frame, text='ROC 06', command=lambda: self.toggle(6)).grid(row=0, column=12, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 07', command=lambda: self.toggle(7)).grid(row=0, column=14, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 08', command=lambda: self.toggle(8)).grid(row=0, column=16, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 09', command=lambda: self.toggle(9)).grid(row=0, column=18, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 10', command=lambda: self.toggle(10)).grid(row=1, column=0, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 11', command=lambda: self.toggle(11)).grid(row=1, column=2, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 12', command=lambda: self.toggle(12)).grid(row=1, column=4, sticky=W, pady=4) Button(self.grid_frame, text='ROC 13', command=lambda: self.toggle(13)).grid(row=1, column=6, sticky=W, pady=4) Button(self.grid_frame, text='ROC 14', command=lambda: self.toggle(14)).grid(row=1, column=8, sticky=W, pady=4) Button(self.grid_frame, text='ROC 15', command=lambda: self.toggle(15)).grid(row=1, column=10, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 16', command=lambda: self.toggle(16)).grid(row=1, column=12, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 17', command=lambda: self.toggle(17)).grid(row=1, column=14, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 18', command=lambda: self.toggle(18)).grid(row=1, column=16, sticky=NW, pady=4) Button(self.grid_frame, text='ROC 19', command=lambda: self.toggle(19)).grid(row=1, column=18, sticky=NW, pady=4) self.start_frame = Frame(self.master_window) self.start_frame.pack() Label(self.start_frame, text="Trigger less acq time (seconds)").grid(row=0, column=0, sticky=NW, pady=4) self.time_in = Entry(self.start_frame, width=3) self.time_in.insert(END, '1') self.time_in.grid(row=0, column=1, sticky=NW, pady=4) Checkbutton(self.start_frame, text="Fast analysis", variable=self.simple_analysis).grid(row=0, column=2, sticky=NW, pady=4) a_frame = Frame(self.master_window) a_frame.pack() self.but6 = Button(a_frame, text='Start acquisition', command=self.start_acq) self.but6.grid(row=1, column=2, sticky=NW, pady=4) self.but7 = Button(a_frame, text='Trigger less acquisition', command=self.switch_mode, background='#ccffff', activebackground='#ccffff', height=1, width=18) self.but7.grid(row=1, column=3, sticky=NW, pady=4) self.but8 = Button(a_frame, text='Stop acquisition', command=self.stop_acq, state='normal') b_frame = LabelFrame(a_frame) b_frame.grid(row=1, column=8, sticky=NW, pady=4, padx=40) if self.PMT: Button(b_frame, text='Turn ON PMT', command=self.PMT_on(), width=10, activeforeground="green").pack(side=LEFT) Button(b_frame, text='Turn OFF PMT', command=self.PMT_OFF(), width=10, activeforeground="red").pack(side=LEFT) # Label(b_frame,text='Message ').grid(row=0, column=1, sticky=NW, pady=4) # self.Launch_error_check=Label(b_frame, text='-', background='white') # self.Launch_error_check.grid(row=0, column=2, sticky=NW, pady=4) # Button(self.master,text='Exit', command='close').place(relx=0.9, rely=0.9, anchor=NW) # Button(a_frame, text='Communication errorinterfacee',command=error_GUI) self.but8.grid(row=1, column=4, sticky=NW, pady=4) for i in range(0, len(self.GEM_to_read)): if i < 10: riga = 0 else: riga = 1 colonna = ((i) % 10) * 2 + 1 self.LED.append(Label(self.grid_frame, image=self.icon_off)) self.LED[i].grid(row=riga, column=colonna) self.errors = Frame(self.master_window) self.errors.pack() self.LBerror = Label(self.errors, text='Acquisition errors check', font=("Courier", 25)) self.LBerror.grid(row=0, column=0, columnspan=8, sticky=S, pady=5) self.butleftG_err = Button( self.errors, text='<', command=lambda: self.change_G_or_T(-1, "G")).grid(row=1, column=0, sticky=S, pady=4) self.LBGEM_err = Label(self.errors, text='GEMROC {}'.format(self.plotting_gemroc), font=("Courier", 14)) self.LBGEM_err.grid(row=1, column=1, sticky=S, pady=4) self.butrightG_err = Button( self.errors, text='>', command=lambda: self.change_G_or_T(1, "G")).grid(row=1, column=2, sticky=S, pady=4) self.LBUDP0 = Label(self.errors, text='UDP packet error ') self.LBUDP0.grid(row=2, column=1, sticky=S, pady=4) Label(self.errors, text=' TIGER missing').grid(row=2, column=2, sticky=S, pady=4) if not self.std_alone: self.open_adv_acq() self.LED_UDP = Label(self.errors, image=self.icon_off) self.LED_UDP.grid(row=4, column=1) self.FIELD_TIGER = Label(self.errors, text='-', background='white') self.FIELD_TIGER.grid(row=4, column=2) self.plot_window = Frame(self.master_window) self.plot_window.pack() # self.plot_window.geometry('900x800') self.corn0 = Frame(self.plot_window) self.corn0.pack() self.LBOCC = Label(self.corn0, text='Channel occupancy', font=("Times", 18)) self.LBOCC.grid(row=0, column=1, sticky=S, pady=4) self.butleftG = Button( self.corn0, text='<', command=lambda: self.change_G_or_T(-1, "G")).grid(row=1, column=0, sticky=S, pady=4) self.LBGEM = Label(self.corn0, text='GEMROC {}'.format(self.plotting_gemroc), font=("Courier", 14)) self.LBGEM.grid(row=1, column=1, sticky=S, pady=4) self.butrightG = Button( self.corn0, text='>', command=lambda: self.change_G_or_T(1, "G")).grid(row=1, column=2, sticky=S, pady=4) self.butleftT = Button( self.corn0, text='<', command=lambda: self.change_G_or_T(-1, "T")).grid(row=2, column=0, sticky=S, pady=4) self.LBTIG = Label(self.corn0, text='TIGER {}'.format(self.plotting_TIGER), font=("Courier", 14)) self.LBTIG.grid(row=2, column=1, sticky=S, pady=4) self.butrightT = Button( self.corn0, text='>', command=lambda: self.change_G_or_T(1, "T")).grid(row=2, column=2, sticky=S, pady=4) self.corn1 = Frame(self.plot_window) self.corn1.pack() # Plot x = np.arange(0, 64) v = np.zeros((64)) self.fig = Figure(figsize=(7, 7)) self.plot_rate = self.fig.add_subplot(111) self.scatter, = self.plot_rate.plot(x, v, 'r+') self.plot_rate.set_title("TIGER {}, GEMROC {}".format( self.plotting_TIGER, self.plotting_gemroc)) self.plot_rate.set_ylabel("HitRates", fontsize=14) self.plot_rate.set_xlabel("Channel", fontsize=14) self.canvas = FigureCanvasTkAgg(self.fig, master=self.plot_window) self.canvas.get_tk_widget().pack(side=BOTTOM) self.canvas.draw() self.canvas.flush_events() self.toolbar = NavigationToolbar2Tk(self.canvas, self.corn1) self.toolbar.draw() def open_adv_acq(self): self.adv_wind = Toplevel(self.main_winz) self.error_dict810 = {} seconfF = Frame(self.adv_wind) seconfF.pack() firstF = Frame(self.adv_wind) firstF.pack() Label(firstF, text='Acquisiton set single TIGERs', font=("Courier", 16)).pack() self.button_dict = {} for number, GEMROC in self.GEMROC_reading_dict.items(): a = Frame(firstF) a.pack() Label(a, text='{} TIGERs: '.format(number)).grid(row=0, column=0, sticky=NW, pady=4) for T in range(0, 8): self.button_dict["{} TIGER {}".format(number, T)] = Button( a, text='{}'.format(T), width=10, command=lambda (number, T)=(number, T): self.Change_Reading_Tigers( (number, T))) self.button_dict["{} TIGER {}".format(number, T)].grid(row=0, column=T + 1, sticky=NW, pady=4) Label(a, text='{} Err(8/10): '.format(number)).grid(row=1, column=0, sticky=NW, pady=4) for T in range(0, 8): self.error_dict810["{} TIGER {}".format(number, T)] = Label( a, text="-------", width=11) self.error_dict810["{} TIGER {}".format(number, T)].grid(row=1, column=T + 1, sticky=NW, pady=4) self.refresh_but_TIGERs() def Change_Reading_Tigers(self, (number, T)): n = (self.GEMROC_reading_dict[number].GEM_COM.gemroc_DAQ_XX. EN_TM_TCAM_pattern >> T) & 0x1 if n == 1: self.GEMROC_reading_dict[ number].GEM_COM.gemroc_DAQ_XX.EN_TM_TCAM_pattern -= 2**T else: self.GEMROC_reading_dict[ number].GEM_COM.gemroc_DAQ_XX.EN_TM_TCAM_pattern += 2**T self.GEMROC_reading_dict[number].GEM_COM.DAQ_set_register() self.refresh_but_TIGERs()
class Application(tk.Frame, object): def __init__(self, master=None): tk.Frame.__init__(self, master) self.grid(sticky=tk.N+tk.S+tk.E+tk.W) self.master.title('OpenCV video capture using tkinter') self.createFrames() self.initOpenCV() def quit(self): self.stop() super(Application, self).quit() # stops mainloop self.destroy() # this is necessary on Windows to prevent # Fatal Python Error: PyEval_RestoreThread: NULL tstate def initOpenCV(self): self.cap = None self.currentFrame = 0 def createFrames(self): top = self.winfo_toplevel() top.rowconfigure(0, weight=1) top.columnconfigure(0, weight=1) self.rowconfigure(0, minsize=200, weight=1) self.rowconfigure(1, minsize=200, weight=1) self.columnconfigure(0, minsize=10, weight=0) self.columnconfigure(1, minsize=400, weight=1) self.toolbarFrame = tk.LabelFrame(self, text='Toolbar') self.originalFrame = tk.LabelFrame(self, text='Original') self.processedFrame = tk.LabelFrame(self, text='Processed') self.toolbarFrame.grid (row=0, column=0, rowspan=2, sticky=tk.N+tk.S+tk.E+tk.W) self.originalFrame.grid (row=0, column=1, sticky=tk.N+tk.S+tk.E+tk.W) self.processedFrame.grid(row=1, column=1, sticky=tk.N+tk.S+tk.E+tk.W) self.createToolbar(self.toolbarFrame) self.createOriginalFrame(self.originalFrame) self.createProcessedFrame(self.processedFrame) def createToolbar(self, parentFrame): self.quitButton = tk.Button(parentFrame, text='Quit', command=self.quit) self.startButton = tk.Button(parentFrame, text='Start capture', command=self.start) self.stopButton = tk.Button(parentFrame, text='Stop capture', command=self.stop) self.startButton.grid(row=0,sticky=tk.N+tk.S+tk.E+tk.W) self.stopButton.grid (row=1,sticky=tk.N+tk.S+tk.E+tk.W) self.quitButton.grid (row=2,sticky=tk.S+tk.E+tk.W) parentFrame.rowconfigure(2, weight=1) def createOriginalFrame(self, parentFrame): self.originalFigure = plt.figure(figsize=(5,3)) self.originalAxes = self.originalFigure.add_subplot(111) self.originalAxes.set_xticklabels([]) self.originalAxes.set_yticklabels([]) self.originalCanvas = FigureCanvasTkAgg(self.originalFigure, master=parentFrame) self.originalCanvas.show() self.originalCanvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1) def createProcessedFrame(self, parentFrame): self.processedFigure = plt.figure(figsize=(5,3)) self.processedAxes = self.processedFigure.add_subplot(111) self.processedAxes.set_xticklabels([]) self.processedAxes.set_yticklabels([]) self.processedCanvas = FigureCanvasTkAgg(self.processedFigure, master=parentFrame) self.processedCanvas.show() self.processedCanvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1) def start(self): if self.cap is None: self.cap = cv2.VideoCapture(0) print 'created video capture object' self.currentFrame = 0 self.processVideo() def stop(self): if self.cap is not None: self.cap.release() self.cap = None print 'released video capture object' def processVideo(self): if self.cap is not None: #print 'process video frame %d' % self.currentFrame _, image_original_bgr = self.cap.read() b,g,r = cv2.split(image_original_bgr) image_original_rgb = cv2.merge([r,g,b]) if self.currentFrame == 0: self.originalImageAxes = self.originalAxes.imshow(image_original_rgb) else: self.originalImageAxes.set_data(image_original_rgb) if self.currentFrame == 0: self.processedImageAxes = self.processedAxes.imshow(image_original_rgb) else: self.processedImageAxes.set_data(image_original_rgb) self.updateFigures() self.currentFrame = self.currentFrame + 1 self.after(1, self.processVideo) def updateFigures(self): self.originalCanvas.draw() self.originalCanvas.flush_events() self.processedCanvas.draw() self.processedCanvas.flush_events()
class TensileTestView(tk.Frame): def __init__(self, parent): tk.Frame.__init__(self, parent) # Initialize this class as a frame self.animationBgCol = "black" # Animation canvas background colour # Create and configure main frame mainArea = tk.Frame(self, bg=st.MAIN_AREA_BG) mainArea.grid(row=0, column=0, sticky="nsew") mainArea.grid_propagate(0) self.grid_rowconfigure(0, weight=1) self.grid_columnconfigure(0, weight=1) # Create and configure main grids grid = tuple([i for i in range(20)]) mainArea.grid_columnconfigure(grid, weight=1, minsize=50) mainArea.grid_rowconfigure(grid, weight=1, minsize=35) # Create title label = tk.Label(mainArea, text="Mechanical Workshop", font=st.LARGE_FONT, bg=st.MAIN_AREA_BG, fg=st.TITLE_COLOUR) label.grid(row=0, column=14, columnspan=6, sticky='nse') # Create description label = tk.Label( mainArea, text="We are now going to perform a tensile test on the " + "sheet of aluminum that we cold rolled! We can see our sample of aluminum on the left side of " + "the screen as well as a stress-strain graph on the right side of the screen. " + "Press the start button to begin the tensile test!", bg=st.INPUT_BG, wraplength=650, fg='black', justify='left', relief='ridge') label.grid(row=1, column=6, rowspan=2, columnspan=14, sticky='nesw') # Canvas for graphic simulation self.height = 595 self.width = 250 self.animationWindow = tk.Canvas(mainArea, bg=self.animationBgCol, height=self.height, width=self.width, bd=0, highlightthickness=0, relief='ridge') self.animationWindow.grid(row=2, column=1, columnspan=5, rowspan=17, sticky='ne') # Create Plot self.f = Figure(figsize=(6, 6), dpi=100) self.a = self.f.add_subplot(111) self.a.grid(color='grey', linestyle='-', linewidth=0.3) self.a.set_ylabel('Stress (MPa)') self.a.set_xlabel('Strain (-)') self.line = self.a.plot([], [], "-") self.a.format_coord = lambda x, y: "Strain (-)={:6.4f}, Stress (MPa)={:6.3f}".format( x, y) # Create canvas for plot self.graphWindow = FigureCanvasTkAgg(self.f, mainArea) self.graphWindow.get_tk_widget().grid(row=5, column=6, rowspan=12, columnspan=12) self.BG = self.graphWindow.copy_from_bbox(self.a.bbox) self.OG = self.BG # Load arrow images self.arrow = ImageTk.PhotoImage(file=st.IMG_PATH + "left_arrow.png") self.arrowClicked = ImageTk.PhotoImage(file=st.IMG_PATH + "left_arrow_clicked.png") self.arrowDisabled = ImageTk.PhotoImage(file=st.IMG_PATH + "left_arrow_disabled.png") # Arrow for previous page self.nextPage = tk.Button(mainArea, image=self.arrow, borderwidth=0) self.nextPage.image = self.arrow self.nextPage.grid(row=9, rowspan=2, column=0, sticky='nesw') # Button to start simulation self.animationButton = ttk.Button(mainArea, text="Start") self.animationButton.grid(row=3, rowspan=2, column=6, columnspan=3, sticky='nesw') # Text for displaying cold work self.CW_text = tk.Label(mainArea, text='', borderwidth=2, bg=st.INPUT_BG, font=st.MEDIUM_FONT) self.CW_text.grid(row=0, rowspan=2, column=2, columnspan=3, sticky='nsew') # Draw the rod self.rod = Rod(self.animationWindow, self.width, self.height, self.animationBgCol) self.rod.drawRod() # Create toolbar for plot self.toolbar = NavigationToolbar2Tk(self.graphWindow, mainArea) self.toolbar.update() self.toolbar.grid(row=17, column=6, rowspan=2, columnspan=10, sticky='nsew') # Draw mac logo logoImg = ImageTk.PhotoImage(Image.open(st.IMG_PATH + "macLogo.png")) canvas = tk.Canvas(mainArea, bg=st.MAIN_AREA_BG, width=130, height=71, bd=0, highlightthickness=0, relief='ridge') canvas.create_image(130 / 2, 71 / 2, image=logoImg, anchor="center") canvas.image = logoImg canvas.grid(row=17, column=17, rowspan=3, columnspan=3) def setGraphSize(self, x, y): """ Set the graph size. Assume it is called before any other function """ self.a.set_xlim([-0.01, x + 0.3]) self.a.set_ylim([0, y + 50]) self.graphWindow.draw() self.BG = self.graphWindow.copy_from_bbox(self.a.bbox) def pressArrow(self): """ Change arrow picture to "pressed arrow" """ self.nextPage.config(image=self.arrowClicked) self.nextPage.image = self.arrowClicked def normalArrow(self): """ Change arrow picture to "normal arrow" """ self.nextPage.config(image=self.arrow) self.nextPage.image = self.arrow def disableArrow(self): """ Change arrow picture to "disabled arrow" """ self.nextPage.config(image=self.arrowDisabled) self.nextPage.image = self.arrowDisabled def resetCanvas(self): """ Reset the rod on canvas """ self.rod.resetRod() def setCW(self, val): """ Set the coldwork text """ self.CW_text.config(text="%CW = " + str(val)) def updateGraph(self, xvals, yvals): """ Update the graph with xvals and yvals. This function is called at a given framerate """ self.line[0].set_data(xvals, yvals) self.graphWindow.restore_region(self.BG) self.a.draw_artist(self.line[0]) self.graphWindow.blit(self.a.bbox) self.graphWindow.flush_events() def updateAnimation(self, elongation, widthFact, neckWidthFact, neckHeightFact): """ Update the canvas based on given values. This function is called at a given framerate """ self.rod.updateRod(elongation, widthFact, neckWidthFact, neckHeightFact) def generateFracture(self, EL): """ Generate a fracture in the Rod. Function is called at the end of the animation """ self.rod.drawFracture(EL)