Upload 3 files

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Instalar dependencias del sistema para OpenCV
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libgl1-mesa-glx \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copiar archivos de requerimientos
+COPY requirements.txt .
+
+# Instalar dependencias de Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiar el código de la aplicación
+COPY app.py .
+
+# Exponer el puerto
+EXPOSE 7860
+
+# Comando para ejecutar la aplicación
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--timeout", "120", "app:app"]

app.py

@@ -0,0 +1,134 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import cv2
+from deepface import DeepFace
+import numpy as np
+import base64
+from io import BytesIO
+from PIL import Image
+import os
+
+app = Flask(__name__)
+CORS(app)  # permitir peticiones desde Android
+
+# cargar el clasificador de rostros
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+@app.route('/')
+def home():
+    return jsonify({
+        'message': 'API de Detección de Emociones',
+        'endpoints': {
+            '/predict': 'POST - Enviar imagen para detectar emoción',
+            '/health': 'GET - Verificar estado del servicio'
+        }
+    })
+
+@app.route('/predict', methods=['POST'])
+def predict_emotion():
+    try:
+        # verificamos si se recibió una imagen
+        if 'file' in request.files:
+            # Imagen desde archivo
+            file = request.files['file']
+            image = Image.open(file.stream)
+            frame = np.array(image)
+            frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            
+        elif request.is_json and 'image' in request.json:
+            # imagen en base64
+            image_data = request.json['image']
+            # remover el prefijo data:image si existe
+            if ',' in image_data:
+                image_data = image_data.split(',')[1]
+            
+            image_bytes = base64.b64decode(image_data)
+            image = Image.open(BytesIO(image_bytes))
+            frame = np.array(image)
+            frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            
+        elif request.data:
+            # imagen como datos binarios
+            image = Image.open(BytesIO(request.data))
+            frame = np.array(image)
+            frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+        else:
+            return jsonify({'error': 'No se recibió ninguna imagen'}), 400
+        
+        # convertir a escala de grises
+        gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        # convertir a RGB para DeepFace
+        rgb_frame = cv2.cvtColor(gray_frame, cv2.COLOR_GRAY2RGB)
+        
+        # detectar rostros en el frame
+        faces = face_cascade.detectMultiScale(
+            gray_frame, 
+            scaleFactor=1.1, 
+            minNeighbors=5, 
+            minSize=(30, 30)
+        )
+        
+        emocion = "Sin Emocion"
+        all_emotions = {}
+        faces_detected = len(faces)
+        
+        # si se detectaron rostros
+        if len(faces) > 0:
+            for (x, y, w, h) in faces:
+                # extraer la región del rostro
+                face_roi = rgb_frame[y:y + h, x:x + w]
+                # realizar análisis de emoción
+                result = DeepFace.analyze(
+                    face_roi, 
+                    actions=['emotion'], 
+                    enforce_detection=False
+                )
+                # determinamos la emoción dominante
+                emocion = result[0]['dominant_emotion']
+                all_emotions = result[0]['emotion']
+                break  # Usar solo el primer rostro detectado
+        else:
+            # si no se detecta rostro, intentar análisis directo
+            try:
+                result = DeepFace.analyze(
+                    frame, 
+                    actions=['emotion'], 
+                    enforce_detection=False
+                )
+                emocion = result[0]['dominant_emotion']
+                all_emotions = result[0]['emotion']
+                faces_detected = 1
+            except:
+                pass
+        
+        # formatear respuesta similar a Hugging Face API
+        response = []
+        if all_emotions:
+            for emotion, score in all_emotions.items():
+                response.append({
+                    'label': emotion,
+                    'score': score / 100.0
+                })
+            # ordenar por score
+            response.sort(key=lambda x: x['score'], reverse=True)
+
+        return jsonify({
+            'emotion': emocion,
+            'faces_detected': faces_detected,
+            'all_emotions': response if response else None
+        })
+    
+    except Exception as e:
+        return jsonify({
+            'error': str(e),
+            'emotion': 'Error al procesar imagen'
+        }), 500
+
+@app.route('/health', methods=['GET'])
+def health():
+    return jsonify({'status': 'healthy', 'service': 'Emotion Detection API'})
+
+if __name__ == '__main__':
+    port = int(os.environ.get('PORT', 7860))
+    app.run(host='0.0.0.0', port=port, debug=False)

requirements.txt

@@ -0,0 +1,9 @@
+flask==2.3.3
+flask-cors==4.0.0
+opencv-python-headless==4.8.1.78
+deepface==0.0.79
+pillow==10.1.0
+numpy==1.24.3
+gunicorn==21.2.0
+tensorflow==2.15.0
+protobuf==3.20.3