Changeset - 79b929f58012
Parent rev.
Child rev.
[Not reviewed]
default
0 2 0
Laman - 6 years ago 2019-03-03 00:47:31

image rectification
2 files changed with 13 insertions and 47 deletions:
exp/board_detect.py
10
46
exp/hough.py
3
1
0 comments (0 inline, 0 general)
exp/board_detect.py
➞
Show inline comments
 
import sys
 

			




	
	
	
		
 
sys.path.append("../src")

			




	
	
	
		
 

			




	
	
	
		
 
import os

			




	
	
	
		
 
import math

			




	
	
	
		
 
import random

			




	
	
	
		
 
import itertools

			




	
	
	
		
 
import logging as log

			




	
	
	
		
 

			




	
	
	
		
 
import cv2 as cv

			




	
	
	
		
 
import numpy as np

			




	
	
	
		
 
import scipy.cluster

			




	
	
	
		
 
import scipy.ndimage

			




	
	
	
		
 
import scipy.signal

			




	
	
	
		
 

			




	
	
	
		
 
from geometry import Line

			




	
	
	
		
 
from annotations import DataFile,computeBoundingBox

			




	
	
	
		
 
from hough import show,prepareEdgeImg,HoughTransform

			




	
	
	
		
 
from analyzer.epoint import EPoint

			




	
	
		
 
