Update main.py

main.py

@@ -5,6 +5,9 @@ import face_detection
 import numpy as np
 import base64
 import os
+import shutil
+import asyncio
+import threading
 
 app = Flask(__name__)
 
@@ -27,51 +30,83 @@ def draw_faces(im, bboxes):
         x0, y0, x1, y1 = [int(_) for _ in bbox]
         cv2.rectangle(im, (x0, y0), (x1, y1), (0, 0, 255), 2)
 
-def detect_faces_and_save(frame):
-    detector = face_detection.build_detector("DSFDDetector", confidence_threshold=0.5, nms_iou_threshold=0.3)
-    det_raw = detector.detect(frame[:, :, ::-1])
-    dets = det_raw[:, :4]
-    draw_faces(frame, dets)
+async def detect_faces_and_save(vidObj, media_folder):
+    with app.app_context():
+        # Get video properties
+        fps = vidObj.get(cv2.CAP_PROP_FPS)
+        total_frames = int(vidObj.get(cv2.CAP_PROP_FRAME_COUNT))
+        video_duration = total_frames / fps
 
-    count_of_people = len(dets)
+        # Calculate frame sampling interval
+        target_fps = 1  # One frame per second
+        sampling_interval = int(fps / target_fps)
+
+        success, image = vidObj.read()
+        frame_counter = 0
+
+        while success:
+            if frame_counter % sampling_interval == 0:
+                detector = face_detection.build_detector("DSFDDetector", confidence_threshold=0.5, nms_iou_threshold=0.3)
+                det_raw = detector.detect(image[:, :, ::-1])
+                dets = det_raw[:, :4]
+                draw_faces(image, dets)
 
+                count_of_people = len(dets)
 
-    frame_data_encoded = base64.b64encode(cv2.imencode('.jpg', frame)[1].tobytes())
-    new_frame = Frame(frame_data=frame_data_encoded, count_of_people=count_of_people)
-    db.session.add(new_frame)
-    db.session.commit()
+                frame_data_encoded = base64.b64encode(cv2.imencode('.jpg', image)[1].tobytes())
+                new_frame = Frame(frame_data=frame_data_encoded, count_of_people=count_of_people)
+                db.session.add(new_frame)
+                db.session.commit()
+
+            success, image = vidObj.read()
+            frame_counter += 1
+
+            if not success:
+                vidObj.release()  # Release the video capture object before breaking out of the loop
+                break
+
+    # After the loop, release the video capture object and delete the file
+    vidObj.release()
+    shutil.rmtree(media_folder)
+
+def process_upload_thread(vidObj, media_folder):
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(detect_faces_and_save(vidObj, media_folder))
+    loop.close()
 
-    return frame, count_of_people
 
 @app.route('/video_feed', methods=['POST'])
 def video_feed():
+
+    media_folder = "media"
+    if not os.path.exists(media_folder):
+        os.makedirs(media_folder)
+
     if 'video' not in request.files:
         return jsonify({'error': 'No video file in the request'})
 
     video_file = request.files['video']
-    video_path = "uploaded_video.mp4"
+    video_path = os.path.join(media_folder, "uploaded_video.mp4")
     video_file.save(video_path)
 
     vidObj = cv2.VideoCapture(video_path)
 
     success, image = vidObj.read()
+    
+    detector = face_detection.build_detector("DSFDDetector", confidence_threshold=0.5, nms_iou_threshold=0.3)
+    det_raw = detector.detect(image[:, :, ::-1])
+    dets = det_raw[:, :4]
+    draw_faces(image, dets)
 
-    while success:
-        try:
-            # Call your face detection function here
-            detect_faces_and_save(image)
-        except Exception as e:
-            return jsonify({'error': f'Error processing frames: {str(e)}'})
-
-        success, image = vidObj.read()
-
-    # Close the video capture object
-    vidObj.release()
-
-    # Delete the video file after processing
-    os.remove(video_path)
+    count_of_people = len(dets)
+    frame_data_encoded = base64.b64encode(cv2.imencode('.jpg', image)[1].tobytes())
+    frame_data_encoded_str = frame_data_encoded.decode('latin1')
+    
+    threading.Thread(target=process_upload_thread, args=(vidObj, media_folder)).start()
+    
+    return jsonify({'frame': frame_data_encoded_str, 'count_of_people': count_of_people})
 
-    return jsonify({'result': 'Video parsed'})
 
 
 @app.route('/')
@@ -89,9 +124,6 @@ def get_frames():
             'count_of_people': frame.count_of_people
         })
     
-    db.session.query(Frame).delete()
-    db.session.commit()
-    
     return jsonify(frames_data)
 
 if __name__ == '__main__':