Update app.py

app.py

@@ -5,6 +5,8 @@ from transformers import DPTForDepthEstimation, DPTImageProcessor
 import gradio as gr
 import torch.quantization
 import torch.nn.utils.prune as prune
+import asyncio
+import queue
 
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
@@ -18,7 +20,7 @@ parameters_to_prune = [
 prune.global_unstructured(
     parameters_to_prune,
     pruning_method=prune.L1Unstructured,
-    amount=0.8,  # Prune 80% of weights
+    amount=0.3,  # Prune 30% of weights
 )
 
 for module, _ in parameters_to_prune:
@@ -35,6 +37,9 @@ color_map = cv2.applyColorMap(np.arange(256, dtype=np.uint8), cv2.COLORMAP_INFER
 
 input_tensor = torch.zeros((1, 3, 128, 128), dtype=torch.float32, device=device)
 
+frame_queue = queue.Queue(maxsize=1)
+result_queue = queue.Queue(maxsize=1)
+
 def preprocess_image(image):
     return cv2.resize(image, (128, 72), interpolation=cv2.INTER_AREA).transpose(2, 0, 1).astype(np.float32) / 255.0
 
@@ -55,11 +60,47 @@ def process_frame(image):
     
     return cv2.cvtColor(depth_map_colored, cv2.COLOR_BGR2RGB)
 
-interface = gr.Interface(
-    fn=process_frame,
-    inputs=gr.Image(sources="webcam", streaming=True),
-    outputs="image",
-    live=True
-)
+async def capture_frames(webcam):
+    frame_count = 0
+    while True:
+        ret, frame = webcam.read()
+        if not ret:
+            break
+        frame_count += 1
+        if frame_count % 5 == 0:  # Process every 5th frame
+            if frame_queue.full():
+                frame_queue.get()  # Remove old frame if queue is full
+            frame_queue.put(frame)
+        await asyncio.sleep(0.01)  # Small delay to prevent blocking
+
+async def process_frames():
+    while True:
+        if not frame_queue.empty():
+            frame = frame_queue.get()
+            result = process_frame(frame)
+            if result_queue.full():
+                result_queue.get()  # Remove old result if queue is full
+            result_queue.put(result)
+        await asyncio.sleep(0.01)  # Small delay to prevent blocking
+
+def get_latest_frame():
+    if result_queue.empty():
+        return None
+    return result_queue.get()
+
+async def main():
+    webcam = cv2.VideoCapture(0)
+    asyncio.create_task(capture_frames(webcam))
+    asyncio.create_task(process_frames())
+
+    interface = gr.Interface(
+        fn=get_latest_frame,
+        inputs=None,
+        outputs="image",
+        live=True
+    )
+
+    await interface.launch()
 
-interface.launch()
+if __name__ == "__main__":
+    asyncio.run(main())