Updated app.py

app.py

@@ -130,94 +130,94 @@ def process_image(image, operation_name, age_filters=[], gender_filters=[], sele
     
     return [image_with_boxes_rgb, processed_image_rgb, json.dumps(results_data, indent=2), face_thumbnails]
 
-def process_video(video_path, operation_name, age_filters=[], gender_filters=[], progress=gr.Progress()):
-    """Process a video with face blurring"""
-    if video_path is None:
-        return None, "Please upload a video"
+# def process_video(video_path, operation_name, age_filters=[], gender_filters=[], progress=gr.Progress()):
+#     """Process a video with face blurring"""
+#     if video_path is None:
+#         return None, "Please upload a video"
     
-    # Get operation code
-    operation = OPERATION_OPTIONS.get(operation_name, 0)
+#     # Get operation code
+#     operation = OPERATION_OPTIONS.get(operation_name, 0)
     
-    # Create a temporary file for the output
-    output_path = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name
+#     # Create a temporary file for the output
+#     output_path = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name
     
-    # Open the video
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        return None, "Could not open video file"
+#     # Open the video
+#     cap = cv2.VideoCapture(video_path)
+#     if not cap.isOpened():
+#         return None, "Could not open video file"
     
-    # Get video properties
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+#     # Get video properties
+#     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+#     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+#     fps = cap.get(cv2.CAP_PROP_FPS)
+#     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     
-    # Determine frame skipping (process every nth frame for speed)
-    frame_skip = max(1, round(fps / 15))  # Process at most 15 fps
+#     # Determine frame skipping (process every nth frame for speed)
+#     frame_skip = max(1, round(fps / 15))  # Process at most 15 fps
     
-    # Create VideoWriter object
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+#     # Create VideoWriter object
+#     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+#     out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
     
-    # Create filters dictionary
-    filters = {
-        "gender": gender_filters,
-        "age": age_filters
-    }
+#     # Create filters dictionary
+#     filters = {
+#         "gender": gender_filters,
+#         "age": age_filters
+#     }
     
-    # Process frames
-    frame_count = 0
-    face_count = 0
+#     # Process frames
+#     frame_count = 0
+#     face_count = 0
     
-    # Process limited frames to prevent timeout (Gradio has a 60s limit by default)
-    max_frames_to_process = min(300, total_frames)  # Limit to 300 frames
+#     # Process limited frames to prevent timeout (Gradio has a 60s limit by default)
+#     max_frames_to_process = min(300, total_frames)  # Limit to 300 frames
     
-    for _ in progress.tqdm(range(max_frames_to_process)):
-        ret, frame = cap.read()
-        if not ret:
-            break
+#     for _ in progress.tqdm(range(max_frames_to_process)):
+#         ret, frame = cap.read()
+#         if not ret:
+#             break
         
-        # Process every nth frame (for efficiency)
-        if frame_count % frame_skip == 0:
-            # Detect faces
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            predictions = loop.run_until_complete(detect_faces_frame(detector=detector, frame=frame))
-            loop.close()
+#         # Process every nth frame (for efficiency)
+#         if frame_count % frame_skip == 0:
+#             # Detect faces
+#             loop = asyncio.new_event_loop()
+#             asyncio.set_event_loop(loop)
+#             predictions = loop.run_until_complete(detect_faces_frame(detector=detector, frame=frame))
+#             loop.close()
             
-            face_count += len(predictions)
+#             face_count += len(predictions)
             
-            # Apply blur
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            processed_frame = loop.run_until_complete(
-                apply_blur(
-                    detected_faces=predictions,
-                    frame=frame,
-                    filters=filters,
-                    operation=operation
-                )
-            )
-            loop.close()
+#             # Apply blur
+#             loop = asyncio.new_event_loop()
+#             asyncio.set_event_loop(loop)
+#             processed_frame = loop.run_until_complete(
+#                 apply_blur(
+#                     detected_faces=predictions,
+#                     frame=frame,
+#                     filters=filters,
+#                     operation=operation
+#                 )
+#             )
+#             loop.close()
             
-            # Write processed frame
-            out.write(processed_frame)
-        else:
-            # Write original frame for skipped frames
-            out.write(frame)
+#             # Write processed frame
+#             out.write(processed_frame)
+#         else:
+#             # Write original frame for skipped frames
+#             out.write(frame)
         
-        frame_count += 1
+#         frame_count += 1
     
-    # Release resources
-    cap.release()
-    out.release()
+#     # Release resources
+#     cap.release()
+#     out.release()
     
-    # Summary message
-    summary = f"Processed {frame_count} frames, detected {face_count} faces"
-    if frame_count < total_frames:
-        summary += f" (limited to first {frame_count} frames out of {total_frames})"
+#     # Summary message
+#     summary = f"Processed {frame_count} frames, detected {face_count} faces"
+#     if frame_count < total_frames:
+#         summary += f" (limited to first {frame_count} frames out of {total_frames})"
     
-    return output_path, summary
+#     return output_path, summary
 
 # Create Gradio interface
 with gr.Blocks(title="Face Privacy Protection Tool") as demo:
@@ -279,37 +279,37 @@ with gr.Blocks(title="Face Privacy Protection Tool") as demo:
                 outputs=[image_with_boxes, image_output, json_output, face_gallery]
             )
         
