Integração do OpenCV com Vídeo 360 ao Vivo para Robótica

À medida que a inteligência artificial se torna mais avançada, os robôs estão sendo cada vez mais utilizados para libertar os humanos dos riscos de inspecionar locais perigosos ou da rotina da vigilância visual. Para fornecer algum grau de decisão autônoma, o robô muitas vezes possui câmeras conectadas a um computador Linux embarcado, como um NVIDIA Jetson ou um computador de placa única (SBC) x86.

Se a aplicação se beneficia de vídeo ao vivo de 360 graus, existem duas abordagens. A primeira, mais difícil, é usar várias câmeras e unir o vídeo no computador ou processar cada feed de vídeo separadamente. O número de câmeras usadas depende do campo de visão de cada câmera. Se o robô usar duas lentes olho de peixe que possam mostrar mais de 180 graus, apenas duas câmeras são necessárias. É comum usar três ou quatro câmeras.

Uma abordagem mais simples é usar uma câmera de 360° para consumidor. Na comunidade de desenvolvedores theta360.guide, um dos tópicos mais populares discutidos pelos desenvolvedores é como adicionar visão de 360 graus ao protótipo de seu robô e inserir o vídeo no OpenCV.

Embora existam diferentes maneiras de obter o vídeo da câmera de 360° para o computador Linux, o método mais popular é usar um cabo USB. WiFi e Ethernet não são tão populares. Os modelos RICOH THETA V, X e Z1 podem aparecer como uma webcam USB para o computador Linux. No entanto, é necessário um pouco de trabalho no Linux. Os computadores MacOS podem usar a câmera RICOH diretamente. Para o Windows, a RICOH fornece um driver. Para o Linux, a RICOH fornece uma versão modificada do libuvc no GitHub chamada libuvc-theta.

Para expor a câmera como um dispositivo de vídeo para o OpenCV, a RICOH fornece um programa de exemplo, libuvc-theta-sample. Isso pode ser usado com v4l2loopback para disponibilizar um dispositivo /dev/video* para o OpenCV.

Para testar a conexão da câmera com o computador Linux, primeiro conecte um cabo USB da câmera ao computador Linux e siga estas etapas:

git clone https://github.com/ricohapi/libuvc-theta.git
sudo apt install libjpeg-dev
cd libuvc-theta
mkdir build
cd build
cmake ..
make
sudo make install
cd ../..
git clone https://github.com/ricohapi/libuvc-theta-sample.git
cd libuvc-theta-sample/gst
make

# A THETA deve estar conectada ao seu computador e em 
# modo de transmissão ao vivo

./gst_viewer

Câmera de vídeo de 360° exibida com o gstreamer

Se a compilação falhar, você pode precisar de bibliotecas gstreamer adicionais. Isso instalará todas as bibliotecas necessárias.

sudo apt-get install \
    libgstreamer1.0-0 \
    gstreamer1.0-plugins-base \
    gstreamer1.0-plugins-good \
    gstreamer1.0-plugins-bad \
    gstreamer1.0-plugins-ugly \
    gstreamer1.0-libav \
    gstreamer1.0-doc \
    gstreamer1.0-tools \
    gstreamer1.0-x \
    gstreamer1.0-alsa \
    gstreamer1.0-gl \
    gstreamer1.0-gtk3 \
    gstreamer1.0-qt5 \
    gstreamer1.0-pulseaudio \
    libgstreamer-plugins-base1.0-dev

Além disso, um Raspberry Pi 4 não funcionará devido à falta de suporte de decodificação de hardware 4K H.264.

Configurando /dev/video*

Para tornar o dispositivo libuvc disponível como um dispositivo de vídeo, podemos usar v4l2loopback. O aplicativo libuvc-theta-sample usará o gstreamer para enviar o vídeo para o v4l2.

Se você tiver apenas uma única câmera de vídeo em seu computador, você deve modificar esta linha antes de executar a compilação. A linha abaixo é para um computador com a RICOH THETA conectada como a única webcam:

"v4l2sink device=/dev/video0 sync=false";

Acesso do OpenCV

Para testar se a câmera pode ser usada pelo OpenCV, vamos começar com um simples redimensionamento de quadro.

import cv2

cap = cv2.VideoCapture(0)

# Verifique se a webcam foi aberta corretamente
if not cap.isOpened():
    raise IOError("Cannot open webcam")

while True:
    ret, frame = cap.read()
    frame = cv2.resize(frame, None, fx=0.25, fy=0.25, interpolation=cv2.INTER_AREA)
    cv2.imshow('Input', frame)

    c = cv2.waitKey(1)
    if c == 27:
        break

