Update app.py

app.py

@@ -5,8 +5,7 @@ import numpy as np
 import pickle
 from datetime import datetime
 
-# ==== Bagian Flask (kode kamu tetap) ====
-flask_app = Flask(__name__)
+app = Flask(__name__)
 
 FACE_DATA_DIR = 'face_data'
 FACE_CASCADE_PATH = cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
@@ -15,20 +14,20 @@ if not os.path.exists(FACE_DATA_DIR):
     os.makedirs(FACE_DATA_DIR)
 
 face_cascade = cv2.CascadeClassifier(FACE_CASCADE_PATH)
+
 camera = None
 face_recognizer = cv2.face.LBPHFaceRecognizer_create()
 is_trained = False
+has_webcam = os.path.exists("/dev/video0")  # deteksi webcam
 
 def load_face_data():
     global is_trained
-    faces = []
-    labels = []
-    names = []
-    
+    faces, labels, names = [], [], []
+
     if os.path.exists(os.path.join(FACE_DATA_DIR, 'names.pkl')):
         with open(os.path.join(FACE_DATA_DIR, 'names.pkl'), 'rb') as f:
             names = pickle.load(f)
-    
+
     for idx, name in enumerate(names):
         face_dir = os.path.join(FACE_DATA_DIR, name)
         if os.path.exists(face_dir):
@@ -38,7 +37,7 @@ def load_face_data():
                     img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
                     faces.append(img)
                     labels.append(idx)
-    
+
     if faces:
         face_recognizer.train(faces, np.array(labels))
         is_trained = True
@@ -47,153 +46,149 @@ def load_face_data():
 
 def get_camera():
     global camera
-    if camera is None:
-        camera = cv2.VideoCapture(0)
-    return camera
+    if has_webcam:
+        if camera is None:
+            camera = cv2.VideoCapture(0)
+        return camera
+    return None
 
-@flask_app.route('/')
+@app.route('/')
 def index():
     names = load_face_data()
-    return render_template('index.html', registered_faces=names)
+    return render_template('index.html', registered_faces=names, has_webcam=has_webcam)
 
-@flask_app.route('/register')
+@app.route('/register')
 def register():
-    return render_template('register.html')
+    return render_template('register.html', has_webcam=has_webcam)
 
-@flask_app.route('/recognize')
+@app.route('/recognize')
 def recognize():
-    return render_template('recognize.html')
+    return render_template('recognize.html', has_webcam=has_webcam)
 
-@flask_app.route('/video_feed')
+@app.route('/video_feed')
 def video_feed():
+    if not has_webcam:
+        return "Webcam tidak tersedia di server ini", 404
+
     def generate():
-        camera = get_camera()
+        cam = get_camera()
         while True:
