Update app.py

app.py

@@ -7,24 +7,59 @@ import time
 from PIL import Image
 from io import BytesIO
 import base64
-
-# 🌟🔥 Initialize global state for threading safety!
-AUTO_CAPTURE_RUNNING = False
-SELECTED_CAM_IMG = None
+import cv2
+import queue
 
 # 🌟🔥 Initialize session state like a galactic DJ spinning tracks!
 if 'file_history' not in st.session_state:
     st.session_state['file_history'] = []
-if 'cam0_file' not in st.session_state:
-    st.session_state['cam0_file'] = None
-if 'cam1_file' not in st.session_state:
-    st.session_state['cam1_file'] = None
+if 'auto_capture_running' not in st.session_state:
+    st.session_state['auto_capture_running'] = False
+
+# 📸📷 Camera thread class for OpenCV capture
+class CamThread(threading.Thread):
+    def __init__(self, preview_name, cam_id, frame_queue):
+        threading.Thread.__init__(self)
+        self.preview_name = preview_name
+        self.cam_id = cam_id
+        self.frame_queue = frame_queue
+        self.running = True
+
+    def run(self):
+        print(f"Starting {self.preview_name}")
+        self.cam_preview()
+
+    def cam_preview(self):
+        cam = cv2.VideoCapture(self.cam_id)
+        cam.set(cv2.CAP_PROP_FRAME_WIDTH, 640)  # Set reasonable resolution
+        cam.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+        cam.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'))  # Use MJPG for better USB compatibility
+        if not cam.isOpened():
+            st.error(f"🚨 Failed to open {self.preview_name}")
+            return
+
+        while self.running:
+            ret, frame = cam.read()
+            if ret:
+                # Convert BGR to RGB for display
+                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                try:
+                    self.frame_queue.put_nowait(frame_rgb)
+                except queue.Full:
+                    pass  # Skip if queue is full
+            time.sleep(0.03)  # ~30 FPS
+
+        cam.release()
+
+    def stop(self):
+        self.running = False
 
 # 📜💾 Save to history like a time-traveling scribe! | 📅✨ save_to_history("🖼️ Image", "pic.jpg", img_data) - Stamps a pic in the history books like a boss!
 def save_to_history(file_type, file_path, img_data):
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    with open(file_path, "wb") as f:
-        f.write(img_data)
+    # Convert RGB to BGR for OpenCV saving
+    img_bgr = cv2.cvtColor(img_data, cv2.COLOR_RGB2BGR)
+    cv2.imwrite(file_path, img_bgr)
     st.session_state['file_history'].append({
         "Timestamp": timestamp,
         "Type": file_type,
@@ -32,30 +67,25 @@ def save_to_history(file_type, file_path, img_data):
     })
 
 # 📸⏰ Auto-capture every 10 secs like a sneaky shutterbug!
-def auto_capture():
-    global AUTO_CAPTURE_RUNNING, SELECTED_CAM_IMG
-    if AUTO_CAPTURE_RUNNING and SELECTED_CAM_IMG:
-        filename = f"auto_snap_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
-        with open(filename, "wb") as f:
-            f.write(SELECTED_CAM_IMG)
-        st.session_state['file_history'].append({
-            "Timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "Type": "🖼️ Image",
-            "Path": filename
-        })
-        threading.Timer(10, auto_capture).start()
+def auto_capture(frame_queues):
+    while st.session_state['auto_capture_running']:
+        for i, q in enumerate(frame_queues):
+            try:
+                frame = q.get_nowait()
+                filename = f"cam{i}_auto_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+                save_to_history("🖼️ Image", filename, frame)
+            except queue.Empty:
+                pass  # Skip if no frame available
+        time.sleep(10)
 
 # 🎛️ Sidebar config like a spaceship control panel!
 with st.sidebar:
     st.header("🎚️📸 Snap Shack")
-    camera_choice = st.selectbox("📷 Pick a Cam", ["Camera 0", "Camera 1"])
     if st.button("⏰ Start Auto-Snap"):
-        global AUTO_CAPTURE_RUNNING
-        AUTO_CAPTURE_RUNNING = True
-        auto_capture()
+        st.session_state['auto_capture_running'] = True
+        threading.Thread(target=auto_capture, args=(frame_queues,), daemon=True).start()
     if st.button("⏹️ Stop Auto-Snap"):
