OneEye Changeset - 176c678923b7

Changeset - 176c678923b7

Parent rev.

Child rev.

[Not reviewed]

default

0 3 0

Laman - 6 years ago 2019-01-06 22:57:07

get stones samples

3 files changed with 39 insertions and 11 deletions:

src/core.py

src/gui/__init__.py

src/gui/imgview.py

0 comments (0 inline, 0 general)

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
 import config as cfg
 import util
 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._imgs=sorted(os.listdir(cfg.misc.imgDir))
+		self._imgs=sorted(filter(lambda s: s.endswith(".jpg"), 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)
 	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])
 		filename=self._imgs[self._imgIndex]
 		imgPath=os.path.join(cfg.misc.imgDir,filename)
 		self._frame=PIL.Image.open(imgPath)
 		self._guiMessages.send("setCurrentFrame",(self._frame.copy(),gui.PREVIEW))
+		self._guiMessages.send("setCurrentFrame",(self._frame.copy(),gui.PREVIEW,filename))
 		self.preview()
 	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):
 		self._guiProc.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),
 			"fetchParams": self.sendParams,

src/gui/__init__.py

➞

Show inline comments

 import logging
 import os
 import json
 import logging
 import threading
 import tkinter as tk
 import config
 from .mainwindow import MainWindow
 from .boardview import BoardView
 from .settings import Settings
 from util import exportBoard
 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._ownMessages=None
 		self._coreMessages=None
 		self._state=GUI.SETUP
 		self._board=[]
 		self._filename=""
 		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.root.bind("s",lambda e: self._save())
 		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 _save(self):
 		board=exportBoard(self._board)
 		corners=[[p.x,p.y] for p in self.mainWindow.imgView.exportCorners()]
 		res={
 			self._filename: {
 				"board": board,
 				"corners": corners
+			}
+		}
 		with open(os.path.join(config.misc.imgDir,self._filename+".json"), mode="wt") as f:
 			json.dump(res,f,indent="\t")
 	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):
+	def _frameHandler(self,newFrame,type,filename):
 		if self._state!=type: return
 		self._filename=filename
 		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._board=gameState
 		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/gui/imgview.py

➞

Show inline comments

 import logging
 from PIL import ImageTk
 import config
 from .resizablecanvas import ResizableCanvas
 from analyzer.corners import Corners
 from analyzer.epoint import EPoint
 from analyzer.grid import Grid
 import analyzer
 log=logging.getLogger(__name__)
 class ImgView(ResizableCanvas):
 	def __init__(self,master=None,parent=None):
 		super().__init__(master)
 		self._parent=parent
 		self._corners=Corners()
 		self._boardGrid=None
 		self._img=None
 		self._tkImg=None
 		self.configure(width=480,height=360)
 		self.bind('<1>',lambda e: self.addCorner(e.x,e.y))
 	## Redraws the current image and its overlay.
 	def redraw(self):
 		self.delete("all")
 		if self._img:
 			img=self._img.resize((int(self._width),int(self._height)))
 			w,h=self._img.size
 			ratio=min(self._width/w, self._height/h)
 			img=self._img.resize((int(w*ratio),int(h*ratio)))
 			self._tkImg=ImageTk.PhotoImage(img) # just to save the image from garbage collector
 			self.create_image(self._width//2, self._height//2, anchor="center", image=self._tkImg)
 		for corner in self._corners.corners:
 			self.markPoint(corner.x,corner.y)
 		if self._boardGrid!=None and config.gui.showGrid:
 			for r in range(19):
 				a=self._boardGrid.intersections[r][0]
 				b=self._boardGrid.intersections[r][-1]
 				self.create_line(a.x,a.y,b.x,b.y,fill='#00ff00')
 			for c in range(19):
 				a=self._boardGrid.intersections[0][c]
 				b=self._boardGrid.intersections[-1][c]
 				self.create_line(a.x,a.y,b.x,b.y,fill='#00ff00')
 		if self._boardGrid!=None and config.gui.showBigPoints:
 			for r in range(19):
 				for c in range(19):
 					((r1,c1),(r2,c2))=analyzer.relevantRect(self._boardGrid.intersections[r][c], *(self._boardGrid.stoneSizeAt(r, c)))
 					self.create_rectangle(r1,c1,r2,c2,outline="#00ffff")
 	def setImg(self,img):
 		self._img=img
 	## Stores a grid corner located at x,y coordinates.
 	def addCorner(self,x,y):
 		self._corners.add(x,y)
 		log.debug("click on %d,%d",x,y)
 		if self._corners.canonizeOrder():
 			# transform corners from show coordinates to real coordinates
 			log.debug(self._corners.corners)
 			self._boardGrid=Grid(self._corners.corners)
 			corners=[self._transformPoint(c) for c in self._corners.corners]
 			self._parent.sendMsg("setCorners",(corners,))
 			self._parent.sendMsg("setCorners",(self.exportCorners(),))
 		self.redraw()
 	## Marks a point at the image with a green cross. Used for corners.
 	def markPoint(self,x,y):
 		self.create_line(x-3,y-3,x+4,y+4,fill="#00ff00")
 		self.create_line(x-3,y+3,x+4,y-4,fill="#00ff00")
 	def exportCorners(self):
 		return [self._transformPoint(c) for c in self._corners.corners]
 	def setUp(self):
 		self.bind('<1>',lambda e: self.addCorner(e.x,e.y))
 	def setRecording(self):
 		self.bind('<1>',lambda e: None)
 	def _onResize(self,event):
 		w=self._width
 		super()._onResize(event)
 		self._corners.scale(self._width/w)
 		if len(self._corners.corners)==4:
 			self._boardGrid=Grid(self._corners.corners)
 		self.redraw()
 	def _transformPoint(self,point):
 		w=int(self._width)
 		h=int(self._height)
 		wo,ho=self._img.size # o for original
 		widthRatio=wo/w
 		heightRatio=ho/h
-		self._imgSizeCoef=max(widthRatio,heightRatio)
+		imgSizeCoef=max(widthRatio,heightRatio)
 		# shift compensates possible horizontal or vertical empty margins from unmatching aspect ratios
 		self._imgShift=EPoint(wo-w*self._imgSizeCoef,ho-h*self._imgSizeCoef)/2
 		return EPoint(self.canvasx(point.x),self.canvasy(point.y)) * self._imgSizeCoef + self._imgShift
 		imgShift=EPoint(wo-w*imgSizeCoef,ho-h*imgSizeCoef)/2
 		return EPoint(self.canvasx(point.x),self.canvasy(point.y)) * imgSizeCoef + imgShift

0 comments (0 inline, 0 general)