from geometry import Line

def groupLines(points,minCount,tolerance):

	random.shuffle(points)

	sample=points[:]

	for (i,a) in enumerate(sample):

		for (j,b) in enumerate(sample):

			if j<=i: continue

			ab=Line(a,b)

			for c in points:

				if c is a or c is b: continue

				if point2lineDistance(a,b,c)<=tolerance:

					ab.points.add(c)

			if len(ab.points)>=minCount:

				yield ab

		# # detect lines passing through the stones

		# lines=self._constructLines(stones)

		#

	def _constructLines(self,stoneLocs):

		lineDict=dict()

		# minCount=min(max(math.sqrt(len(stoneLocs))-4,3),7)

		minCount=6

		log.debug("min count: %s",minCount)

		points=[point for (point,contour) in stoneLocs]

		for line in groupLines(points,minCount,2):

			key=line.getSortedPoints()

			if key in lineDict: # we already have a line with the same incident points

				continue

			lineDict[line.getSortedPoints()]=line

			obsolete=set()

			for ab in lineDict.values():

				if ab is line: continue

				if line.points<ab.points: # == impossible

					del lineDict[key]

					break

				if ab.points<line.points:

					obsolete.add(ab.getSortedPoints())

			for key in obsolete: del lineDict[key]

		log.debug("valid lines: %s",len(lineDict))

		lines=sorted(lineDict.values(), key=lambda ab: len(ab.points), reverse=True)

		# visualize

		linesImg=cv.cvtColor(np.zeros((self._rectH,self._rectW),np.uint8),cv.COLOR_GRAY2BGR)

		cv.drawContours(linesImg,[c for (point,c) in stoneLocs],-1,(255,255,255),-1)

		for (p,c) in stoneLocs:

			cv.drawMarker(linesImg,(int(p.x),int(p.y)),(255,0,0),cv.MARKER_CROSS)

		self._printLines(lines,points,linesImg)

		for line in lines:

			points=line.getSortedPoints()

			(xa,ya)=points[0]

			(xb,yb)=points[-1]

			cv.line(linesImg,(int(xa),int(ya)),(int(xb),int(yb)),(255,255,0),1)

		show(linesImg)

		return lines

from analyzer.epoint import EPoint

	def _filterClose(self,peaks): # a naive implementation

		"""Discard points with Euclidean distance on the original image lower than 10.

		From such pairs keep only the one with a higher value in the accumulator.

		This can delete a series of points. If a-b and b-c are close and a>b>c, only a is kept."""

		minDist=13

		center=EPoint(*self._center)

		res=[]

		for (alphaDeg,d) in peaks:

			alphaRad=alphaDeg*math.pi/180

			point=EPoint.fromPolar((alphaRad,d),center)

			ctrl=True

			for (betaDeg,e) in peaks:

				betaRad=betaDeg*math.pi/180

				point_=EPoint.fromPolar((betaRad,e),center)

				if point.dist(point_)<minDist and self._acc[(alphaDeg,d)]<self._acc[(betaDeg,e)]:

					ctrl=False

			if ctrl: res.append((alphaDeg,d))

		return res

	def _detectDominantAngles(self,peaks):

		angles=[alpha for (alpha,d) in peaks]

		n=len(angles)

		bandwidth=self._angleBandwidth

		k1=0

		k2=1

		histogram=[]

		while k1<n:

			while (k2<n and angles[k1]+bandwidth>angles[k2]) or (k2>=n and angles[k1]+bandwidth>angles[k2%n]+180):

				k2+=1

			histogram.append((angles[k1],k2-k1))

			k1+=1

		log.debug("angles histogram: %s",histogram)

		dominantAngles=sorted(histogram,key=lambda xy: xy[1],reverse=True)

		alpha=dominantAngles[0]

		dominantAngles=[beta for beta in dominantAngles if 180-bandwidth>abs(alpha[0]-beta[0])>bandwidth]

		beta=dominantAngles[0]

		log.debug("dominant angles: %s, %s",alpha,beta)

		return (alpha[0],beta[0])

	def _computeGridParams(self,lines):

		log.debug("computing grid parameters for: %s",lines)

		angles=[alpha for (alpha,d) in lines]

		dists=[d for (alpha,d) in lines]

		curve=lambda x,a,b,c,d: a*x**3+b*x**2+c*x+d

		(params,cov)=scipy.optimize.curve_fit(curve,dists,angles)

		log.debug("result: %s",params)

		return params

	def _markPeaks(self,img,peaks):

		colors=[[255,0,0],[255,255,0],[0,255,0],[0,255,255],[0,0,255]]

		for (i,(alpha,d)) in enumerate(peaks[:38]):

			cv.drawMarker(img,(d,alpha),colors[i//9],cv.MARKER_TILTED_CROSS)

		return img

	def _drawGridCurve(self,img,params,colorKey=0):

		colors=[[0,255,255],[255,0,255],[255,255,0]]

		color=colors[colorKey]

		(a,b,c,d)=params

		(h,w)=img.shape[:2]

		curve=lambda x: a*x**3+b*x**2+c*x+d

		for x in range(0,w,3):

			y=round(curve(x))

			if y<0 or y>=2*h: continue

			if y<h:	img[y,x]=color

			else: img[y%h,-x]=color

	def drawLine(self,img,line,colorKey=0):

		colors=[[0,255,255],[255,0,255],[255,255,0]]

		color=colors[colorKey]

		(h,w)=img.shape[:2]

		(a,b,c)=line.toNormal()

		if b==0: return

		for x in range(1,w,3):

			y=round((-c-a*x)/b) + (0 if b>=0 else 180)

			if y<0 or y>=h: continue

			img[y,x]=color

def findPeaks(arr2d): # a naive implementation

	"""Scan 8-neighbourhood and for each peak or top plateau yield one point. For plateaus yield the """

	(h,w)=arr2d.shape

	neighbours=[(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]

	for r in range(h):

		for c in range(w):

			if all(r+dr<0 or r+dr>=h or c+dc<0 or c+dc>=w or arr2d[r,c]>arr2d[r+dr,c+dc] or (i<4 and arr2d[r,c]>=arr2d[r+dr,c+dc]) for (i,(dr,dc)) in enumerate(neighbours)):

				yield (r,c)

def houghLines(bwImg):

	colorImg=cv.cvtColor(bwImg,cv.COLOR_GRAY2BGR)

	lines = cv.HoughLinesP(bwImg,1,np.pi/180,10,minLineLength=10,maxLineGap=40)

	if lines is None: lines=[]

	for line in lines:

		x1,y1,x2,y2 = line[0]

		cv.line(colorImg,(x1,y1),(x2,y2),(0,255,0),1)

	show(colorImg)