def __init__(self,boardSize=19):

		self.boardSize=boardSize

	## Executes a move.

	#

	#  Doesn't check for kos. Suicide not allowed.

	#

	#  @return True on success, False on failure (illegal move)

	def move(self,color,row,col):

		self.board[row][col]=color

		# capture neighbors

		for r,c in ((-1,0),(1,0),(0,-1),(0,1)):

			self.temp=[[False]*self.boardSize for x in self.board]

			if not self._floodFill(-color,row+r,col+c): self._remove()

		# check for suicide

		self.temp=[[False]*self.boardSize for x in self.board]

		if not self._floodFill(color,row,col):

			return False

		return True

	## Checks for liberties of a stone at given coordinates.

	#

	#  The stone's group is marked with True in self.temp, ready for capture if needed. Recursively called for stone's neighbors.

	#

	#  @return True if alive, False if captured

	def _floodFill(self,color,row,col):

		if col<0 or col>=self.boardSize or row<0 or row>=self.boardSize: return False # out of range

		if self.temp[row][col]: return False # already visited

		if self.board[row][col]!=color: return False # opponent's stone

		self.temp[row][col]=True # set visited

		return self._floodFill(color,row,col-1) or self._floodFill(color,row,col+1) or self._floodFill(color,row-1,col) or self._floodFill(color,row+1,col) # check neighbors

	## Removes stones at coordinates marked with True in self.temp.

	def _remove(self):

		for r in range(self.boardSize):

			for c in range(self.boardSize):

import threading

import logging as log

import tkinter as tk

from PIL import ImageTk

import PIL

import config

from epoint import EPoint

from corners import Corners

import image_analyzer

from grid import Grid

class MainWindow(tk.Frame):

	def __init__(self,parent,master=None):

		self.parent=parent

		self.corners=Corners()

		self.currentFrame=None

		self._boardGrid=None

		self.img=None

	def drawStars(self):

		for r in range(4,19,6):

			for c in range(4,19,6):

				self.create_oval(r*18-2,c*18-2,r*18+2,c*18+2,fill='#000000')

	## Draws a stone at provided coordinates.

	#

	#  For an unknown color draws nothing and returns False.

	#

	#  @param r row coordinate, [0-18], counted from top

	#  @param c column coordinate, [0-18], counted from left

	def drawStone(self,r,c,color):

		else: return False

		r+=1

		c+=1

		self.create_oval(c*18-9,r*18-9,c*18+9,r*18+9,fill=hexCode)

class GUI:

	def __init__(self):

		self.root = tk.Tk()

		self.root.title("OneEye {0}.{1}.{2}".format(*config.misc.version))

		self._coreMessages=None

import logging as log

from grid import Grid

class ImageAnalyzer:

	def __init__(self,tresB=30,tresW=60):

		self.grid=None

		self.tresB=tresB

		self.tresW=tresW

	# let's not concern ourselves with sizecoef and shift here anymore. we want corners to come already properly recomputed

	def analyze(self,image):

		if self.grid==None:

			log.info("ImageAnalyzer.analyze() aborted: no grid available.")

			return False

		for r in range(19):

			for c in range(19):

				intersection=self.grid.intersections[r][c]

				self.board[r][c]=self.analyzePoint(image,r,c,intersection,*(self.grid.stoneSizeAt(r,c)))

	def analyzePoint(self,image,row,col,imageCoords,stoneWidth,stoneHeight):

		b=w=e=0

		((x1,y1),(x2,y2))=relevantRect(imageCoords,stoneWidth,stoneHeight)

		for y in range(y1,y2+1):

			for x in range(x1,x2+1):

				red,green,blue=image.getpixel((x,y))

				I=(red+green+blue)/255/3

				m=min(red,green,blue)

				S=1-m/I

				if 100*I<self.tresB: b+=1

				elif 100*I>self.tresW: w+=1

				else: e+=1

		log.debug("(%d,%d) ... (b=%d,w=%d,e=%d)", row, col, b, w, e)

	def setGridCorners(self,corners):

		self.grid=Grid(corners)

def relevantRect(imageCoords,stoneWidth,stoneHeight):

	x=int(imageCoords.x)

	y=int(imageCoords.y)

	xmax=max(int(stoneWidth*2//7), 2) # !! optimal parameters subject to further research

	ymax=max(int(stoneHeight*2//7), 2)

	return ((x-xmax,y-ymax), (x+xmax,y+ymax))