Update pages/1_real_time_prediction.py

pages/1_real_time_prediction.py

@@ -1,28 +1,19 @@
 import streamlit as st
+from home import face_rec
+from streamlit_webrtc import webrtc_streamer
 import av
-import cv2
-import numpy as np
-import pandas as pd
 import time
-import queue
-import logging
+import pandas as pd
 from datetime import datetime
-from pathlib import Path
-from typing import List, NamedTuple
-
-from streamlit_webrtc import webrtc_streamer, WebRtcMode
-
-# Configure logging
-logger = logging.getLogger(__name__)
 
 # Page configuration
 st.set_page_config(
-    page_title="Live Attendance System",
+    page_title="Live Attendance | AI Attendance",
     page_icon="🟢",
     layout="wide"
 )
 
-# Apply custom CSS
+# Custom CSS
 st.markdown("""
 <style>
     .main-header {
@@ -66,301 +57,236 @@ st.markdown("""
         70% { box-shadow: 0 0 0 10px rgba(76, 175, 80, 0); }
         100% { box-shadow: 0 0 0 0 rgba(76, 175, 80, 0); }
     }
+    .inactive {
+        background-color: #9e9e9e;
+    }
+    .section-title {
+        font-size: 1.3rem;
+        font-weight: 600;
+        color: #424242;
+        margin-bottom: 15px;
+        padding-bottom: 8px;
+        border-bottom: 2px solid #e0e0e0;
+    }
+    .attendance-table {
+        font-size: 0.9rem;
+    }
+    .footer {
+        text-align: center;
+        margin-top: 30px;
+        padding: 20px;
+        color: #6c757d;
+        border-top: 1px solid #e9ecef;
+    }
+    .stats-box {
+        background-color: #f8f9fa;
+        border-radius: 8px;
+        padding: 15px;
+        text-align: center;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+    }
+    .stats-number {
+        font-size: 1.8rem;
+        font-weight: bold;
+        color: #4CAF50;
+    }
+    .stats-label {
+        color: #757575;
+        font-size: 0.9rem;
+    }
 </style>
 """, unsafe_allow_html=True)
 
 # Header
-st.markdown("<h1 class='main-header'>🟢 Live Attendance System</h1>", unsafe_allow_html=True)
+st.markdown("<h1 class='main-header'>🟢 Live Attendance Tracking</h1>", unsafe_allow_html=True)
 
-# Initialize session state variables if not already set
-if 'last_log_time' not in st.session_state:
-    st.session_state.last_log_time = time.time()
-if 'attendance_logs' not in st.session_state:
-    st.session_state.attendance_logs = []
-if 'demo_face_db' not in st.session_state:
-    # Create a demo database for testing
-    st.session_state.demo_face_db = pd.DataFrame({
-        'Name': ['John Doe', 'Jane Smith', 'Alex Johnson', 'Maria Garcia'],
-        'Role': ['Student', 'Teacher', 'Student', 'Student'],
-        'Facial Feature': [np.random.rand(128) for _ in range(4)]  # Dummy facial embeddings
-    })
+# System status indicators
+col1, col2, col3 = st.columns(3)
+with col1:
+    st.markdown("""
+    <div class="status-indicator">
+        <div class="status-dot active"></div>
+        <div>Recognition System: <b>Active</b></div>
+    </div>
+    """, unsafe_allow_html=True)
+with col2:
+    st.markdown("""
+    <div class="status-indicator">
+        <div class="status-dot active"></div>
+        <div>Database Connection: <b>Active</b></div>
+    </div>
+    """, unsafe_allow_html=True)
+with col3:
+    st.markdown("""
+    <div class="status-indicator">
+        <div class="status-dot active"></div>
+        <div>Auto-Logging: <b>Enabled</b></div>
+    </div>
+    """, unsafe_allow_html=True)
 
-# For thread safety, use a queue
-result_queue = queue.Queue()
-
-# Define a named tuple for face detection results
-class FaceDetection(NamedTuple):
-    name: str
-    role: str
-    confidence: float
-    box: np.ndarray
-
-# Main layout
+# Main content
 left_col, right_col = st.columns([3, 2])
 
 with left_col:
     st.markdown("<div class='card'>", unsafe_allow_html=True)
-    st.markdown("<h2>📹 Live Recognition Feed</h2>", unsafe_allow_html=True)
+    st.markdown("<h2 class='section-title'>📹 Live Recognition Feed</h2>", unsafe_allow_html=True)
+    
+    # Retrieve registered data
+    with st.spinner('Retrieving data from Redis database...'):
+        try:
+            redis_face_db = face_rec.retrive_data(name='academy:register')
+            if not redis_face_db.empty:
+                st.success('✅ User data retrieved successfully!')
+            else:
+                st.warning('⚠️ No registered users found in the database.')
+        except Exception as e:
+            st.error(f"Error retrieving data: {e}")
+            redis_face_db = pd.DataFrame()
     
-    # Recognition settings
+    # Configuration options
     with st.expander("Recognition Settings"):
+        wait_time = st.slider("Log Update Interval (seconds)", 10, 120, 30)
         confidence_threshold = st.slider("Recognition Confidence Threshold", 0.3, 0.9, 0.5, 0.05)
-        log_interval = st.slider("Log Update Interval (seconds)", 5, 60, 30)
     
-    # Load face detection model (using OpenCV's built-in face detector for simplicity)
-    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+    # Initialize real-time prediction
+    set_time = time.time()
+    realtime_pred = face_rec.RealTimePred()
     
-    # Simple face recognition simulator
-    def recognize_face(face_img, db):
-        """Simulate face recognition using random matching for demo purposes"""
-        # In a real app, you would use a proper face recognition model here
-        # This is just a placeholder for demonstration
-        if np.random.random() > 0.3:  # 70% chance of "recognizing" a face
-            person_idx = np.random.randint(0, len(db))
-            person = db.iloc[person_idx]
-            confidence = np.random.uniform(0.5, 0.95)
-            return person['Name'], person['Role'], confidence
-        return None, None, 0.0
-    
-    # Video frame callback
+    # Video frame callback function
     def video_frame_callback(frame):
+        global set_time
         img = frame.to_ndarray(format="bgr24")
         
-        # Convert to grayscale for face detection
-        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        
-        # Detect faces
-        faces = face_cascade.detectMultiScale(gray, 1.1, 5)
-        
-        detections = []
+        # Perform face prediction
+        pred_img = realtime_pred.face_prediction(
+            img, 
+            redis_face_db, 
+            'Facial Feature', 
+            ['Name', 'Role'], 
+            thresh=confidence_threshold
+        )
         
-        # Process each detected face
-        for (x, y, w, h) in faces:
-            # Draw rectangle around the face
-            cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
+        # Check if it's time to save logs
+        time_now = time.time()
+        diff_time = time_now - set_time
+        if diff_time >= wait_time:
+            realtime_pred.saveLogs_redis()
+            set_time = time.time()  # Reset timer
             
-            # Extract the face ROI
-            face_roi = img[y:y+h, x:x+w]
-            
-            # Recognize face (simulated)
-            name, role, confidence = recognize_face(face_roi, st.session_state.demo_face_db)
-            
-            if name and confidence > confidence_threshold:
-                # Create detection object
-                detection = FaceDetection(
-                    name=name,
-                    role=role,
-                    confidence=confidence,
-                    box=np.array([x, y, x+w, y+h])
-                )
-                detections.append(detection)
-                
-                # Add text labels
-                label = f"{name}: {confidence:.2f}"
-                cv2.putText(img, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
-                
-                # Check if it's time to log attendance
-                current_time = time.time()
-                if current_time - st.session_state.last_log_time >= log_interval:
-                    # Log attendance
-                    for detection in detections:
-                        st.session_state.attendance_logs.append({
-                            'Name': detection.name,
-                            'Role': detection.role,
-                            'Timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                            'Confidence': f"{detection.confidence:.2f}"
-                        })
-                    st.session_state.last_log_time = current_time
-        
-        # Put detections in queue for display
-        result_queue.put(detections)
-        
-        return av.VideoFrame.from_ndarray(img, format="bgr24")
+        return av.VideoFrame.from_ndarray(pred_img, format="bgr24")
     
-    # WebRTC streamer with STUN/TURN config
+    # Webcam feed with face recognition
     st.markdown("<div class='webcam-container'>", unsafe_allow_html=True)
-    
-    # Define proper RTC configuration with multiple fallback STUN/TURN servers
-    rtc_configuration = {
-        "iceServers": [
-            {"urls": ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302", "stun:stun2.l.google.com:19302"]},
-            {
-                "urls": "turn:openrelay.metered.ca:80",
-                "username": "openrelayproject",
-                "credential": "openrelayproject"
-            },
-            {
-                "urls": "turn:openrelay.metered.ca:443",
-                "username": "openrelayproject",
-                "credential": "openrelayproject"
-            },
-            {
-                "urls": "turn:openrelay.metered.ca:443?transport=tcp",
-                "username": "openrelayproject",
-                "credential": "openrelayproject"
-            }
-        ],
-        "iceTransportPolicy": "all"
-    }
-    
-    # Add WebRTC options for better compatibility
-    webrtc_options = {
-        "media_stream_constraints": {"video": {"width": {"ideal": 640}, "height": {"ideal": 480}}, "audio": False},
-    }
-    
-    webrtc_ctx = webrtc_streamer(
-        key="face-recognition",
-        mode=WebRtcMode.SENDRECV,
+    webrtc_streamer(
+        key="realTimePrediction", 
         video_frame_callback=video_frame_callback,
-        rtc_configuration=rtc_configuration,
-        media_stream_constraints=webrtc_options["media_stream_constraints"],
-        async_processing=True,
+        rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]},
+        media_stream_constraints={"video": True, "audio": False},
     )
     st.markdown("</div>", unsafe_allow_html=True)
     
-    # Add troubleshooting information
-    if not webrtc_ctx.state.playing:
-        st.warning("""
-        ### Troubleshooting WebRTC Connection
-        If you're seeing "Connection is taking longer than expected" error:
-        
-        1. **Check your browser**: Make sure you're using Chrome, Firefox, or Edge
-        2. **Allow camera access**: When prompted, allow the browser to access your camera
-        3. **Network issues**: If behind a firewall or VPN, try disabling it temporarily
-        4. **Try refresh**: Sometimes a simple page refresh can fix connection issues
-        
-        This application requires camera access to function properly.
-        """)
-    
-    # Display instructions
+    # Instructions
     st.info("""
     **Instructions:**
     1. Stand in front of the camera
     2. Wait for the system to recognize your face
     3. Your attendance will be logged automatically
