Fixed FSA interface to show X, S and Y

interface/FSA/main.py

@@ -3,6 +3,9 @@ matplotlib.use("TkAgg")
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 from matplotlib.figure import Figure
 
+from matplotlib import rcParams
+rcParams.update({'figure.autolayout': True})
+
 from Tkinter import *
 from PIL import Image, ImageTk
 import tkSimpleDialog
@@ -13,9 +16,9 @@ import json
 
 import time
 
-JUMP = 25
-MAX_WIDTH = 20 * JUMP
-MAX_HEIGHT = 20 * JUMP
+JUMP = 50
+MAX_WIDTH = 10 * JUMP
+MAX_HEIGHT = 10 * JUMP
 CLICK_TOLERANCE = 5
 address = "http://127.0.0.1:8001"
 username = "test"
@@ -39,16 +42,13 @@ class FakeLayer():
         pass
 
     def read_available_attributes(self, name):
-        if self.types[name] == "const":
-            return ["value"]
-        else:
-            return []
+        return [("name", "String")]
 
     def read_attribute(self, name, attr):
-        return self.attr.get(name, {}).get(attr, None)
+        return self.attrs.get(name, {}).get(attr, None)
 
     def set_attribute(self, name, attr, value):
-        self.attrs[name][attr] = value
+        self.attrs.setdefault(name, {})[attr] = value
 
     def instantiate_block(self, name, block_type):
         self.types[name] = block_type
@@ -65,6 +65,9 @@ class FakeLayer():
     def pause(self):
         pass
 
+    def delete(self):
+        pass
+
 attribute = []
 available_attrs = []
 simulation = []
@@ -220,7 +223,7 @@ class InterfaceCore():
                     if lname in names:
                         self.canvas.delete(names[lname])
                         del names[lname]
-                    entry = [x for x in self.drawn if x[4] == lname]
+                    entry = [x for x in self.drawn if str(x[4]) == str(lname)][0]
                     xc, xy = avg(entry[0], entry[2]), avg(entry[1], entry[3])
                     names[lname] = self.canvas.create_text(xc, xy, text=new_value)
 
@@ -247,7 +250,7 @@ class InterfaceCore():
                 distance = abs((y2 - y1) * x0 - (x2 - x1) * y0 + x2 * y1 - y2 * x1) / sqrt((y2 - y1) ** 2 + (x2 - x1) ** 2) - CLICK_TOLERANCE
             elif e[5] == "NODE":
                 if x0 <= x2 and x0 > x1 and y0 <= y2 and y0 > y1:
-                        distance = -float("inf")
+                        distance = 0.0
                 else:
                     distance = float("inf")
             matches.append((distance, e[4]))
@@ -325,33 +328,88 @@ visual = Toplevel(root)
 
 # Example:
 #    simulation = [(1, "A"), (3, "B"), (4, "A")]
-simulation = [(1, "A"), (3, "B"), (4, "A")]
+#inp_evts = [(2, "arm"), (6, "detected")]
+#state = [(0, "idle"), (2, "armed"), (6, "detected"), (8, "idle")]
+#outp_evts = [(6, "soundAlarm"), ]
+
+inp_evts = []
+state = []
+outp_evts = []
 
 frame = Frame(visual)
 frame.pack(fill=BOTH,expand=True)
 
-f = Figure()
-a = f.add_subplot(111)
-a.plot([], [])
-f.suptitle("Events")
+figsize = (6, 3)
+f_inp = Figure(figsize=figsize)
+a_inp = f_inp.add_subplot(111)
+a_inp.plot([], [])
+f_inp.suptitle("Inputs")
+
+fcanvas_inp = FigureCanvasTkAgg(f_inp, frame)
+fcanvas_inp.show()
+fcanvas_inp.get_tk_widget().pack()
 
-fcanvas = FigureCanvasTkAgg(f, frame)
-fcanvas.show()
-fcanvas.get_tk_widget().pack()
+f_state = Figure(figsize=figsize)
+a_state = f_state.add_subplot(111)
+a_state.plot([], [])
+f_state.suptitle("State")
 
-reverse_lookup = {}
+fcanvas_state = FigureCanvasTkAgg(f_state, frame)
+fcanvas_state.show()
+fcanvas_state.get_tk_widget().pack()
+
+f_outp = Figure(figsize=figsize)
+a_outp = f_outp.add_subplot(111)
+a_outp.plot([], [])
+f_outp.suptitle("Outputs")
+
+fcanvas_outp = FigureCanvasTkAgg(f_outp, frame)
+fcanvas_outp.show()
+fcanvas_outp.get_tk_widget().pack()
+
+reverse_lookup_inp = {}
+reverse_lookup_state = {}
+reverse_lookup_outp = {}
 
 def update_graphs():
-    times = [x[0] for x in simulation]
-    events = [reverse_lookup.setdefault(x[1], len(reverse_lookup)) for x in simulation]
-    lookup = [None] * len(reverse_lookup)
-    for k, v in reverse_lookup.items():
+    # Input events
+    times = [x[0] for x in inp_evts]
+    events = [reverse_lookup_inp.setdefault(x[1], len(reverse_lookup_inp)) for x in inp_evts]
+    lookup = [None] * len(reverse_lookup_inp)
+    for k, v in reverse_lookup_inp.items():
+        lookup[v] = k
+    a_inp.clear()
+    a_inp.plot(times, events, linestyle="none", marker="o")
+    #f_inp.get_axes()[0].set_xbound(lower=0.0, upper=10.0)
+    f_inp.get_axes()[0].set_yticks(range(-2, len(lookup) + 2))
+    f_inp.get_axes()[0].set_yticklabels(["", ""] + lookup + ["", ""])
+    fcanvas_inp.draw()
+
+    # States
+    times = [x[0] for x in state]
+    events = [reverse_lookup_state.setdefault(x[1], len(reverse_lookup_state)) for x in state]
+    lookup = [None] * len(reverse_lookup_state)
+    for k, v in reverse_lookup_state.items():
+        lookup[v] = k
+    a_state.clear()
+    a_state.plot(times, events, linestyle="solid", marker="o", drawstyle="steps-post")
+    #f_state.get_axes()[0].set_xbound(lower=0.0, upper=10.0)
+    f_state.get_axes()[0].set_yticks(range(-2, len(lookup) + 2))
+    f_state.get_axes()[0].set_yticklabels(["", ""] + lookup + ["", ""])
+    fcanvas_state.draw()
+
+    # Input events
+    times = [x[0] for x in outp_evts]
+    events = [reverse_lookup_outp.setdefault(x[1], len(reverse_lookup_outp)) for x in outp_evts]
+    lookup = [None] * len(reverse_lookup_outp)
+    for k, v in reverse_lookup_outp.items():
         lookup[v] = k
-    a.clear()
-    a.plot(times, events, linestyle="none", marker="o")
-    f.get_axes()[0].set_yticks(range(-2, len(lookup) + 2))
-    f.get_axes()[0].set_yticklabels(["", ""] + lookup + ["", ""])
-    fcanvas.draw()
+    a_outp.clear()
+    a_outp.plot(times, events, linestyle="none", marker="o")
+    #f_outp.get_axes()[0].set_xbound(lower=0.0, upper=10.0)
+    f_outp.get_axes()[0].set_yticks(range(-2, len(lookup) + 2))
+    f_outp.get_axes()[0].set_yticklabels(["", ""] + lookup + ["", ""])
+    fcanvas_outp.draw()
     root.after(500, update_graphs)
 
 root.after(500, update_graphs)