Upload 2 files

app.py

@@ -1,176 +1,185 @@
-import os
-import cv2
-import numpy as np
-import base64
-import json
-from io import BytesIO
-from PIL import Image
-import tensorflow as tf
-from tensorflow import keras
-from fastapi import FastAPI, Request, Form, File, UploadFile
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-import uvicorn
-from huggingface_hub import hf_hub_download
-
-emotion_model = None
-
-app = FastAPI()
-
-@app.on_event("startup")
-def load_model():
-    global emotion_model
-    model_path = hf_hub_download(
-        repo_id="PatriciaWening/moodDetection",
-        filename="moodDetection.keras",  # pastikan sesuai
-        cache_dir="/tmp"
-    )
-    # ini akan assign objek keras.Model
-    emotion_model = keras.models.load_model(model_path)
-
-emotion_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
-
-face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-sessions = {}
-
-@app.post("/api/deteksi-emosi")
-async def detect_emotion(request: Request):
-    try:
-        form = await request.form()
-        image_data = form.get("image")
-        
-        print(f"Received request with sessionId: {form.get('sessionId', 'not provided')}")
-        print(f"Image data received: {bool(image_data)}")
-        
-        if image_data and "base64" in image_data:
-            try:
-                base64_data = image_data.split(',')[1]
-                image_bytes = base64.b64decode(base64_data)
-                
-                print("Successfully decoded base64 data")
-                
-                img = Image.open(BytesIO(image_bytes))
-                img_array = np.array(img)
-                
-                if len(img_array.shape) > 2 and img_array.shape[2] == 3:
-                    gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
-                else:
-                    gray = img_array
-                
-                print(f"Processed image shape: {gray.shape}")
-                
-                faces = face_cascade.detectMultiScale(gray, 1.3, 5)
-                print(f"Detected {len(faces)} faces")
-                
-                if len(faces) > 0:
-                    (x, y, w, h) = faces[0]
-                    
-                    face_roi = gray[y:y+h, x:x+w]
-                    
-                    resized_face = cv2.resize(face_roi, (48, 48))
-                    normalized_face = resized_face / 255.0
-                    reshaped_face = normalized_face.reshape(1, 48, 48, 1)
-                    
-                    prediction = emotion_model.predict(reshaped_face)
-                    emotion_idx = np.argmax(prediction[0])
-                    emotion = emotion_labels[emotion_idx]
-                    confidence = float(prediction[0][emotion_idx])
-                    
-                    stress_mapping = {
-                        'angry': 85, 'disgust': 65, 'fear': 70,
-                        'sad': 75, 'surprise': 45, 'neutral': 30, 'happy': 15
-                    }
-                    
-                    stress_level = stress_mapping.get(emotion, 50)
-                    
-                    session_id = form.get("sessionId", "default")
-                    if session_id not in sessions:
-                        sessions[session_id] = {
-                            "emotions": [],
-                            "stress_levels": []
-                        }
-                    
-                    sessions[session_id]["emotions"].append(emotion)
-                    sessions[session_id]["stress_levels"].append(stress_level)
-                    
-                    result = {
-                        "emotion": emotion,
-                        "confidence": confidence,
-                        "stressLevel": stress_level,
-                        "faceDetected": True,
-                        "faceRegion": {"x": int(x), "y": int(y), "width": int(w), "height": int(h)}
-                    }
-                else:
-                    result = {
-                        "emotion": "unknown",
-                        "confidence": 0,
-                        "stressLevel": 0,
-                        "faceDetected": False
-                    }
-            except Exception as e:
-                print(f"Error processing image: {str(e)}")
-                import traceback
-                traceback.print_exc()
-                result = {"error": f"Image processing error: {str(e)}"}
-        else:
-            result = {"error": "Invalid image data"}
-    
-    except Exception as e:
-        print(f"Request handling error: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        result = {"error": f"Server error: {str(e)}"}
-    
-    response = JSONResponse(content=result)
-    response.headers["Access-Control-Allow-Origin"] = "*"
-    response.headers["Access-Control-Allow-Credentials"] = "true"
-    return response
-
-@app.get("/api/session-report/{session_id}")
-async def session_report(session_id: str):
-    if session_id not in sessions:
-        return JSONResponse(content={"error": "Session not found"}, status_code=404)
-    
-    session_data = sessions[session_id]
-    
-    if session_data["emotions"]:
-        emotion_counts = {}
-        for emotion in session_data["emotions"]:
-            if emotion in emotion_counts:
-                emotion_counts[emotion] += 1
-            else:
-                emotion_counts[emotion] = 1
-        
-        dominant_emotion = max(emotion_counts, key=emotion_counts.get)
-        
-        avg_stress = sum(session_data["stress_levels"]) / len(session_data["stress_levels"])
-        
-        min_stress = min(session_data["stress_levels"])
-        max_stress = max(session_data["stress_levels"])
-        
-        result = {
-            "dominantEmotion": dominant_emotion,
-            "emotionCounts": emotion_counts,
-            "averageStressLevel": round(avg_stress, 2),
-            "minStressLevel": min_stress,
-            "maxStressLevel": max_stress,
-            "totalFrames": len(session_data["emotions"])
-        }
-    else:
-        result = {
-            "error": "No data in session"
-        }
-    
-    return JSONResponse(content=result)
-
-if __name__ == "__main__":
+import os
+import cv2
+import numpy as np
+import base64
+import json
+from io import BytesIO
+from PIL import Image
+import tensorflow as tf
+from tensorflow import keras
+from fastapi import FastAPI, Request, Form, File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import uvicorn
+import requests
+
+emotion_model = None
+
+app = FastAPI()
+
+@app.on_event("startup")
+def load_model():
+    global emotion_model
+
+    file_id = "1ist4U_0oCmHe7atGZvnxRCDMEGXCqqke"  # 🔁 Ganti dengan ID milikmu
+    url = f"https://drive.google.com/uc?export=download&id={file_id}"
+    output_path = "/tmp/moodDetection.keras"
+
+    print("📥 Mengunduh model dari Google Drive...")
+    response = requests.get(url)
+    if response.status_code != 200:
+        raise Exception("❌ Gagal mengunduh model dari Google Drive")
+
+    with open(output_path, "wb") as f:
+        f.write(response.content)
+
+    print("✅ Model berhasil diunduh, memuat ke memory...")
+    emotion_model = keras.models.load_model(output_path)
+    print("✅ Model siap digunakan!")
+
+emotion_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+sessions = {}
+
+@app.post("/api/deteksi-emosi")
+async def detect_emotion(request: Request):
+    try:
+        form = await request.form()
+        image_data = form.get("image")
+        
+        print(f"Received request with sessionId: {form.get('sessionId', 'not provided')}")
+        print(f"Image data received: {bool(image_data)}")
+        
+        if image_data and "base64" in image_data:
+            try:
+                base64_data = image_data.split(',')[1]
+                image_bytes = base64.b64decode(base64_data)
+                
+                print("Successfully decoded base64 data")
+                
+                img = Image.open(BytesIO(image_bytes))
+                img_array = np.array(img)
+                
+                if len(img_array.shape) > 2 and img_array.shape[2] == 3:
+                    gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+                else:
+                    gray = img_array
+                
+                print(f"Processed image shape: {gray.shape}")
+                
+                faces = face_cascade.detectMultiScale(gray, 1.3, 5)
+                print(f"Detected {len(faces)} faces")
+                
+                if len(faces) > 0:
+                    (x, y, w, h) = faces[0]
+                    
+                    face_roi = gray[y:y+h, x:x+w]
+                    
+                    resized_face = cv2.resize(face_roi, (48, 48))
+                    normalized_face = resized_face / 255.0
+                    reshaped_face = normalized_face.reshape(1, 48, 48, 1)
+                    
+                    prediction = emotion_model.predict(reshaped_face)
+                    emotion_idx = np.argmax(prediction[0])
+                    emotion = emotion_labels[emotion_idx]
+                    confidence = float(prediction[0][emotion_idx])
+                    
+                    stress_mapping = {
+                        'angry': 85, 'disgust': 65, 'fear': 70,
+                        'sad': 75, 'surprise': 45, 'neutral': 30, 'happy': 15
+                    }
+                    
+                    stress_level = stress_mapping.get(emotion, 50)
+                    
+                    session_id = form.get("sessionId", "default")
+                    if session_id not in sessions:
+                        sessions[session_id] = {
+                            "emotions": [],
+                            "stress_levels": []
+                        }
+                    
+                    sessions[session_id]["emotions"].append(emotion)
+                    sessions[session_id]["stress_levels"].append(stress_level)
+                    
+                    result = {
+                        "emotion": emotion,
+                        "confidence": confidence,
+                        "stressLevel": stress_level,
+                        "faceDetected": True,
+                        "faceRegion": {"x": int(x), "y": int(y), "width": int(w), "height": int(h)}
+                    }
+                else:
+                    result = {
+                        "emotion": "unknown",
+                        "confidence": 0,
+                        "stressLevel": 0,
+                        "faceDetected": False
+                    }
+            except Exception as e:
+                print(f"Error processing image: {str(e)}")
+                import traceback
+                traceback.print_exc()
+                result = {"error": f"Image processing error: {str(e)}"}
+        else:
+            result = {"error": "Invalid image data"}
+    
+    except Exception as e:
+        print(f"Request handling error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        result = {"error": f"Server error: {str(e)}"}
+    
+    response = JSONResponse(content=result)
+    response.headers["Access-Control-Allow-Origin"] = "*"
+    response.headers["Access-Control-Allow-Credentials"] = "true"
+    return response
+
+@app.get("/api/session-report/{session_id}")
+async def session_report(session_id: str):
+    if session_id not in sessions:
+        return JSONResponse(content={"error": "Session not found"}, status_code=404)
+    
+    session_data = sessions[session_id]
+    
+    if session_data["emotions"]:
+        emotion_counts = {}
+        for emotion in session_data["emotions"]:
+            if emotion in emotion_counts:
+                emotion_counts[emotion] += 1
+            else:
+                emotion_counts[emotion] = 1
+        
+        dominant_emotion = max(emotion_counts, key=emotion_counts.get)
+        
+        avg_stress = sum(session_data["stress_levels"]) / len(session_data["stress_levels"])
+        
+        min_stress = min(session_data["stress_levels"])
+        max_stress = max(session_data["stress_levels"])
+        
+        result = {
+            "dominantEmotion": dominant_emotion,
+            "emotionCounts": emotion_counts,
+            "averageStressLevel": round(avg_stress, 2),
+            "minStressLevel": min_stress,
+            "maxStressLevel": max_stress,
+            "totalFrames": len(session_data["emotions"])
+        }
+    else:
+        result = {
+            "error": "No data in session"
+        }
+    
+    return JSONResponse(content=result)
+
+if __name__ == "__main__":
     uvicorn.run("app:app", host="127.0.0.1", port=8080, reload=True)

requirements.txt

@@ -4,4 +4,4 @@ tensorflow
 opencv-python-headless
 pillow
 python-multipart
-huggingface_hub
+requests