Detecção de objetos 3D (3D Bounding Boxes) em Python com MediaPipe Objectron

Introdução

A detecção de objetos vem ganhando força e melhorias estão sendo feitas em diversas abordagens para resolvê-la. Nos últimos anos, os métodos baseados em YOLO têm superado outros em termos de precisão e velocidade, com avanços recentes como YOLOv7 e YOLOv6 (que foi lançado de forma independente, após YOLOv7).

No entanto - tudo isso é preocupante Detecção de objetos 2D, o que é uma tarefa difícil por si só. Recentemente, conseguimos realizar com sucesso Detecção de objetos 3D, e embora esses detectores ainda estejam em um estágio mais instável do que os detectores de objetos 2D, sua precisão está aumentando.

Neste guia, realizaremos a detecção de objetos 3D em Python com Objectron do MediaPipe.

Observação: MediaPipe é a estrutura de código aberto do Google para a construção de pipelines de aprendizado de máquina para processar imagens, vídeos e fluxos de áudio, principalmente para dispositivos móveis. Ele está sendo usado interna e externamente e fornece modelos pré-treinados para diversas tarefas, como detecção de rosto, malha de rosto, estimativa de mãos e poses, segmentação de cabelo, detecção de objetos, rastreamento de caixas, etc.

Tudo isso pode e é usado para tarefas posteriores – como aplicação de filtros em rostos, foco automatizado de câmera, verificação biométrica, robótica controlada manualmente, etc. A maioria dos projetos está disponível com APIs para Android, iOS, C++, Python e JavaScript, enquanto alguns estão disponíveis apenas para determinados idiomas.

Neste guia, trabalharemos com Objectron do MediaPipe, disponível para Android, C++, Python e JavaScript.

MediaPipe e detecção de objetos 3D

A Objectron solução foi treinada no Conjunto de dados Objectron, que contém vídeos curtos centrados em objetos. O conjunto de dados contém apenas 9 objetos: bicicletas, livros, garrafas, câmeras, caixas de cereais, cadeiras, xícaras, laptops e sapatos, portanto não é um conjunto de dados muito geral, mas o processamento e a aquisição desses vídeos são bastante caros (poses de câmera, esparsos nuvens de pontos, caracterização das superfícies planas, etc. para cada quadro de cada vídeo), tornando o conjunto de dados com quase 2 terabytes de tamanho.

O modelo treinado da Objectron (conhecido como solução para projetos MediaPipe) é treinado em quatro categorias – sapatos, cadeiras, canecas e câmeras.

A detecção de objetos 2D usa o termo “caixas delimitadoras”, embora na verdade sejam retângulos. A detecção de objetos 3D realmente prevê caixas em torno de objetos, a partir dos quais você pode inferir sua orientação, tamanho, volume aproximado, etc. Esta é uma tarefa bastante difícil de realizar, especialmente devido à falta de conjuntos de dados apropriados e ao custo de criá-los. Embora difícil, o problema é promissor para vários Augmented Reality (AR) formulários!

A solução Objectron pode ser executada em modo de um ou dois estágios – onde o modo de um estágio é melhor na detecção de múltiplos objetos, enquanto o modo de dois estágios é melhor na detecção de um único objeto principal na cena, e funciona significativamente mais rápido. O pipeline de estágio único usa um backbone MobileNetV2, enquanto o pipeline de dois estágios usa a API TensorFlow Object Detection.

Quando um objeto é detectado em um vídeo, não são feitas previsões adicionais em cada quadro por dois motivos:

• As previsões contínuas introduzem grande nervosismo (devido à estocasticidade inerente às previsões)
• É caro executar modelos grandes em cada quadro

A equipe transfere as previsões pesadas apenas para os primeiros encontros e depois rastreia aquela caixa enquanto o objeto em questão ainda estiver na cena. Uma vez que a linha de visão é quebrada e o objeto é reintroduzido, uma previsão é feita novamente. Isso torna possível usar modelos maiores com maior precisão, mantendo baixos os requisitos computacionais e reduzindo os requisitos de hardware para inferência em tempo real!

Vamos instalar o MediaPipe, importar a solução Objectron e aplicá-la a imagens estáticas e um feed de vídeo vindo direto de uma câmera.

Instalando o MediaPipe

Vamos primeiro instalar o MediaPipe e preparar um método auxiliar para buscar imagens de uma determinada URL:

! pip install mediapipe

Com o framework instalado, vamos importá-lo junto com as bibliotecas comuns:

import mediapipe as mp

import cv2
import numpy as np
import matplotlib.pyplot as plt

Vamos definir um método auxiliar para buscar imagens a partir de uma URL e que retorna um array RGB representando essa imagem:

import PIL
import urllib

def url_to_array(url):
    req = urllib.request.urlopen(url)
    arr = np.array(bytearray(req.read()), dtype=np.int8)
    arr = cv2.imdecode(arr, -1)
    arr = cv2.cvtColor(arr, cv2.COLOR_BGR2RGB)
    return arr