@@ -100,48 +101,39 @@ class BoardDetector:

			




	
	
	
		
 
		quantized=quantized & (255-cv.cvtColor(edges,cv.COLOR_GRAY2BGR))

			




	
	
	
		
 
		show(quantized,"quantized, edges separated")

			




	
	
	
		
 

			




	
	
	
		
 
		# detect black and white stones

			




	
	
	
		
 
		stones=self._detectStones(quantized,black,white)

			




	
	
	
		
 

			




	
	
	
		
 
		# detect lines from edges and stones

			




	
	
	
		
 
		edgeImg=prepareEdgeImg(rect)

			




	
	
	
		
 
		hough=HoughTransform(edgeImg)

			




	
	
	
		
 
		stonesImg=np.zeros((self._rectH,self._rectW),np.uint8)

			




	
	
	
		
 
		for (point,c) in stones:

			




	
	
	
		
 
			cv.circle(stonesImg,(int(point.x),int(point.y)),2,255,-1)

			




	
	
	
		
 
		# cv.drawContours(stonesImg,[c for (point,c) in stones],-1,255,-1)

			




	
	
	
		
 

			




	
	
	
		
 
		show(stonesImg,"detected stones")

			




	
	
	
		
 
		hough.update(stonesImg,10)

			




	
	
	
		
 
		lines=hough.extract()

			




	
	
	
		
 

			




	
	
	
		
 
		linesImg=np.copy(rect)

			




	
	
	
		
 
		for line in lines:

			




	
	
	
		
 
		for line in itertools.chain(*lines):

			




	
	
	
		
 
			self._drawLine(linesImg,line)

			




	
	
	
		
 
		show(linesImg,"detected lines")

			




	
	
	
		
 

			




	
	
	
		
 
		# # detect vanishing points of the lines

			




	
	
	
		
 
		# imgCenter=EPoint(w//2-x1, h//2-y1)

			




	
	
	
		
 
		# (a,b,c,d)=(p-EPoint(x1,y1) for p in self._annotations[filename][0])

			




	
	
	
		
 
		# (p,q,r,s)=(Line(a,b),Line(b,c),Line(c,d),Line(d,a))

			




	
	
	
		
 
		# v1=p.intersect(r)

			




	
	
	
		
 
		# v2=q.intersect(s)

			




	
	
	
		
 
		# log.debug("true vanishing points: %s ~ %s, %s ~ %s",v1,v1.toPolar(imgCenter),v2,v2.toPolar(imgCenter))

			




	
	
	
		
 
		# vanish=self._detectVanishingPoints(lines,imgCenter,(v1.toPolar(imgCenter),v2.toPolar(imgCenter)))

			




	
	
	
		
 
		#

			




	
	
	
		
 
		# # rectify the image

			




	
	
	
		
 
		# matrix=self._computeTransformationMatrix(vanish,lines)

			




	
	
	
		
 
		# transformed=cv.warpPerspective(rect,matrix,(self._rectW,self._rectH))

			




	
	
	
		
 
		#

			




	
	
	
		
 
		# # determine precise board edges

			




	
	
	
		
 
		matrix=self._computeTransformationMatrix(lines[0][0],lines[0][-1],lines[1][0],lines[1][-1])

			




	
	
	
		
 
		transformed=cv.warpPerspective(rect,matrix,(self._rectW,self._rectH))

			




	
	
	
		
 

			




	
	
	
		
 
		# determine precise board edges

			




	
	
	
		
 

			




	
	
	
		
 
	def _detectRough(self,img,filename):

			




	
	
	
		
 
		corners=self._annotations[filename][0]

			




	
	
	
		
 
		(x1,y1,x2,y2)=computeBoundingBox(corners)

			




	
	
	
		
 
		log.debug("bounding box: (%s,%s) - (%s,%s)",x1,y1,x2,y2)

			




	
	
	
		
 
		return (x1,y1,x2,y2)

			




	
	
	
		
 

			




	
	
	
		
 
	def _sampleColors(self,rect):

			




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

			




	
	
	
		
 
		minirect=rect[h//4:3*h//4, w//4:3*w//4]

			




	
	
	
		
 
		return kmeans(minirect)

			




	
	
	
		
 

			




	
	
		
 
@@ -168,71 +160,43 @@ class BoardDetector:

			




	
	
	
		
 

			




	
	
	
		
 
		if white is not None:

			




	
	
	
		
 
			maskW=cv.inRange(quantized,white-unit,white+unit)

			




	
	
	
		
 
			distTransform=cv.distanceTransform(maskW,cv.DIST_L2,5)

			




	
	
	
		
 
			maskW=cv.inRange(distTransform,6,20)

			




	
	
	
		
 
			show(maskW,"white areas")

			




	
	
	
		
 
		else: maskW=np.zeros(quantized.shape[:2],dtype=np.uint8)

			




	
	
	
		
 

			




	
	
	
		
 
		stones=cv.bitwise_or(maskB,maskW)

			




	
	
	
		
 
		show(stones,"black and white areas")

			




	
	
	
		
 
		return stones

			




	
	
	
		
 

			




	
	
	
		
 
	def _printLines(self,lines,allPoints,img):

			




	
	
	
		
 
		for (i,line) in enumerate(lines):

			




	
	
	
		
 
			img_=np.copy(img)

			




	
	
	
		
 
			points=list(line.getSortedPoints())

			




	
	
	
		
 
			(a,b)=max(((a,b) for a in points for b in points if a<b),key=lambda ab: ab[0].dist(ab[1]))

			




	
	
	
		
 
			(xa,ya)=a

			




	
	
	
		
 
			(xb,yb)=b

			




	
	
	
		
 
			points.sort(key=lambda p: a.dist(p))

			




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

			




	
	
	
		
 
			cv.imwrite("/tmp/{0}.png".format(i),img_)

			




	
	
	
		
 
			pointDists=",".join(str(round(p1.dist(p2),3)) for (p1,p2) in zip(points[:-1],points[1:]))

			




	
	
	
		
 
			log.debug("\t".join(map(str,[i,line,line.score(allPoints),pointDists])))

			




	
	
	
		
 

			




	
	
	
		
 
	def _detectVanishingPoints(self,lines,imgCenter,trueVs):

			




	
	
	
		
 
		polarHough=PolarHough(math.pi/180,10)

			




	
	
	
		
 
		for (i,ab) in enumerate(lines):

			




	
	
	
		
 
			for cd in lines[i+1:]:

			




	
	
	
		
 
				point=ab.intersect(cd)

			




	
	
	
		
 
				if 0<=point.x<=self._rectW and 0<=point.y<=self._rectH: continue

			




	
	
	
		
 
				# log.debug("%s -> %s",point,point.toPolar(imgCenter))

			




	
	
	
		
 
				polarHough.put(point.toPolar(imgCenter))

			




	
	
	
		
 
		vanish=[EPoint.fromPolar(p,imgCenter) for p in polarHough.extract(2,trueVs)]

			




	
	
	
		
 
		log.debug(vanish)

			




	
	
	
		
 
		return vanish

			




	
	
	
		
 

			




	
	
	
		
 
	def _computeTransformationMatrix(self,vanish,lines):

			




	
	
	
		
 
		(v1,v2)=vanish

			




	
	
	
		
 
		(p,r)=sorted(lines,key=lambda p: point2lineDistance(p.a,p.b,v1))[:2]

			




	
	
	
		
 
		(q,s)=sorted(lines,key=lambda p: point2lineDistance(p.a,p.b,v2))[:2]

			




	
	
	
		
 
		(a,b,c,d)=Corners([p.intersect(q),q.intersect(r),r.intersect(s),s.intersect(p)]) # canonize the abcd order

			




	
	
	
		
 
	def _computeTransformationMatrix(self,p,q,r,s): # p || q, r || s

			




	
	
	
		
 
		(a,b,c,d)=Corners([p.intersect(r),p.intersect(s),q.intersect(r),q.intersect(s)]) # canonize the abcd order

			




	
	
	
		
 
		a_=EPoint(b.x,min(a.y,d.y))

			




	
	
	
		
 
		b_=EPoint(b.x,max(b.y,c.y))

			




	
	
	
		
 
		c_=EPoint(c.x,max(b.y,c.y))

			




	
	
	
		
 
		d_=EPoint(c.x,min(a.y,d.y))

			




	
	
	
		
 
		abcd=[list(point) for point in (a,b,c,d)]

			




	
	
	
		
 
		abcd_=[list(point) for point in (a_,b_,c_,d_)]

			




	
	
	
		
 
		log.debug("abcd: %s ->",(a,b,c,d))

			




	
	
	
		
 
		log.debug("-> abcd_: %s",(a_,b_,c_,d_))

			




	
	
	
		
 
		matrix=cv.getPerspectiveTransform(np.float32(abcd),np.float32(abcd_))

			




	
	
	
		
 
		log.debug("transformation matrix: %s",matrix)

			




	
	
	
		
 

			




	
	
	
		
 
		rect=np.copy(self._rect)

			




	
	
	
		
 
		for point in (a,b,c,d):

			




	
	
	
		
 
			cv.drawMarker(rect,(int(point.x),int(point.y)),(0,255,255),cv.MARKER_TILTED_CROSS)

			




	
	
	
		
 
		show(rect)

			




	
	
	
		
 
		transformed=cv.warpPerspective(rect,matrix,(self._rectW,self._rectH))

			




	
	
	
		
 
		show(transformed)

			




	
	
	
		
 
		show(transformed,"rectified image")

			




	
	
	
		
 

			




	
	
	
		
 
		return matrix

			




	
	
	
		
 

			




	
	
	
		
 
	def _drawLine(self,img,line):

			




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

			




	
	
	
		
 
		corners=[EPoint(0,0),EPoint(w,0),EPoint(0,h),EPoint(w,h)] # NW NE SW SE

			




	
	
	
		
 
		borders=[

			




	
	
	
		
 
			[Line.fromPoints(corners[0],corners[1]), Line.fromPoints(corners[2],corners[3])], # N S

			




	
	
	
		
 
			[Line.fromPoints(corners[0],corners[2]), Line.fromPoints(corners[1],corners[3])] # W E

			




	
	
	
		
 
		]

			




	
	
	
		
 

			




	
	
	
		
 
		(a,b)=(line.intersect(borders[0][0]), line.intersect(borders[0][1]))

			




        

    


    
    

    

        

                

                    exp/hough.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -50,29 +50,31 @@ class HoughTransform:

			




	
	
	
		
 

			




	
	
	
		
 
	def extract(self):

			




	
	
	
		
 
		img=self._createImg()

			




	
	
	
		
 
		self.show(img)

			




	
	
	
		
 
		lines=self._detectLines()

			




	
	
	
		
 
		res=[]

			




	
	
	
		
 
		i=0

			




	
	
	
		
 
		for (score,alpha,beta,peaks) in lines:

			




	
	
	
		
 
			log.debug("score: %s",score)

			




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

			




	
	
	
		
 
			self._drawLine(img,alpha,beta,peaks,i)

			




	
	
	
		
 

			




	
	
	
		
 
			res.append([])

			




	
	
	
		
 
			keys=self._readLineKeys(alpha,beta)

			




	
	
	
		
 
			for k in peaks:

			




	
	
	
		
 
				(alphaDeg,d)=keys[k]

			




	
	
	
		
 
				line=Line(alphaDeg*math.pi/180,d-self._diagLen//2)

			




	
	
	
		
 
				res.append(self._transformOutput(line))

			




	
	
	
		
 
				res[-1].append(self._transformOutput(line))

			




	
	
	
		
 
			res[-1].sort(key=lambda line: line.d)

			




	
	
	
		
 
			i+=1

			




	
	
	
		
 

			




	
	
	
		
 
		self.show(img)

			




	
	
	
		
 
		return res

			




	
	
	
		
 

			




	
	
	
		
 
	def update(self,img,weight=1):

			




	
	
	
		
 
		start=datetime.now().timestamp()

			




	
	
	
		
 
		for (r,row) in enumerate(img):

			




	
	
	
		
 
			for (c,pix) in enumerate(row):

			




	
	
	
		
 
				if pix==0: continue

			




	
	
	
		
 
				for alphaDeg in range(0,180):

			




	
	
	
		
 
					d=self._computeDist(c,r,alphaDeg)+self._diagLen//2

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: Sirius-560
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2023 by various authors & licensed under GPLv3.
            – Support