Rastreamento automático de objetos de visão

Uma coisa que tentaremos realizar será a detecção e rastreamento de um determinado objeto de cor. Para isso, devemos entender um pouco mais sobre como o OpenCV interpreta as cores.

Henri Dang escreveu um ótimo tutorial sobre detecção de cores em Python com OpenCV.

Normalmente, nossa câmera funcionará com o modo de cor RGB, que pode ser entendido pensando nele como todas as cores possíveis que podem ser feitas de três luzes coloridas para vermelho, verde e azul. Em vez disso, trabalharemos aqui com BGR (azul, verde, vermelho).

Conforme descrito acima, com BGR, um pixel é representado por 3 parâmetros, azul, verde e vermelho. Cada parâmetro geralmente tem um valor de 0 a 255 (ou O a FF em hexadecimal). Por exemplo, um pixel azul puro na tela do computador teria um valor B de 255, um valor G de 0 e um valor R de 0.

OpenCV trabalha com modelo de cores HSV (Hue, Saturation, Value), que é uma representação alternativa do modelo de cores RGB, projetado na década de 1970 por pesquisadores de computação gráfica para se alinhar mais de perto com a forma humana a visão percebe os atributos de criação de cores:

Ótimo. Portanto, se você deseja rastrear uma determinada cor usando OpenCV, deve defini-la usando o modelo HSV.

Exemplo

Digamos que devo rastrear um objeto amarelo como a caixa de plástico mostrada na imagem acima. A parte mais fácil é encontrar seus elementos BGR. Você pode usar qualquer programa de design para encontrá-lo (usei o PowerPoint).

No meu caso, encontrei:

• Azul:71

• Verde:234

• Vermelho:213

Em seguida, devemos converter o modelo BGR (71, 234, 213) para um modelo HSV, que será definido com limites de intervalo superior e inferior. Para isso, vamos executar o código abaixo:

 importar sysimport numpy como npimport cv2blue =sys.argv [1] green =sys.argv [2] red =sys.argv [3] color =np.uint8 ([[[blue, green , vermelho]]]) hsv_color =cv2.cvtColor (color, cv2.COLOR_BGR2HSV) hue =hsv_color [0] [0] [0] print ("O limite inferior é:"), print ("[" + str (hue- 10) + ", 100, 100] \ n") print ("O limite superior é:"), print ("[" + str (hue + 10) + ", 255, 255]") 

Como alternativa, você pode baixar o código do meu GitHub:bgr_hsv_converter.py

Para executar, digite o comando abaixo tendo como parâmetros os valores BGR encontrados antes:

 python bgr_hsv_converter.py 71 234 213 

O programa imprimirá os limites superior e inferior da cor do nosso objeto.

Neste caso:

 limite inferior:[24, 100, 100] 

e

 limite superior:[44, 255, 255] 

O Terminal PrintScreen mostra o resultado.

Por último, mas não menos importante, vamos ver como o OpenCV pode “mascarar” nosso objeto depois de determinar sua cor:

 import cv2import numpy as np # Leia a imagem - O 1 significa que queremos a imagem em BGRimg =cv2.imread ('yellow_object.JPG', 1) # redimensionar a imagem para 20% em cada axisimg =cv2.resize (img, (0,0), fx =0.2, fy =0.2) # converter imagem BGR em uma imagem HSVhsv =cv2.cvtColor (img, cv2.COLOR_BGR2HSV) # NumPy para criar matrizes para manter superior e inferior intervalo # O “dtype =np.uint8” significa que o tipo de dados é um inteiro de 8 bits intervalo inferior =np.array ([24, 100, 100], dtype =np.uint8) intervalo superior =np.array ([44, 255, 255 ], dtype =np.uint8) # criar uma máscara para imagemask =cv2.inRange (hsv, lower_range, upper_range) # exibir a máscara e a imagem lado a lado-sidecv2.imshow ('mask', mask) cv2.imshow ('imagem', img) # espere que o usuário pressione [ESC] enquanto (1):k =cv2.waitKey (0) if (k ==27):breakcv2.destroyAllWindows () 

Como alternativa, você pode baixar o código do meu GitHub:colorDetection.py

Para executar, digite o comando abaixo tendo em seu diretório uma foto com seu objeto alvo (no meu caso:yellow_object.JPG):

 python colorDetection.py 

A imagem acima mostrará a imagem original (“imagem”) e como o objeto aparecerá (“máscara”) após a aplicação da máscara.

Etapa 5:rastreamento de movimento do objeto

Agora que sabemos como “selecionar” nosso objeto usando uma máscara, vamos rastrear seu movimento em tempo real usando a câmera. Para isso, baseei meu código no tutorial de Rastreamento de bola com OpenCV de Adrian Rosebrock.

Eu sugiro fortemente que você leia o tutorial de Adrian em detalhes.

Primeiro, confirme se você tem a biblioteca imutils instalado. é a coleção de funções de conveniência OpenCV de Adrian para tornar algumas tarefas básicas (como redimensionar ou virar a tela) muito mais fáceis. Caso contrário, insira o comando abaixo para instalar a biblioteca em seu ambiente Python virtual:

 pip install imutils 

