from .resizablecanvas import ResizableCanvas

from go import BLACK,WHITE

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

		self._drawGrid()

	def redrawState(self,gameState):

		self.delete("black","white")

		for r,row in enumerate(gameState):

			for c,point in enumerate(row):

				self._drawStone(r, c, point)

	def _drawGrid(self):

		padding=self._padding

		for i in range(19):

			self.create_line(padding,18*i+padding,self._width-padding,18*i+padding,tags="row",fill="#000000") # rows

			self.create_line(18*i+padding,padding,18*i+padding,self._height-padding,tags="col",fill="#000000") # cols

		self._drawStars()

	def _drawStars(self):

		radius=2

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

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

				x=c*self._cellHeight+self._padding

				y=r*self._cellWidth+self._padding

				self.create_oval(x-radius,y-radius,x+radius,y+radius,tags="star",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

	#  @param color color indicator, go.BLACK or go.WHITE

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

		if color==BLACK:

			hexCode='#000000'

			tag="black"

		elif color==WHITE:

			hexCode='#ffffff'

			tag="white"

		else: return False

		x=c*self._cellWidth+self._padding

		y=r*self._cellHeight+self._padding

		radius=self._cellWidth/2

		self.create_oval(x-radius,y-radius,x+radius,y+radius,tags=tag,fill=hexCode)

import logging as log

from PIL import ImageTk

import config

from .resizablecanvas import ResizableCanvas

from corners import Corners

from grid import Grid

import imageanalyzer

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.copy()

			img.thumbnail((int(self._width),int(self._height)))

			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))=imageanalyzer.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)

			self._parent.sendMsg("setCorners",(corners,))

		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 _onResize(self,event):

		w=self._width

		super()._onResize(event)

		self._corners.scale(self._width/w)

		self.redraw()

import logging as log

from grid import Grid

from go import exportBoard

import go

class ImageAnalyzer:

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

		self.board=[[go.EMPTY]*19 for r in range(19)]

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

		log.info("board analyzed:\n%s", exportBoard(self.board))

		return True

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

				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)

		if b>=w and b>=e: return go.BLACK

		if w>=b and w>=e: return go.WHITE

		return go.EMPTY

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