OneEye Changeset - 52d1a214c032

Changeset - 52d1a214c032

Parent rev.

Child rev.

[Not reviewed]

default

1 3 1

Laman - 6 years ago 2018-12-12 22:38:32

refactoring and documenting API

5 files changed with 34 insertions and 46 deletions:

overview.md

project.md

src/core.py

src/gui/__init__.py

src/gui/mainwindow.py

0 comments (0 inline, 0 general)

overview.md

➞

Show inline comments

@@ new file 100644 @@
 Processes and threads
 =====================
 Processes communicate through MsgQueues (a wrapper around multiprocessing.Queue). Each owns one incoming and holds any number of outcoming queues. The queue runs in one thread, reads messages and calls handlers on its owner.
 Core
 ----
 * Main process, starts GUI and VideoCapture. Waits for them to finish.
 * Runs ImageAnalyzer and StateBag.
 * Messages API:
 	* putFrame(frame)
 	* setParams(params)
 	* fetchFrame(key)
 	* fetchParams(params)
 GUI
 ---
 * Presents data for the user, handles user input.
 VideoCapture
 ------------
 * Consumes a video stream, sending captured frames to Core.
@@ \ No newline at end of file @@

project.md

➞

Show inline comments

deleted file

src/core.py

➞

Show inline comments

 import multiprocessing
 import threading
 import logging
 import PIL
 import config as cfg
 from util import MsgQueue
 from gui import gui
 from analyzer import ImageAnalyzer
 from analyzer.framecache import FrameCache
 from go.core import Go, isLegalPosition
 from statebag import StateBag
 from video import capVideo
 import config as cfg
 log=logging.getLogger(__name__)
 class Core:
 	def __init__(self):
 		self.grid=None
 		self.go=Go()
 		self.detector=ImageAnalyzer()
 		self._cache=FrameCache()
 		self.states=StateBag()
 		self._ownMessages=MsgQueue(self._handleEvent)
 		self._guiMessages=MsgQueue()
 		self._vidMessages=MsgQueue()
 		self._frame=None
 		self._guiProc=multiprocessing.Process(name="gui", target=gui, args=(self._guiMessages,self._ownMessages))
 		self._guiProc.start()
 		self._vidProc=multiprocessing.Process(
 			name="video",
 			target=capVideo,
 			args=(cfg.misc.video, self._vidMessages,self._ownMessages)
+		)
 		self._vidProc.start()
-	def showFrame(self,key):
+	def fetchFrame(self,key):
 		frame=self._cache.get(key)
 		if frame is None:
 			(key,frame)=self._cache.getRelative(10)
-		self._guiMessages.send("setCurrentFrame", (frame.copy(), gui.PREVIEW, key))
+		self._guiMessages.send("setFrame", (frame.copy(), gui.PREVIEW, key))
 	def putFrame(self,frame):
 		self._frame=PIL.Image.fromarray(frame)
 		k=self._cache.put(self._frame)
