def animatStatWindow(self, anim):
stats = anim.getStats()
win = tk.Toplevel(height=600, width=700)
#title and icon
win.title("Animat Stats")
# icon = tk.Label(win,image=self.aImage,relief="ridge")
# icon.place(x=20,y=20)
#stat list
title = tk.Label(win,
text="Stats for Animat: " + str(anim.id),
font="bold",
relief="ridge",
padx=5,
pady=5)
type_l = tk.Label(win, text=("Type: "))
type_t = tk.Text(win, height=1, width=30, bg="grey")
type_t.insert(tk.END, str(anim.__class__))
nrg_l = tk.Label(win, text=("Energy: "))
nrg_t = tk.Text(win, height=1, width=30, bg="grey")
nrg_t.insert(tk.END, str(anim.Energy))
title2 = tk.Label(win,
text="Internals",
font="bold",
relief="ridge",
padx=5,
pady=5)
cme_l = tk.Label(win, text=("cMotionEnergy: "))
cme_t = tk.Text(win, height=1, width=30, bg="grey")
cme_t.insert(tk.END, str(anim.cMotionEnergy))
kbe_l = tk.Label(win, text=("kBasalEnergy: "))
kbe_t = tk.Text(win, height=1, width=30, bg="grey")
kbe_t.insert(tk.END, str(anim.kBasalEnergy))
tab_box = TabBox(win, [20, 250, 620, 550], toolbar=True)
count = 1
for type in self.tracked_types:
f = Figure(figsize=(5, 4), dpi=50)
a = f.add_subplot(111)
t = self.tracked_data[anim.id][type].keys()
s = self.tracked_data[anim.id][type].values()
if type == self.TRACK_NEURAL_FIRINGS:
t = []
s = []
for ti in self.tracked_data[anim.id][type].keys():
for si in self.tracked_data[anim.id][type][ti][0]:
t.append(ti)
s.append(si)
if type == self.TRACK_POS:
t = []
s = []
for ti in self.tracked_data[anim.id][type].keys():
t.append(self.tracked_data[anim.id][type][ti][0])
s.append(self.tracked_data[anim.id][type][ti][1])
if type == self.TRACK_NEURAL_FIRINGS:
a.plot(t, s, '.k')
else:
a.plot(t, s, '-k')
canvas = FigureCanvasTkAgg(f, master=win)
tbcan = tab_box.add_canvas(canvas.get_tk_widget(), type)
NavigationToolbar2TkAgg(canvas, tbcan)
#placements
title.place(x=300, y=20)
type_l.place(x=300, y=60)
type_t.place(x=390, y=60)
nrg_l.place(x=300, y=90)
nrg_t.place(x=390, y=90)
title2.place(x=300, y=130)
cme_l.place(x=300, y=170)
cme_t.place(x=390, y=170)
kbe_l.place(x=300, y=200)
kbe_t.place(x=390, y=200)
def __init__(self, master, devWin, simParams):
self.sP = simParams
#some parameters
self.paused = False # whether simulation playback is paused
self.simRunning = True # whether simulation is running - so buffering to GUI
self.lastTime = 0 # the last time on the clock
self.sim_msps = 0 # how many simulated milliseconds pass per second in display: i.e., a value of 1000 means real-time - useful for animat moving, but too fast to see neural activity
self.dis_t = 1 #the time being currently displayed by the GUI
self.buff_t = 0 #the time buffered by the Simulation Engine
self.writeInterval = 25 # sets the interval between write states (in simulated ms);
self.simHistory = {} # dictionary of time: dynamic world state
self.tracked_data = collections.defaultdict(
lambda: collections.defaultdict(lambda: collections.OrderedDict()
)) # not clear what this is; SH
self.TRACK_NEURAL_FIRINGS = "Neural Firings"
self.TRACK_ENERGY = "Energy"
self.TRACK_POS = "Position"
self.TRACK_LFP = "LFP" # probably should give this another name
self.tracked_types = []
self.simEngine = SimulationEngine() #constructs a Simulation Engine
self.world = 0 #placeholder for the World currently being displayed
self.devWin = devWin # development window is parent; use this to set up parameters
#some general-purpose colors
self.colorWhite = "#ffffff"
self.colorGrey = "#dddddd"
self.colorBlack = "#000000"
self.colorLightBlue = "#ADD8E6"
self.colorBlue = "#0000ff"
self.colorRed = "#ff0000"
self.colorGreen = "#00ff00"
#setting up Tk window
self.root = master # window passed in
self.root.title("Animat Simulation")
self.canvas = tk.Canvas(self.root, width=1280, height=720)
self.canvas.pack()
#set up file options to save simulations
self.file_opt = options = {}
options['defaultextension'] = '.sim'
options['filetypes'] = [('all files', '.*'), ('text files', '.txt'),
('Simulation Files', '.sim')]
#options['initialdir'] = 'C:\\'
options['initialfile'] = '.sim'
options['parent'] = self.root
options['title'] = 'Save Simulation As...'
#set up menu bar
self.menubar = tk.Menu(self.root)
filemenu = tk.Menu(self.menubar, tearoff=0)
filemenu.add_command(label="Save Current Simulation",
command=self.saveCurrentSimulation)
filemenu.add_command(label="Load Simulation from File",
command=self.loadSimulationFromFile)
filemenu.add_command(label="Calculate Benchmark",
command=self.benchmark)
filemenu.add_separator()
filemenu.add_command(label="Exit", command=self.quit)
self.menubar.add_cascade(label="File", menu=filemenu)
speedmenu = tk.Menu(self.menubar, tearoff=0)
speedCheckVar = tk.IntVar()
speedmenu.add_radiobutton(label="1ms",
variable=speedCheckVar,
command=lambda: self.setWriteInterval(1))
speedmenu.add_radiobutton(label="25ms",
variable=speedCheckVar,
command=lambda: self.setWriteInterval(25))
speedmenu.add_radiobutton(label="50ms",
variable=speedCheckVar,
command=lambda: self.setWriteInterval(50))
speedmenu.add_radiobutton(label="100ms",
variable=speedCheckVar,
command=lambda: self.setWriteInterval(100))
speedmenu.add_radiobutton(label="1s",
variable=speedCheckVar,
command=lambda: self.setWriteInterval(1000))
speedmenu.add_radiobutton(label="Do not write", variable=speedCheckVar)
speedmenu.invoke(1) #default write interval is 100
worldmenu = tk.Menu(self.menubar, tearoff=0)
worldVar = tk.IntVar() #not used just required
worldmenu.add_radiobutton(label="World 1",
variable=worldVar,
command=lambda: self.setWorldNum(1))
worldmenu.add_radiobutton(label="World 2",
variable=worldVar,
command=lambda: self.setWorldNum(2))
worldmenu.add_radiobutton(label="World 3",
variable=worldVar,
command=lambda: self.setWorldNum(3))
worldmenu.add_radiobutton(label="World 4",
variable=worldVar,
command=lambda: self.setWorldNum(4))
worldmenu.add_radiobutton(label="World 5",
variable=worldVar,
command=lambda: self.setWorldNum(5))
speedmenu.invoke(self.sP.worldToRun - 1) #default write interval is 25
editmenu = tk.Menu(self.menubar, tearoff=0)
editmenu.add_cascade(label="Write Interval", menu=speedmenu)
editmenu.add_cascade(label="World to Run", menu=worldmenu)
editmenu.add_command(label="Parameters", command=self.showDevWin)
self.menubar.add_cascade(label="Edit", menu=editmenu)
trackmenu = tk.Menu(self.menubar, tearoff=0)
trackmenu.add_checkbutton(
label="Neural Firings",
command=lambda: self.track(self.TRACK_NEURAL_FIRINGS))
trackmenu.add_checkbutton(
label="Energy", command=lambda: self.track(self.TRACK_ENERGY))
trackmenu.add_checkbutton(label="Position",
command=lambda: self.track(self.TRACK_POS))
trackmenu.add_checkbutton(label="LFP",
command=lambda: self.track(self.TRACK_LFP))
trackmenu.invoke(0)
trackmenu.invoke(1)
trackmenu.invoke(2)
trackmenu.invoke(3)
self.menubar.add_cascade(label="Track", menu=trackmenu)
viewMenu = tk.Menu(self.menubar, tearoff=0)
viewMenu.add_command(label="Internal Variables",
command=self.varViewer)
viewMenu.add_command(label="Connection Viewer",
command=self.connectionViewer)
self.menubar.add_cascade(label="View", menu=viewMenu)
debugMenu = tk.Menu(self.menubar, tearoff=0)
debugMenu.add_command(label="Print S", command=self.printS)
debugMenu.add_command(label="Print RL", command=self.printRL)
self.menubar.add_cascade(label="Debug", menu=debugMenu)
self.root.config(menu=self.menubar)
#initialize the graphs and video control bar
self.worldGraph = Graph(self.root, [100, 50, 500, 475],
[-10, 10, -10, 10])
self.worldGraph.title('World')
self.worldGraph.xlabel('distance')
self.neuron_graphs = {}
self.neuron_box = TabBox(self.root, [600, 50, 1000, 475])
self.videoBar = VideoBar(self.canvas, (100, 515, 500, 525), (0, 15000),
self.timeClicked)
#some images--will probably eventually go in respective classes (static state) - can remove
self.animatImage = Image.open("roomba.png")
self.aImage = ImageTk.PhotoImage(self.animatImage)
self.foodImage = Image.open("beer.png")
self.fImage = ImageTk.PhotoImage(self.foodImage)
playImage = ImageTk.PhotoImage(
Image.open("play.png").resize((40, 40), Image.ANTIALIAS))
pauseImage = ImageTk.PhotoImage(
Image.open("pause.png").resize((40, 40), Image.ANTIALIAS))
stopImage = ImageTk.PhotoImage(
Image.open("stop.png").resize((40, 40), Image.ANTIALIAS))
restartImage = ImageTk.PhotoImage(
Image.open("restart.png").resize((40, 40), Image.ANTIALIAS))
step_fImage = ImageTk.PhotoImage(
Image.open("step_f.png").resize((40, 40), Image.ANTIALIAS))
step_bImage = ImageTk.PhotoImage(
Image.open("step_b.png").resize((40, 40), Image.ANTIALIAS))
continueImage = ImageTk.PhotoImage(
Image.open("continue.png").resize((40, 40), Image.ANTIALIAS))
#video control buttons
self.playButton = tk.Button(self.root,
command=self.play,
image=playImage,
relief='sunken')
self.playButton.place(x=100, y=545)
self.pauseButton = tk.Button(self.root,
command=self.pause,
image=pauseImage,
relief='raised')
self.pauseButton.place(x=155, y=545)
# self.stopButton = tk.Button(self.root, command = self.stop, image = stopImage)
# self.stopButton.place(x=320, y=545)
self.restartButton = tk.Button(self.root,
command=self.restart,
text="Start New Simulation")
self.restartButton.place(x=320, y=575)
self.step_bButton = tk.Button(self.root,
command=self.step_b,
image=step_bImage)
self.step_bButton.place(x=210, y=545)
self.step_fButton = tk.Button(self.root,
command=self.step_f,
image=step_fImage)
self.step_fButton.place(x=265, y=545)
# self.continueButton = tk.Button(self.root, command = self.continue_, image = continueImage)
# self.continueButton.place(x=430, y=545)
self.simCtrlButton = tk.Button(self.root,
command=self.simCtrl,
text="Stop Simulation",
bg='red')
self.simCtrlButton.place(x=320, y=545)
# Buttons using images
# self.playButton = tk.Button(self.root, command = self.play, text="Play", relief='sunken')
# self.playButton.place(x = 100,y=545)
# self.pauseButton = tk.Button(self.root, command = self.pause, text="Pause", relief='raised')
# self.pauseButton.place(x=155,y=545)
# # self.stopButton = tk.Button(self.root, command = self.stop, image = stopImage)
# # self.stopButton.place(x=320, y=545)
# self.restartButton = tk.Button(self.root, command = self.restart, text="Start New Simulation")
# self.restartButton.place(x=320, y=575)
# self.step_bButton = tk.Button(self.root, command = self.step_b, text = "Step <-")
# self.step_bButton.place(x=210,y=545)
# self.step_fButton = tk.Button(self.root, command = self.step_f, text = "Step ->")
# self.step_fButton.place(x=265, y=545)
# # self.continueButton = tk.Button(self.root, command = self.continue_, image = continueImage)
# # self.continueButton.place(x=430, y=545)
# self.simCtrlButton = tk.Button(self.root, command=self.simCtrl, text="Stop Simulation",bg='red')
# self.simCtrlButton.place(x=320,y=545)
#speed lock buttons
self.speedButtons = tk.IntVar()
rb1 = tk.Radiobutton(self.root,
text="Real-Time",
variable=self.speedButtons,
value=1,
command=self.realTime)
rb1.place(x=100, y=600)
rb2 = tk.Radiobutton(self.root,
text="Synced",
variable=self.speedButtons,
value=2,
command=self.synced)
rb3 = tk.Radiobutton(self.root,
text="Select:",
variable=self.speedButtons,
value=3,
command=self.chooseSpeed)
rb2.place(x=100, y=630)
rb3.place(x=100, y=660)
spdlabel = self.canvas.create_text(357,
635,
text="Select Speed (ms/s)")
self.speedScale = tk.Scale(self.root,
from_=0,
to=500,
orient="horizontal",
length=300)
self.speedScale.place(x=215, y=645)
rb3.invoke() #needs to be called after speed scale is created
#Create legend for neuron map
tk.Label(self.root,
text="Neural Network Legend",
font="bold",
relief="ridge",
padx=5,
pady=5).place(x=1050, y=100)
#inhib_t = tk.Label(self.root, text="Inhibitory Neuron: ")
#inhib_t.place(x=1050,y=150)
#inhib_c = self.canvas.create_oval(1175,150,1200,175, fill = "#b1b1ff")
tk.Label(self.root, text="Excitatory Neuron: ").place(x=1050, y=150)
self.canvas.create_oval(1200,
150,
1225,
175,
fill=NeuronModule.ExcitatoryNeuron(0, 0,
0).color)
tk.Label(self.root, text="Hunger Neuron: ").place(x=1050, y=200)
self.canvas.create_oval(1200,
200,
1225,
225,
fill=NeuronModule.HungerNeuron(0, 0, 0).color)
tk.Label(self.root, text="Motor Neuron: ").place(x=1050, y=250)
self.canvas.create_oval(1200,
250,
1225,
275,
fill=NeuronModule.MotorNeuron(0, 0, 0).color)
tk.Label(self.root, text="Sensory Neuron A: ").place(x=1050, y=300)
self.canvas.create_oval(1200,
300,
1225,
325,
fill=NeuronModule.SensoryNeuron_A(0, 0,
0).color)
tk.Label(self.root, text="Sensory Neuron B: ").place(x=1050, y=350)
self.canvas.create_oval(1200,
350,
1225,
375,
fill=NeuronModule.SensoryNeuron_B(0, 0,
0).color)
#pack up the Frame and run
mainContainer = tk.Frame(self.root)
mainContainer.pack()
self.run() #runs a simulation, for now
self.root.mainloop() #starts the Tkinter event loop
