Changeset - d5d8fe073c1c
[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:
0 comments (0 inline, 0 general)
src/config.py
Show inline comments
 
@@ -43,12 +43,13 @@ 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
 
@@ -6,12 +6,13 @@ 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:
 
@@ -21,21 +22,27 @@ class Core:
 
		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):
 
@@ -47,12 +54,18 @@ class Core:
 
		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)
 
@@ -64,13 +77,12 @@ class Core:
 
	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)
 
@@ -82,32 +94,38 @@ class Core:
 
				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
src/gui/__init__.py
Show inline comments
 
@@ -70,13 +70,15 @@ class GUI:
 
		}
 
		(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)
src/util.py
Show inline comments
 
@@ -28,13 +28,15 @@ class MsgQueue:
 
		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
 

	
 

	
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)