mug = 'https://goodstock.photos/wp-content/uploads/2018/01/Laptop-Coffee-Mug-on-Table.jpg'
mug = url_to_array(mug)

Finalmente, queremos importar a solução Objectron e os utilitários de desenho para visualizar as previsões:

mp_objectron = mp.solutions.objectron
mp_drawing = mp.solutions.drawing_utils

Detecção de objetos 3D em imagens estáticas com MediaPipe

A Objectron classe permite vários argumentos, incluindo:

• static_image_mode: esteja você alimentando uma imagem ou um fluxo de imagens (vídeo)
• max_num_objects: O número máximo identificável de objetos
• min_detection_confidence: O limite de confiança de detecção (quão segura a rede deve ter para classificar um objeto para uma determinada classe)
• model_name: Qual modelo você gostaria de carregar entre 'Cup', 'Shoe', 'Camera' e 'Chair'.

Com isso em mente – vamos instanciar uma instância do Objectron e process() a imagem de entrada:

objectron = mp_objectron.Objectron(
    static_image_mode=True,
    max_num_objects=5,
    min_detection_confidence=0.2,
    model_name='Cup')


results = objectron.process(mug)

A results contêm os pontos de referência 2D e 3D do(s) objeto(s) detectado(s), bem como a rotação, translação e escala de cada um. Podemos processar os resultados e desenhar as caixas delimitadoras facilmente usando os utilitários de desenho fornecidos:

if not results.detected_objects:
    print(f'No box landmarks detected.')


annotated_image = mug.copy()
for detected_object in results.detected_objects:
    
    mp_drawing.draw_landmarks(annotated_image, 
                              detected_object.landmarks_2d, 
                              mp_objectron.BOX_CONNECTIONS)

    
    mp_drawing.draw_axis(annotated_image, 
                         detected_object.rotation, 
                         detected_object.translation)
  

fig, ax = plt.subplots(figsize=(10, 10))
ax.imshow(annotated_image)
ax.axis('off')
plt.show()

Isto resulta em:

Detecção de objetos 3D de vídeo ou webcam com MediaPipe

Uma aplicação mais interessante está nos vídeos! Você não precisa alterar muito o código para acomodar vídeos, seja um da webcam ou um arquivo de vídeo existente. OpenCV é uma opção natural para ler, manipular e alimentar quadros de vídeo no modelo objectron:

cap = cv2.VideoCapture(0)



objectron = mp_objectron.Objectron(static_image_mode=False,
                            max_num_objects=5,
                            min_detection_confidence=0.4,
                            min_tracking_confidence=0.70,
                            model_name='Cup')
                            

while cap.isOpened():
    success, image = cap.read()

    image.flags.writeable = False
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    results = objectron.process(image)

    image.flags.writeable = True
    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
    if results.detected_objects:
        for detected_object in results.detected_objects:
            
            mp_drawing.draw_landmarks(image, 
                                      detected_object.landmarks_2d, 
                                      mp_objectron.BOX_CONNECTIONS)
            
            mp_drawing.draw_axis(image, 
                                 detected_object.rotation,
                                 detected_object.translation)

    cv2.imshow('MediaPipe Objectron', cv2.flip(image, 1))
    if cv2.waitKey(10) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

Tornando a imagem não gravável com image.flags.writeable = False torna o processo um pouco mais rápido e é uma alteração opcional. O final cv2.flip() na imagem resultante também é opcional – e simplesmente torna a saída espelhada para torná-la um pouco mais intuitiva.

Quando executado em uma câmera e em uma caneca Ikea globalmente comum, estes são os resultados:

A saída é um pouco instável, mas lida bem com a translação rotacional, mesmo com a mão trêmula segurando a câmera de baixa resolução. O que acontece quando um objeto é retirado do enquadramento?

As previsões param para o objeto na primeira detecção, e o rastreamento de caixa detecta claramente que o objeto saiu do quadro e executa a previsão e o rastreamento mais uma vez assim que o objeto entra novamente no quadro. Parece que o rastreamento funciona um pouco melhor quando o modelo pode ver o alça de caneca, pois as saídas ficam mais agitadas quando a alça não está visível (presumivelmente porque é mais difícil determinar com precisão a verdadeira orientação da caneca).

Além disso, alguns ângulos parecem produzir resultados significativamente mais estáveis ​​do que outros, em condições de luz desafiadoras. Especificamente para canecas, é útil poder ver a borda da caneca, pois ajuda na perspectiva, em vez de ver uma projeção ortogonal do objeto.

Além disso, quando testado em uma caneca transparente, o modelo teve dificuldade em identificá-la como uma caneca. Este é provavelmente um exemplo de fora de distribuição objeto, já que a maioria das canecas são opacas e possuem várias cores.

Conclusão

A detecção de objetos 3D ainda é um pouco jovem e o Objectron do MediaPipe é uma demonstração capaz! Embora sensível às condições de iluminação, tipos de objetos (canecas transparentes versus opacas, etc.) e ligeiramente nervoso, o Objectron é um bom vislumbre do que em breve será possível fazer com maior precisão e acessibilidade do que nunca.