feherbehebung

Masterarbeit/UIController.py

             "test": self.test
         }
 
+        self.nexts = {
+            "filterXdawn" : self.filterXdawn,
+            "filterClassic": self.filterClassic
+        }
+
         self.pages = {
             "stop": "StartPage",
             "copySpelling": "WorkingPage",
     
     #wird durch Copy-Speller Thread copystelling gestartet -> startete filtern als thread
     def filterXdawn(self):
-        #self.setTitle("start training Xdawn")
-        #self.setInfos("start training Xdawn")
         self.model = Modell(self)
         self.model.setFunktion(self.model.trainXDawn)
         self.model.start()
         self.model.start()
 
     def commandFreeSpelling(self):
-        self.model.freeSpelling()
+        print("freespelling")
+        self.model = Modell(self)
+        self.model.setFunktion(self.model.freeSpelling)
+        self.model.start()
 
     def commandStop(self):
+        self.setInfos("Action: STOP-Command")
+        self.model.stop()
+        self.model.join()
+        self.model.killProzess()
+        self.mode = None    
+
+
+    def stop(self, next=None):
+        print("Stop aus Modell")
         self.model.stop()
         self.model.join()
         self.model.killProzess()
         self.mode = None    
+        if(next is not None):
+            func = self.nexts.get(next)
+            func()
 
     def setInfos(self,text):
         self.view.setInfoText(text)
 
     def setTitle(self,text):
-        self.view.setTitleText(text)   
+        self.view.setTitleText(text)  
+
+    def changeScreen(self, pageName):
+        self.view.changeFrame(pageName=pageName) 
 
 
 

Masterarbeit/UIModell.py

         Thread.__init__(self)
         self.controller  = c
         self.aktiv= True
+        self.openVibeAktiv = False
+        self.infoText = ''
     
     def stop(self):
-        print("stop")
+        print("stop thread")
         self.aktiv = False
     
     def setFunktion(self, func, args=None, kwargs=None):
         self.kwargs = kwargs or {}
     
     def run(self): 
+        print("start thread")
         #self.aktiv = True
         t = Thread(target=self.func, args=self.args, kwargs=self.kwargs)
         t.setDaemon(True)
     
     def startCopySpelling(self):
         print("start copySpelling")
+        self.infoText = 'start copyspelling -- '
+        self.controller.setInfos(self.infoText)
+        self.controller.setTitle("Copy Spelling")
         path = self.PATH_FILES + 'p300-visual-1-acquisition.xml'
         process = Popen(['bash', self.PATH_OV, '--play', path, '--no-gui'], 
                                 stdout=PIPE,
-                                universal_newlines=True)                              
+                                universal_newlines=True)   
+        self.openVibeAktiv = True                           
         while True:
             output = process.stdout.readline()
             print(output.strip())
             x = output.find("schlagwort?")
+            y = output.find("Error")
             if(x != -1):
                 print("Training finished")
                 process.terminate()
+                self.infoText = self.infoText + 'finished Copyspelling\n'
+                self.controller.setInfos(self.infoText)
+                self.controller.stop("filterXdawn")
                 break
-
-        self.killProzess()
-        self.controller.filterXdawn()
+            elif(y != -1 ):
+                print("Error occured")
+                self.controller.changeScreen("StartPage")
+                self.controller.setInfos(self.infoText + "Fehler beim Copyspelling aufgetaucht\n")
+                process.terminate()
+                self.controller.stop()
+                break
+            
+        self.controller.stop()
+        #self.killProzess()
+        #self.controller.filterXdawn()
     
     def trainXDawn(self):
         print("start training Xdawn")
-        self.controller.setTitle("start training with Xdawn")
-        self.controller.setInfos("This may take a while")
-        print("test")
+        self.infoText = self.infoText + 'start training XDawn -- '
+        self.controller.setInfos(self.infoText)
         path = self.PATH_FILES + 'p300-visual-2-train-xDAWN.xml'
         process = Popen(['bash', self.PATH_OV, '--play', path, '--no-gui'], 
                                 stdout=PIPE,
-                                universal_newlines=True)                              
+                                universal_newlines=True)   
+        self.openVibeAktiv = True                             
         while self.aktiv:
             output = process.stdout.readline()
             print(output.strip())
             x = output.find("Training finished and saved")
