Upload 3 files

app.py

@@ -0,0 +1,239 @@
+import numpy as np
+import cv2
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+import logging
+import tempfile
+from pathlib import Path
+import firebase_admin
+from firebase_admin import credentials, firestore, storage
+from pydantic import BaseModel
+from deepface import DeepFace
+from tqdm import tqdm
+
+
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Initialize Firebase
+try:
+    cred = credentials.Certificate("serviceAccountKey.json")
+    firebase_app = firebase_admin.initialize_app(cred, {
+        'storageBucket': 'future-forge-60d3f.appspot.com'
+    })
+    db = firestore.client()
+    bucket = storage.bucket(app=firebase_app)
+    logger.info("Firebase initialized successfully")
+except Exception as e:
+    logger.error(f"Failed to initialize Firebase: {str(e)}")
+
+app = FastAPI()
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Define the input model
+class FileProcess(BaseModel):
+    file_path: str
+
+
+@app.post("/process")
+async def process_file(file_data: FileProcess):
+    logger.info(f"Processing file from Firebase Storage: {file_data.file_path}")
+    try:
+        # Get the file from Firebase Storage
+        blob = bucket.blob(file_data.file_path)
+
+        # Create a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file_data.file_path.split('.')[-1]}") as tmp_file:
+            blob.download_to_filename(tmp_file.name)
+            tmp_file_path = Path(tmp_file.name)
+        logger.info(f"File downloaded temporarily at: {tmp_file_path}")
+
+        file_type = file_data.file_path.split('.')[-1].lower()
+
+        result = None
+
+        try:
+            if file_type in ['jpg', 'jpeg', 'png', 'bmp']:
+                # Decode image directly from Firebase
+                image = decode_image_from_firebase(tmp_file_path)
+                processed_image = process_image(image)
+                output_path = Path('processed_image.jpg')
+                output_path.parent.mkdir(parents=True, exist_ok=True)
+                cv2.imwrite(str(output_path), processed_image)
+                result = {"type": "image", "path": str(output_path)}
+            elif file_type in ['mp4', 'avi', 'mov', 'wmv']:
+                graph_paths = process_video(str(tmp_file_path))
+                result = {"type": "video", "paths": graph_paths}
+            else:
+                raise HTTPException(status_code=400, detail="Unsupported file type")
+
+            logger.info(f"Processing complete. Result: {result}")
+
+            # Store result in Firebase
+            try:
+                doc_ref = db.collection('results').add(result)
+                return {"message": "File processed successfully", "result": result}
+            except Exception as e:
+                logger.error(f"Failed to store result in Firebase: {str(e)}")
+                return {"message": "File processed successfully, but failed to store in Firebase", "result": result,
+                        "error": str(e)}
+
+        finally:
+            # Clean up the temporary file after processing
+            if tmp_file_path.exists():
+                tmp_file_path.unlink()
+
+    except Exception as e:
+        logger.error(f"Error processing file: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error processing file: {str(e)}")
+
+
+# Initialize face detector
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+def process_video(video_path, output_video_path='output_video.mp4', frame_sample_rate=5):
+    cap = cv2.VideoCapture(video_path)
+
+    # Check if video opened successfully
+    if not cap.isOpened():
+        logger.error("Error: Could not open video.")
+        return None
+
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    # Define the codec and create VideoWriter object
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_video_path, fourcc, fps, (width, height))
+
+    output = {}
+    frame_index = 0
+
+    # Create a progress bar
+    with tqdm(total=total_frames, desc="Processing video") as pbar:
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                logger.info("End of video or cannot capture the frame.")
+                break
+
+            if frame_index % frame_sample_rate == 0:  # Only analyze every nth frame
+                try:
+                    result = DeepFace.analyze(frame, actions=['emotion'], detector_backend='retinaface',
+                                              enforce_detection=False)
+                except Exception as e:
+                    logger.error(f"Error analyzing frame {frame_index}: {e}")
+                    output[frame_index] = {}
+                    out.write(frame)  # Write the original frame
+                    frame_index += 1
+                    pbar.update(1)
+                    continue  # Skip to the next frame
+
+                for face in result:
+                    x, y, w, h = face['region']['x'], face['region']['y'], face['region']['w'], face['region']['h']
+                    emotion = face['dominant_emotion']
+                    emotion_scores = face['emotion']
+
+                    cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
+                    cv2.putText(frame, f"{emotion} ({emotion_scores[emotion]:.2f})", (x, y - 10),
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
+
+            out.write(frame)  # Write the processed frame
+            frame_index += 1
+            pbar.update(1)  # Update progress bar
+
+    # Release resources
+    cap.release()
+    out.release()
+
+    # Save the results to a file
+    with open('results_video.txt', 'w') as file:
+        for frame_num, faces_info in output.items():
+            file.write(f"Frame {frame_num}\n")
+            for face_key, info in faces_info.items():
+                file.write(f"  {face_key}: {info}\n")
+
+    logger.info(f"Processed {frame_index} frames.")
+    return output_video_path
+
+
+def process_image(image_path):
+    # Load the image using OpenCV
+    image = cv2.imread(image_path)
+
+    if image is None:
+        print(f"Error: Unable to load image from path {image_path}")
+        return
+
+    # Use RetinaFace for face detection and emotion analysis
+    try:
+        # Analyze the image for face detection and emotion analysis
+        result = DeepFace.analyze(image_path, actions=['emotion'], detector_backend='retinaface',
+                                  enforce_detection=False)
+    except Exception as e:
+        print(f"Error analyzing image: {e}")
+        return image
+
+    if len(result) == 0:
+        print("No faces detected.")
+        return image  # Return the original image if no faces are detected
+
+    output = {}
+    tmp = {}
+
+    for face in result:
+        # Get bounding box coordinates for each detected face
+        x, y, w, h = face['region']['x'], face['region']['y'], face['region']['w'], face['region']['h']
+
+        # Extract emotion data
+        emotion = face['dominant_emotion']
+        emotion_scores = face['emotion']
+        tmp[(x, y, w, h)] = {'emotion': emotion, 'score': emotion_scores[emotion]}
+
+        # Draw rectangle around face and label with predicted emotion
+        cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
+        cv2.putText(image, f"{emotion} ({emotion_scores[emotion]:.2f})", (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8,
+                    (0, 255, 0), 2)
+
+    output['image'] = tmp
+
+    # Save the processed image with bounding boxes and labels
+    output_image_path = 'output_image_with_emotions.jpg'
+    cv2.imwrite(output_image_path, image)
+    print(f"Processed image saved as {output_image_path}")
+
+    # Save the results to a file
+    with open('results_image.txt', 'w') as file:
+        file.write(f"Image {image_path}\n")
+        for face_key, info in output['image'].items():
+            file.write(f"  {face_key}: {info}\n")
+
+    return image
+
+
+def decode_image_from_firebase(temp_file_path):
+    """Reads the temporary file and decodes the image for OpenCV."""
+    with open(temp_file_path, 'rb') as f:
+        image_array = np.asarray(bytearray(f.read()), dtype=np.uint8)
+    image = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
+    return image
+
+
+
+if __name__ == "__main__":
+   logger.info("Starting the Face Emotion Recognition API")
+   uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,7 @@
+numpy
+opencv-python-headless
+deepface
+tf_keras
+firebase_admin
+fastapi
+uvicorn

serviceAccountKey.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "future-forge-60d3f",
+  "private_key_id": "d4b57c55b2d34f8083fa856a170357dbca851841",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC6T3OD/7hNZSxc\nfDVcrHNbR6GkvLvyYuA/tUr6AOTg31LD7JO5EYHkH2MYsKIYGCMhcvvEj0mu+DiC\nzqovlKerlUoXQ+emau9C3UM2pIa/0RAD+z3yE/VONpY4IaGrirss9g3Q6stoyYya\nYZF0h/5wkFXE4rhl6PHDony0SPEnNDKQ8DZPX3N/cfU/g3xYl+P9/x+eijXroHRG\nHnZ7Wns44vJGX40UvZTPew4F4T3Aq0bFfDvcW5NLpJTaeNbwr9Na8i5HMe7aU7AD\nzE9/dIrwZHCAAl8TuKQKAjybUdOYS9noHKuhJHU4IagkX0ups0bFgOLvuvB0RTce\nL9HmQg8ZAgMBAAECggEAKrIZ+BpCd3QT1Db/uJbpkbXK8Jhy3tNzbg4jGkNZsEHl\ncvJUkSEWuftKZ6ZU4z4m0NvLoCoxGdiXBL0NKb3ApfTep5G/dLcFUTapGEzgd3VW\n3P623bLesLeYOdFVPh1bEyzpEiM4jbFAmEF7RrACqnOdQDMvzGTzgKCMQPmFUDUF\nBZBHDnzJt0I+hAZd7GtzVqeJT5BnTG+NBl6WNUO8puOImWn63yPNflwGOC1wYPoq\nDwEvVMvP11CztK5e2330Io/VC4QdZ3rgEruPnjqyeLwoAfGQu1tclDMCVyMUq0dg\nHfW0+TbR4+XjDn6OiGFk3OcXsSphjYxPopnaFXGh7QKBgQDoerpPFgfcr8islbCE\ngM5fcJhzFjtPqtJNo7t9n1imtGFZe7x2ML4db7XQk6DrJ48JAHAlaDYlWM58r0f9\nP+Dmv/YGNa1WC+4NeRdrvcn4zKkPISgjOXrlE14/L14JazOkn9/ZD5dl9crh6+zU\nGNaXPul8dHCDV/b4otytkbo11QKBgQDNKO8dtZAXTF2lBxBwWC7506972nwHhAFC\nAZq2n6izjdKXozspyriPQZMF5opgELrK177/pKACRECzMsDexcO4ESx+zmuhjZtq\nmNxItypNFNp60DLYalutvyBpb4ZPipvhjLY4gWMTOhwfOqgmpOMoovFfZRVpUs1O\nOphhm4RCNQKBgQCUFQCxuZW+c9X+YMb0T9uknWLuA945y9RzkfSuex6L6WANEK0m\nF7wxoeOM/UxGHYeVs0q7+RpsRZoZf8j6PoMyWFoM8In9wlGbEWPixBxvt2WEdplL\nfqSSX/jrhG+AzmEx3ohGihDk6GCX8aCEJWIjKvasyLqWXyS4kXzBro6PFQKBgDhW\nrltdOaV8PhcMepIvVS8b14vOctLpiCLlJ+RQsdYk8xjbJWsTlV0Zp9Mt/P/meDUt\ny/CN97bHoXDUViyW6GlKpgpoixwBNBWwxoVdb0tdl6W0ONI/Ws+6tZ7elmaPbMEi\nkAOyXE+yXHii9fwuuYa2QExvCNM0ftaltqTPPSGlAoGAR5ehNI04299PODpSMLK+\nANAdgchhrawGMejQyWCYuccYUmWa5uNMYnKpv+KmYu3eh6+fZ0kJh8Et0GRUUkJp\nIRdrGNvXTSAY6EFI2mymBOvuPkk4Tk9L3eanZlS+R+woONMpxRbFrM5Yo9O/F02k\nU/B17xjAMfVLkknWB8593wY=\n-----END PRIVATE KEY-----\n",
+  "client_email": "firebase-adminsdk-f6nhs@future-forge-60d3f.iam.gserviceaccount.com",
+  "client_id": "106627761042069447585",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-f6nhs%40future-forge-60d3f.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}