Update app.py

app.py

@@ -1,57 +1,55 @@
-import cv2
-import streamlit as st
+import torch
 import numpy as np
 from PIL import Image
-import time
-
-# Load the pre-trained Haar Cascade face detector
-face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-
-# Define a function to detect faces in a frame
-def detect_faces(frame):
-    # Convert the frame to grayscale (Haar Cascade works on grayscale images)
-    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-
-    # Detect faces in the image
-    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+from transformers import AutoImageProcessor, AutoModelForDepthEstimation
+import streamlit as st
+import cv2
 
-    # Draw rectangles around the faces
-    for (x, y, w, h) in faces:
-        cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
+# Load model and image processor
+image_processor = AutoImageProcessor.from_pretrained("depth-anything/Depth-Anything-V2-Small-hf")
+model = AutoModelForDepthEstimation.from_pretrained("depth-anything/Depth-Anything-V2-Small-hf")
 
-    return frame
+# Set the device for model (CUDA if available)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model.to(device)
 
-# Streamlit UI for the app
-st.title("Real-Time Face Detection")
+# Use FP16 if available (half precision for speed)
+if torch.cuda.is_available():
+    model = model.half()
 
-# Create a container for the webcam video feed
-video_placeholder = st.empty()
+# Streamlit App
+st.title("Depth Estimation from Webcam")
 
-# Start the webcam feed
-cap = cv2.VideoCapture(0)  # 0 is the default webcam device
+# Capture image from webcam
+image_data = st.camera_input("Capture an image")
 
-if not cap.isOpened():
-    st.error("Error: Could not access the webcam.")
-else:
-    # Start capturing video frames
-    while True:
-        ret, frame = cap.read()
+if image_data is not None:
+    # Convert the captured image data to a PIL image
+    image = Image.open(image_data)
 
-        if not ret:
-            st.error("Failed to grab frame.")
-            break
+    # Prepare the image for the model
+    inputs = image_processor(images=image, return_tensors="pt").to(device)
 
-        # Detect faces in the current frame
-        result_frame = detect_faces(frame)
+    # Model inference (no gradients needed)
+    with torch.no_grad():
+        outputs = model(**inputs)
+        predicted_depth = outputs.predicted_depth
 
-        # Convert BGR (OpenCV format) to RGB (for Streamlit display)
-        result_frame_rgb = cv2.cvtColor(result_frame, cv2.COLOR_BGR2RGB)
+    # Interpolate depth map to match the image's dimensions
+    prediction = torch.nn.functional.interpolate(
+        predicted_depth.unsqueeze(1),
+        size=(image.height, image.width),  # Match the image's dimensions
+        mode="bicubic",
+        align_corners=False,
+    )
 
-        # Display the frame in Streamlit (dynamically updating the image)
-        video_placeholder.image(result_frame_rgb, channels="RGB", use_column_width=True)
+    # Convert depth map to numpy for visualization
+    depth_map = prediction.squeeze().cpu().numpy()
 
-        # Add a small delay to control the frame rate (optional)
-        time.sleep(0.03)  # This gives roughly 30 FPS
+    # Normalize depth map for display (visualization purposes)
+    depth_map_normalized = np.uint8(depth_map / np.max(depth_map) * 255)
+    depth_map_colored = cv2.applyColorMap(depth_map_normalized, cv2.COLORMAP_JET)
 
-# Release the webcam when the stream ends
-cap.release()
+    # Display the original image and the depth map in Streamlit
+    st.image(image, caption="Captured Image", use_column_width=True)
+    st.image(depth_map_colored, caption="Depth Map", use_column_width=True)