Fix: implement WebRTC for camera access and update dependencies

README.md

@@ -18,7 +18,7 @@ Este projeto é uma aplicação Streamlit para detecção de objetos utilizando
 
 ## 🚀 Funcionalidades
 
-- Detecção de objetos em tempo real em imagens carregadas.
+- Detecção de objetos em tempo real via Webcam usando WebRTC (compatível com Hugging Face Spaces).
 - Suporte a 80 classes do dataset COCO.
 - Interface amigável com Streamlit.
 - Configuração via variáveis de ambiente.

requirements.txt

@@ -11,3 +11,5 @@ requests>=2.32.0
 tqdm>=4.66.0
 streamlit>=1.35.0
 pillow>=10.3.0
+streamlit-webrtc>=0.47.0
+av>=12.0.0

streamlit_app.py

@@ -1,12 +1,40 @@
-# Importações necessárias para Streamlit, OpenCV e processamento de imagem
 import streamlit as st
 import cv2
 import numpy as np
 from PIL import Image
 from yolo_inference import build_detector_from_env
+from streamlit_webrtc import webrtc_streamer, VideoProcessorBase, RTCConfiguration
+import av
 
 # Configuração inicial da página do Streamlit (Título e Layout)
-st.set_page_config(page_title="YOLO Detection - Streamlit", layout="wide", page_icon="🚗")
+st.set_page_config(page_title="YOLO Detection - Streamlit", layout="wide", page_icon="🚀")
+
+# Configuração RTC para STUN servers (necessário para conexões fora da rede local)
+RTC_CONFIGURATION = RTCConfiguration(
+    {"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]}
+)
+
+# Lista de classes do dataset personalizado para monitoramento especial
+CUSTOM_CLASSES = {"car", "truck", "bus", "motorbike", "bicycle", "van", "threewheel"}
+
+class YoloVideoProcessor(VideoProcessorBase):
+    def __init__(self, detector):
+        self.detector = detector
+
+    def recv(self, frame):
+        img = frame.to_ndarray(format="bgr24")
+        
+        # Realiza a detecção de objetos
+        detections = self.detector.detect(img)
+        
+        # Desenha os resultados no frame
+        img_out = self.detector.draw(img, detections)
+        
+        # Adiciona overlay de instrução
+        cv2.putText(img_out, "YOLO Real-time Detection", (20, 40), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+        
+        return av.VideoFrame.from_ndarray(img_out, format="bgr24")
 
 def main():
     """
@@ -28,112 +56,53 @@ def main():
     
     st.sidebar.markdown("---")
     # Seleção do modo de operação
-    mode = st.sidebar.radio("📡 Escolha o Modo de Entrada", ["Imagem", "Câmera (Real-time)"])
+    mode = st.sidebar.radio("📡 Escolha o Modo de Entrada", ["Imagem", "Câmera (WebRTC)"])
 
     # Inicializa o detector YOLO
-    # A função build_detector_from_env gerencia o download automático dos pesos se necessário.
     try:
         detector = build_detector_from_env(conf_threshold=conf_threshold, nms_threshold=nms_threshold)
     except Exception as e:
         st.error(f"❌ Erro ao inicializar detector: {e}")
         return
 
-    # Lista de classes do dataset personalizado para monitoramento especial
-    CUSTOM_CLASSES = {"car", "truck", "bus", "motorbike", "bicycle", "van", "threewheel"}
-
     if mode == "Imagem":
         st.subheader("📁 Upload e Detecção em Imagem")
         uploaded_file = st.file_uploader("Arraste ou selecione uma imagem...", type=["jpg", "jpeg", "png"])
 
         if uploaded_file is not None:
-            # Converte o arquivo carregado (BytesIO) para uma imagem PIL e depois para array numpy
             image = Image.open(uploaded_file)
             image_np = np.array(image)
-            
-            # Streamlit/PIL trabalham em RGB, mas o detector OpenCV espera BGR
             frame_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
 
-            # Realiza a detecção de objetos
             with st.spinner('Processando imagem...'):
                 detections = detector.detect(frame_bgr)
             
-            # Filtra e exibe classes encontradas que pertencem ao dataset customizado
             hits = sorted({d['class_name'] for d in detections if d['class_name'] in CUSTOM_CLASSES})
             
-            # Layout em duas colunas: Imagem original vs Resultado
             col1, col2 = st.columns(2)
-            
             with col1:
                 st.image(image, caption="Imagem Original", use_column_width=True)
-            
             with col2:
-                # Desenha os retângulos e labels no frame BGR
                 result_bgr = detector.draw(frame_bgr, detections)
-                # Converte de volta para RGB para exibição correta no Streamlit
                 result_rgb = cv2.cvtColor(result_bgr, cv2.COLOR_BGR2RGB)
                 st.image(result_rgb, caption="Detecções Encontradas", use_column_width=True)
 
-            # Exibe alertas baseados nas classes detectadas
             if hits:
-                st.success(f"✅ Objetos do dataset detectados: **{', '.join(hits)}**")
+                st.success(f"✅ Objetos detectados: **{', '.join(hits)}**")
             else:
-                st.info("ℹ️ Nenhuma classe do dataset específico foi detectada nesta imagem.")
+                st.info("ℹ️ Nenhuma classe de interesse detectada.")
 
-    elif mode == "Câmera (Real-time)":
-        st.subheader("🎥 Detecção via Webcam em Tempo Real")
-        st.warning("⚠️ Certifique-se de que sua webcam não está sendo usada por outro aplicativo.")
-        
-        # Checkbox para ligar/desligar o loop da câmera
-        run = st.checkbox("Ativar Câmera")
+    elif mode == "Câmera (WebRTC)":
+        st.subheader("🎥 Detecção via Webcam (WebRTC)")
+        st.info("Esta opção utiliza o WebRTC para acessar sua câmera diretamente do navegador, ideal para deploy em nuvem (Hugging Face).")
         
-        # Placeholders para atualização dinâmica do frame e status sem recarregar a página toda
-        frame_placeholder = st.empty()
-        status_placeholder = st.empty()
-
-        if run:
-            # Inicializa a captura de vídeo (ID 0 costuma ser a webcam padrão)
-            cap = cv2.VideoCapture(0)
-            if not cap.isOpened():
-                st.error("Não foi possível acessar a câmera. Verifique as permissões.")
-                return
-
-            while run:
-                ret, frame = cap.read()
-                if not ret:
-                    st.error("Falha ao capturar vídeo.")
-                    break
-
-                # Processa o frame atual
-                detections = detector.detect(frame)
-                
-                # Renderiza as detecções no frame
-                frame_out = detector.draw(frame, detections)
-                
-                # Adiciona overlay de instrução no frame (estilo solicitado anteriormente)
-                cv2.putText(frame_out, "Desmarque 'Ativar Camera' para sair", (20, 40), 
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
-
-                # Identifica classes do dataset para exibição de status dinâmico
-                hits = sorted({d['class_name'] for d in detections if d['class_name'] in CUSTOM_CLASSES})
-                if hits:
-                    status_placeholder.success(f"Detectado: **{', '.join(hits)}**")
-                else:
-                    status_placeholder.empty()
-
-                # Conversão BGR -> RGB para o Streamlit renderizar corretamente
-                frame_rgb = cv2.cvtColor(frame_out, cv2.COLOR_BGR2RGB)
-                frame_placeholder.image(frame_rgb, channels="RGB", use_column_width=True)
-
-                # Pequeno delay opcional para sincronia (cv2.waitKey não é necessário aqui para exibição, 
-                # mas ajuda a liberar CPU)
-                if cv2.waitKey(1) & 0xFF == ord('q'):
-                    break
-            
-            # Libera recursos ao encerrar
-            cap.release()
-            st.write("🏁 Captura encerrada.")
-        else:
-            st.write("💤 Câmera em espera.")
+        webrtc_streamer(
+            key="yolo-detection",
+            video_processor_factory=lambda: YoloVideoProcessor(detector),
+            rtc_configuration=RTC_CONFIGURATION,
+            media_stream_constraints={"video": True, "audio": False},
+            async_processing=True,
+        )
 
 if __name__ == "__main__":
     main()