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)
