def _markCorners(self):

		self.canvas.delete("mark")

		for c in self.corners:

			(x,y)=(c.x,c.y)

			self.canvas.create_oval(x-2,y-2,x+2,y+2,fill="#00ff00",tags="mark")

			(a,b,c,d)=self.corners

			self.canvas.create_line(a.x,a.y,b.x,b.y,fill="#00ff00",tags="mark")

			self.canvas.create_line(b.x,b.y,c.x,c.y,fill="#00ff00",tags="mark")

			self.canvas.create_line(c.x,c.y,d.x,d.y,fill="#00ff00",tags="mark")

			self.canvas.create_line(d.x,d.y,a.x,a.y,fill="#00ff00",tags="mark")

log=logging.getLogger(__name__)

class Corners:

	def __init__(self,cornerList=[]):

		self._corners=cornerList[:]

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

		index,minDist=0,float('inf') # replace the corner closest to the clicked point

		for i,c in enumerate(self._corners):

			if a.dist(c)<minDist:

				index,minDist=i,a.dist(c)

		self._corners[index]=a

	## Order the corners (0,1,2,3) so they make a quadrangle with vertices KLMN in counter-clockwise order, K being in the upper left.

	#

	#  For four points ABCD, there are 24 possible permutations corresponding to the desired KLMN.

	#  When we relax the condition of K being the upper left one, we get six groups of four equivalent permutations. KLMN ~ LMNK ~ MNKL ~ NKLM.

	#

	#  A DCB        |  -  |  -  |  -  |  -  |     0 | BD

	#

	#  For every non-degenerate quadrangle, there must be 1-3 edges going right-left (from a higher to a lower x coordinate).

	#  From these pick the one with the lowest slope (dy/dx) and declare its ending point the upper left corner. For the same slope pick the one further left.

	#

	#  @return True for a convex quadrangle, False for concave and degenerate cases.

		a,b,c,d=self._corners

		abc=doubleTriangleArea(a,b,c)

		abd=doubleTriangleArea(a,b,d)

		acd=doubleTriangleArea(a,c,d)

		bcd=doubleTriangleArea(b,c,d)

		swaps=[(1,3),(0,1),(1,2),(0,3),(2,3),(0,0)]

		index=(8 if abc>0 else 0)|(4 if abd>0 else 0)|(2 if acd>0 else 0)|(1 if bcd>0 else 0)

		if index%3!=0: return False # concave degenerate

		swap=swaps[index//3]

				kIndex=ii

				lowestSlope=slope

		self._corners= self._corners[kIndex:] + self._corners[:kIndex] # rotate the upper left corner to the first place

		log.debug(self._corners)

	def scale(self,scale):

		self._corners=[c * scale for c in self._corners]

	def __iter__(self):

		return iter(self._corners)

	def __len__(self):

		return len(self._corners)

## Computes twice the area of the triangle formed by points a,b,c.

#

#  @return positive value for points oriented counter-clockwise, negative for clockwise, zero for degenerate cases.

def doubleTriangleArea(a,b,c):

	return (a.x-b.x)*(c.y-a.y)-(c.x-a.x)*(a.y-b.y)

	#

	#  The horizon can be used to construct a matrix for affine rectification of the image (restoring parallel lines parallelism). We transform the corner points by this matrix,

	#  interpolate them to get proper intersections' coordinates and then transform these back to get their placement at the original image.

	#

	#  The result is stored in grid.intersections, a boardSize*boardSize list with [row][column] coordinates.

	#

	# !! Needs a check for proper initialization.

	def __init__(self,corners):

		# ad

		# bc

		a,b,c,d=[c.toProjective() for c in corners]

		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)

			# transform corners from show coordinates to real coordinates

			self._boardGrid=Grid(self._corners)

			corners=[self._transformPoint(c) for c in self._corners]

			self._gui.detector.setCorners(corners)

			self._gui.preview()