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

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

		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)

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

	def _frameHandler(self,newFrame):

		self.mainWindow.setCurrentFrame(newFrame)

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

gui=GUI()

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

	#

	#  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

	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)

		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=[]

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