-            success, frame = camera.read()
+            success, frame = cam.read()
             if not success:
                 break
             ret, buffer = cv2.imencode('.jpg', frame)
             frame = buffer.tobytes()
             yield (b'--frame\r\n'
                    b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
+
     return Response(generate(), mimetype='multipart/x-mixed-replace; boundary=frame')
 
-@flask_app.route('/recognition_feed')
+@app.route('/recognition_feed')
 def recognition_feed():
+    if not has_webcam:
+        return "Webcam tidak tersedia di server ini", 404
+
     def generate():
-        camera = get_camera()
+        cam = get_camera()
         names = load_face_data()
-        
+
         while True:
-            success, frame = camera.read()
+            success, frame = cam.read()
             if not success:
                 break
+
             gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
             faces = face_cascade.detectMultiScale(gray, 1.3, 5)
-            
+
             for (x, y, w, h) in faces:
                 cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
-                
+
                 if is_trained and names:
                     roi_gray = gray[y:y+h, x:x+w]
                     roi_gray = cv2.resize(roi_gray, (100, 100))
+
                     id_, confidence = face_recognizer.predict(roi_gray)
-                    
                     if confidence < 100:
                         name = names[id_]
                         confidence_text = f"{name} ({round(100-confidence)}%)"
                     else:
                         confidence_text = "Unknown"
-                    
-                    cv2.putText(frame, confidence_text, (x, y-10), 
+
+                    cv2.putText(frame, confidence_text, (x, y-10),
                               cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)
-            
+
             ret, buffer = cv2.imencode('.jpg', frame)
             frame = buffer.tobytes()
             yield (b'--frame\r\n'
                    b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
+
     return Response(generate(), mimetype='multipart/x-mixed-replace; boundary=frame')
 
-@flask_app.route('/capture_face', methods=['POST'])
+@app.route('/capture_face', methods=['POST'])
 def capture_face():
-    name = request.json.get('name', '').strip()
+    if has_webcam:
+        name = request.json.get('name', '').strip()
+        if not name:
+            return jsonify({'error': 'Nama tidak boleh kosong'})
+
+        cam = get_camera()
+        success, frame = cam.read()
+        if not success:
+            return jsonify({'error': 'Gagal mengambil gambar dari kamera'})
+
+        return save_face(name, frame)
+    else:
+        return jsonify({'error': 'Webcam tidak tersedia, gunakan /upload_face'})
+
+@app.route('/upload_face', methods=['POST'])
+def upload_face():
+    """Upload foto untuk registrasi (tanpa webcam)"""
+    name = request.form.get('name', '').strip()
+    file = request.files.get('file')
+
     if not name:
         return jsonify({'error': 'Nama tidak boleh kosong'})
-    
-    camera = get_camera()
-    success, frame = camera.read()
-    if not success:
-        return jsonify({'error': 'Gagal mengambil gambar dari kamera'})
-    
+    if not file:
+        return jsonify({'error': 'File tidak ditemukan'})
+
+    np_img = np.frombuffer(file.read(), np.uint8)
+    frame = cv2.imdecode(np_img, cv2.IMREAD_COLOR)
+    return save_face(name, frame)
+
+def save_face(name, frame):
     gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
     faces = face_cascade.detectMultiScale(gray, 1.3, 5)
-    
+
     if len(faces) == 0:
         return jsonify({'error': 'Tidak ada wajah yang terdeteksi'})
     if len(faces) > 1:
         return jsonify({'error': 'Terdeteksi lebih dari satu wajah'})
-    
+
     (x, y, w, h) = faces[0]
     face_roi = gray[y:y+h, x:x+w]
     face_roi = cv2.resize(face_roi, (100, 100))
-    
+
     person_dir = os.path.join(FACE_DATA_DIR, name)
     if not os.path.exists(person_dir):
         os.makedirs(person_dir)
-    
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"{timestamp}.jpg"
+
+    filename = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
     cv2.imwrite(os.path.join(person_dir, filename), face_roi)
-    
+
     names_file = os.path.join(FACE_DATA_DIR, 'names.pkl')
     if os.path.exists(names_file):
         with open(names_file, 'rb') as f:
             names = pickle.load(f)
     else:
         names = []
-    
+
     if name not in names:
         names.append(name)
         with open(names_file, 'wb') as f:
             pickle.dump(names, f)
-    
+
     load_face_data()
     return jsonify({'success': f'Wajah {name} berhasil didaftarkan'})
 
-@flask_app.route('/delete_face/<name>')
-def delete_face(name):
-    person_dir = os.path.join(FACE_DATA_DIR, name)
-    if os.path.exists(person_dir):
-        for filename in os.listdir(person_dir):
-            os.remove(os.path.join(person_dir, filename))
-        os.rmdir(person_dir)
-        
-        names_file = os.path.join(FACE_DATA_DIR, 'names.pkl')
-        if os.path.exists(names_file):
-            with open(names_file, 'rb') as f:
-                names = pickle.load(f)
-            if name in names:
-                names.remove(name)
-                with open(names_file, 'wb') as f:
-                    pickle.dump(names, f)
-        load_face_data()
-    return redirect(url_for('index'))
-
-# ==== Bungkus Flask ke FastAPI untuk Hugging Face ====
-from fastapi import FastAPI
-from fastapi.middleware.wsgi import WSGIMiddleware
-
-app = FastAPI()
-
-# Endpoint bawaan FastAPI
-@app.get("/hello")
-def greet_json():
-    return {"Hello": "World!"}
-
-# Mount Flask app ke FastAPI
-app.mount("/", WSGIMiddleware(flask_app))
-
-# Jalankan dengan uvicorn kalau lokal
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)