-        with gr.TabItem("Video Processing"):
-            with gr.Row():
-                with gr.Column():
-                    video_input = gr.Video(label="Upload Video")
-                    video_operation = gr.Dropdown(
-                        choices=list(OPERATION_OPTIONS.keys()),
-                        value="Gaussian Blur",
-                        label="Blur Operation"
-                    )
+        # with gr.TabItem("Video Processing"):
+        #     with gr.Row():
+        #         with gr.Column():
+        #             video_input = gr.Video(label="Upload Video")
+        #             video_operation = gr.Dropdown(
+        #                 choices=list(OPERATION_OPTIONS.keys()),
+        #                 value="Gaussian Blur",
+        #                 label="Blur Operation"
+        #             )
                     
-                    with gr.Accordion("Advanced Filtering", open=False):
-                        video_age_filter = gr.CheckboxGroup(
-                            choices=AGE_OPTIONS,
-                            label="Filter by Age (select to blur)"
-                        )
-                        video_gender_filter = gr.CheckboxGroup(
-                            choices=GENDER_OPTIONS,
-                            label="Filter by Gender (select to blur)"
-                        )
+        #             with gr.Accordion("Advanced Filtering", open=False):
+        #                 video_age_filter = gr.CheckboxGroup(
+        #                     choices=AGE_OPTIONS,
+        #                     label="Filter by Age (select to blur)"
+        #                 )
+        #                 video_gender_filter = gr.CheckboxGroup(
+        #                     choices=GENDER_OPTIONS,
+        #                     label="Filter by Gender (select to blur)"
+        #                 )
                     
-                    video_button = gr.Button("Process Video")
+        #             video_button = gr.Button("Process Video")
                 
-                with gr.Column():
-                    video_output = gr.Video(label="Processed Video")
-                    video_summary = gr.Textbox(label="Processing Summary")
+        #         with gr.Column():
+        #             video_output = gr.Video(label="Processed Video")
+        #             video_summary = gr.Textbox(label="Processing Summary")
             
-            video_button.click(
-                process_video,
-                inputs=[video_input, video_operation, video_age_filter, video_gender_filter],
-                outputs=[video_output, video_summary]
-            )
+        #     video_button.click(
+        #         process_video,
+        #         inputs=[video_input, video_operation, video_age_filter, video_gender_filter],
+        #         outputs=[video_output, video_summary]
+        #     )
     
     gr.Markdown("""
     ## How to Use