+            y = output.find("Error")
             if(x != -1):
                 print("Training finished")
                 process.terminate()
+                self.infoText = self.infoText + 'finished Training\n'
+                self.controller.setInfos(self.infoText)
+                self.controller.stop("filterClassic")
+                break
+            elif(y != -1 ):
+                print("Error occured")
+                self.controller.changeScreen("StartPage")
+                self.controller.setInfos(self.infoText + "Fehler beim XDawn Training aufgetaucht\n")
+                self.controller.stop()
+                process.terminate()
                 break
+        
+        self.controller.stop()
 
-        self.controller.setInfos("finished Training with xDawn")  
-        self.killProzess()
         #self.controller.filterClassic()
 
 
     def trainClassifier(self):
         print("start training Classifier")
+        self.infoText = self.infoText + "start training with Classifier -- "
+        self.controller.setInfos(self.infoText)
+
         path = self.PATH_FILES + 'p300-visual-3-train-classifier.xml'
         process = Popen(['bash', self.PATH_OV, '--play', path, '--no-gui'], 
                                 stdout=PIPE,
-                                universal_newlines=True)                              
+                                universal_newlines=True)       
+        self.openVibeAktiv = True                         
         while True:
             output = process.stdout.readline()
             print(output.strip())
             x = output.find("schlagwort?")
+            y = output.find("Error")
             if(x != -1):
                 print("Training finished")
+                self.infoText = self.infoText + 'finished Training\n'
+                self.controller.setInfos(self.infoText)
+                process.terminate()
+                break
+            elif(y != -1 ):
+                print("Error occured")
+                self.controller.changeScreen("StartPage")
+                self.controller.setInfos(self.infoText + "Fehler beim Classifier Training aufgetaucht\n")
                 process.terminate()
                 break
 
-        self.killProzess()
+        self.controller.changeScreen("StartPage")
+        self.controller.stop()
 
     def freeSpelling(self):
+        #bei error auch abrechen?
         print("start freeSpelling")
+        self.infoText = 'start free spelling -- '
+        self.controller.setInfos(self.infoText)
         path = self.PATH_FILES + 'p300-visual-4-online.xml'
         process = Popen(['bash', self.PATH_OV, '--play', path, '--no-gui'], 
                                 stdout=PIPE,
-                                universal_newlines=True)                              
+                                universal_newlines=True)        
+        self.openVibeAktiv = True                        
         while True:
             output = process.stdout.readline()
             print(output.strip())
-            x = output.find("schlagwort?")
+            y = output.find("Error")
+            x = output.find("Schlagwort")
             if(x != -1):
                 print("End Spelling")
                 process.terminate()
+                self.infoText = self.infoText + 'finished freespelling\n'
+                self.controller.setInfos(self.infoText)
+                self.controller.changeScreen("StartPage")
+                self.controller.stop()
+                break
+            elif(y != -1 ):
+                print("Error occured")
+                self.controller.changeScreen("StartPage")
+                self.controller.setInfos(self.infoText + "Fehler beim Freespelling aufgetaucht\n")
+                process.terminate()
+                self.controller.stop()
                 break
 
-        self.killProzess()
+        self.controller.changeScreen("StartPage")
+        self.controller.stop()
 
     def killProzess(self):
-        print('start killing')
-        pidOV = 0
-        pidP = 0
-        items = []
-
-        prozesse = Popen(["ps", "-e"], stdout=PIPE).communicate()[0].strip()
-        zeilen = prozesse.split('\n')
-        for z in zeilen:
-            if(z.find("openvibe-design") != -1):
-                z = z.strip()
-                items = z.split(' ')
-                pidOV = items[0]
-        
-        #kill -TERM veranlasst dem Prozess sich selbst zu beenden (nicht erzwungen)
-        Popen(["kill", "-TERM", pidOV], stdout=PIPE).communicate()
-
-
-        print("killed openvibe-designer")
+        if(self.openVibeAktiv):
+            self.openVibeAktiv = False
+            print('start killing')
+            pidOV = 0
+            items = []
+
+            prozesse = Popen(["ps", "-e"], stdout=PIPE).communicate()[0].strip()
+            zeilen = prozesse.split('\n')
+            for z in zeilen:
+                if(z.find("openvibe-design") != -1):
+                    z = z.strip()
+                    items = z.split(' ')
+                    pidOV = items[0]
+            
+            #kill -TERM veranlasst dem Prozess sich selbst zu beenden (nicht erzwungen)
+            Popen(["kill", "-TERM", str(pidOV)], stdout=PIPE).communicate()
+
+
+            print("killed openvibe-designer")
 
 
 

