self.analyze()

	def relativeFrame(self,step):

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

		self.analyze()

	def analyze(self):

		if self.detector.analyze(self._frame):

			if isLegalPosition(self.detector.board):

				self.go.transitionMove(self.detector.board)

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

from .core import PASS

from .transpositiontable import TranspositionTable

from . import core

## Compute move sequence from state1 to state2.

#

# @param colorIn {BLACK,WHITE}: color to start the sequence

# @param colorOut {BLACK,WHITE}: color to close the sequence

def getTransitionSequence(state1,state2,colorIn,colorOut,diff):

	eng.load(state1)

	return eng.iterativelyDeepen(state2,diff,colorIn,colorOut)

class SpecGo(core.Go):

	def __init__(self,boardSize=19):

		super().__init__(boardSize)

	def listRelevantMoves(self,diff):

		"""There can be 3 different changes in the diff: additions, deletions and replacements.

		Additions can be taken as relevant right away.

		Deletions and replacements had to be captured, so we add their liberties.

		Also any non-missing stones of partially deleted (or replaced) groups had to be replayed, so add them too.

		Needs to handle snapback, throw-in.

		res=({PASS},{PASS})

		for d in diff:

			(r,c,action,color)=d

			colorKey=(1-color)>>1 # {-1,1}->{1,0}

			if action!="-" and (r,c) not in res[colorKey]:

				res[colorKey].add((r,c))

				if action=="*":

					for (ri,ci) in self.listNeighbours(r,c): # in case a stone was played and captured. !! might want to add even more

						res[1-colorKey].add((ri,ci))

			# this is rather sloppy but correct. the time will show if it is effective enough

			# just floodFill from the current intersection, add everything you find and also all the neighbours to be sure

			if action!="+" and (r,c) not in res[colorKey] and (r,c) not in res[1-colorKey]:

class Engine:

	"""Class searching for move sequences changing one board state into another."""

	def __init__(self,g=None):

		self._g=g or SpecGo()

		self._moveList=(set(),set())

		self._transpositions=TranspositionTable()

	def load(self,state1):

		self._g.load(state1)

	def iterativelyDeepen(self,state2,diff,colorIn,colorOut):

		self._moveList=self._g.listRelevantMoves(diff)

		startDepth=1 if colorIn==colorOut else 2

		self._g.toMove=colorIn

		for i in range(startDepth,5,2):

			seq=self._dfs(state2,i)

			if seq:

				seq.reverse()

				return seq

		return None

	def _dfs(self,state2,limit):

		self._coreMessages.send(actionName,args,kwargs)

	def _handleEvent(self,e):

		actions={"setCurrentFrame":self._frameHandler, "setGameState":self._stateHandler}

		(actionName,args,kwargs)=e

		return actions[actionName](*args,**kwargs)

	def _frameHandler(self,newFrame):

		self.mainWindow.setCurrentFrame(newFrame)

		self.root.event_generate("<<redrawImgView>>")

gui=GUI()

from .resizablecanvas import ResizableCanvas

from go.core 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._drawGrid()

		for r,row in enumerate(gameState):

			for c,point in enumerate(row):

	def _drawGrid(self):

		padding=self._padding

		for i in range(19):

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

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

		self._drawStars()

		self._drawCoordinates()

	def _drawStars(self):

		radius=2

			self.create_text(self._padding+i*self._cellWidth,self._height-self._padding+textWidth,text=letters[i],tags="coords")

			# rows

			self.create_text(self._padding-textWidth,self._padding+i*self._cellHeight,text=str(19-i),tags="coords")

			self.create_text(self._width-self._padding+textWidth,self._padding+i*self._cellHeight,text=str(19-i),tags="coords")

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

		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)

	def _onResize(self,event):

		super()._onResize(event)

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

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

	elif action2=="-": return ("-",item2)

	elif (action1=="*" and item1==item2) or (action1=="-" and item1!=item2): return ("*",item2)

	return None

class StateBag:

	def __init__(self):

		self._states=[]

	def pushState(self,board):

		sn=BoardState(board)

		if len(self._states)>0:

			sn.cachedDiff=sn-self._states[-1]

		else: sn.setWeight(1)

		diff=sn.cachedDiff

		for s in reversed(self._states):

			sn.tryConnect(s,diff)

			diff=updateDiff(s.cachedDiff,diff)

		self._states.append(sn)

		return sn

	def merge(self,branch):

		pass

		self.weight=0

	## Connect itself after v if it gains itself more weight.

	def tryConnect(self,v,diff):

		moves=getTransitionSequence(v.parent,self.parent,-1*v.color,self.color,diff)

		if not moves: return

		w=v.weight+2-len(moves) # proper one move transition increases the weight by 1

		if w>self.weight:

			self.moves=moves

			self.prev=v

			self.weight=w

class BoardState:

	def __init__(self,board):

		self._board=tuple(tuple(x for x in row) for row in board)

		self.nodes=(GameTreeNode(self,BLACK),GameTreeNode(self,WHITE))

		self.cachedDiff=[]

		self._hash=None

	def tryConnect(self,s,diff=None):

		if diff is None: diff=self-s

		distEst=estimateDistance(diff)

		if distEst>3: return # we couldn't find every such move sequence anyway without a clever algorithm

				v2.tryConnect(v1,diff)

	def hash(self):

		if self._hash is None: self._hash=hashBoard(self._board)

		return self._hash

	def export(self):

		return exportBoard(self._board)

	def exportDiff(self,s2):

		return "vvv\n{0}\n=== {1} ===\n{2}\n^^^".format(self.export(), s2-self, s2.export())

	def __iter__(self): return iter(self._board)

	def __getitem__(self,key): return self._board[key]

	## Compute difference self-s.

	def __sub__(self,s):

		res=[]

		for (r,(row,rowS)) in enumerate(zip(self._board,s)):

			for (c,(item,itemS)) in enumerate(zip(row,rowS)):

				if item==itemS: continue

				elif itemS==EMPTY: res.append((r,c,"+",item))