Update app.py

app.py

@@ -2,94 +2,26 @@ import streamlit as st
 import pandas as pd
 from datetime import datetime
 import os
-import threading
-import time
-from PIL import Image
-from io import BytesIO
 import base64
-import cv2
-import numpy as np
-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 '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}. Check connection or index.")
-            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")
-    # Convert RGB to BGR for OpenCV saving
-    img_bgr = cv2.cvtColor(img_data, cv2.COLOR_RGB2BGR)
-    cv2.imwrite(file_path, img_bgr)
+    with open(file_path, "wb") as f:
+        f.write(base64.b64decode(img_data.split(',')[1]))
     st.session_state['file_history'].append({
         "Timestamp": timestamp,
         "Type": file_type,
         "Path": file_path
     })
 
-# 📸⏰ Auto-capture every 10 secs like a sneaky shutterbug!
-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")
-    frame_queues = [queue.Queue(maxsize=1), queue.Queue(maxsize=1)]  # Define frame_queues here
-    if st.button("⏰ Start Auto-Snap"):
-        st.session_state['auto_capture_running'] = True
-        threading.Thread(target=auto_capture, args=(frame_queues,), daemon=True).start()
-    if st.button("⏹️ Stop Auto-Snap"):
-        st.session_state['auto_capture_running'] = False
-
-    # 📂 Sidebar file outline with emoji flair!
     st.subheader("📜 Snap Stash")
     if st.session_state['file_history']:
         images = [f for f in st.session_state['file_history'] if f['Type'] == "🖼️ Image"]
@@ -101,33 +33,94 @@ with st.sidebar:
         st.write("🕳️ Empty Stash!")
 
 # 🌍🎨 Main UI kicks off like a cosmic art show!
-st.title("📸 OpenCV Snap Craze")
-
-# 📸📷 Start camera threads
-threads = [
-    CamThread("Camera 0", 0, frame_queues[0]),
-    CamThread("Camera 1", 1, frame_queues[1])
-]
-for thread in threads:
-    thread.start()
+st.title("📸 Multi-Cam Snap Craze")
 
-# 📸📷 Camera snap zone!
+# 📸📷 JS camera zone with multiple streams!
 st.header("📸🎥 Snap Zone")
-cols = st.columns(2)
-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}...")
+multi_cam_html = """
+<div id="videoContainer"></div>
+<script>
+    let streams = [];
+    const container = document.getElementById('videoContainer');
+    let autoCaptureIntervals = [];
+
+    // 📹🔍 Enumerate cameras like a tech detective!
+    async function enumerateAndStartCameras() {
+        const devices = await navigator.mediaDevices.enumerateDevices();
+        const videoDevices = devices.filter(device => device.kind === 'videoinput');
+        videoDevices.forEach((device, index) => {
+            const div = document.createElement('div');
+            div.innerHTML = `
+                <p>${device.label || 'Camera ' + index}</p>
+                <video id="video${index}" autoplay playsinline style="width:100%;"></video>
+                <canvas id="canvas${index}" style="display:none;"></canvas>
+                <button onclick="takeSnapshot(${index})">📸 Snap Cam ${index}</button>
+            `;
+            container.appendChild(div);
+            startStream(device.deviceId, index);
+        });
+    }
+
+    // 📸🎥 Start streaming like a live broadcast pro!
+    async function startStream(deviceId, index) {
+        const constraints = { video: { deviceId: { exact: deviceId } } };
+        const stream = await navigator.mediaDevices.getUserMedia(constraints);
+        const video = document.getElementById(`video${index}`);
+        video.srcObject = stream;
+        streams.push(stream);
+        // Auto-capture every 10 seconds
+        autoCaptureIntervals[index] = setInterval(() => takeSnapshot(index), 10000);
+    }
+
+    // 📸✂️ Snap a pic like a stealthy paparazzi!
+    function takeSnapshot(index) {
+        const video = document.getElementById(`video${index}`);
+        const canvas = document.getElementById(`canvas${index}`);
+        canvas.width = video.videoWidth;
+        canvas.height = video.videoHeight;
+        canvas.getContext('2d').drawImage(video, 0, 0);
+        const dataUrl = canvas.toDataURL('image/jpeg');
+        window.parent.postMessage({ type: 'snapshot', data: dataUrl, camIndex: index }, '*');
+    }
+
+    // ⏹️📴 Stop all streams like a broadcast kill switch!
+    function stopStreams() {
+        streams.forEach(stream => stream.getTracks().forEach(track => track.stop()));
+        streams = [];
+        autoCaptureIntervals.forEach(interval => clearInterval(interval));
+        autoCaptureIntervals = [];
+    }
+
+    // 🎬 Kick off the camera party!
+    enumerateAndStartCameras();
+    window.onunload = stopStreams;
+</script>
+"""
+st.markdown(multi_cam_html, unsafe_allow_html=True)
+
+# 📸📥 Handle snapshots from JS
+def handle_snapshot():
+    if "snapshot" in st.session_state:
+        snapshot_data = st.session_state["snapshot"]
+        cam_index = st.session_state.get("camIndex", 0)
+        filename = f"cam{cam_index}_snap_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+        save_to_history("🖼️ Image", filename, snapshot_data)
+        st.image(Image.open(BytesIO(base64.b64decode(snapshot_data.split(',')[1]))), caption=f"Cam {cam_index} Snap", use_container_width=True)
+        del st.session_state["snapshot"]
+
+st.components.v1.html(
+    """
+    <script>
+    window.addEventListener('message', function(event) {
+        if (event.data.type === 'snapshot') {
+            window.streamlitAPI.setComponentValue({snapshot: event.data.data, camIndex: event.data.camIndex});
+        }
+    });
+    </script>
+    """,
+    height=0
+)
+handle_snapshot()
 
 # 📂 Upload zone like a media drop party!
 st.header("📥🎉 Drop Zone")
@@ -135,10 +128,8 @@ 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"
-        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)
+        save_to_history("🖼️ Image", file_path, base64.b64encode(uploaded_file.getvalue()).decode())
+        st.image(Image.open(uploaded_file), caption=uploaded_file.name, use_container_width=True)
 
 # 🖼️ Gallery like a media circus!
 st.header("🎪 Snap Show")
@@ -165,14 +156,4 @@ if st.session_state['file_history']:
     df = pd.DataFrame(st.session_state['file_history'])
     st.dataframe(df)
 else:
-    st.write("🕳️ Nothing snapped yet!")
-
-# Cleanup on app exit
-def cleanup():
-    for thread in threads:
-        thread.stop()
-    for thread in threads:
-        thread.join()
-
-import atexit
-atexit.register(cleanup)
+    st.write("🕳️ Nothing snapped yet!")