Prosty układ śledzący - RaspberryPi i kamera

[ZbychuW]

Witam

Przesyłam opis prostego układu śledzącego, który zbudowałem podczas pracy nad moim robotem mapującym (Mobilny robot z kamerą)

Konstrukcja jest bardzo prosta i składa się z dwóch serw i kamery. Do sterowania serwami wykorzystuję sterownik  "https://pl.aliexpress.com/item/32820023296.html?gatewayAdapt=glo2pol&spm=a2g0o.order_list.0.0.21ef1c24O5zdZZ".

W załączeniu kod oprogramowania do sterowanika i program śledzący w Pythonie.

Celem ćwiczenia było zbudownie układu, w którym kamera podąża za wybranym kolorem (w moim przypaku to flamaster). Współrzędne są przekształcane na polecenia wysyłane do sterowanika.

from collections import deque
import time
import threading
import socketserver 
import socket

from LobotServoController import ServoController
import numpy as np
import argparse
import imutils
import cv2
import Utils

screenWidth = 800

# określ granice dla "pisaka" - żółty kolor
colorLower = (17, 100, 100)
colorUpper = (37, 255, 255)

camera = cv2.VideoCapture(0)
lsc = ServoController(debug=False)
servoTime = 1
minServoPosition = 500
maxServoPosition = 2500
servoX = 1500
servoY = 1500
lsc.moveServo(10,int(servoX),int(servoTime))
lsc.moveServo(11,int(servoY),int(servoTime))
time.sleep(1)

previousTime = time.time()

# pętla
while True:
    # pobierz aktualną ramkę
    (grabbed, frame) = camera.read()
    frame=cv2.flip(frame,-1)
 
    # zmień rozmiar ramki,
    frame = imutils.resize(frame, width=screenWidth)

    # konwersja obrazu z przestrzeni RGB do HSV
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
 
    # wytnij obszar, którego kolor jest w granicach określonych w definicji
    mask = cv2.inRange(hsv, colorLower, colorUpper)
    #wyświetl maskę
    #cv2.imshow("Frame", mask)

    #wygładzam brzegi i usuwam drobne szczegóły
    mask = cv2.erode(mask, None, iterations=2)
    mask = cv2.dilate(mask, None, iterations=2)
    
    # znajdź kontury i oblicz środek "kursora"
    cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
        cv2.CHAIN_APPROX_SIMPLE)[-2]
    center = None
 
    # przetwarzanie tylko, gdy znajeziony przynajmniej jeden obszar
    if len(cnts) > 0:
        #odszukaj największy kontur    
        #użyj go do okręgu opisującego 
        c = max(cnts, key=cv2.contourArea)
        ((x, y), radius) = cv2.minEnclosingCircle(c)
        M = cv2.moments(c)
        center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
 
        #przetwarzaj ,jeśli promień jest większy niż minimum 10 pikseli
        if radius > 10:
            #narysuj okrąg,
            #uzupełnij listę punktów
            cv2.circle(frame, (int(x), int(y)), int(radius),
                (0, 255, 255), 2)
            cv2.circle(frame, center, 5, (0, 0, 255), -1)
            #oblicz odległość od środka ekranu
            width = camera.get(cv2. CAP_PROP_FRAME_WIDTH )
            height = camera.get(cv2. CAP_PROP_FRAME_HEIGHT )
            fps = camera.get(cv2. CAP_PROP_FPS)
            
 
            now = time.time()
            duration = now - previousTime 
            #print(duration)
            if now-previousTime > int(servoTime)/1000:
                dx = width/2 - x
                dy = height/2 - y
                
                if abs(dx) > 10:
                    stepX = round(dx/10)
                    servoX = servoX + stepX
             
                    if servoX < minServoPosition:
                        servoX = minServoPosition
                    if servoX > maxServoPosition:
                        servoX = maxServoPosition
                        
                    lsc.moveServo(10,int(servoX),int(servoTime))   

                if abs(dy) > 10:
                    stepY = -round(dy/10)
                    servoY = servoY + stepY
                    
                    if servoY < minServoPosition:
                        servoY = minServoPosition
                    if servoY > maxServoPosition:
                        servoY = maxServoPosition    
                   
                    lsc.moveServo(11,int(servoY),int(servoTime))
                
                previousTime = now
            
    #pokaż obraz z kółkiem
    cv2.imshow("Frame", frame)
    
    key = cv2.waitKey(1) & 0xFF
 
    # if the 'q' key is pressed, stop the loop
    if key == ord("q"):
        break

 
# cleanup the camera and close any open windows
camera.release()
cv2.destroyAllWindows()

Aby uniknąć gwałtownych ruchów przy zmianie kierunku zastosowałem metodę, w której cel jest uzyskiwany w sposób przyrostowy. 

Ważna jest w projekcie właściwa identyfikacja koloru. Poniżej prosty kod w Pythonie.

import sys
import numpy as np
import cv2
 
blue = sys.argv[1]
green = sys.argv[2]
red = sys.argv[3]  
 
color = np.uint8([[[blue, green, red]]])
hsv_color = cv2.cvtColor(color, cv2.COLOR_BGR2HSV)
 
hue = hsv_color[0][0][0]
 
print("Lower bound is :"),
print("[" + str(hue-10) + ", 100, 100]\n")
 
print("Upper bound is :"),
print("[" + str(hue + 10) + ", 255, 255]")

Forbot.zip

Edytowano Marzec 25, 2022 przez ZbychuW

[Gieneq]

@ZbychuW dziękujemy za pochwalenie się ciekawym projektem  

[Marooned]

Myślę, że dobrym dodatkiem byłoby dodanie kodu, który w przypadku zgubienia celu obraca kamerą w kierunku, gdzie cel zniknął. To widać jak za szybko uciekałeś za kadr, kamera stawała w miejscu, gdzie dalsze poruszanie spowodowałoby odnalezienie obiektu.

[trainee]

Creepy.