OneEye Changeset - d5d8fe073c1c

Changeset - d5d8fe073c1c

Parent rev.

Child rev.

[Not reviewed]

default

0 4 1

Laman - 6 years ago 2018-12-11 10:32:25

capturing video with openCV

5 files changed with 95 insertions and 8 deletions:

src/config.py

src/core.py

src/gui/__init__.py

src/util.py

src/video.py

0 comments (0 inline, 0 general)

src/config.py

➞

Show inline comments

 import os
 import logging.config
 import json
 srcDir=os.path.dirname(__file__)
 with open(os.path.join(srcDir, "..", "config.json")) as f:
 	cfgFile=json.load(f)
 logCfg = cfgFile.get("logging") or {
 	"version": 1,
 	"handlers": {
 		"file": {
 			"level": "DEBUG",
 			"class": "logging.FileHandler",
 			"filename": "/tmp/oneeye.log",
 			"formatter": "default"
 		},
 		"console": {
 			"level": "DEBUG",
 			"class": "logging.StreamHandler",
 			"formatter": "default"
+		}
 	},
 	"root": {
 		"handlers": ["console","file"],
 		"level": "DEBUG"
 	},
 	"formatters": {
 		"default": {
 			"format": "%(asctime)s %(levelname)s: %(message)s",
 			"datefmt": "%Y-%m-%d %H:%M:%S"
+		}
+	}
+}
 logging.config.dictConfig(logCfg)
 class misc:
 	file=cfgFile["misc"]
 	version=(0,0,0)
 	defaultImage=file.get("defaultImage", 0)
 	_imgDir=file.get("imgDir","../images")
 	imgDir=_imgDir if os.path.isabs(_imgDir) else os.path.join(srcDir,_imgDir)
 	video=file.get("video",0)
 class gui:
 	file=cfgFile["gui"]
 	showBigPoints=file.get("showBigPoints", False)
 	showGrid=file.get("showGrid", True)

src/core.py

➞