cap.release()
cv2.destroyAllWindows()

Latência da Câmera

A latência é um grande problema nas discussões da comunidade. A latência da câmera THETA é de aproximadamente 350ms. Isso é muito alto para muitas aplicações que exigem que o robô reaja rapidamente. Também é muito alto para telepresença se você estiver controlando um drone que está se movendo ao redor de obstáculos. A latência se deve à costura interna da câmera das duas lentes. A costura não pode ser desativada no feed de vídeo.

Alternativa ao v4l2loopback

Como o v4l2loopback adiciona complexidade e sobrecarga, o pacote gstthetauvc pode ser usado para acessar a câmera diretamente do gstreamer.

Aqui está o mesmo teste usando gstthetauvc.

import cv2
# o pipeline abaixo funcionou
# cap = cv2.VideoCapture("thetauvcsrc \
#     ! decodebin \
#     ! autovideoconvert \
#     ! video/x-raw,format=BGRx \
#     ! queue ! videoconvert \
#     ! video/x-raw,format=BGR ! queue ! appsink")

# sugestão de pipeline graças ao nickel110
# tentativa de forçar a aceleração de hardware
# testado com NVIDIA 510.73 com uma antiga GTX 950 no Ubuntu 22.04
cap = cv2.VideoCapture("thetauvcsrc \
    ! queue \
    ! h264parse \
    ! nvdec \
    ! gldownload \
    ! queue \
    ! videoconvert n-threads=0 \
    ! video/x-raw,format=BGR \
    ! queue \
    ! appsink")

if not cap.isOpened():
    raise IOError('Cannot open RICOH THETA')

while True:
    ret, frame = cap.read()
    frame = cv2.resize(frame, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_AREA)
    cv2.imshow('frame', frame)


    c = cv2.waitKey(1)
    if c == 27:
        break

cap.release()
cv2.destroyAllWindows()

Exemplos de Feed de Vídeo 360 Ao Vivo

Aqui estão alguns exemplos de como usar o OpenCV para transformação de cor e detecção de bordas.

# Converter para escala de cinza
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Desfocar a imagem para melhor detecção de bordas
img_blur = cv2.GaussianBlur(img_gray, (3,3), 0) 
# Detecção de Bordas de Canny
edges = cv2.Canny(image=img_blur, threshold1=100, threshold2=200) # Detecção de Bordas de Canny
# Exibir Imagem de Detecção de Bordas de Canny
cv2.imshow('Canny Edge Detection', edges) 

Detecção de pessoas ao vivo e monitoramento.

A câmera tem duas lentes. O lado oposto ao botão do obturador é a lente traseira e será colocada no centro da cena. A detecção de objetos é mais precisa quando o objeto está centrado na visão equiretangular.

Humano centrado na lente traseira

No entanto, a detecção funciona razoavelmente bem quando o humano está na borda da visão equiretangular, mesmo à noite. Você pode precisar treinar seu modelo em um banco de dados de imagens fisheye ou 360°.

Humano detectado na borda da visão equiretangular

Melhorando a Detecção

Agora que você tem a detecção básica funcionando em frames equiretangulares de um feed de vídeo 360° ao vivo, você pode experimentar diferentes técnicas para melhorar a precisão. Um método é criar várias cenas achatadas de cada frame e então detectar o objeto em cada cena. O vídeo 360° Object Detect(Yolo) in ROS2 rviz2 and KR260 do engenheiro misoji fornece uma boa demonstração dessa técnica. Também há uma versão do YOLO que foi modificada para uso com vídeo panorâmico. Consulte o artigo PV-YOLO: Um Modelo de Detecção de Objetos para Vídeo Panorâmico baseado em YOLOv4.

Conclusão

Usando uma câmera 360° de consumo, você pode facilmente fazer com que o vídeo 360° apareça como uma webcam USB para softwares como OpenCV. Com o vídeo 360° acessível como um dispositivo de vídeo ou acessado através do gstreamer, softwares padrão como OpenCV ou outros softwares de detecção podem ser utilizados nos quadros equiretangulares do vídeo ao vivo. Devido à distorção da imagem, o algoritmo de detecção de objetos não funcionará tão bem em comparação a uma webcam padrão não 360°. No entanto, mesmo sem modificação, você ainda pode começar a realizar algumas detecções.

Para realmente usar a detecção para mais do que um projeto educacional ou de pesquisa, você precisará investigar técnicas para melhorar o reconhecimento dos objetos na visão equiretangular distorcida.