Em seguida, baixe o código ball_tracking.py do meu GitHub e execute-o usando o comando:

 python ball_traking.py 

Basicamente, é o mesmo código de Adrian, a menos que seja o “vídeo flip vertical”, que obtive com a linha:

 frame =imutils.rotate (frame, angle =180) 

Além disso, observe que os limites da máscara usados ​​foram os que obtivemos na etapa anterior.

Etapa 6:Testando os GPIOs

Agora que brincamos com o básico do OpenCV, vamos instalar um LED em nosso RPi e começar a interagir com nossos GPIOs.

Siga o diagrama elétrico acima:O cátodo do LED será conectado ao GPIO 21 e seu ânodo ao GND por meio de um resistor de 220 ohms.

Vamos testar nosso LED dentro de nosso ambiente virtual Python.

Lembre-se de que é possível que RPi.GPIO não esteja instalado em seu ambiente virtual Python! Para corrigir esse problema, uma vez lá (lembre-se de confirmar que o (cv) está em seu terminal), você precisa usar o pip para instalá-lo em seu ambiente virtual:

 pip install RPi.GPIO 

Vamos usar o script Python para executar um teste simples:

 importar sysimport timeimport RPi.GPIO como GPIO # inicializar GPIO e variablesredLed =int (sys.argv [1]) freq =int (sys.argv [2]) GPIO.setmode (GPIO.BCM ) GPIO.setup (redLed, GPIO.OUT) GPIO.setwarnings (False) print ("\ n [INFO] LED piscando (5 vezes) conectado no GPIO {0} a cada {1} segundo (s)". Formato ( redLed, freq)) para i no intervalo (5):GPIO.output (redLed, GPIO.LOW) time.sleep (freq) GPIO.output (redLed, GPIO.HIGH) time.sleep (freq) # faça um pouco de cleanupprint ("\ n [INFO] Saindo do programa e coisas de limpeza \ n") GPIO.cleanup () 

Este código receberá como argumentos um número GPIO e a frequência em segundos que nosso LED deve piscar. O LED piscará 5 vezes e o programa será encerrado. Observe que antes de encerrar, iremos liberar os GPIOs.

Portanto, para executar o script, você deve inserir como parâmetros, LED GPIO , e frequência .

Por exemplo:

 python LED_simple_test.py 21 1 

O comando acima piscará 5 vezes o LED vermelho conectado ao “GPIO 21” a cada “1” segundo.

O arquivo GPIO_LED_test.py pode ser baixado do meu GitHub

A tela de impressão do Terminal acima mostra o resultado (e é claro que você deve confirmar se o LED está piscando.

Agora, vamos trabalhar com OpenCV e algumas coisas básicas do GPIO.

Etapa 7:Reconhecendo cores e interação GPIO

Vamos começar a integrar nossos códigos OpenCV com interação GPIO. Começaremos com o último código OpenCV e integraremos a biblioteca GPIO-RPI nele, portanto, acenderemos o LED vermelho sempre que nosso objeto colorido for encontrado pela câmera. O código usado nesta etapa foi baseado no ótimo tutorial de Adrian OpenCV, RPi.GPIO e GPIO Zero no Raspberry Pi:

A primeira coisa a fazer é “criar” nosso LED, conectando-o ao GPIO específico:

 importar RPi.GPIO como GPIOredLed =21GPIO.setmode (GPIO.BCM) GPIO.setwarnings (False) GPIO.setup (redLed, GPIO.OUT) 

Em segundo lugar, devemos inicializar nosso LED (desligado):

 GPIO.output (redLed, GPIO.LOW) ledOn =False 

Agora, dentro do loop, onde o “círculo” é criado quando o objeto é encontrado, ligaremos o LED:

 GPIO.output (redLed, GPIO.HIGH) ledOn =True 

Vamos baixar o código completo do meu GitHub:object_detection_LED.py

Execute o código usando o comando:

 python object_detection_LED.py 

Experimente com diferentes objetos (cor e formato). Você verá que, uma vez que a cor corresponda dentro dos limites da máscara, o LED é ligado.

O vídeo abaixo mostra algumas experiências. Observe que apenas objetos amarelos que ficam dentro da faixa de cores serão detectados, ligando o LED. Objetos com cores diferentes são ignorados.

Estamos usando apenas o LED aqui, conforme explicado na última etapa. Eu tinha meu Pan Tilt já montado quando fiz o vídeo, então ignore. Trataremos do mecanismo PAN / TILT na próxima etapa.

Step 8:The Pan Tilt Mechanism

Now that we have played with the basics of OpenCV and GPIO, let’s install our Pan/tilt mechanism.

For details, please visit my tutorial: Pan-Tilt-Multi-Servo-Control

The servos should be connected to an external 5V supply, having their data pin (in my case, their yellow wiring) connect to Raspberry Pi GPIO as below:

• GPIO 17 ==> Tilt Servo

• GPIO 27 ==> Pan Servo

Do not forget to connect the GNDs together ==> Raspberry Pi – Servos – External Power Supply)

