fixed video

.gitignore

@@ -1,4 +1,7 @@
 __pycache__/
 *.pth
 data/
-.DS_Store
+.DS_Store
+flagged/
+# main.ipynb
+*.mp4

app.py

@@ -32,12 +32,12 @@ os.environ['OMP_NUM_THREADS'] = '4'
 os.environ['AWS_ACCESS_KEY_ID'] = 'AKIA3JAMX4K53MFDKMGJ'
 os.environ['AWS_SECRET_ACCESS_KEY'] = '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'
 
-app_version = 'ddn2'
+app_version = 'dsdg_vid_1'
 
 device = torch.device("cpu")
 labels = ['Live', 'Spoof']
 PIX_THRESHOLD = 0.45
-DSDG_THRESHOLD = 80
+DSDG_THRESHOLD = 0.5
 MIN_FACE_WIDTH_THRESHOLD = 210
 examples = [
     ['examples/1_1_21_2_33_scene_fake.jpg'],
@@ -101,6 +101,7 @@ def prepare_data_dsdg(images, boxes, depths):
     depth_x = torch.from_numpy(depth_x.astype(float)).float()
     return image_x, depth_x
 
+
 def find_largest_face(faces):
     # find the largest face in the list
     largest_face = None
@@ -144,7 +145,7 @@ def deepix_model_inference(img, bbox):
 
 
 def dsdg_model_inference(img, bbox, dsdg_thresh):
-    dsdg_thresh = dsdg_thresh / 30000
+    dsdg_thresh = dsdg_thresh / 10000
     dense_flag = True
     x, y, x2, y2 = bbox
     w = x2 - x
@@ -155,7 +156,7 @@ def dsdg_model_inference(img, bbox, dsdg_thresh):
         img_dsdg = cv.rectangle(img.copy(), (x, y), (x2, y2), color_dsdg, 2)
         cv.putText(img_dsdg, text, (x, y2 + 30),
                    cv.FONT_HERSHEY_COMPLEX, 1, color_dsdg)
-        cls_dsdg = 2
+        cls_dsdg = -1
         return img_dsdg, {}, cls_dsdg
     bbox_conf = list(bbox)
     bbox_conf.append(1)
@@ -183,14 +184,14 @@ def dsdg_model_inference(img, bbox, dsdg_thresh):
         res_dsdg = 0.0
     cls_dsdg = 'Real' if res_dsdg >= dsdg_thresh else 'Spoof'
     text = f'{cls_dsdg} {w}*{h}'
-    res_dsdg = res_dsdg * 300
     confidences_dsdg = {'Real confidence': res_dsdg}
     color_dsdg = (0, 255, 0) if cls_dsdg == 'Real' else (255, 0, 0)
     img_dsdg = cv.rectangle(img.copy(), (x, y), (x2, y2), color_dsdg, 2)
     cv.putText(img_dsdg, text, (x, y2 + 30),
                 cv.FONT_HERSHEY_COMPLEX, 1, color_dsdg)
-    cls_dsdg = 1 if cls_dsdg == 'Real' else 0
-    return img_dsdg, confidences_dsdg, res_dsdg * 100
+    res_dsdg = res_dsdg * 1000000
+    # cls_dsdg = 1 if cls_dsdg == 'Real' else 0
+    return img_dsdg, confidences_dsdg, res_dsdg
 
 
 def inference(img, dsdg_thresh):
@@ -214,9 +215,9 @@ def process_video(vid_path, dsdg_thresh):
     input_height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
 
     # Set video codec and create VideoWriter object to save the output video
-    fourcc = cv.VideoWriter_fourcc(*'XVID')
+    fourcc = cv.VideoWriter_fourcc(*'mp4v')
     output_vid_path = 'output_dsdg.mp4'
-    out_dsdg = cv.VideoWriter(output_vid_path, fourcc, 6.0, (input_width, input_height))
+    out_dsdg = cv.VideoWriter(output_vid_path, fourcc, 20.0, (input_width, input_height))
 
     frame_counter = 0
     confidences_arr = []
@@ -224,76 +225,72 @@ def process_video(vid_path, dsdg_thresh):
         ret, frame = cap.read()
         if not ret:
             break
-
         # Process only every 5th frame
         if frame_counter % 5 == 0:
             # Run inference on the current frame
-            _, _, _, img_dsdg, confidences_dsdg, _ = inference(frame, dsdg_thresh)
-            confidences_arr.append(confidences_dsdg['Real confidence'])
-
-            # Resize the DSDG frame to match the input video dimensions
-            img_dsdg = cv.resize(img_dsdg, (input_width, input_height))
-
+            _, _, _, img_dsdg, confidences_dsdg, res_dsdg = inference(frame, dsdg_thresh)
+            if res_dsdg == -1:
+                continue
+            confidences_arr.append(res_dsdg)
             # Write the DSDG frame to the output video
             out_dsdg.write(img_dsdg)
-
         frame_counter += 1
-    avg_conf = sum(confidences_arr) / len(confidences_arr)
-    confidences_dsdg = {'Average real confidence': avg_conf}
     # Release resources
     cap.release()
     out_dsdg.release()
-    return vid_path, {'Not supported right now': 0}, 2, output_vid_path, avg_conf, avg_conf
+    if not confidences_arr:
+        return vid_path, {'Not supported right now': 0}, -1, vid_path, 'Faces too small or not found', -1
+    avg_conf = sum(confidences_arr) / len(confidences_arr)
+    text_dsdg = f'Average real confidence: {avg_conf}\nFrames used: {len(confidences_arr)}\nConfidences:{confidences_arr}'
+    return vid_path, {'Not supported right now': 0}, -1, output_vid_path, text_dsdg, avg_conf
 
 
-def upload_to_s3(image_array, app_version, *labels):
+def upload_to_s3(vid_path, app_version, *labels):
     folder = 'demo'
     bucket_name = 'livenessng'
-    if image_array is None:
+
+    if vid_path is None:
         return 'Error. Take a photo first.'
-    elif labels[-2] == -1:
+    elif labels[-2] == -2:
         return 'Error. Run the detection first.'
     elif labels[0] is None:
         return 'Error. Select the true label first.'
+    elif labels[0] == 2:
+        labels[0] = -1
 
     # Initialize S3 client
     s3 = boto3.client('s3')
 
-    # Encode labels and app version in image file name
+    # Encode labels and app version in video file name
     encoded_labels = '_'.join([str(int(label)) for label in labels])
     random_string = str(uuid.uuid4()).split('-')[-1]
-    image_name = f"{folder}/{app_version}/{encoded_labels}_{random_string}.jpg"
+    video_name = f"{folder}/{app_version}/{encoded_labels}_{random_string}.mp4"
 
-    # Save image as JPEG
-    image = Image.fromarray(image_array)
-    image_bytes = io.BytesIO()
-    image.save(image_bytes, format='JPEG')
-    image_bytes.seek(0)
+    # Upload video to S3
+    with open(vid_path, 'rb') as video_file:
+        res = s3.upload_fileobj(video_file, bucket_name, video_name)
 
-    # Upload image to S3
-    res = s3.upload_fileobj(image_bytes, bucket_name, image_name)
-    # Return the S3 URL of the uploaded image
+    # Return the S3 URL of the uploaded video
     status = 'Successfully uploaded'
     return status
 
 
-# interface = .queue(concurrency_count=2)
 demo = gr.Blocks()
 
 with demo:
     with gr.Row():
         with gr.Column():
             input_vid = gr.Video(format='mp4', source='webcam')
-            dsdg_thresh = gr.Slider(value=DSDG_THRESHOLD, label='DSDG threshold')
+            dsdg_thresh = gr.Slider(value=DSDG_THRESHOLD, label='DSDG threshold', maximum=3.0, step=0.05)
             btn_run = gr.Button(value="Run")
         with gr.Column():
             outputs=[
                 gr.Video(label='DeePixBiS', format='mp4'),
                 gr.Label(num_top_classes=2, label='DeePixBiS'),
-                gr.Number(visible=False, value=-1),
+                gr.Number(visible=False, value=-2),
                 gr.Video(label='DSDG', format='mp4'),
-                gr.Label(num_top_classes=2, label='DSDG'),
-                gr.Number(visible=False, value=-1)]
+                gr.Textbox(label='DSDG'),
+                gr.Number(visible=False, value=-2)]
         with gr.Column():
             radio = gr.Radio(
                 ["Spoof", "Real", "None"], label="True label", type='index')