-        global AUTO_CAPTURE_RUNNING
-        AUTO_CAPTURE_RUNNING = False
+        st.session_state['auto_capture_running'] = False
 
     # 📂 Sidebar file outline with emoji flair!
     st.subheader("📜 Snap Stash")
@@ -69,33 +99,34 @@ with st.sidebar:
         st.write("🕳️ Empty Stash!")
 
 # 🌍🎨 Main UI kicks off like a cosmic art show!
-st.title("📸 Streamlit Snap Craze")
+st.title("📸 OpenCV Snap Craze")
+
+# 📸📷 Start camera threads
+frame_queues = [queue.Queue(maxsize=1), queue.Queue(maxsize=1)]
+threads = [
+    CamThread("Camera 0", 0, frame_queues[0]),
+    CamThread("Camera 1", 1, frame_queues[1])
+]
+for thread in threads:
+    thread.start()
 
 # 📸📷 Camera snap zone!
 st.header("📸🎥 Snap Zone")
 cols = st.columns(2)
-with cols[0]:
-    cam0_img = st.camera_input("📷 Camera 0", key="cam0")
-    if cam0_img and camera_choice == "Camera 0":
-        filename = f"cam0_snap_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
-        if st.session_state['cam0_file'] and os.path.exists(st.session_state['cam0_file']):
-            os.remove(st.session_state['cam0_file'])
-        save_to_history("🖼️ Image", filename, cam0_img.getvalue())
-        st.session_state['cam0_file'] = filename
-        global SELECTED_CAM_IMG
-        SELECTED_CAM_IMG = cam0_img.getvalue()
-        st.image(Image.open(BytesIO(cam0_img.getvalue())), caption="Camera 0 Snap", use_container_width=True)
-with cols[1]:
-    cam1_img = st.camera_input("📷 Camera 1", key="cam1")
-    if cam1_img and camera_choice == "Camera 1":
-        filename = f"cam1_snap_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
-        if st.session_state['cam1_file'] and os.path.exists(st.session_state['cam1_file']):
-            os.remove(st.session_state['cam1_file'])
-        save_to_history("🖼️ Image", filename, cam1_img.getvalue())
-        st.session_state['cam1_file'] = filename
-        global SELECTED_CAM_IMG
-        SELECTED_CAM_IMG = cam1_img.getvalue()
-        st.image(Image.open(BytesIO(cam1_img.getvalue())), caption="Camera 1 Snap", use_container_width=True)
+placeholders = [cols[0].empty(), cols[1].empty()]
+for i, (placeholder, q, thread) in enumerate(zip(placeholders, frame_queues, threads)):
+    if st.button(f"📸 Snap Cam {i}", key=f"snap{i}"):
+        try:
+            frame = q.get_nowait()
+            filename = f"cam{i}_snap_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+            save_to_history("🖼️ Image", filename, frame)
+        except queue.Empty:
+            st.error(f"🚨 No frame from Cam {i} yet!")
+    try:
+        frame = q.get_nowait()
+        placeholder.image(frame, caption=f"Live Cam {i}", use_container_width=True)
+    except queue.Empty:
+        placeholder.write(f"📷 Waiting for Cam {i}...")
 
 # 📂 Upload zone like a media drop party!
 st.header("📥🎉 Drop Zone")
@@ -103,8 +134,10 @@ uploaded_files = st.file_uploader("📸 Toss Pics", accept_multiple_files=True,
 if uploaded_files:
     for uploaded_file in uploaded_files:
         file_path = f"uploaded_{uploaded_file.name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
-        save_to_history("🖼️ Image", file_path, uploaded_file.getvalue())
-        st.image(Image.open(BytesIO(uploaded_file.getvalue())), caption=uploaded_file.name, use_container_width=True)
+        img = Image.open(uploaded_file)
+        img_array = np.array(img)
+        save_to_history("🖼️ Image", file_path, img_array)
+        st.image(img, caption=uploaded_file.name, use_container_width=True)
 
 # 🖼️ Gallery like a media circus!
 st.header("🎪 Snap Show")
@@ -131,4 +164,14 @@ if st.session_state['file_history']:
     df = pd.DataFrame(st.session_state['file_history'])
     st.dataframe(df)
 else:
-    st.write("🕳️ Nothing snapped yet!")
+    st.write("🕳️ Nothing snapped yet!")
+
+# Cleanup on app exit (not typically needed in Streamlit, but good practice)
+def cleanup():
+    for thread in threads:
+        thread.stop()
+    for thread in threads:
+        thread.join()
+
+import atexit
+atexit.register(cleanup)