From f2335307a26a8ab3e18d8990d2640a8de4cbd0e4 Mon Sep 17 00:00:00 2001
From: UnavailableDev <69792062+UnavailableDev@users.noreply.github.com>
Date: Tue, 6 Jun 2023 11:57:48 +0200
Subject: keypoint sign recognition

---
 openMV/POC_signs_red.py | 108 +++++++++++++++++++++++++++++-------------------
 1 file changed, 66 insertions(+), 42 deletions(-)

(limited to 'openMV')

diff --git a/openMV/POC_signs_red.py b/openMV/POC_signs_red.py
index 3279467..c996a88 100644
--- a/openMV/POC_signs_red.py
+++ b/openMV/POC_signs_red.py
@@ -4,70 +4,94 @@
 
 import sensor, image, time
 
-# Color Tracking Thresholds (Grayscale Min, Grayscale Max)
-min_rgb = 128
-max_rgb = 255
-threshold_list = [(min_rgb, max_rgb)]# only bright grey colours will get tracked.
-threshold_rgb = [(0, 100, 75, 32, 2, 127)] #only find red
-#threshold_rgb = [(18, 78, -8, 127, 24, 127)]
-
 sensor.reset()                      # Reset and initialize the sensor.
 sensor.set_pixformat(sensor.RGB565) # Set pixel format to RGB565 (or GRAYSCALE)
 #sensor.set_pixformat(sensor.GRAYSCALE)
-sensor.set_framesize(sensor.QVGA)   # Set frame size to QVGA (320x240)
+sensor.set_framesize(sensor.HVGA)   # Set frame size to QVGA (320x240)
 sensor.skip_frames(time = 2000)     # Wait for settings take effect.
 clock = time.clock()                # Create a clock object to track the FPS.
 
-while(True):
-    clock.tick()                    # Update the FPS clock.
-    img = sensor.snapshot()         # Take a picture and return the image.
 
-    ThR = 0
-    ThG = 255
-    ThB = 128
-    threshold_r = [(ThR,255,0,255,255,ThG)]
+def init_kpts(str):
+    temp_img = image.Image(f"./{str}.jpg", copy_to_fb=True)
+    temp_img.to_grayscale()
+
+    kpts = temp_img.find_keypoints(max_keypoints=128, threshold=kpts_threshold, corner_detector=kpts_corner, scale_factor=1.2)
+    return kpts
+
+def match_kpts(kpts0, kpts1):
+    if kpts0 is not None and kpts1 is not None:
+
+        match = image.match_descriptor(kpts0, kpts1, threshold=70)
+        #print("matched:%d dt:%d"%(match.count(), match.theta()))
+
+        if match.count() > 0:
+            print(match.count())
+
+        return match.count() > 1
+
+    else:
+        return 0
+
+def read_red_sign(val, img, kpts):
+
+    #img.draw_keypoints(kpts,255)
+
+    if match_kpts(kpts, stop):
+        img.draw_rectangle(val.rect())
+        #img.draw_cross(match.cx(), match.cy(), size=10)
+        print("stop")
 
-    #Red
-    #if(R >= ThR and G <= thG)
+    if match_kpts(kpts, speed):
+        img.draw_rectangle(val.rect())
+        print("speed")
 
-    #Blue
-    #if(B >= thB)
+    if match_kpts(kpts, car):
+        img.draw_rectangle(val.rect())
+        print("car")
 
+#def read_red_sign(val, img, kpts):
+
+
+kpts_threshold = 20
+kpts_corner = image.CORNER_FAST
+
+speed = init_kpts("speed")
+stop = init_kpts("stop")
+car = init_kpts("image")
+
+
+while(True):
+    clock.tick()                    # Update the FPS clock.
+    img = sensor.snapshot()         # Take a picture and return the image.
+
+    ######## Detect signs
 
     blobs_r = img.find_blobs([(0, 100, 25, 63, -128, 127)])
     blobs_b = img.find_blobs([(0, 29, 11, -128, -31, -5)])
-    #blobs.count()
-    #print(blobs)
-    ##kpts = img.find_keypoints()
-
-    print(f"old: { len(blobs_r) + len(blobs_b) }")
+    #print(f"old: { len(blobs_r) + len(blobs_b) }")
 
     blobs_r[:] = [b for b in blobs_r if (b.convexity() < 0.7 and b.area() > 64)]
     blobs_b[:] = [b for b in blobs_b if (b.convexity() < 0.7 and b.area() > 64)]
+    #print(f"new: { len(blobs_r) + len(blobs_b) }")
+
+
+    ######## Read signs
+    img = img.to_grayscale()
 
-    print(f"new: { len(blobs_r) + len(blobs_b) }")
+    if(len(blobs_r) > 0 or len(blobs_b) > 0):
 
-    #for index, b in enumerate(blobs_r):
-        #convex = b.convexity()
-        #roundn = b.roundness()
-        #if convex < 0.8:
-            #img.draw_rectangle(b.rect(),[255,int((256)*roundn),0],2)
-            #print(index)
-        #else:
-            #del blobs_r[index]
-            #img.draw_rectangle(b.rect(),[128,128,128],4)
+        kpts_img = img.find_keypoints(max_keypoints=255, threshold=kpts_threshold, corner_detector=kpts_corner)
 
-    for index, b in enumerate(blobs_r):
-        roundn = b.roundness()
-        img.draw_rectangle(b.rect(),[255,int((256)*roundn),0],2)
-        #print(index)
+        for index, b in enumerate(blobs_r):
+            read_red_sign(b, img, kpts_img)
 
-    for index, b in enumerate(blobs_b):
-        roundn = b.roundness()
-        img.draw_rectangle(b.rect(),[0,int((256)*roundn),255],2)
+        for index, b in enumerate(blobs_b):
+            read_blu_sign(b, img, kpts_img)
 
 
     # Note: OpenMV Cam runs about half as fast when connected
     # to the IDE. The FPS should increase once disconnected.
+    #img = gr
 
-    print("EOC")
+    #print("EOC")
-- 
cgit v1.2.3