Show inline comments

 import os
 import multiprocessing
 import threading
 import logging
 import PIL
 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._imgs=sorted(os.listdir(cfg.misc.imgDir))
 		self._imgIndex=cfg.misc.defaultImage
 		imgPath=os.path.join(cfg.misc.imgDir,self._imgs[self._imgIndex])
 		self._frame=PIL.Image.open(imgPath)
 		self._guiProc=multiprocessing.Process(name="gui", target=gui, args=(self._guiMessages,self._ownMessages))
 		self._guiProc.start()
 		self.relativeFrame(0)
 		self._vidProc=multiprocessing.Process(
 			name="video",
 			target=capVideo,
 			args=(cfg.misc.video, self._vidMessages,self._ownMessages)
+		)
 		self._vidProc.start()
 	def setCorners(self,corners):
 		self.detector.setGridCorners(corners)
 		self.analyze()
 	def setTresholds(self,tresB=None,tresW=None):
 		if tresB is not None: self.detector.tresB=tresB
 		if tresW is not None: self.detector.tresW=tresW
 		self.preview()
 	def relativeFrame(self,step):
 		self._imgIndex=(self._imgIndex+step)%len(self._imgs)
 		imgPath=os.path.join(cfg.misc.imgDir,self._imgs[self._imgIndex])
 		self._frame=PIL.Image.open(imgPath)
 		self._guiMessages.send("setCurrentFrame",(self._frame.copy(),gui.PREVIEW))
 		self.preview()
 	def putFrame(self,frame):
 		img=PIL.Image.fromarray(frame)
 		self._cache.put(img)
 		self._guiMessages.send("setCurrentFrame",(img,gui.PREVIEW)) # !! RECORDING
 		# self.analyze()
 	def sendParams(self):
 		params={
 			"tresB": self.detector.tresB,
 			"tresW": self.detector.tresW
+		}
 		self._guiMessages.send("setParams",tuple(),params)
 	def setParams(self,tresB=0,tresW=0):
 		self.detector.tresB=tresB
 		self.detector.tresW=tresW
 	def preview(self):
 		if self.detector.analyze(self._frame):
 			self._guiMessages.send("setGameState", (self.detector.board,[]))
 	def analyze(self):
 		if self.detector.analyze(self._frame):
 			self._cache.put(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 joinGui(self):
+	def joinChildren(self):
 		self._guiProc.join()
 		self._vidMessages.send("shutDown")
 		self._vidProc.join()
 		self._ownMessages.send("!kill",("core",))
 	def _handleEvent(self,e):
 		actions={
 			"setCorners": self.setCorners,
 			"setTresholds": self.setTresholds,
 			"prevFrame": lambda: self.relativeFrame(-1),
 			"nextFrame": lambda: self.relativeFrame(1),
 			"putFrame": self.putFrame,
 			"fetchParams": self.sendParams,
 			"setParams": self.setParams
+		}
 		(actionName,args,kwargs)=e
 		return actions[actionName](*args,**kwargs)
 core=Core()
 core.listen()
 core.joinGui()
 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

@@ @@ -28,79 +28,81 @@ class GUI: @@
 		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
 	def _handleEvent(self,e):
 		actions={
 			"setCurrentFrame": self._frameHandler,
 			"setGameState": self._stateHandler,
 			"setParams": self._paramsHandler
+		}
 		(actionName,args,kwargs)=e
 		return actions[actionName](*args,**kwargs)
 	def _frameHandler(self,newFrame,type):
 		if self._state!=type: return
 		if self._state!=type:
 			log.info("ignored setCurrentFrame event, wrong type")
 			return
 		self.mainWindow.setCurrentFrame(newFrame)
 		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.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/util.py

➞

Show inline comments

 import random
 import multiprocessing
 import logging
 log=logging.getLogger(__name__)
 EMPTY=0
 BLACK=1
 WHITE=-1
 colorNames={BLACK:"B",WHITE:"W"}
 class MsgQueue:
 	def __init__(self,handler=None):
 		self._queue=multiprocessing.Queue()
 		self._event=multiprocessing.Event()
 		self._handleEvent=handler
 	def send(self,actionName,args=tuple(),kwargs=None):
 		if kwargs is None: kwargs=dict()
 		self._queue.put((actionName,args,kwargs))
 		self._event.set()
 	def listen(self,handleEvent=None):
 		if handleEvent is not None: self._handleEvent=handleEvent
 		while True:
 			self._event.wait()
 			msg=self._queue.get()
 			if self._queue.empty():
 				self._event.clear()
 			log.info(msg)
 			if msg[0]=="!kill": break
 			if msg[0]=="!kill":
 				self._queue.cancel_join_thread()
 				break
 			self._handleEvent(msg)
 	def setHandler(self,handler):
 		self._handleEvent=handler
 rand=random.Random()
 rand.seed(361)
 zobristNums=tuple(
 	tuple(
 		tuple(rand.getrandbits(32) for i in range(3)) for c in range(19)
 	) for r in range(19)
+)
 def hashBoard(board):
 	res=0
 	for (r,row) in enumerate(board):
 		for (c,item) in enumerate(row):
 			res^=zobristNums[r][c][item+1]
 	return res
 def diffHash(r,c,oldItem,newItem):
 	h=zobristNums[r][c]
 	return h[oldItem+1] ^ h[newItem+1]
 def exportBoard(board):
 	substitutions={BLACK:"X", WHITE:"O"}
 	template=[["."]*19 for r in range(19)]
 	for r in range(3,19,6):
 		for c in range(3,19,6):
 			template[r][c]=","
 	for (row,templateRow) in zip(board,template):
 		for (c,x) in enumerate(row):
 			if x!=EMPTY: templateRow[c]=substitutions[x]
 	return "\n".join("".join(row) for row in template)

src/video.py

➞

Show inline comments

@@ new file 100644 @@
 import time
 import threading
 import cv2 as cv
 class VideoCapture:
 	def __init__(self, video_source=0):
 		self._ownMessages=None
 		self._coreMessages=None
 		self._shutdown=False
 		self._vid = cv.VideoCapture(video_source)
 		if not self._vid.isOpened():
 			raise ValueError("Unable to open video source", video_source)
 		self.width = self._vid.get(cv.CAP_PROP_FRAME_WIDTH)
 		self.height = self._vid.get(cv.CAP_PROP_FRAME_HEIGHT)
 	def getFrame(self):
 		if self._vid.isOpened():
 			(res,frame) = self._vid.read()
 			if res:
 				return (res, cv.cvtColor(frame, cv.COLOR_BGR2RGB))
 			else:
 				return (res,None)
 		else:
 			return (False,None)
 	def shutDown(self):
 		self._ownMessages.send("!kill",("video",))
 		self._shutdown=True
 	def __call__(self,ownMessages,coreMessages):
 		self._ownMessages=ownMessages
 		self._coreMessages=coreMessages
 		self.listenerThread=threading.Thread(target=lambda: ownMessages.listen(self._handleEvent))
 		self.listenerThread.start()
 		t=0
 		while not self._shutdown:
 			self._vid.set(cv.CAP_PROP_POS_MSEC,t*1000)
 			(res,frame)=self.getFrame()
 			if res: self._coreMessages.send("putFrame",(frame,))
 			time.sleep(1)
 			t+=1
 	def __del__(self):
 		if self._vid.isOpened():
 			self._vid.release()
 	def _handleEvent(self,e):
 		actions={
 			"shutDown": self.shutDown
+		}
 		(actionName,args,kwargs)=e
 		return actions[actionName](*args,**kwargs)
 def capVideo(stream,ownMessages,coreMessages):
 	v=VideoCapture(stream)
 	v(ownMessages,coreMessages)

0 comments (0 inline, 0 general)