-    4. The system records entry times at the specified interval
+    4. The system records entry and exit times
     """)
     
-    # Display detections
-    if webrtc_ctx.state.playing:
-        detection_placeholder = st.empty()
-        
-        # Similar to the working example, show detected faces in a table
-        if st.checkbox("Show detected people", value=True):
-            while True:
-                try:
-                    result = result_queue.get(timeout=1.0)
-                    if result:
-                        # Convert detections to DataFrame for display
-                        detection_data = []
-                        for det in result:
-                            detection_data.append({
-                                'Name': det.name,
-                                'Role': det.role,
-                                'Confidence': f"{det.confidence:.2f}"
-                            })
-                        
-                        detection_df = pd.DataFrame(detection_data)
-                        detection_placeholder.dataframe(detection_df)
-                except queue.Empty:
-                    continue
-    
     st.markdown("</div>", unsafe_allow_html=True)
 
 with right_col:
-    # Registered users
-    st.markdown("<div class='card'>", unsafe_allow_html=True)
-    st.markdown("<h2>👥 Registered Users</h2>", unsafe_allow_html=True)
-    
-    # Display user database
-    st.dataframe(
-        st.session_state.demo_face_db[['Name', 'Role']],
-        use_container_width=True,
-        hide_index=True
-    )
-    
-    # Add new user
-    with st.expander("Add New User"):
-        new_name = st.text_input("Name")
-        new_role = st.selectbox("Role", ["Student", "Teacher"])
-        
-        if st.button("Add User"):
-            if new_name:
-                # Add new user with random facial features
-                new_user = pd.DataFrame({
-                    'Name': [new_name],
-                    'Role': [new_role],
-                    'Facial Feature': [np.random.rand(128)]
-                })
-                st.session_state.demo_face_db = pd.concat([st.session_state.demo_face_db, new_user], ignore_index=True)
-                st.success(f"Added user: {new_name}")
-            else:
-                st.error("Please enter a name")
-    
-    st.markdown("</div>", unsafe_allow_html=True)
-    
-    # Recent activity
+    # User database card
     st.markdown("<div class='card'>", unsafe_allow_html=True)
-    st.markdown("<h2>🕒 Recent Activity</h2>", unsafe_allow_html=True)
+    st.markdown("<h2 class='section-title'>👥 Registered Users</h2>", unsafe_allow_html=True)
     
-    if st.session_state.attendance_logs:
-        logs_df = pd.DataFrame(st.session_state.attendance_logs)
+    # Display registered users
+    if not redis_face_db.empty:
         st.dataframe(
-            logs_df[['Name', 'Role', 'Timestamp', 'Confidence']],
+            redis_face_db[['Name', 'Role']].sort_values('Name'),
             use_container_width=True,
-            hide_index=True
+            hide_index=True,
+            height=200
         )
+        
+        # Display statistics
+        total_users = len(redis_face_db)
+        students = len(redis_face_db[redis_face_db['Role'] == 'Student'])
+        teachers = len(redis_face_db[redis_face_db['Role'] == 'Teacher'])
+        
+        st.markdown("<br>", unsafe_allow_html=True)
+        stats_cols = st.columns(3)
+        with stats_cols[0]:
+            st.markdown(f"""
+            <div class="stats-box">
+                <div class="stats-number">{total_users}</div>
+                <div class="stats-label">Total Users</div>
+            </div>
+            """, unsafe_allow_html=True)
+        with stats_cols[1]:
+            st.markdown(f"""
+            <div class="stats-box">
+                <div class="stats-number">{students}</div>
+                <div class="stats-label">Students</div>
+            </div>
+            """, unsafe_allow_html=True)
+        with stats_cols[2]:
+            st.markdown(f"""
+            <div class="stats-box">
+                <div class="stats-number">{teachers}</div>
+                <div class="stats-label">Teachers</div>
+            </div>
+            """, unsafe_allow_html=True)
     else:
-        st.info("No activity logged yet")
-    
-    # Clear logs button
-    if st.button("Clear Logs"):
-        st.session_state.attendance_logs = []
-        st.success("Logs cleared")
+        st.warning("No registered users found in the database.")
     
     st.markdown("</div>", unsafe_allow_html=True)
-
-# Add alternative method if WebRTC fails
-st.sidebar.markdown("## Alternative Mode")
-use_fallback = st.sidebar.checkbox("Use Image Upload Mode (if webcam doesn't work)")
-
-if use_fallback:
-    st.sidebar.info("Upload a photo to simulate face recognition")
-    uploaded_file = st.sidebar.file_uploader("Upload image", type=["jpg", "jpeg", "png"])
     
-    if uploaded_file is not None:
-        # Read image
-        file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
-        img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
-        
-        # Convert BGR to RGB (for display)
-        img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-        
-        # Perform face detection
-        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        faces = face_cascade.detectMultiScale(gray, 1.1, 5)
+    # Recent activity card
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<h2 class='section-title'>🕒 Recent Activity</h2>", unsafe_allow_html=True)
+    
+    # Load and display recent logs
+    try:
+        logs_list = face_rec.r.lrange('attendance:logs', 0, 9)  # Get last 10 logs
         
-        for (x, y, w, h) in faces:
-            # Draw rectangle
-            cv2.rectangle(img_rgb, (x, y), (x+w, y+h), (0, 255, 0), 2)
+        if logs_list:
+            # Convert bytes to string and create dataframe
+            logs_string = [log.decode('utf-8').split('@') for log in logs_list]
+            logs_df = pd.DataFrame(logs_string, columns=['Name', 'Role', 'Timestamp'])
             
-            # Simulate recognition
-            name, role, confidence = recognize_face(img[y:y+h, x:x+w], st.session_state.demo_face_db)
+            # Format timestamp
+            logs_df['Timestamp'] = pd.to_datetime(logs_df['Timestamp'],format='ISO8601')
+            logs_df['Time'] = logs_df['Timestamp'].dt.strftime('%H:%M:%S')
+            logs_df['Date'] = logs_df['Timestamp'].dt.strftime('%Y-%m-%d')
             
-            if name and confidence > confidence_threshold:
-                # Add text labels
-                label = f"{name}: {confidence:.2f}"
-                cv2.putText(img_rgb, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
-                
-                # Add to logs
-                st.session_state.attendance_logs.append({
-                    'Name': name,
-                    'Role': role,
-                    'Timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                    'Confidence': f"{confidence:.2f}",
-                    'Method': 'Image Upload'
-                })
-        
-        # Show image with detections
-        st.sidebar.image(img_rgb, caption="Processed Image", use_column_width=True)
+            # Display recent logs
+            st.dataframe(
+                logs_df[['Name', 'Role', 'Time', 'Date']],
+                use_container_width=True,
+                hide_index=True
+            )
+        else:
+            st.info("No recent activity logged.")
+    except Exception as e:
+        st.error(f"Error loading logs: {e}")
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Quick actions
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<h2 class='section-title'>⚡ Quick Actions</h2>", unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("📊 View Reports", use_container_width=True):
+            st.switch_page("pages/report.py")
+    with col2:
+        if st.button("📝 Add New User", use_container_width=True):
+            st.switch_page("pages/page1.py")
+    
+    st.markdown("</div>", unsafe_allow_html=True)
 
+# Footer
+st.markdown("<div class='footer'>AI-Powered Attendance System • © 2025</div>", unsafe_allow_html=True)