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
 
@@ -5,6 +5,7 @@ sys.path.append("../src")
 
import os
 
import math
 
import random
 
import itertools
 
import logging as log
 

			




	
	
	
		
 
import cv2 as cv

			




	
	
		
 
@@ -109,30 +110,21 @@ class BoardDetector:

			




	
	
	
		
 
		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]

			




	
	
		
 
@@ -177,36 +169,8 @@ class BoardDetector:

			




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

			




	
	
		
 
@@ -223,7 +187,7 @@ class BoardDetector:

			




	
	
	
		
 
			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

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    exp/hough.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -59,11 +59,13 @@ class HoughTransform:

			




	
	
	
		
 
			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)

			




        

    



    


    



    



      

      





    
    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