def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
root = tk.Tk()
# root.wm_title("PySNID")
fig = Figure(figsize=(10, 4), dpi=100)
fig1 = Figure(figsize=(10, 4), dpi=100)
fig.add_subplot(111).plot(input_spectrum[:, 0], input_spectrum[:, 1])
fig.add_subplot(111).plot(template_spectrum[:, 0],
template_spectrum[:, 1])
fig1.add_subplot(121).plot(correlation)
canvas = FigureCanvasTkAgg(fig, master=root) # A tk.DrawingArea.
canvas.draw()
canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=1)
tkagg.NavigationToolbar2Tk(canvas, root)
canvas1 = FigureCanvasTkAgg(fig1, master=root) # A tk.DrawingArea.
canvas1.draw()
canvas1.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=1)
# canvas is your canvas, and root is your parent (Frame, TopLevel, Tk instance etc.)
tkagg.NavigationToolbar2Tk(canvas1, root)
tk.Label(root, text=rlap % (0, 0), borderwidth=1).grid(row=0, column=0)
def displaychart(plot, chartframe):
""" Helper function for creating the tk widgets """
canvas = tkagg.FigureCanvasTkAgg(plot, chartframe)
chart = canvas.get_tk_widget()
chart.pack(fill='both')
charttoolbar = tkagg.NavigationToolbar2Tk(canvas, chartframe)
return canvas, chart, charttoolbar
def draw_radial(candidates, name=None, nadir=None, ideal=None):
window = tk.Tk()
window.title(f"Candidate comparison")
fig_radial = plt.figure(figsize=(5, 4), dpi=120)
canvas_res = tkagg.FigureCanvasTkAgg(fig_radial, master=window)
if name is not None:
fig_radial.suptitle(name)
data = np.zeros((candidates.shape[0], candidates.shape[1] + 1))
data[:, :-1] = candidates
data[:, -1] = candidates[:, 0]
n_vars = candidates.shape[1]
angles = [n / n_vars * 2 * np.pi for n in range(n_vars)]
angles += angles[:1]
ax = fig_radial.add_subplot(111, polar=True)
ax.set_theta_offset(np.pi / 2)
ax.set_theta_direction(-1)
plt.xticks(angles[:-1], objective_names)
ax.set_rlabel_position(0)
plt.yticks([0, 1], ["nadir", "ideal"], color="grey", size=7)
plt.ylim(-.25, 1)
ax.plot(angles,
data[0],
linewidth=1,
linestyle="solid",
label="Candidate 1")
ax.fill(angles, data[0], "b", alpha=0.1)
ax.plot(angles,
data[1],
linewidth=1,
linestyle="solid",
label="Candidate 2")
ax.fill(angles, data[1], "r", alpha=0.1)
ax.legend(loc="upper right", bbox_to_anchor=(0.1, 0.1))
fig_radial.tight_layout(rect=[0, 0.03, 1, 0.95])
canvas_res.draw()
canvas_res.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
toolbar_res = tkagg.NavigationToolbar2Tk(canvas_res, window)
toolbar_res.update()
canvas_res.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
btn_close = tk.Button(window,
text="Close",
command=lambda: window.destroy())
btn_close.pack(side=tk.BOTTOM, fill=tk.X)
return True
def init_graphic(self, child):
frame = tk.Frame(child)
frame.pack(fill=tk.BOTH, expand=True)
# Graphics
fig = plt.Figure(figsize=(8, 3))
child.ax = fig.add_subplot(111)
child.ax.plot(0, 0, '.w')
child.canvas = tkagg.FigureCanvasTkAgg(fig, frame)
child.canvas.draw()
child.canvas.get_tk_widget().pack(fill='both', expand=True, side='top')
nav = tkagg.NavigationToolbar2Tk(child.canvas, frame)
nav.pack(side='bottom')
def createPlot(master):
f = pltf.Figure(figsize=(3, 3), dpi=100)
a = f.add_subplot(111)
a.plot([1, 2, 3, 4, 5, 6, 7, 8], [5, 6, 1, 3, 8, 9, 3, 5])
canvasTkagg = plttk.FigureCanvasTkAgg(f, master)
# canvasTkagg.draw()
toolbar = plttk.NavigationToolbar2Tk(canvasTkagg, master)
# toolbar.update()
canvas = canvasTkagg.get_tk_widget()
canvas.config(bd=0, highlightthickness=0)
canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
def draw_ranking(window, brb, paretofront):
fig_3d = plt.figure(figsize=(8, 6), dpi=120)
canvas_res = tkagg.FigureCanvasTkAgg(fig_3d, master=window)
plot_3d_ranks_colored(brb, paretofront, fig=fig_3d)
canvas_res.draw()
canvas_res.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
toolbar_res = tkagg.NavigationToolbar2Tk(canvas_res, window)
toolbar_res.update()
canvas_res.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
btn_next = tk.Button(window, text="Next", command=lambda: quit(window))
btn_next.pack(side=tk.BOTTOM, fill=tk.X)
return True
def draw_utility(window, brb):
fig_util = plt.figure(figsize=(9, 6), dpi=120)
canvas_res = tkagg.FigureCanvasTkAgg(fig_util, master=window)
plot_utility_monotonicity(brb, [[0, 1], [0, 1], [0, 1]], fig=fig_util)
canvas_res.draw()
canvas_res.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
toolbar_res = tkagg.NavigationToolbar2Tk(canvas_res, window)
toolbar_res.update()
canvas_res.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
btn_next = tk.Button(window, text="Next", command=lambda: quit(window))
btn_next.pack(side=tk.BOTTOM, fill=tk.X)
return True
def draw_parallel(candidates, obj_names=["INCOME", "CO2", "CHSI"]):
print(candidates)
window = tk.Tk()
window.title(f"Candidate comparison")
fig_par = plt.figure(figsize=(7, 4), dpi=120)
canvas_res = tkagg.FigureCanvasTkAgg(fig_par, master=window)
fig_par.suptitle("Candidate comparison")
ax = fig_par.add_subplot(111)
df = pandas.DataFrame(
data=candidates,
index=[f"Candidate {i+1}" for i in range(len(candidates))],
columns=obj_names).reset_index()
if len(candidates) == 5:
parallel_coordinates(df,
"index",
ax=ax,
colors=["red", "green", "grey", "blue", "orange"])
else:
parallel_coordinates(df, "index", ax=ax)
ax.set_ylim(0, 1)
ax.set_yticks([0, 0.25, 0.5, 0.75, 1])
ax.set_yticklabels(["nadir", "", "", "", "ideal"])
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.65, box.height])
legend_x = 1
legend_y = 0.5
ax.legend(loc="center left", bbox_to_anchor=(legend_x, legend_y))
canvas_res.draw()
canvas_res.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
toolbar_res = tkagg.NavigationToolbar2Tk(canvas_res, window)
toolbar_res.update()
canvas_res.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
btn_close = tk.Button(window,
text="Close",
command=lambda: window.destroy())
btn_close.pack(side=tk.BOTTOM, fill=tk.X)
return True
def __init__(self, add_subplot=True, root=None, **kwargs):
args = kwargs
figure = matplotlib.pyplot.figure(figsize=(10,6), dpi=100)
figure.set_facecolor('white')
axis = figure.add_subplot(111) if add_subplot else None
self.figure, self.axis = figure, axis
window = Tk.Tk() if root is None else Tk.Toplevel(root)
figure_frame = ttk.Frame(window)
canvas = backend.FigureCanvasTkAgg(figure, master=figure_frame)
canvas._tkcanvas.config(highlightthickness=0, width=1000, height=600)
toolbar = backend.NavigationToolbar2Tk(canvas, figure_frame)
toolbar.pack(side=Tk.TOP, fill=Tk.X)
canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
toolbar.update()
figure_frame.grid(column=0, row=0, sticky=(Tk.N, Tk.S, Tk.E, Tk.W))
window.columnconfigure(0, weight=1)
window.rowconfigure(0, weight=1)
self.window, self.canvas, self.toolbar = window, canvas, toolbar
self.figure_frame = figure_frame
def add_canvas(figure, container):
"""Add the figure and toolbar to GUI.
Args:
figure (matplotlib.Figure): The figure object to visualize.
container: The GUI part where the figure is shown.
"""
canvas = tk_backend.FigureCanvasTkAgg(figure, master=container)
canvas.draw()
canvas.get_tk_widget().pack(side=tkinter.TOP,
fill=tkinter.BOTH,
expand=True)
# NavigationToolbar2TkAgg is deprecated since matplotlib 2.2,
# NavigationToolbar2Tk should be used and is only available in new version.
toolbar = tk_backend.NavigationToolbar2Tk(canvas, container) \
if hasattr(tk_backend, 'NavigationToolbar2Tk') \
else tk_backend.NavigationToolbar2TkAgg(canvas, container)
toolbar.update()
canvas._tkcanvas.pack(side=tkinter.TOP, fill=tkinter.BOTH, expand=True)
pyplot.close(figure.number)
def __initIonsFrame(self):
self.ion_frame = tk.Frame(
self.root_frame,
bd=1,
relief="raised"
)
self.ion_frame.pack(
side="left",
fill="y",
)
self.ion_fig = plt.Figure()
self.ion_ax = self.ion_fig.add_subplot(111)
self.ion_canvas = tkagg.FigureCanvasTkAgg(self.ion_fig, self.ion_frame)
self.ion_toolbar = tkagg.NavigationToolbar2Tk(
self.ion_canvas,
self.ion_frame
)
self.ion_canvas.get_tk_widget().pack(
fill='both',
expand=True
)
self.getAxisType()
self.ion_ax.set_title("Ions")
def plot(self):
canvas = tkagg.FigureCanvasTkAgg(self.figure, master=self.window)
wcanvas = canvas.get_tk_widget()
wcanvas.config(width=1000, height=300)
wcanvas.pack(side=tk.TOP, expand=True, fill=tk.BOTH)
toolbar = tkagg.NavigationToolbar2Tk(canvas, self.window)
toolbar.update()
self.output = tk.StringVar()
label = tk.Label(self.window,
textvariable=self.output,
bg="white",
fg="red",
bd=2)
label.pack(side=tk.RIGHT, expand=True, fill=tk.X)
wcanvas.pack(side=tk.TOP, expand=True, fill=tk.BOTH)
canvas.draw()
# Print task type using mouse clicks or motion.
if self.motion:
fig.canvas.mpl_connect("motion_notify_event", self.onclick)
else:
fig.canvas.mpl_connect("button_press_event", self.onclick)
def __init__(self, *args, **kwargs):
# window = tk.Tk()
tk.Tk.__init__(self, *args, **kwargs)
#tk.Tk.iconbitmap(self, default="clienticon.ico")
tk.Tk.wm_title(self, "PySNID")
container = tk.Frame(self)
container.pack(side="top", fill="both", expand=True)
container.grid_rowconfigure(0, weight=1)
container.grid_columnconfigure(0, weight=1)
menubar = tk.Menu(container)
filemenu = tk.Menu(menubar, tearoff=0)
filemenu.add_command(label="rlap values", command=lambda: rlappopup())
filemenu.add_separator()
filemenu.add_command(
label="Save settings",
command=lambda: popupmsg("Not supported just yet!"))
filemenu.add_separator()
filemenu.add_command(label="Exit", command=quit)
menubar.add_cascade(label="File", menu=filemenu)
tk.Tk.config(self, menu=menubar)
fig, ax1 = plt.subplots(1, 1)
ax1.plot(input_spectrum[:, 0],
input_spectrum[:, 1],
label='User Spectrum')
ax1.plot(template_spectrum[:, 0],
template_spectrum[:, 1],
label='Template Spectrum')
ax1.set_title('Input v Best Fit Template')
ax1.set_ylabel('Normalised Flux (arb. units)')
ax1.set_xlabel('Wavelength (Angstrom)')
ax1.legend()
canvas = FigureCanvasTkAgg(fig, master=container) # A tk.DrawingArea.
canvas.draw()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=0)
tkagg.NavigationToolbar2Tk(
canvas, container
) # NavigationToolbar2Tk is the most up-to-date versionj, many users may be using an older version of tkagg
OPTIONS = [
'sn1980K',
'sn1989B',
'sn2004et',
'sn2012aw',
] #etc
#master = Tk()
variable = tk.StringVar(container)
variable.set(OPTIONS[0]) # default value
w = tk.OptionMenu(container, variable, *OPTIONS)
w.pack()
def glines(ax1):
ax1.vlines(x=6500,
ymin=-1,
ymax=2,
colors='m',
linestyles='dashdot',
label='Hydrogen Alpha')
b = tk.Button(container,
text='Galaxy lines',
command=lambda: glines(ax1))
b.pack()
def plot_histogram(up_times_days, down_times_days, now=0.0,
tk_frame=None):
"""Plot the histogram of the uploaded and downloaded blobs.
The Y is the number of blobs uploaded or downloaded in a single hour.
The X is the fraction of day (hour) when those blobs were uploaded.
The days are negative because it assumes the blobs were downloaded
in the past, meaning all values to the left correspond to days
before the present time.
Parameters
----------
up_times_days: list of float
List of intervals in days from now to the past, when blobs
were uploaded, `[-40, -30, -10, -5.235, -0.001]`.
It is negative because these occurrences were in the past,
that is, 40 days ago, 30 days ago, 10 days ago, etc.
down_times_days: list of float
List of intervals in days from now to the past, when blobs
were downloaded.
now: float, optional
It defaults to `0.0`, in which case it calculates the time
in this instance, `time.time()`.
It is a float indicating the Unix epoch time, meaning seconds
since 1970-01-01.
This value represent the reference time for all values
in `up_times_days` and `down_times_days`.
"""
if not now:
now = time.time()
now_txt = time.strftime("%Y-%m-%d_%H:%M:%S%z %A",
time.localtime(now))
up_times_d = np.array(up_times_days)
down_times_d = np.array(down_times_days)
oldest_day = np.min(np.hstack([up_times_d, down_times_d]))
# The bins for the histograms will be the fractions of day
# representing hours of the day
days_per_hour = 1/24
fractions_day = [0.0]
while fractions_day[-1] > oldest_day:
fractions_day.append(fractions_day[-1] - days_per_hour)
# More negative values left and zero to the right
fractions_day = fractions_day[::-1]
blobs_up = len(up_times_d)
blobs_down = len(down_times_d)
ratio = 0.0
try:
ratio = float(blobs_up)/blobs_down
except ZeroDivisionError:
pass
xlabel = "Time (days ago)"
ylabel = "Blobs per hour"
opt = {"alpha": 0.9, "edgecolor": "k"}
X0 = Y0 = [0]
mk = {"label": now_txt,
"marker": "o", "markeredgecolor": "k", "markersize": 9,
"markeredgewidth": 2.0, "linestyle": ""}
fig, axs = plt.subplots(2, 1, sharey=False, sharex=True)
axs[0].hist(up_times_d, bins=fractions_day,
color="g", label=f"Uploaded: {blobs_up}", **opt)
axs[0].set_xlabel(xlabel)
axs[0].set_ylabel(ylabel)
axs[0].plot(X0, Y0, markerfacecolor="g", **mk)
axs[0].legend()
axs[0].set_title(f"Up/down ratio: {ratio:.4f}")
axs[1].hist(down_times_d, bins=fractions_day,
color="r", label=f"Downloaded: {blobs_down}", **opt)
axs[1].set_xlabel(xlabel)
axs[1].set_ylabel(ylabel)
axs[1].plot(X0, Y0, markerfacecolor="r", **mk)
axs[1].legend()
if tk_frame:
canvas = mbacks.FigureCanvasTkAgg(fig, master=tk_frame)
canvas.draw()
# canvas.get_tk_widget().grid(row=0, column=0)
canvas.get_tk_widget().pack(fill="both", expand=True)
tbar = mbacks.NavigationToolbar2Tk(canvas, tk_frame)
tbar.update()
# canvas.get_tk_widget().grid(row=1, column=0)
canvas.get_tk_widget().pack(fill="both", expand=True)
else:
plt.show()
def __initAggregatesFrame(self):
self.aggregate_frame = tk.Frame(
self.root_frame,
bd=1,
relief="raised"
)
self.aggregate_frame.pack(
side="left",
fill="both",
expand=True
)
self.aggregate_fig = plt.Figure()
self.aggregate_ax = self.aggregate_fig.add_subplot(111)
self.aggregate_canvas = tkagg.FigureCanvasTkAgg(self.aggregate_fig, self.aggregate_frame)
self.aggregate_canvas.get_tk_widget().pack(
fill='both',
expand=True
)
self.aggregate_toolbar = tkagg.NavigationToolbar2Tk(
self.aggregate_canvas,
self.aggregate_frame
)
default_release = self.aggregate_toolbar.release
def release(event):
default_release(event)
self.refresh()
self.aggregate_toolbar.release = release
self.aggregate_ax.set_xlim(
[
np.min(self.dataset.anchors["RT"]),
np.max(self.dataset.anchors["RT"]),
]
)
self.aggregate_ax.set_ylim(
[
np.min(self.dataset.anchors["DT"]),
np.max(self.dataset.anchors["DT"]),
]
)
self.aggregate_ax.set_xlabel("RT")
self.aggregate_ax.set_ylabel("DT")
self.aggregate_ax.set_title("Aggregates")
def onclick(event):
if (event is None) or (not event.dblclick):
return
self.dataset.updateSelectedNodes(self, event)
self.dataset.plotSelectedNodes(self)
self.dataset.plotIons(self)
self.refreshAggregateCanvas()
self.refreshIonCanvas()
self.aggregate_canvas.mpl_disconnect(self.click_connection)
self.click_connection = self.aggregate_canvas.mpl_connect(
'button_press_event',
onclick
)
self.click_connection = self.aggregate_canvas.mpl_connect(
'button_press_event',
onclick
)
def create_widgets(self):
self.long_deg = tk.IntVar()
self.long_min = tk.IntVar()
self.long_sec = tk.IntVar()
self.lat_deg = tk.IntVar()
self.lat_min = tk.IntVar()
self.lat_sec = tk.IntVar()
self.long_dest_deg = tk.IntVar()
self.long_dest_min = tk.IntVar()
self.long_dest_sec = tk.IntVar()
self.lat_dest_deg = tk.IntVar()
self.lat_dest_min = tk.IntVar()
self.lat_dest_sec = tk.IntVar()
self.master.title("Welcome to Mushroom Router")
self.master.geometry('600x700')
frame_coord_location = tk.Frame(master=self.master)
self.Current_location_label = tk.Label(master=frame_coord_location, text="Current location:", anchor="w",
width=25).grid(row=0, column=0)
self.longitude_label = tk.Label(master=frame_coord_location, text="Longitude").grid(row=0, column=1)
self.entry_longitude_degree = tk.Entry(master=frame_coord_location, fg="blue", width=4,
textvariable=self.long_deg).grid(row=0, column=2)
self.longitude_deg_unit_label = tk.Label(master=frame_coord_location, text="°").grid(row=0, column=3)
self.entry_longitude_minute = tk.Entry(master=frame_coord_location, fg="blue", width=2,
textvariable=self.long_min).grid(row=0, column=4)
self.longitude_minute_unit_label = tk.Label(master=frame_coord_location, text="'").grid(row=0, column=5)
self.entry_longitude_second = tk.Entry(master=frame_coord_location, fg="blue", width=2,
textvariable=self.long_sec).grid(row=0, column=6)
self.longitude_second_unit_label = tk.Label(master=frame_coord_location, text="\"").grid(row=0, column=7)
self.latitude_label = tk.Label(master=frame_coord_location, text="Latitude").grid(row=0, column=8)
self.entry_latitude_degree = tk.Entry(master=frame_coord_location, fg="blue", width=4,
textvariable=self.lat_deg).grid(row=0, column=9)
self.latitude_deg_unit_label = tk.Label(master=frame_coord_location, text="°").grid(row=0, column=10)
self.entry_latitude_minute = tk.Entry(master=frame_coord_location, fg="blue", width=2,
textvariable=self.lat_min).grid(row=0, column=11)
self.latitude_minute_unit_label = tk.Label(master=frame_coord_location, text="'").grid(row=0, column=12)
self.entry_latitude_second = tk.Entry(master=frame_coord_location, fg="blue", width=2,
textvariable=self.lat_sec).grid(row=0, column=13)
self.latitude_second_unit_label = tk.Label(master=frame_coord_location, text="\"").grid(row=0, column=14)
self.dest_location_label = tk.Label(master=frame_coord_location, text="Destination location:", anchor="w",
width=25).grid(row=1,
column=0)
self.longitude_dest_label = tk.Label(master=frame_coord_location, text="Longitude").grid(row=1, column=1)
self.entry_longitude_dest_degree = tk.Entry(master=frame_coord_location, fg="blue", width=4,
textvariable=self.long_dest_deg).grid(row=1,
column=2)
self.longitude_dest_deg_unit_label = tk.Label(master=frame_coord_location, text="°").grid(row=1, column=3)
self.entry_longitude_dest_minute = tk.Entry(master=frame_coord_location, fg="blue", width=2,
textvariable=self.long_dest_min).grid(row=1,
column=4)
self.longitude_dest_minute_unit_label = tk.Label(master=frame_coord_location, text="'").grid(row=1, column=5)
self.entry_longitude_dest_second = tk.Entry(master=frame_coord_location, fg="blue", width=2,
textvariable=self.long_dest_sec).grid(row=1,
column=6)
self.longitude_dest_second_unit_label = tk.Label(master=frame_coord_location, text="\"").grid(row=1, column=7)
self.latitude_dest_label = tk.Label(master=frame_coord_location, text="Latitude").grid(row=1, column=8)
self.entry_latitude_dest_degree = tk.Entry(master=frame_coord_location, fg="blue", width=4,
textvariable=self.lat_dest_deg).grid(row=1,
column=9)
self.latitude_dest_deg_unit_label = tk.Label(master=frame_coord_location, text="°").grid(row=1, column=10)
self.entry_latitude_dest_minute = tk.Entry(master=frame_coord_location, fg="blue", width=2,
textvariable=self.lat_dest_min).grid(row=1,
column=11)
self.latitude_dest_minute_unit_label = tk.Label(master=frame_coord_location, text="'").grid(row=1, column=12)
self.entry_latitude_dest_second = tk.Entry(master=frame_coord_location, fg="blue", width=2,
textvariable=self.lat_dest_sec).grid(row=1,
column=13)
self.latitude_dest_second_unit_label = tk.Label(master=frame_coord_location, text="\"").grid(row=1, column=14)
frame_coord_location.pack()
def submit_coord():
if (self.long_deg.get() >= -180) and (self.long_deg.get() <= 180):
self.myboat.current_location[0] = degree_minute_second_to_decimal(self.long_deg.get(),
self.long_min.get(),
self.long_sec.get()) % 360
self.myboat.current_location[1] = degree_minute_second_to_decimal(self.lat_deg.get(),
self.lat_min.get(),
self.lat_sec.get())
self.myboat.destination_location[0] = degree_minute_second_to_decimal(self.long_dest_deg.get(),
self.long_dest_min.get(),
self.long_dest_sec.get()) % 360
self.myboat.destination_location[1] = degree_minute_second_to_decimal(self.lat_dest_deg.get(),
self.lat_dest_min.get(),
self.lat_dest_sec.get())
print("current location", self.myboat.current_location)
print("destination location", self.myboat.destination_location)
self.myboat.navigate(self.dswind)
# Button navigate
navigate_button = ttk.Button(master=self.master, text='Navigate', command=submit_coord)
navigate_button.pack(pady=10)
def submit_polarspeed():
self.reset_polar_chart()
nb = np.shape(self.myboat.sail_speed)
for i in range(0, nb[2]):
self.ax.plot(np.deg2rad(np.arange(0, 181, 1)),
self.myboat.get_sail_interpolated(self.myboat.sail_speed[:, :, i],
float(self.windspeed_polar.get())),
label=self.myboat.sail_name[i])
self.ax.plot(np.deg2rad(np.arange(0, 181, 1)),
self.myboat.get_sail_interpolated(self.myboat.best_polar_sail,
float(self.windspeed_polar.get())), "k:", label="All_sail")
self.ax.legend(bbox_to_anchor=(1.2, 1.05))
graph = FigureCanvasTkAgg(self.fig1, master=frame1)
canvas = graph.get_tk_widget()
canvas.grid(row=4)
notebook = ttk.Notebook(self.master)
notebook.pack(pady=1, expand=True)
# create frames
frame1 = ttk.Frame(notebook, width=800, height=800)
frame2 = ttk.Frame(notebook, width=800, height=800)
self.windspeed_polar = tk.DoubleVar()
self.windspind_level_label = tk.Label(master=frame1, text="Wind speed : (kts)").grid(row=0, column=0)
self.windspind_level_input = tk.Entry(master=frame1, fg="blue",
textvariable=self.windspeed_polar).grid(row=1, column=0)
# Button graph_polar
graph_polar_button = ttk.Button(master=frame1, text='Validate', command=submit_polarspeed)
graph_polar_button.grid(row=2, column=0)
# add frame to interface
frame1.pack(fill='both', expand=True)
frame2.pack(fill='both', expand=True)
# add notebook to frame 1 and 2
notebook.add(frame1, text='Polar')
notebook.add(frame2, text='Map')
self.fig1 = plt.figure()
self.ax = self.fig1.add_subplot(projection='polar')
self.reset_polar_chart()
graph = FigureCanvasTkAgg(self.fig1, master=frame1)
canvas = graph.get_tk_widget()
canvas.grid(row=4)
self.mapmonde = plt.figure("mapmonde")
self.mapmonde.ax2 = plt.axes(projection=ccrs.PlateCarree())
self.mapmonde.ax2.coastlines(resolution='10m')
#self.dswind.magnitude.isel(time=2, step=1).plot(cmap=plt.cm.nipy_spectral, transform=ccrs.PlateCarree())
plt.scatter(x=0, y=0, transform=ccrs.PlateCarree())
graph2 = FigureCanvasTkAgg(self.mapmonde, master=frame2)
canvas2 = graph2.get_tk_widget()
tkagg.NavigationToolbar2Tk(graph2, frame2)
canvas2.pack()
def __init__(self, master):
self.master = master
master.title('ExPaND')
default_font = font.nametofont("TkDefaultFont")
default_font.configure(size=8)
# Model visualization
self.figure = mplfig.Figure(figsize=(7, 7), dpi=100)
self.ax = self.figure.add_subplot(111)
self.ax.tick_params(axis='both',
which='both',
bottom=False,
labelbottom=False,
left=False,
labelleft=False)
self.figure.subplots_adjust(left=0,
bottom=0.02,
right=1,
top=0.98,
wspace=0,
hspace=0)
self.canvas = tkagg.FigureCanvasTkAgg(self.figure, self.master)
self.canvas.get_tk_widget().grid(row=1,
column=4,
columnspan=1,
rowspan=10)
self.toolbar_frame = tk.Frame(self.master)
self.toolbar_frame.grid(row=12, column=4, columnspan=1)
self.toolbar = tkagg.NavigationToolbar2Tk(self.canvas,
self.toolbar_frame)
# Parameters
# Start date
self.start = tk.IntVar()
self.start.set(4500)
self.start_label = tk.Label(master, text='Start date (BP):')
self.start_label.grid(row=3, column=1)
self.start_entry = tk.Entry(master, textvariable=self.start)
self.start_entry.config(width=10)
self.start_entry.grid(row=3, column=2, columnspan=2)
# Start coordinates
self.lon = tk.DoubleVar()
self.lon.set(-65.77)
self.lat = tk.DoubleVar()
self.lat.set(7.82)
self.coords_label = tk.Label(master, text='Origin (Lon/Lat):')
self.coords_label.grid(row=4, column=1)
self.lon_entry = tk.Entry(master, textvariable=self.lon)
self.lon_entry.config(width=5)
self.lon_entry.grid(row=4, column=2)
self.lat_entry = tk.Entry(master, textvariable=self.lat)
self.lat_entry.config(width=5)
self.lat_entry.grid(row=4, column=3)
# K*
self.k = tk.Scale(master,
label='K* (persons/100 km2)',
from_=20,
to=100,
resolution=20,
orient=tk.HORIZONTAL,
length=200)
self.k.grid(row=5, column=1, columnspan=3)
# Fission threshold
self.fiss = tk.Scale(master,
label='Fission threshold',
from_=50,
to=300,
resolution=50,
orient=tk.HORIZONTAL,
length=200)
self.fiss.grid(row=6, column=1, columnspan=3)
# Catchment
self.catch = tk.Scale(master,
label='Catchment (km)',
from_=10,
to=30,
resolution=10,
orient=tk.HORIZONTAL,
length=200)
self.catch.grid(row=7, column=1, columnspan=3)
# Leap distance
self.leap = tk.Scale(master,
label='Leap distance (km)',
from_=0,
to=300,
resolution=50,
orient=tk.HORIZONTAL,
length=200)
self.leap.grid(row=8, column=1, columnspan=3)
# Permanence
self.perm = tk.Scale(master,
label='Permanence (years)',
from_=10,
to=30,
resolution=10,
orient=tk.HORIZONTAL,
length=200)
self.perm.grid(row=9, column=1, columnspan=3)
# Controls
self.setup_button = tk.Button(master,
text='Setup',
width=10,
command=self.setup_model)
self.setup_button.grid(row=1, column=1)
self.run_button = tk.Button(master,
text='Run',
width=10,
command=self.run_model)
self.run_button.grid(row=1, column=2)
self.stop_button = tk.Button(master,
text='Stop',
width=10,
command=self.stop)
self.stop_button.grid(row=1, column=3)
self.iter_thousand_button = tk.Button(master,
text='▶ 1000 yrs',
width=10,
command=self.iter_thousand)
self.iter_thousand_button.grid(row=2, column=1)
self.write_button = tk.Button(master,
text='Write',
width=10,
command=self.write_model)
self.write_button.grid(row=2, column=2)
self.eval_button = tk.Button(master,
text='Evaluate',
width=10,
command=self.eval_model)
self.eval_button.grid(row=2, column=3)
# South America elevation map as a background
self.basemap = np.vstack(
np.loadtxt('./layers/ele.asc', skiprows=6).astype(float))
self.basemap[self.basemap == -9999] = np.nan
self.setup_model()
def __init__(
self, parent, func, interactives,
title=__doc__.strip().split('\n')[0],
about=__doc__,
width=_WIDTH, height=_HEIGHT,
min_width=_MIN_WIDTH, min_height=_MIN_HEIGHT,
**func_kwargs):
self.func = func
self.func_kwargs = func_kwargs
self.interactives = interactives
self.about = about
self.cwd = '.'
# :: initialization of the UI
self.win = super(PytkMain, self).__init__(
parent, width=width, height=height)
self.parent = parent
self.parent.title(title)
self.parent.protocol('WM_DELETE_WINDOW', self.actionExit)
self.parent.minsize(min_width, min_height)
self.style = pytk.Style()
# print(self.style.theme_names())
self.style.theme_use('clam')
self.pack(fill='both', expand=True)
pytk.util.center(self.parent)
self._make_menu()
# :: define UI items
# : main
self.frmMain = pytk.widgets.Frame(self)
self.frmMain.pack(fill='both', padx=4, pady=4, expand=True)
self.frmSpacers = []
# : left frame
self.frmLeft = pytk.widgets.Frame(self.frmMain)
self.frmLeft.pack(
side='left', fill='both', padx=4, pady=4, expand=True)
self.fig = mpl.figure.Figure(figsize=(0.1, 0.1))
self.canvas = tkagg.FigureCanvasTkAgg(
self.fig, self.frmLeft)
self.nav_toolbar = tkagg.NavigationToolbar2Tk(
self.canvas, self.frmLeft)
self.canvas.get_tk_widget().pack(fill='both', expand=True)
# : right frame
self.frmRight = pytk.widgets.ScrollingFrame(
self.frmMain,
label_kws=dict(text='Parameters'),
label_pack_kws=dict(
side='top', padx=0, pady=0, expand=False, anchor='n'))
self.frmRight.pack(
side='right', fill='both', padx=4, pady=4, expand=False)
self.frmParams = self.frmRight.scrolling
spacer = pytk.widgets.Frame(self.frmParams)
spacer.pack(side='top', padx=4, pady=4)
self.frmSpacers.append(spacer)
self.wdgInteractives = collections.OrderedDict()
for name, info in self.interactives.items():
if isinstance(info['default'], bool):
var = pytk.tk.BooleanVar()
chk = pytk.widgets.Checkbox(
self.frmParams, text=info['label'], variable=var)
chk.pack(fill='x', padx=1, pady=1)
self.wdgInteractives[name] = dict(var=var, chk=chk)
elif isinstance(info['default'], (int, float)):
var = pytk.tk.StringVar()
var.set(str(info['default']))
frm = pytk.widgets.Frame(self.frmParams)
frm.pack(fill='x', padx=1, pady=1, expand=True)
lbl = pytk.widgets.Label(frm, text=info['label'])
lbl.pack(side='left', fill='x', padx=1, pady=1, expand=False)
rng = pytk.widgets.Range(
frm,
start=info['start'], stop=info['stop'], step=info['step'],
orient='horizontal', variable=var)
rng.pack(
side='right', fill='x', anchor='w', padx=1, pady=1,
expand=False)
spb = pytk.widgets.Spinbox(
frm,
start=info['start'], stop=info['stop'], step=info['step'],
textvariable=var)
spb.pack(
side='right', fill='none', anchor='w', padx=1, pady=1,
expand=False)
self.wdgInteractives[name] = dict(
var=var, frm=frm, lbl=lbl, spb=spb, rng=rng)
elif isinstance(info['default'], str):
var = pytk.tk.StringVar()
var.set(str(info['default']))
frm = pytk.widgets.Frame(self.frmParams)
frm.pack(fill='x', padx=1, pady=1, expand=True)
lbl = pytk.widgets.Label(frm, text=info['label'])
lbl.pack(side='left', fill='x', padx=1, pady=1, expand=False)
cmb = pytk.widgets.Combobox(
frm,
values=info['values'], textvariable=var)
cmb.pack(
side='right', fill='x', anchor='w', padx=1, pady=1,
expand=False)
self.wdgInteractives[name] = dict(
var=var, frm=frm, lbl=lbl, cmb=cmb)
self._bind_interactions()
self.actionReset()
def pack_graph(self, master, type='scatter'):
#setting up default params
data = self.data
self.xlabel = self.tkvar1.get()
self.ylabel = self.tkvar2.get()
self.x = data[self.xlabel]
self.y = data[self.ylabel]
self.label_col = self.tkvar3.get()
self.type = type
try:
self.clear_graph() #checking if a graph is already populated
plt.clf()
except AttributeError as e:
# print('at pack_graph '+str(e)) #for testing only. This is supposed to throw AttributeError on the first run
pass
#setting up the graph properties
low_ylim = self.low_ylim_entry.get()
high_ylim = self.high_ylim_entry.get()
if not high_ylim:
high_ylim = self.y.max()
if not low_ylim:
low_ylim = self.y.min()
if not self.label_col:
self.label_col = data[self.xlabel]
self.names = np.array(list(
data[self.label_col])) #creating a numpy array list from label_col
self.c = np.random.randint(1, 5, size=len(
self.names)) #for picking random color
self.norm = plt.Normalize(1, 5) #for normalizing luminance data
self.cmap = plt.cm.Greens
self.fig, self.ax = plt.subplots()
self.graphs_frame = ttk.Frame(master)
self.canvas = FigureCanvasTkAgg(
self.fig, master=self.graphs_frame) # A tk.DrawingArea.
tkagg.NavigationToolbar2Tk(self.canvas, self.graphs_frame)
self.canvas.draw()
self.canvas.get_tk_widget().pack(fill=X)
self.graphs_frame.pack(fill=X)
plt.title('{} vs {}'.format(self.xlabel.upper(), self.ylabel.upper()))
plt.xlabel(self.xlabel.title())
plt.ylabel(self.ylabel.title())
plt.ylim(float(low_ylim), float(high_ylim))
#setting up properties for different type of graphs
if self.type == 'scatter':
low_xlim = self.low_xlim_entry.get()
high_xlim = self.high_xlim_entry.get()
if not high_xlim:
high_xlim = self.x.max()
if not low_xlim:
low_xlim = self.x.min()
plt.xlim(float(low_xlim), float(high_xlim))
self.sc = plt.scatter(self.x,
self.y,
c=self.c,
s=50,
cmap=self.cmap,
norm=self.norm)
elif self.type == 'line':
self.x = self.x.astype('object')
self.pos = np.arange(len(self.y))
self.sc = plt.plot(self.pos, self.y)
plt.xticks(self.pos, self.x)
elif self.type == 'bar':
self.x = self.x.astype('object')
pos = np.arange(len(self.y))
self.sc = plt.bar(pos, self.y, width=0.8)
plt.xticks(pos, self.x)
elif self.type == 'pie':
self.sc = plt.pie(self.y, labels=self.x)
plt.title(self.ylabel)
plt.xlabel('')
plt.ylabel('')
messagebox.showinfo(
title='Info',
message=
'Pie takes X column as label column, changes label column will not affect the pie graph.'
)
'''else:
self.x = self.x.astype('object')
self.pos = np.arange(len(self.y))
self.sc = plt.plot(self.pos,self.y, 'ro')
plt.xticks(self.pos, self.x)
self.type = 'line' '''
self.annot = self.ax.annotate("",
xy=(0, 0),
xytext=(20, 20),
textcoords="offset points",
bbox=dict(boxstyle="round", fc="w"),
arrowprops=dict(arrowstyle="->"))
self.annot.set_visible(False)
self.canvas.mpl_connect("motion_notify_event", self.hover)
'Stock_Index_Price':
[1500, 1520, 1525, 1523, 1515, 1540, 1545, 1560, 1555, 1565]
}
df3 = DataFrame(data3, columns=['Interest_Rate', 'Stock_Index_Price'])
root = tk.Tk()
import matplotlib.backends.backend_tkagg as tkagg
# canvas is your canvas, and root is your parent (Frame, TopLevel, Tk instance etc.)
figure1 = plt.Figure(figsize=(6, 5), dpi=100)
ax1 = figure1.add_subplot(111)
bar1 = FigureCanvasTkAgg(figure1, root)
tkagg.NavigationToolbar2Tk(bar1, root)
bar1.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH)
df1 = df1[['Country', 'GDP_Per_Capita']].groupby('Country').sum()
df1.plot(kind='bar', legend=True, ax=ax1)
ax1.set_title('Country Vs. GDP Per Capita')
figure2 = plt.Figure(figsize=(5, 4), dpi=100)
ax2 = figure2.add_subplot(111)
line2 = FigureCanvasTkAgg(figure2, root)
line2.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH)
df2 = df2[['Year', 'Unemployment_Rate']].groupby('Year').sum()
df2.plot(kind='line', legend=True, ax=ax2, color='r', marker='o', fontsize=10)
ax2.set_title('Year Vs. Unemployment Rate')
figure3 = plt.Figure(figsize=(5, 4), dpi=100)
def method(data_dir: str,
fname_po: str,
fname_pf: str,
objective_names: str = objective_names):
# setup tkinter app instance
window = tk.Tk()
window.title(f"INFRINGER - Variant {variant}")
# load pre-computed paretofront, nadir, ideal, and the scaler
# the data is scaled between 0 and 1 using the nadir and ideal points
nadir, ideal, paretofront, payoff, scaler = load_and_scale_data(
data_dir, fname_po, fname_pf)
nadir = np.squeeze(nadir)
ideal = np.squeeze(ideal)
# used to store a reference point given by the DM
global reference_point
reference_point = None
# show ideal and nadir
def make_table(row_names: [str],
col_names: [str],
data: np.ndarray,
row=1,
column=0):
tframe = tk.Frame(window, height=700, width=500, borderwidth=2)
tframe.grid(row=row, column=column)
entry = tk.Label(tframe, text="", font=const_fontsetting)
entry.grid(row=0, sticky="we")
# set row names
for i, name in enumerate(row_names):
entry = tk.Label(tframe, text=f"{name}", font=const_fontsetting)
entry.grid(row=i + 1, column=0, padx=20, sticky="we")
# set column names
for i, name in enumerate(col_names):
entry = tk.Label(tframe, text=f"{name}", font=const_fontsetting)
entry.grid(row=0, column=i + 1, sticky="we")
# set contents
for i, _ in enumerate(row_names):
for j, _ in enumerate(col_names):
print(f"{(i, j)}")
entry = tk.Label(
tframe,
text=
f"{np.format_float_scientific(data[i, j], precision=2)}",
font=const_fontsetting,
relief="ridge")
entry.grid(row=i + 1,
column=j + 1,
sticky="we",
padx=5,
pady=2.5)
pass
return True
def close_window(frame=window):
frame.quit()
return True
def give_reference_point(nadir: np.ndarray,
ideal: np.ndarray,
to_destroy=None):
# destroy frames
[thing.destroy() for thing in to_destroy]
# build a reference form
reference_frame = tk.Frame(window)
reference_frame.grid(row=4)
lbl = tk.Label(
reference_frame,
text=
"Please specify a reference point with objective values between the nadir and ideal.",
font=const_fontsetting)
lbl.grid(row=0, column=0, columnspan=len(nadir))
reference_point_entry_list = []
for i in range(len(nadir)):
print(i)
lbl_ref = tk.Label(reference_frame, text=f"Objective {i+1}:")
lbl_ref.grid(row=1, column=i)
txt_entry = tk.Entry(reference_frame, font=const_fontsetting)
txt_entry.insert(tk.END, f"{nadir[i]}")
txt_entry.grid(row=2, column=i, sticky="we")
reference_point_entry_list.append(txt_entry)
def check_reference_point():
entry_txt_list = [
entry.get() for entry in reference_point_entry_list
]
try:
res = [float(txt) for txt in entry_txt_list]
res = np.array(res)
except ValueError as e:
tk.messagebox.showerror(
"Error in parsing reference point",
f"Could not parse {entry_txt_list}. Are you sure the entries are numerical?"
)
return False
if not np.all(nadir <= res) or not np.all(res <= ideal):
tk.messagebox.showerror(
"Invalid reference point",
"The given reference point is not between the nadir and ideal points"
)
return False
# good reference point given
global reference_point
reference_point = res
window.quit()
return True
btn_check = tk.Button(reference_frame,
text="Check",
command=check_reference_point)
btn_check.grid(row=3, columnspan=len(nadir), sticky="we", pady=5)
return True
# Start drawing on main window
lbl_idealandnadir = tk.Label(window,
text=f"Ideal and nadir points",
font=const_fontsetting)
lbl_idealandnadir.grid(row=0, padx=250)
# show ideal and nadir
make_table(["nadir", "ideal"], objective_names,
scaler.inverse_transform(np.stack((nadir, ideal))))
# ask if DM wants to give a ref point
lbl_question = tk.Label(window,
text="Would you like to give a reference point?",
pady=5,
font=const_fontsetting)
lbl_question.grid(row=2)
btn_frame = tk.Frame(window)
btn_frame.grid(row=3)
yes_btn = tk.Button(
btn_frame,
text="Yes",
command=lambda: give_reference_point(
scaler.inverse_transform(nadir.reshape(1, -1)).squeeze(),
scaler.inverse_transform(ideal.reshape(1, -1)).squeeze(),
[btn_frame, lbl_question]))
yes_btn.grid(row=0, column=1)
no_btn = tk.Button(btn_frame, text="No", command=close_window)
no_btn.grid(row=0, column=0)
# show window until DM gives valid ref point or chooses not to
window.mainloop()
# clear the main window
[child.destroy() for child in window.winfo_children()]
# normalize reference point if given
if reference_point is not None:
print(f"ref point given: {reference_point}")
reference_point = scaler.transform(reference_point.reshape(
1, -1)).squeeze()
print(f"ref point normed: {reference_point}")
else:
print("ref point not given")
reference_point = np.array([0.5, 0.5, 0.5])
print(f"ref point is {reference_point}")
# show the paretofront
fig_pf = plt.figure(figsize=(8, 6), dpi=120)
fig_pf.suptitle("Paretofront in original scale")
canvas_pf = tkagg.FigureCanvasTkAgg(fig_pf, master=window)
ax_pf = fig_pf.add_subplot(111, projection="3d")
extrema = scaler.inverse_transform(np.stack((nadir, ideal)))
ax_pf.scatter(extrema[0, 0], extrema[0, 1], extrema[0, 2], label="nadir")
ax_pf.scatter(extrema[1, 0], extrema[1, 1], extrema[1, 2], label="ideal")
reference_point_orig = scaler.inverse_transform(
reference_point.reshape(1, -1)).squeeze()
ax_pf.scatter(reference_point_orig[0],
reference_point_orig[1],
reference_point_orig[2],
label="reference point")
paretofront_orig = scaler.inverse_transform(paretofront)
ax_pf.scatter(paretofront_orig[:, 0], paretofront_orig[:, 1],
paretofront_orig[:, 2])
ax_pf.set_xlabel("Income")
ax_pf.set_ylabel("Carbon")
ax_pf.set_zlabel("CHSI")
fig_pf.legend()
canvas_pf.draw()
canvas_pf.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
toolbar_pf = tkagg.NavigationToolbar2Tk(canvas_pf, window)
toolbar_pf.update()
canvas_pf.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
btn_next = tk.Button(window, text="Next", command=lambda: quit(window))
btn_next.pack(side=tk.BOTTOM, fill=tk.X)
# show the 3D plot
window.mainloop()
# clear main window
[child.destroy() for child in window.winfo_children()]
# initialize BRB
# define parameters for the BRB
precedents = np.stack((nadir, reference_point, ideal)).T
consequents = np.array([[0, 0.25, 0.5, 0.75, 1]])
brb = BRBPref(precedents, consequents, f=lambda x: simple_mapping(x))
if variant == 1:
pf_scores = brb_score(brb, paretofront)
pf_scores_mean = np.mean(pf_scores)
pf_scores_std = np.std(pf_scores)
# show pairs to compare and asses fitness of model
dm_choices = ask_preference(window,
brb,
paretofront,
scaler,
nadir=nadir,
ideal=ideal)
# check compatibility
fitness, brb_choices = calculate_fitness(window, brb, dm_choices)
# clear main window
[child.destroy() for child in window.winfo_children()]
# find 5 evenly distributed points (score wise) around the mean to be scored by the DM
target_scores = np.array([
pf_scores_mean - pf_scores_std, pf_scores_mean - pf_scores_std / 2,
pf_scores_mean, pf_scores_mean + pf_scores_std / 2,
pf_scores_mean + pf_scores_std
])
diff_to_target = np.abs(pf_scores[:, None] - target_scores)
score_indices = np.argmin(diff_to_target, axis=0)
points_to_compare = paretofront[score_indices]
# ask DM to score the points
lbl_title = tk.Label(
window,
text="Please score each candidate between 0(worst) and 100(best)",
font=const_fontsetting)
lbl_title.grid(row=0, columnspan=3)
lbl_scoring = tk.Label(window,
text="Candidates",
font=const_fontsetting)
lbl_scoring.grid(row=1, column=0, sticky="we")
make_table([f"Candidate {i+1}" for i in range(len(points_to_compare))],
objective_names,
scaler.inverse_transform(points_to_compare),
row=1,
column=0)
lbl_score = tk.Label(window, text="Score", font=const_fontsetting)
lbl_score.grid(row=1, column=1, sticky="we")
frame_scoring = tk.Frame(window)
frame_scoring.grid(row=1, column=1)
lbl_scoring = tk.Label(frame_scoring,
text="Scores",
font=const_fontsetting)
lbl_scoring.grid(row=0)
candidate_scores_entries = []
for i in range(len(points_to_compare)):
entry_score = tk.Entry(frame_scoring, font=const_fontsetting)
entry_score.grid(row=1 + i, column=0, sticky="we", pady=2.5)
entry_score.insert(tk.END, f"{np.random.randint(0, 101)}")
candidate_scores_entries.append(entry_score)
# show nadir and ideal
lbl_nadirandideal = tk.Label(window,
text="Nadir and ideal points",
font=const_fontsetting)
lbl_nadirandideal.grid(row=1, column=2, sticky="we")
make_table(["nadir", "ideal"],
objective_names,
scaler.inverse_transform(np.stack((nadir, ideal))),
row=1,
column=2)
no_btn = tk.Button(window, text="Cancel", command=close_window)
no_btn.grid(row=4, column=2)
btn_plot = tk.Button(window,
text="Plot",
command=lambda: draw_parallel(
points_to_compare, obj_names=objective_names))
btn_plot.grid(row=4, column=4)
global candidate_scores
candidate_scores = None
def check_scores():
entry_txt_list = [
entry.get() for entry in candidate_scores_entries
]
try:
res = [int(txt) for txt in entry_txt_list]
res = np.array(res) / 100
except ValueError as e:
tk.messagebox.showerror(
"Error in parsing candidate scores",
f"Could not parse {entry_txt_list}. Are you sure the entries are integers?"
)
return False
if not np.all(0 <= res) or not np.all(res <= 1):
tk.messagebox.showerror(
"Invalid candidate score(s)",
"The given candidate score(s)is not between the 0 and 100")
return False
# valid scores given
global candidate_scores
candidate_scores = res
window.quit()
return True
next_btn = tk.Button(window, text="Next", command=check_scores)
next_btn.grid(row=4, column=1)
window.mainloop()
# clear main window
[child.destroy() for child in window.winfo_children()]
tk.messagebox.showinfo(
"Training...",
"The BRB model will be trained now, this might take a while.")
# train BRB
brb.train(
None,
None,
brb._flatten_parameters(),
obj_args=(np.atleast_2d(nadir), np.atleast_2d(ideal),
np.atleast_2d(points_to_compare),
np.atleast_2d(candidate_scores)),
use_de=True,
)
print(brb)
print(brb_score(brb, np.atleast_2d(points_to_compare)))
print(candidate_scores)
if variant == 2:
# check fitness again
dm_choices = ask_preference(window,
brb,
paretofront,
scaler,
nadir=nadir,
ideal=ideal)
fitness, brb_choices = calculate_fitness(window, brb, dm_choices)
if fitness >= 80:
tk.messagebox.showinfo("Success",
"Success! Fitness of over 80% achieveved!")
print("Top 5 best solutions are:")
pf_scores = brb_score(brb, paretofront)
best_5 = np.argsort(pf_scores)[::-1][:5]
print(
f"{paretofront_orig[best_5]}\n with scores {pf_scores[best_5]}"
)
return
tk.messagebox.showinfo(
"Training...",
"The BRB model will be trained now, this might take a while.")
brb.train(
None,
None,
brb._flatten_parameters(),
obj_args=(np.atleast_2d(nadir), np.atleast_2d(ideal), None, None,
dm_choices),
use_de=True,
)
while True:
# clear main window
[child.destroy() for child in window.winfo_children()]
# show value funtion
draw_utility(window, brb)
window.mainloop()
# clear main window
[child.destroy() for child in window.winfo_children()]
# show ranking
draw_ranking(window, brb, paretofront)
window.mainloop()
# clear main window
[child.destroy() for child in window.winfo_children()]
# check fitness again
dm_choices = ask_preference(window,
brb,
paretofront,
scaler,
nadir=nadir,
ideal=ideal)
fitness, brb_choices = calculate_fitness(window, brb, dm_choices)
if fitness >= 80:
tk.messagebox.showinfo("Success",
"Success! Fitness of over 80% achieveved!")
print("Top 5 best solutions are:")
pf_scores = brb_score(brb, paretofront)
best_5 = np.argsort(pf_scores)[::-1][:5]
print(
f"{paretofront_orig[best_5]}\n with scores {pf_scores[best_5]}"
)
draw_parallel(paretofront[best_5])
window.mainloop()
print(brb)
break
tk.messagebox.showinfo(
"Training...",
"The BRB model will be trained now, this might take a while.")
if variant == 1:
brb.train(
None,
None,
brb._flatten_parameters(),
obj_args=(np.atleast_2d(nadir), np.atleast_2d(ideal),
np.atleast_2d(points_to_compare),
np.atleast_2d(candidate_scores), dm_choices),
use_de=True,
)
if variant == 2:
brb.train(
None,
None,
brb._flatten_parameters(),
obj_args=(np.atleast_2d(nadir), np.atleast_2d(ideal), None,
None, dm_choices),
use_de=True,
)
print(brb)
return 0