Masterarbeit/UIViewTKinter.py

             self.container.configure(height=(self.h*self.faktor[1]), width=self.w)
             for f in self.frames:
                 self.frames[f].configure(height=(self.h*self.faktor[1]), width=self.w)
+                self.frames[f].adjustSize(height=(self.h*self.faktor[1]), width=self.w/2)
 
 
     def onClosing(self):
           
     def createBottomFrame(self):
         self.bottomFrame = Frame(self, bg="green", height=100, width=500)
+        self.bottomlabel = Label(self.bottomFrame, text="Hier stehen Infos\nGanz viele", justify='left')
+
+        #self.bottomFrame.columnconfigure(0, weight=1)   # Set weight to row and 
+        #self.bottomFrame.rowconfigure(0, weight=1)      # column where the widget is
+
         self.bottomFrame.grid(column=0, row=2)
         self.bottomFrame.pack_propagate(0)
+        self.bottomFrame.grid_propagate(0)
 
-        self.bottomlabel = Label(self.bottomFrame, text="Hier stehen Infos")
-        self.bottomlabel.pack()  
+        self.bottomlabel.grid(padx=5,pady=5)  
 
     def setInfoText(self, text):
         self.bottomlabel['text'] = text
         self.pack_propagate(0)
         self.controller = controller
 
-        testBtn = Button(self, text="test", command=lambda: self.controller.actionPerformed("test"), height=6, width = 10)
-        testBtn.grid(row=0, column=0)
+        self.leftFrame = Frame(self, bg="cyan", height=250, width=250)
+        self.rightFrame = Frame(self, bg="blue", height=250, width=250)
+
+        self.leftFrame.columnconfigure(0, weight=1)   # Set weight to row and 
+        self.leftFrame.rowconfigure(0, weight=1)      # column where the widget is
+        self.leftFrame.grid_propagate(0)
+        self.leftFrame.pack_propagate(0)
+
+        self.rightFrame.columnconfigure(0, weight=1)   # Set weight to row and 
+        self.rightFrame.rowconfigure(0, weight=1)      # column where the widget is
+        self.rightFrame.grid_propagate(0)
+        self.rightFrame.pack_propagate(0)
+
+        self.leftFrame.grid(column=0, row=0)
+        self.rightFrame.grid(column=1, row=0)
 
-        freeSpellingBtn = Button(self, text="freeSpelling", command=lambda: self.controller.actionPerformed("freeSpelling"), height=6, width = 10)
-        freeSpellingBtn.grid(row=0, column=1)
+        testBtn = Button(self.leftFrame, text="test", command=lambda: self.controller.actionPerformed("test"), height=6, width = 10)
+        testBtn.grid()
+
+        freeSpellingBtn = Button(self.rightFrame, text="freeSpelling", command=lambda: self.controller.actionPerformed("freeSpelling"), height=6, width = 10)
+        freeSpellingBtn.grid()
+
+    def adjustSize(self, height, width):
+        self.leftFrame.configure(height=height, width= width)
+        self.rightFrame.configure(height=height, width= width)
 
 class WorkingPage(Frame):
     def __init__(self, parent, controller):
         Frame.__init__(self, parent)
         self.controller = controller
+
+        self.columnconfigure(0, weight=1)   # Set weight to row and 
+        self.rowconfigure(0, weight=1)      # column where the widget is
+
         stopBtn = Button(self, text="stop", command=lambda: self.controller.actionPerformed("stop"), height=6, width = 10)
-        stopBtn.pack()
+        stopBtn.grid()
+
+    def adjustSize(self, height, width):
+        pass