-		self._guiMessages.send("setCurrentFrame", (self._frame, gui.RECORDING, k))
+		self._guiMessages.send("setFrame", (self._frame, gui.RECORDING, k))
 		self.analyze()
 	def sendParams(self):
 		self._guiMessages.send("setParams",(self.detector.params.copy(),))
 	def setParams(self,params):
 		self.detector.setParams(params)
 	def analyze(self):
 		if self.detector.analyze(self._frame):
 			if isLegalPosition(self.detector.board):
 				state=self.states.pushState(self.detector.board)
 				rec=[]
 				if state:
 					rec=state.exportRecord()
 					log.debug("progressive game record: %s",rec)
 				self._guiMessages.send("setGameState", (self.detector.board,rec))
 				self.go.transitionMove(self.detector.board)
 				log.debug("conservative game record: %s",self.go._record)
 			else:
 				log.info("illegal position detected")
 	def listen(self):
 		listenerThread=threading.Thread(target=lambda: self._ownMessages.listen())
 		listenerThread.start()
 	def joinChildren(self):
 		self._guiProc.join()
 		self._vidMessages.send("shutDown")
 		self._vidProc.join()
 		self._ownMessages.send("!kill",("core",))
 	def _handleEvent(self,e):
 		actions={
 			"prevFrame": lambda: self.relativeFrame(-1),
 			"nextFrame": lambda: self.relativeFrame(1),
 			"fetchFrame": self.fetchFrame,
 			"putFrame": self.putFrame,
 			"fetchParams": self.sendParams,
 			"setParams": self.setParams
+		}
 		(actionName,args,kwargs)=e
 		return actions[actionName](*args,**kwargs)
 if __name__=="__main__":
 	core=Core()
 	core.listen()
 	log.info("OneEye started.")
 	core.joinChildren()
 	log.info("Exited correctly.")
 """
 core
 ====
 grid
 go
 imageAnalyzer
 gui
 ===
 corners
 a) keeps references to important objects and uses them
 b) gets and sets all relevant data through method calls with core
 GUI
 <- addCorner(corner)
 -> redrawImgView(img,grid)
 <- refreshTresholds(tresB,tresW)
 BoardView
 -> redrawState(go)
 core-gui: just pass messages with relevant data (!! always pass object copies, don't share instances)
 """
@@ \ No newline at end of file @@

src/gui/__init__.py

➞

Show inline comments

 import logging
 import threading
 import tkinter as tk
 import config
 from analyzer import ImageAnalyzer
 from .mainwindow import MainWindow
 from .boardview import BoardView
 from .settings import Settings
 log=logging.getLogger(__name__)
 class GUI:
 	SETUP=PREVIEW=0
 	RECORDING=REAL=1
 	def __init__(self):
 		self.root = tk.Tk()
 		self.root.title("OneEye {0}.{1}.{2}".format(*config.misc.version))
 		self.root.option_add('*tearOff',False) # for menu
 		self.detector=ImageAnalyzer()
 		self._frameKey=0
 		self._ownMessages=None
 		self._coreMessages=None
 		self._state=GUI.SETUP
 		self.mainWindow = MainWindow(self, master=self.root)
 		self.settings=None
 		self.root.columnconfigure(0,weight=1)
 		self.root.rowconfigure(0,weight=1)
 		self.root.bind("<<redrawImgView>>", lambda e: self.mainWindow.redrawImgView())
 		self.root.bind("<<setUp>>", lambda e: self.setUp())
 		self.root.bind("<<setRecording>>", lambda e: self.setRecording())
 		self.root.bind("<F12>",lambda e: Settings(self))
 		self.mainWindow.bind("<Destroy>",lambda e: self._ownMessages.send("!kill",("gui",)))
 		self.setUp()
 	def __call__(self,ownMessages,coreMessages):
 		self._ownMessages=ownMessages
 		self._coreMessages=coreMessages
 		self.listenerThread=threading.Thread(target=lambda: ownMessages.listen(self._handleEvent))
 		self.listenerThread.start()
 		self.mainWindow.mainloop()
 	def sendMsg(self,actionName,args=tuple(),kwargs=None):
 		self._coreMessages.send(actionName,args,kwargs)
 	def setUp(self):
 		self.mainWindow.setUp()
 		self.root.bind("<Left>",lambda e: self.sendMsg("prevFrame"))
 		self.root.bind("<Right>",lambda e: self.sendMsg("nextFrame"))
 	def setRecording(self):
 		self.mainWindow.setRecording()
 		self.root.bind("<Left>",lambda e: None)
 		self.root.bind("<Right>",lambda e: None)
 		if self.settings:
 			self.settings.destroy()
 			self.settings=None
 		self.sendParams()
 	def sendParams(self):
 		self.sendMsg("setParams",(self.detector.params.copy(),))
 	def _handleEvent(self,e):
 		actions={
-			"setCurrentFrame": self._frameHandler,
+			"setFrame": self._frameHandler,
 			"setGameState": self._stateHandler,
 			"setParams": self._paramsHandler
+		}
 		(actionName,args,kwargs)=e
 		return actions[actionName](*args,**kwargs)
