Gesture Hawk: robô controlado por gestos manuais usando interface baseada em processamento de imagens: 13 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Gesture Hawk foi apresentado no TechEvince 4.0 como uma interface homem-máquina simples baseada em processamento de imagem. Sua utilidade reside no fato de que nenhum sensor adicional ou vestível, exceto uma luva, é necessário para controlar o carro robótico que funciona com o princípio de tração diferencial. Neste instrutível, iremos guiá-lo através do princípio de funcionamento por trás do rastreamento de objetos e detecção de gestos usados no sistema. O código-fonte deste projeto pode ser baixado do Github via link:

Etapa 1: COISAS NECESSÁRIAS:

1. Motorista L298N
2. Motores DC
3. Chassis de carro robô
4. Arduino Uno
5. Baterias LiPo
6. Cabo USB Arduino (longo)
7. Biblioteca OpenCV com Python

Etapa 2: PRINCÍPIO DE TRABALHO:

O Gesture Hawk é um sistema de processamento trifásico, como você pode ver no diagrama acima.

Etapa 3: CAPTURA DE ENTRADA E PROCESSAMENTO:

A captura de entrada pode ser compreendida nas categorias mais amplas fornecidas no diagrama acima.

Para extrair a forma da mão do ambiente, precisamos usar mascaramento ou filtragem de uma cor definida (neste caso - azul violeta '). Para fazer isso, você precisa converter a imagem do formato BGR para HSV, o que pode ser feito usando o seguinte trecho de código.

hsv = cv2.cvtColor (frame, cv2. COLOR_BGR2HSV)

Agora, a próxima etapa é encontrar a faixa desejada de parâmetros do HSV para extrair a mão por meio de máscara ou filtro. Para isso, a melhor maneira é usar barras de controle para encontrar um intervalo adequado. Aqui está a captura de tela de uma barra de controle usada para este projeto.

Passo 4:

Etapa 5:

Aqui, há um trecho de código fornecido abaixo para fazer uma barra de controle para construção de máscara:

import cv2

import numpy como npdef nothing (x): passe cv2.namedWindow ('image') img = cv2. VideoCapture (0) cv2.createTrackbar ('l_H', 'image', 110, 255, nothing) cv2.createTrackbar ('l_S ',' imagem ', 50, 255, nada) cv2.createTrackbar (' l_V ',' imagem ', 50, 255, nada) cv2.createTrackbar (' h_H ',' imagem ', 130, 255, nada) cv2. createTrackbar ('h_S', 'image', 255, 255, nada) cv2.createTrackbar ('h_V', 'imagem', 255, 255, nada) while (1): _, frame = img.read ()

hsv = cv2.cvtColor (frame, cv2. COLOR_BGR2HSV) lH = cv2.getTrackbarPos ('l_H', 'imagem') lS = cv2.getTrackbarPos ('l_S', 'imagem') lV = cv2.getTrackbarPos ('l_V', 'imagem') hH = cv2.getTrackbarPos ('h_H', 'imagem') hS = cv2.getTrackbarPos ('h_S', 'imagem') hV = cv2.getTrackbarPos ('h_V', 'imagem') lower_R = np. array ([lH, lS, lV]) higher_R = np.array ([hH, hS, hV]) mask = cv2.inRange (hsv, lower_R, higher_R) res = cv2.bitwise_and (frame, frame, mask = mask) cv2.imshow ('imagem', res) k = cv2.waitKey (1) & 0xFF se k == 27: quebrar cv2.destroyAllWindows ()

Etapa 6: PARTE DE PROCESSAMENTO:

Bem, temos a forma geométrica de uma mão, agora é hora de explorá-la e utilizá-la para descobrir o gesto da mão.

Casco convexo:

Por meio do casco convexo, tentamos encaixar um polígono aproximado por meio de pontos extremos presentes na forma. A imagem presente à esquerda mostra o polígono aproximado que foi atribuído à forma com os pontos convexos marcados em vermelho.

Os pontos convexos são aqueles pontos na forma que estão mais distantes de um lado desse polígono aproximado. Mas, o problema com o casco convexo é que, durante seu cálculo, obteremos uma matriz de todos os pontos convexos, mas o que precisamos é o ponto convexo com ponta azul. Nós lhe diremos por que é necessário.

Para encontrar este ponto convexo, precisamos aplicar a fórmula da distância perpendicular para encontrar a distância do ponto convexo com o lado mais próximo. Observamos que o ponto pontiagudo azul possui distância máxima da lateral e assim chegamos a este ponto.

Etapa 7:

Etapa 8:

Em seguida, precisamos encontrar a inclinação da linha que une a ponta do polegar (ou o ponto extremo) a este ponto convexo com a horizontal.

Etapa 9:

No caso acima, o ângulo α deve estar entre 0 a 90 graus se o gesto for para virar à esquerda. Ou seja, tan (α) deve ser positivo.

Etapa 10:

No caso acima, o ângulo α deve estar entre 180 a 90 graus se o gesto for para virar à direita. Ou seja, tan (α) deve ser negativo.

Portanto, se Tan α for positivo, vire à esquerda. Se Tan α for negativo, vire à direita. Agora, é hora de ver como detectar o comando de parada mais importante.

Aqui, uma proporção especificada (encontrada por acerto e tentativa) é examinada e, em casos máximos, essa proporção de distâncias permanece neste intervalo específico.

Etapa 11:

Por fim, o gesto de movimento anterior é analisado pela função matchShape () no OpenCV. Esta função compara a forma de dois contadores, neste caso, entre o exemplo de treinamento em impulso na imagem acima com o contorno no lado esquerdo da imagem acima. Retorna um valor que varia de 0 a 2 ou 3, de acordo com a variação presente na forma de dois contornos. Para o mesmo contorno de forma idêntica, retorna 0.

ret = cv2.matchShapes (cnt1, cnt2, 1, 0,0)

Aqui, cn1 e cnt2 são os dois contornos que devem ser comparados.

Etapa 12: CONTROLE DE MOVIMENTO:

PySerial:

Usamos a biblioteca PySerial do python para converter os dados processados em dados seriais para comunicação ao Arduino Uno via cabo USB do Arduino. Uma vez que um gesto específico foi detectado pelo opencv, criamos uma variável temporária, digamos 'x', atribuímos a ela algum valor único e a convertemos em entrada serial usando a seguinte linha de comando: -

import serial #para importar a biblioteca Pyserial

serial. Serial ('', baudrate = '9600', timeout = '0') # configurando a saída serial.. NOME DA PORTA é o nome da porta pela qual a transmissão de dados ocorrerá.

serial.write (b'x ') # x é o alfabeto enviado para a porta … b é para converter esta string em bytes.

Processamento Arduino:

Agora o arduino é codificado de tal forma que cada serial x diferente é mapeado linearmente para certa ação responsável por um movimento suave do robô (digamos que a detecção do gesto para a esquerda acionará os motores da direita para virar à esquerda). Podemos controlar o movimento de cada roda tanto em termos de translação quanto de rotação, alterando o código de maneira adequada.

Motorista L298N: -

O driver do motor é usado como mediador entre o motor e a fonte de alimentação, uma vez que os motores não podem ser alimentados diretamente devido às classificações de baixa tensão. A bateria Li-Po é conectada ao seu terminal de entrada de 12 V e conectamos o soquete de 5 V do arduino ao soquete de entrada de 5 V do driver do motor, finalmente conectando o aterramento do Li-Po, bem como do Arduino em um soquete de aterramento comum do driver do motor.

Agora os terminais dos motores são conectados nas tomadas fornecidas. Por fim, conectamos os terminais de entrada do motor aos soquetes de saída PWM do Arduino, permitindo-nos decidir com precisão os aspectos de rotação e translação do movimento.