import logging as log

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):

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

				except IndexError: continue

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

				m=min(red,green,blue)

				S=1-m/I if I!=0 else 0

				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))

class Corners:

	def __init__(self):

		self.corners=[]

	## Adds a new corner if there are less than four, replaces the closest otherwise.

	def add(self,x,y):

		a=EPoint(x,y)

		# for i,c in enumerate(self.corners): # move an improperly placed point

			# if a.dist(c)<20:

				# self.corners[i]=a

import numpy

## Projective transformation of a point with a matrix A.

#  

#  Takes a point as a horizontal vector, transposes it and multiplies with A from left.

#  

#  @return transformed point as a numpy.array

def transformPoint(point,A):

	return (A*numpy.matrix(point).transpose()).getA1()

class Grid:

import os

import multiprocessing

import threading

import logging as log

import PIL

from util import MsgQueue

from gui import gui

from statebag import StateBag

import config as cfg

class Core:

	def __init__(self):

		self.grid=None

		self.go=Go()

		self.detector=ImageAnalyzer()

		self.states=StateBag()

		self._ownMessages=MsgQueue(self._handleEvent)

import logging as log

from util import EMPTY,BLACK,WHITE,colorNames

class Go:

	## Initializes self.board to a list[r][c]=EMPTY.

	def __init__(self,boardSize=19):

		self.boardSize=boardSize

		self.board=[[EMPTY]*boardSize for x in range(boardSize)]

		self._temp=[[EMPTY]*boardSize for x in range(boardSize)]

		self.toMove=BLACK

		self._record=GameRecord()

	## Executes a move.

from .resizablecanvas import ResizableCanvas

## Handles and presents the game state as detected by the program.

class BoardView(ResizableCanvas):

	def __init__(self, master=None):

		super().__init__(master)

		self.configure(width=360,height=360,background="#ffcc00")

		self._padding=18

		self._cellWidth=(self._width-2*self._padding)/18

		self._cellHeight=(self._height-2*self._padding)/18

import logging as log

from PIL import ImageTk

import config

from .resizablecanvas import ResizableCanvas

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

			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):

					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)

User can change detector parameters, presumably in case the previous don't fit the (current) situation.

In such a case we assume the new parameters are correct from the current position onwards.

But the change might have been appropriate even earlier (before the user detected and fixed an error).

So we try to find the correct crossover point like this:

- construct a sequence S' = s'_i, ..., s'_n by reanalyzing the positions with a new set of parameters, where s_i is the point of previous user intervention or s_0

- for each s'_j:

	- try to append it to S[:j]

	- try to append it to S'[:j]

	- remember the better variant

- linearize the fork back by discarding s'_j-s preceding the crossover and s_j-s following the crossover

"""

## Crude lower bound on edit distance between states.

def estimateDistance(diff):

	additions=sum(1 for d in diff if d[2]=="+")

	deletions=sum(1 for d in diff if d[2]=="-")

	replacements=len(diff)-additions-deletions

	if additions>0: return additions+replacements

	elif replacements==0 and deletions>0: return 2 # take n, return 1

	return replacements # ???

from unittest import TestCase

class TestLegal(TestCase):

	def testLegal(self):

		board=[

			[0,0,0,0,0],

			[1,1,1,1,1],

			[-1,-1,0,1,0],

			[0,0,0,-1,-1],

			[0,-1,0,-1,0]

		]

		self.assertTrue(isLegalPosition(board))