-	def _frameHandler(self,newFrame,type,key):
+	def _frameHandler(self,frame,type,key):
 		if self._state!=type and self.mainWindow.imgView.isSet():
-			log.info("ignored setCurrentFrame event, wrong type")
+			log.info("ignored setFrame event, wrong type")
 			return
 		self._frameKey=key
-		self.mainWindow.setCurrentFrame(newFrame)
+		self.mainWindow.setFrame(frame)
 		self.root.event_generate("<<redrawImgView>>")
 	def _stateHandler(self,gameState,moves):
 		labels={(row,col):(i+1) for (i,(c,row,col)) in enumerate(moves)}
 		self.mainWindow.boardView.redrawState(gameState,labels)
 	def _paramsHandler(self,params):
 		if not self.settings:
 			log.warning("received 'setParams' message while settings is '%s'",str(self.settings))
 			return
 		self.detector.setParams(params)
 		self.settings.setParams(params)
 gui=GUI()
 """
 # setup #
 * we can click around the ImgView
 * we can walk through the frames back and forth
 * BoardView is showing what the reading of ImgView _would_ be
 * core is reading and analyzing frames, pushing results to StateBag, but not showing them
 # recording #
 * ImgView is showing the current picture, is not clickable
 * BoardView is showing last detected position
 * on switch to recording (if parameters have changed):
 	* feed analyzer new parameters and start using them
 	* in the background reanalyze cached frames with the new parameters and merge them into StateBag
 """

src/gui/mainwindow.py

➞

Show inline comments

 import tkinter as tk
 from tkinter import N,S,E,W
 from .util import MsgMixin
 from .menu import MainMenu
 from .boardview import BoardView
 from .imgview import ImgView
 from .statusbar import StatusBar
 class MainWindow(tk.Frame,MsgMixin):
 	def __init__(self,parent,master=None):
 		self.parent=parent
 		tk.Frame.__init__(self, master)
 		self.grid(column=0,row=0,sticky=(N,S,E,W))
 		self._createWidgets()
-	def setCurrentFrame(self,frame):
+	def setFrame(self,frame):
 		self.imgView.setImg(frame)
 	def _createWidgets(self):
 		# menu
 		self.parent.root.option_add('*tearOff',False)
 		self._menu=MainMenu(self.parent,self.parent.root)
 		# a captured frame with overlay graphics
 		self._imgWrapper=tk.Frame(self,width=480,height=360)
 		self.imgView=ImgView(self._imgWrapper,self)
 		self._imgWrapper.grid(column=0,row=0,sticky=(N,S,E,W))
 		# board with detected stones
 		self._boardWrapper=tk.Frame(self,width=360,height=360)
 		self.boardView=BoardView(self._boardWrapper)
 		self._boardWrapper.grid(column=1,row=0,sticky=(N,S,E,W))
 		self.columnconfigure(0,weight=1)
 		self.columnconfigure(1,weight=1)
 		self.rowconfigure(0,weight=1)
 		self._statusBar=StatusBar(self)
 		self._statusBar.grid(column=0,row=1,columnspan=2,sticky=(S,E,W))
 		self.rowconfigure(1,weight=0)
 		# render everything
 		self.imgView.redraw()
 	## Redraws the current image and its overlay.
 	def redrawImgView(self):
 		self.imgView.redraw()
 	def setUp(self):
 		self._statusBar.setUp()
 		self.imgView.setUp()
 	def setRecording(self):
 		self._statusBar.setRecording()
 		self.imgView.setRecording()

0 comments (0 inline, 0 general)