You can have as an option, a resistor of 1K ohm in series, between Raspberry Pi GPIO and Server data input pin. This would protect your RPi in case of a servo problem.

Let’s also use the opportunity and test our servos inside our Virtual Python Environment.

Let’s use Python script to execute some tests with our drivers:

from time import sleepimport RPi.GPIO as GPIOGPIO.setmode(GPIO.BCM)GPIO.setwarnings(False)def setServoAngle(servo, angle):pwm =GPIO.PWM(servo, 50) pwm.start(8) dutyCycle =angle / 18. + 3. pwm.ChangeDutyCycle(dutyCycle) sleep(0.3) pwm.stop()if __name__ =='__main__':import sys servo =int(sys.argv[1]) GPIO.setup(servo, GPIO.OUT) setServoAngle(servo, int(sys.argv[2])) GPIO.cleanup()

The core of above code is the function setServoAngle(servo, angle). This function receives as arguments, a servo GPIO number, and an angle value to where the servo must be positioned. Once the input of this function is “angle”, we must convert it to an equivalent duty cycle.

To execute the script, you must enter as parameters, servo GPIO , and angle .

For example:

python angleServoCtrl.py 17 45

The above command will position the servo connected on GPIO 17 (“tilt”) with 45 degrees in “elevation”.

The file angleServoCtrl.py can be downloaded from my GitHub

Step 9:Finding the Object Realtime Position

The idea here will be to position the object in the middle of the screen using the Pan/Tilt mechanism. The bad news is that for starting we must know where the object is located in real time. But the good news is that it is very easy, once we already have the object center’s coordinates.

First, let’s take the “object_detect_LED” code used before and modify it to print the x,y coordinates of the founded object.

Download from my GitHub the code: objectDetectCoord.py

The “core” of the code is the portion where we find the object and draw a circle on it with a red dot in its center.

# only proceed if the radius meets a minimum sizeif radius> 10:# draw the circle and centroid on the frame, # then update the list of tracked points cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2) cv2.circle(frame, center, 5, (0, 0, 255), -1) # print center of circle coordinates mapObjectPosition(int(x), int(y)) # if the led is not already on, turn the LED on if not ledOn:GPIO.output(redLed, GPIO.HIGH) ledOn =True

Let’s “export” the center coordinates to mapObjectPosition(int(x), int(y)) function in order to print its coordinates. Below the function:

def mapObjectPosition (x, y):print ("[INFO] Object Center coordenates at X0 ={0} and Y0 ={1}".format(x, y))

Running the program, we will see at our terminal, the (x, y) position coordinates, as shown above. Move the object and observe the coordinates. We will realize that x goes from 0 to 500 (left to right) and y goes from o to 350 (top to down). See the above pictures.

Great! Now we must use those coordinates as a starting point for our Pan/Tilt tracking system

Step 10:Object Position Tracking System

We want that our object stays always centered on the screen. So, let’s define for example, that we will consider our object “centered” if:

• 220

• 160

Outside of those boundaries, we must move our Pan/Tilt mechanism to compensate deviation. Based on that, we can build the function mapServoPosition(x, y)  as below. Note that the “x” and “y” used as parameters in this function are the same that we have used before for printing central position:

# position servos to present object at center of the framedef mapServoPosition (x, y):global panAngle global tiltAngle if (x <220):panAngle +=10 if panAngle> 140:panAngle =140 positionServo (panServo, panAngle) if (x> 280):panAngle -=10 if panAngle <40:panAngle =40 positionServo (panServo, panAngle) if (y <160):tiltAngle +=10 if tiltAngle> 140:tiltAngle =140 positionServo (tiltServo, tiltAngle) if (y> 210):tiltAngle -=10 if tiltAngle <40:tiltAngle =40 positionServo (tiltServo, tiltAngle)

Based on the (x, y) coordinates, servo position commands are generated, using the function positionServo(servo, angle). For example, suppose that y position is “50”, what means that our object is almost in the top of the screen, that can be translated that out “camera sight” is “low” (let’s say a tilt angle of 120 degrees) So we must “decrease” Tilt angle (let’s say to 100 degrees), so the camera sight will be “up” and the object will go “down” on screen (y will increase to let’s say, 190).

The above diagram shows the example in terms of geometry.

Think how the Pan camera will operate. note that the screen is not mirroring, what means that if you move the object to “your left”, it will move on screen for “your right”, once you are in opposition to the camera.

The function positionServo(servo, angle) can be written as:

def positionServo (servo, angle):os.system("python angleServoCtrl.py " + str(servo) + " " + str(angle)) print("[INFO] Positioning servo at GPIO {0} to {1} degrees\n".format(servo, angle))

We will be calling the script shown before for servo positioning.

Note that angleServoCtrl.py must be in the same directory as objectDetectTrac.py

The complete code can be download from my GitHub: objectDetectTrack.py

Step 11:Conclusion

As always, I hope this project can help others find their way into the exciting world of electronics!

For details and final code, please visit my GitHub depository: OpenCV-Object-Face-Tracking

For more projects, please visit my blog: MJRoBot.org

Saludos from the south of the world!

See you in my next tutorial!

Thank you,

Fonte: Automatic Vision Object Tracking