extractor and display

Author: antonio

.DS_Store

@@ -0,0 +1,16 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+numpy = "*"
+opencv-python = "*"
+pygame = "*"
+matplotlib = "*"
+scikit-image = "*"
+
+[dev-packages]
+
+[requires]
+python_version = "3.9"

Pipfile

@@ -0,0 +1,15 @@
+import numpy as np
+import cv2 as cv
+from matplotlib import pyplot as plt
+
+img = cv.imread('cubes.png')
+gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
+
+corners = cv.goodFeaturesToTrack(gray,300,0.01,3)
+corners = np.int0(corners)
+
+for i in corners:
+    x,y = i.ravel()
+    cv.circle(img,(x,y),3,255,-1)
+
+plt.imshow(img),plt.show()

Pipfile.lock

@@ -0,0 +1,23 @@
+import pygame
+from pygame.locals import DOUBLEBUF
+
+class Display(object):
+    def __init__(self, W, H):
+        pygame.init()
+        self.screen = pygame.display.set_mode((W, H), DOUBLEBUF)
+        self.surface = pygame.Surface(self.screen.get_size()).convert()
+
+    def paint(self, img):
+    # junk
+        for event in pygame.event.get():
+            pass
+
+        # draw
+        #pygame.surfarray.blit_array(self.surface, img.swapaxes(0,1)[:, :, [2,1,0]])
+
+        # RGB, not BGR (might have to switch in twitchslam)
+        pygame.surfarray.blit_array(self.surface, img.swapaxes(0,1)[:, :, [0,1,2]])
+        self.screen.blit(self.surface, (0,0))
+
+        # blit
+        pygame.display.flip()

corner_detector.py

@@ -0,0 +1,46 @@
+import cv2
+import numpy as np
+from skimage.measure import ransac
+from skimage.transform import FundamentalMatrixTransform
+
+class Extractor(object):
+    def __init__(self):
+        self.orb = cv2.ORB_create()
+        self.bf = cv2.BFMatcher.create(cv2.NORM_HAMMING)
+        self.last = None
+
+    def extract(self, img):
+        # preprocessing
+        # temporaly disabled because of np.float32() required for the followirng steps
+        #gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        # detection
+        feats = cv2.goodFeaturesToTrack(np.mean(img, axis=2).astype(np.uint8), maxCorners=300, qualityLevel=0.01, minDistance=3)
+
+        # extraction
+        kps = [cv2.KeyPoint(x=f[0][0], y=f[0][1], _size=20) for f in feats]
+        kps, des = self.orb.compute(img, kps)
+
+        # matching
+        ret = []
+        if self.last is not None:
+            matches = self.bf.knnMatch(des, self.last['des'], k=2)
+            for m,n in matches:
+                if m.distance < 0.75*n.distance:
+                    kp1 = kps[m.queryIdx].pt
+                    kp2 = self.last['kps'][m.trainIdx].pt
+                    ret.append((kp1, kp2))
+        
+        # filter
+        if len(ret) > 0:
+            ret = np.array(ret)
+
+            model, inliers = ransac((ret[:, 0], ret[:, 1]),
+                                    FundamentalMatrixTransform,
+                                    min_samples=8,
+                                    residual_threshold=1, 
+                                    max_trials=100)
+            ret = ret[inliers]
+
+        # return 
+        self.last = {'kps': kps, 'des': des}
+        return ret

cubes.png

@@ -0,0 +1,38 @@
+import cv2
+import pygame
+from display import Display
+from extractor import Extractor
+import numpy as np
+
+#cv2.namedWindow('image', cv2.WINDOW_NORMAL)
+W = 1920//2
+H = 1080//2
+
+disp = Display(W, H)            
+fe = Extractor()
+
+def process_frame(img):
+    img = cv2.resize(img, (W, H))
+    matches = fe.extract(img)
+
+    print("%d matches" % len(matches))
+
+    for pt1, pt2 in matches:
+        u1,v1 = map(lambda x: int(round(x)), pt1 )
+        u2,v2 = map(lambda x: int(round(x)), pt2 )
+
+        cv2.circle(img, (u1,v1), color=(0,255,0), radius=3)
+        cv2.line(img, (u1,v1), (u2,v2), color=(255,0,0))
+
+    disp.paint(img)
+
+
+if __name__ == "__main__":
+    cap = cv2.VideoCapture("test.mp4")
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if ret == True:
+            process_frame(frame)
+        else:
+            break