Deploy NAVADA 2.0 Lite - Optimized for HF Spaces (no face recognition)

.gitattributes

@@ -1 +1 @@
-*.pt filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,45 +1,45 @@
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-env/
-venv/
-.venv/
-ENV/
-
-# Environment variables
-.env
-.env.local
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Streamlit
-.streamlit/secrets.toml
-
-# Database
-*.db
-*.sqlite
-*.sqlite3
-
-# Models (if too large)
-yolov8m.pt
-yolov8l.pt
-yolov8x.pt
-
-# Logs
-*.log
-
-# Temporary files
-*.tmp
-temp/
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+ENV/
+
+# Environment variables
+.env
+.env.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Models (if too large)
+yolov8m.pt
+yolov8l.pt
+yolov8x.pt
+
+# Logs
+*.log
+
+# Temporary files
+*.tmp
+temp/
 tmp/

README.md

@@ -1,44 +1,44 @@
----
-title: NAVADA 2.0 - Advanced AI Computer Vision
-emoji: 🚀
-colorFrom: blue
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.28.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-# 🚀 NAVADA 2.0 - Advanced AI Computer Vision Application
-
-An advanced AI-powered computer vision application featuring:
-- 🎯 Real-time object detection using YOLOv8
-- 👤 Face detection and recognition
-- 🤖 AI-powered explanations
-- 📊 Interactive analytics
-- 🎤 Voice narration
-- 💬 Intelligent chat agent
-
-## Features
-- **Object Detection**: State-of-the-art YOLOv8 model for accurate object detection
-- **Face Recognition**: Advanced face detection with emotion and feature analysis
-- **AI Intelligence**: OpenAI-powered explanations and insights
-- **Interactive Charts**: Real-time visualization of detection results
-- **Voice Output**: Text-to-speech narration of detection results
-- **Chat Interface**: Intelligent assistant for image analysis
-
-## Usage
-1. Upload an image using the file uploader
-2. The system will automatically detect objects and faces
-3. View detailed analytics and AI-generated explanations
-4. Interact with the chat agent for deeper insights
-
-## Technology Stack
-- Streamlit for the web interface
-- YOLOv8 for object detection
-- OpenAI API for intelligent analysis
-- Face Recognition library
-- Plotly for interactive visualizations
-
+---
+title: NAVADA 2.0 - Advanced AI Computer Vision
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.28.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🚀 NAVADA 2.0 - Advanced AI Computer Vision Application
+
+An advanced AI-powered computer vision application featuring:
+- 🎯 Real-time object detection using YOLOv8
+- 👤 Face detection and recognition
+- 🤖 AI-powered explanations
+- 📊 Interactive analytics
+- 🎤 Voice narration
+- 💬 Intelligent chat agent
+
+## Features
+- **Object Detection**: State-of-the-art YOLOv8 model for accurate object detection
+- **Face Recognition**: Advanced face detection with emotion and feature analysis
+- **AI Intelligence**: OpenAI-powered explanations and insights
+- **Interactive Charts**: Real-time visualization of detection results
+- **Voice Output**: Text-to-speech narration of detection results
+- **Chat Interface**: Intelligent assistant for image analysis
+
+## Usage
+1. Upload an image using the file uploader
+2. The system will automatically detect objects and faces
+3. View detailed analytics and AI-generated explanations
+4. Interact with the chat agent for deeper insights
+
+## Technology Stack
+- Streamlit for the web interface
+- YOLOv8 for object detection
+- OpenAI API for intelligent analysis
+- Face Recognition library
+- Plotly for interactive visualizations
+
 Created by Lee Akpareva | AI Consultant & Computer Vision Specialist

app.py

@@ -1,1254 +1,271 @@
-"""
-🚀 NAVADA 2.0 - Advanced AI Computer Vision Application
-Streamlit Version for Hugging Face Spaces Deployment
-
-Enhanced Edition by Lee Akpareva | AI Consultant & Computer Vision Specialist
-"""
-
-import streamlit as st # type: ignore
-
-# Configure Streamlit page (MUST be first!)
-st.set_page_config(
-    page_title="🚀 NAVADA 2.0 - AI Computer Vision",
-    page_icon="🚀",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Add Font Awesome CSS
-st.markdown("""
-<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
-<style>
-    .fa-icon { margin-right: 8px; }
-    .fa-primary { color: #3498db; }
-    .fa-success { color: #27ae60; }
-    .fa-warning { color: #f39c12; }
-    .fa-error { color: #e74c3c; }
-    .fa-spin { animation: fa-spin 2s infinite linear; }
-</style>
-""", unsafe_allow_html=True)
-
-# Font Awesome icon mapping function
-def fa_icon(icon_class, color="primary", text=""):
-    """Generate Font Awesome icon HTML"""
-    return f'<i class="fas fa-{icon_class} fa-{color} fa-icon"></i>{text}'
-import time
-from datetime import datetime
-import plotly.graph_objects as go # type: ignore
-import plotly.express as px # type: ignore
-from PIL import Image # type: ignore
-import numpy as np # type: ignore
-
-# Backend imports
-try:
-    from backend.yolo_enhanced import detect_objects_enhanced, get_intelligence_report
-    from backend.yolo import detect_objects  # Keep original for fallback
-    from backend.openai_client import explain_detection, generate_voice
-    from backend.face_detection import face_detector
-    from backend.recognition import recognition_system
-    from backend.database import db
-    from backend.chat_agent import chat_with_agent, reset_chat, get_chat_history
-    from backend.two_stage_inference import two_stage_inference
-except ImportError as e:
-    st.error(f"⚠️ Import error: {e}")
-    st.error("📦 Please install dependencies: pip install -r requirements.txt")
-    st.stop()
-
-# Page configuration moved to top of file
-
-# Custom CSS for enhanced styling
-st.markdown("""
-<style>
-    .main-header {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        padding: 2rem;
-        border-radius: 10px;
-        color: white;
-        text-align: center;
-        margin-bottom: 2rem;
-    }
-    
-    .feature-card {
-        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
-        padding: 1.5rem;
-        border-radius: 10px;
-        color: white;
-        margin: 1rem 0;
-    }
-    
-    .stats-card {
-        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
-        padding: 1rem;
-        border-radius: 8px;
-        color: white;
-        text-align: center;
-        margin: 0.5rem;
-    }
-    
-    .launch-button {
-        background: linear-gradient(135deg, #000000 0%, #434343 100%);
-        color: white;
-        padding: 1rem 2rem;
-        border: none;
-        border-radius: 8px;
-        font-size: 1.2rem;
-        font-weight: bold;
-        cursor: pointer;
-        width: 100%;
-        margin: 1rem 0;
-    }
-    
-    .stButton > button {
-        background: linear-gradient(135deg, #000000 0%, #434343 100%);
-        color: white;
-        border: none;
-        border-radius: 8px;
-        font-weight: bold;
-    }
-    
-    .compass {
-        position: fixed;
-        top: 10px;
-        right: 10px;
-        background: rgba(0,0,0,0.7);
-        color: white;
-        padding: 10px;
-        border-radius: 50%;
-        font-size: 16px;
-        z-index: 1000;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-# Compass (News indicator)
-st.markdown("""
-<div class="compass">
-    📰 NEWS
-</div>
-""", unsafe_allow_html=True)
-
-# Main header
-st.markdown(f"""
-<div class="main-header">
-    <h1><i class="fas fa-rocket fa-primary fa-icon"></i>NAVADA 2.0 - Advanced AI Computer Vision</h1>
-    <h3><i class="fas fa-brain fa-primary fa-icon"></i>Real-time Computer Vision with Custom Recognition Database & RAG Technology</h3>
-    <p><strong>Enhanced Edition by Lee Akpareva</strong> | AI Consultant & Computer Vision Specialist</p>
-    <p><i class="fas fa-crosshairs fa-primary fa-icon"></i>AI Computer Vision Application Designed for Hugging Face - Build ML Models in 15 Minutes</p>
-</div>
-""", unsafe_allow_html=True)
-
-# Initialize session state
-if 'processing_complete' not in st.session_state:
-    st.session_state.processing_complete = False
-if 'last_results' not in st.session_state:
-    st.session_state.last_results = None
-if 'chat_messages' not in st.session_state:
-    st.session_state.chat_messages = []
-if 'use_enhanced' not in st.session_state:
-    st.session_state.use_enhanced = True
-
-def create_detection_chart(detected_objects, face_stats=None, face_matches=None):
-    """Create an interactive chart showing detection statistics"""
-    
-    # Count object types
-    object_counts = {}
-    for obj in detected_objects:
-        object_counts[obj] = object_counts.get(obj, 0) + 1
-    
-    # Add face detection to counts
-    if face_stats and face_stats.get('total_faces', 0) > 0:
-        object_counts['Faces'] = face_stats['total_faces']
-        if face_stats.get('features_detected', {}).get('smiles', 0) > 0:
-            object_counts['Smiles'] = face_stats['features_detected']['smiles']
-    
-    # Add recognized faces
-    if face_matches:
-        known_faces = sum(1 for match in face_matches if match['name'] != 'Unknown')
-        if known_faces > 0:
-            object_counts['Known Faces'] = known_faces
-    
-    if not object_counts:
-        fig = go.Figure()
-        fig.add_annotation(
-            text="No objects detected",
-            xref="paper", yref="paper",
-            x=0.5, y=0.5, showarrow=False,
-            font=dict(size=20, color="gray")
-        )
-        fig.update_layout(
-            height=300,
-            title="Detection Results",
-            template="plotly_dark"
-        )
-        return fig
-    
-    # Create bar chart
-    fig = go.Figure(data=[
-        go.Bar(
-            x=list(object_counts.keys()),
-            y=list(object_counts.values()),
-            marker_color=['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FECA57', '#FF9FF3', '#54A0FF'],
-            text=list(object_counts.values()),
-            textposition='auto',
-        )
-    ])
-    
-    fig.update_layout(
-        title="🎯 Detection Statistics",
-        xaxis_title="Detected Items",
-        yaxis_title="Count",
-        height=400,
-        template="plotly_dark"
-    )
-    
-    return fig
-
-def create_confidence_pie_chart(detected_objects, face_matches=None):
-    """Create a confidence distribution pie chart"""
-    try:
-        # This is a simplified version - in the full app you'd get actual confidence scores
-        categories = list(set(detected_objects)) if detected_objects else []
-        if face_matches:
-            categories.extend([match['name'] for match in face_matches if match['name'] != 'Unknown'])
-        
-        if not categories:
-            return None
-            
-        # Generate sample confidence data
-        values = [len([obj for obj in detected_objects if obj == cat]) for cat in set(detected_objects)]
-        
-        fig = go.Figure(data=[go.Pie(
-            labels=list(set(detected_objects)),
-            values=values,
-            hole=.3,
-            marker_colors=['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FECA57']
-        )])
-        
-        fig.update_layout(
-            title="📊 Detection Distribution",
-            height=400,
-            template="plotly_dark"
-        )
-        
-        return fig
-    except:
-        return None
-
-def process_image(image, enable_voice=False, enable_face_detection=False, enable_recognition=False, use_enhanced=True, confidence_threshold=0.5):
-    """Process uploaded image with all NAVADA 2.0 features"""
-    try:
-        if image is None:
-            return None, "No image provided", None, None, None, None
-            
-        start_time = time.time()
-        
-        # Convert PIL to numpy array
-        image_array = np.array(image)
-        
-        # Object detection - use two-stage inference, enhanced, or standard
-        detailed_attributes = None
-        if use_enhanced:
-            try:
-                # Try two-stage inference first (YOLO + Custom Model)
-                detected_img, detected_objects, detailed_attributes = two_stage_inference.detect_with_custom_model(
-                    image_array, confidence_threshold
-                )
-            except:
-                try:
-                    # Fallback to enhanced YOLO only
-                    detected_img, detected_objects, detailed_attributes = detect_objects_enhanced(image_array, confidence_threshold)
-                except:
-                    # Final fallback to standard detection
-                    detected_img, detected_objects = detect_objects(image_array)
-        else:
-            detected_img, detected_objects = detect_objects(image_array)
-        
-        # Face detection if enabled
-        face_stats = None
-        face_matches = None
-        if enable_face_detection and face_detector:
-            detected_img, face_stats = face_detector.detect_faces(detected_img)
-            
-            # Face recognition if enabled
-            if enable_recognition and recognition_system:
-                detected_img, face_matches = recognition_system.recognize_faces(detected_img)
-        
-        # AI explanation - enhanced version includes detailed attributes
-        if detailed_attributes:
-            ai_explanation = get_intelligence_report(detailed_attributes)
-        else:
-            ai_explanation = explain_detection(detected_objects)
-        
-        # RAG enhancement if recognition enabled
-        if enable_recognition and recognition_system:
-            rag_enhancement = recognition_system.enhance_with_rag(detected_objects, face_matches)
-            ai_explanation = f"{ai_explanation}\n\n{rag_enhancement}"
-        
-        # Voice generation if enabled
-        audio_file = None
-        if enable_voice:
-            try:
-                st.info("🔊 Generating voice narration...")
-                audio_file = generate_voice(ai_explanation)
-                if audio_file:
-                    st.success("✅ Voice narration generated successfully!")
-                else:
-                    st.error("❌ Voice generation failed - no audio file created")
-            except Exception as e:
-                st.error(f"❌ Voice generation failed: {e}")
-                import traceback
-                st.error(f"Details: {traceback.format_exc()}")
-        
-        # Save session data
-        processing_time = time.time() - start_time
-        if recognition_system:
-            recognition_system.save_session_data(
-                image_array, detected_objects, face_matches, processing_time
-            )
-        
-        return detected_img, ai_explanation, detected_objects, face_stats, face_matches, audio_file, detailed_attributes
-        
-    except Exception as e:
-        st.error(f"Processing failed: {e}")
-        return None, f"Error: {e}", [], None, None, None, None
-
-def get_database_stats():
-    """Get current database statistics"""
-    try:
-        if db:
-            stats = db.get_stats()
-            return {
-                "faces": stats.get("faces", 0),
-                "objects": stats.get("objects", 0), 
-                "sessions": stats.get("recent_detections", 0),
-                "total_detections": stats.get("total_detections", 0)
-            }
-        return {"faces": 0, "objects": 0, "sessions": 0, "total_detections": 0}
-    except Exception as e:
-        st.warning(f"Database stats unavailable: {e}")
-        return {"faces": 0, "objects": 0, "sessions": 0, "total_detections": 0}
-
-# Sidebar for database features and stats
-with st.sidebar:
-    st.markdown("""
-    <div class="feature-card">
-        <h3>🗄️ NAVADA Database</h3>
-        <p>Custom Recognition & RAG System</p>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Database statistics
-    stats = get_database_stats()
-
-    # Prisma Studio Integration
-    st.markdown("#### 🔧 Database Management")
-    col_studio1, col_studio2 = st.columns(2)
-
-    with col_studio1:
-        if st.button("🎯 Open Prisma Studio", help="View and edit database in Prisma Studio"):
-            try:
-                import subprocess
-                subprocess.Popen(["npm", "run", "studio"], cwd=".", shell=True)
-                st.success("🚀 Prisma Studio starting on http://localhost:5556")
-            except Exception as e:
-                st.error(f"Failed to start Prisma Studio: {e}")
-                st.info("💡 Run manually: npm run studio")
-
-    with col_studio2:
-        if st.button("📊 Database Info", help="Show database connection details"):
-            st.info("📍 Database: navada_recognition.db\n🌐 Prisma Studio: http://localhost:5556")
-
-    col1, col2 = st.columns(2)
-    with col1:
-        st.markdown(f"""
-        <div class="stats-card">
-            <h4>{stats.get('faces', 0)}</h4>
-            <p>👥 Faces</p>
-        </div>
-        """, unsafe_allow_html=True)
-        
-        st.markdown(f"""
-        <div class="stats-card">
-            <h4>{stats.get('sessions', 0)}</h4>
-            <p>📊 Sessions</p>
-        </div>
-        """, unsafe_allow_html=True)
-    
-    with col2:
-        st.markdown(f"""
-        <div class="stats-card">
-            <h4>{stats.get('objects', 0)}</h4>
-            <p>🏷️ Objects</p>
-        </div>
-        """, unsafe_allow_html=True)
-        
-        st.markdown(f"""
-        <div class="stats-card">
-            <h4>{stats.get('total_detections', 0)}</h4>
-            <p>🎯 Detections</p>
-        </div>
-        """, unsafe_allow_html=True)
-    
-    st.markdown("---")
-    
-    # Computer Vision Educational Section
-    with st.expander("🔬 Computer Vision Guide", expanded=False):
-        st.markdown('<i class="fas fa-microscope fa-primary fa-icon"></i>**Advanced CV Learning Hub**', unsafe_allow_html=True)
-        st.markdown('<h3><i class="fas fa-brain fa-primary fa-icon"></i>What is Computer Vision?</h3>', unsafe_allow_html=True)
-        st.markdown("""
-        **Computer Vision (CV)** is a field of artificial intelligence that enables machines to interpret and understand visual information from the world, mimicking human vision capabilities.
-        
-        **Key Components:**
-        - **Image Processing**: Enhancing and filtering visual data
-        - **Pattern Recognition**: Identifying objects, faces, and features  
-        - **Machine Learning**: Training models on visual datasets
-        - **Deep Learning**: Neural networks for complex visual understanding
-        """)
-        
-        st.markdown('<h3><i class="fas fa-crosshairs fa-primary fa-icon"></i>Top 5 Real-World Use Cases</h3>', unsafe_allow_html=True)
-        
-        use_cases = [
-            {
-                "icon": "hospital",
-                "title": "Healthcare & Medical Imaging",
-                "description": "Detecting diseases in X-rays, MRIs, and CT scans. Early cancer detection, automated diagnosis, and surgical assistance.",
-                "impact": "95% accuracy in mammography screening"
-            },
-            {
-                "icon": "car", 
-                "title": "Autonomous Vehicles",
-                "description": "Real-time object detection, lane recognition, traffic sign identification, and pedestrian safety systems.",
-                "impact": "$7 trillion global market potential"
-            },
-            {
-                "icon": "industry",
-                "title": "Manufacturing & Quality Control", 
-                "description": "Automated defect detection, product inspection, assembly line monitoring, and predictive maintenance.",
-                "impact": "40% reduction in production errors"
-            },
-            {
-                "icon": "shield-alt",
-                "title": "Security & Surveillance",
-                "description": "Facial recognition, anomaly detection, crowd monitoring, and threat identification in real-time.",
-                "impact": "$62B global security market"
-            },
-            {
-                "icon": "shopping-cart",
-                "title": "Retail & E-commerce",
-                "description": "Visual search, inventory management, customer behavior analysis, and augmented reality shopping.",
-                "impact": "30% increase in conversion rates"
-            }
-        ]
-        
-        for case in use_cases:
-            st.markdown(f"""
-            **<i class="fas fa-{case['icon']} fa-primary fa-icon"></i>{case['title']}**  
-            {case['description']}  
-            *<i class="fas fa-chart-bar fa-primary fa-icon"></i>Impact: {case['impact']}*
-            """, unsafe_allow_html=True)
-            st.markdown("---")
-        
-        st.markdown('<h3><i class="fas fa-rocket fa-primary fa-icon"></i>Future Economic Impact</h3>', unsafe_allow_html=True)
-        st.markdown("""
-        **Job Market Transformation:**
-        
-        **🔮 2025-2030 Predictions:**
-        - **+2.3M new CV jobs** globally by 2030
-        - **$733B market value** by 2030 (15.3% CAGR)
-        - **50% of industries** will integrate CV solutions
-        
-        **💼 Emerging Job Roles:**
-        - CV Engineers & Architects
-        - AI Ethics Specialists  
-        - Computer Vision Product Managers
-        - Visual AI Trainers
-        - Augmented Reality Developers
-        
-        **🌍 Economic Benefits:**
-        - **Productivity**: 25-40% efficiency gains
-        - **Cost Reduction**: $390B in operational savings
-        - **Innovation**: New business models & services
-        - **Accessibility**: Enhanced tools for disabilities
-        
-        **⚡ Industry Revolution:**
-        - **Healthcare**: Personalized medicine & diagnostics
-        - **Agriculture**: Precision farming & crop monitoring  
-        - **Education**: Interactive learning & assessment
-        - **Entertainment**: Immersive AR/VR experiences
-        """)
-        
-        st.markdown("### 🎓 Learning Path")
-        st.markdown("""
-        **Start Your CV Journey:**
-        1. **📚 Learn Fundamentals**: Python, OpenCV, Image Processing
-        2. **🧠 Master ML/DL**: TensorFlow, PyTorch, Neural Networks
-        3. **🔧 Hands-on Projects**: Like this NAVADA 2.0 demo!
-        4. **📊 Specialize**: Choose healthcare, automotive, etc.
-        5. **🚀 Build Portfolio**: Create real-world applications
-        """)
-        
-        st.markdown('<h3><i class="fas fa-microchip fa-primary fa-icon"></i>Raspberry Pi Introduction</h3>', unsafe_allow_html=True)
-        st.markdown("""
-        **What is Raspberry Pi?**
-        
-        The Raspberry Pi is a series of small, affordable single-board computers perfect for AI and computer vision projects.
-        
-        **🎯 Real-World CV Use Cases:**
-        - **🏠 Smart Security**: Door surveillance with face recognition
-        - **🌿 Wildlife Monitoring**: Automated animal detection in reserves  
-        - **🏭 Industrial Inspection**: Quality control in manufacturing
-        - **🚜 Agricultural Monitoring**: Plant health & pest detection
-        - **🚦 Traffic Analysis**: Vehicle counting & license recognition
-        
-        **⚙️ NAVADA 2.0 on Pi Setup:**
-        ```bash
-        # Optimized for Pi 4 (4GB+ recommended)
-        pip install ultralytics[cpu]
-        streamlit run app.py --server.port 8080
-        ```
-        
-        **🚀 Performance Tips:**
-        - Use YOLOv8n (nano) for faster Pi inference
-        - Enable VideoCore GPU acceleration
-        - External USB3 storage for database ops
-        - Lightweight OpenCV builds
-        """)
-        
-        st.markdown('<h3><i class="fas fa-robot fa-primary fa-icon"></i>Robotics Introduction</h3>', unsafe_allow_html=True)  
-        st.markdown("""
-        **Computer Vision in Robotics**
-        
-        CV is the "eyes" of modern robots, enabling intelligent perception and interaction with environments.
-        
-        **🔧 Integration Applications:**
-        - **🗺️ Autonomous Navigation**: Path planning & obstacle avoidance
-        - **🔧 Object Manipulation**: Precise pick-and-place operations
-        - **👥 Human-Robot Interaction**: Gesture & facial recognition
-        - **✅ Quality Assurance**: Robotic inspection systems
-        - **🏥 Medical Robotics**: Surgical assistance & monitoring
-        
-        **🏢 Real-World Success Stories:**
-        - **📦 Amazon Warehouses**: Kiva robots with vision navigation
-        - **🚗 Tesla Autopilot**: Advanced CV for autonomous driving  
-        - **🐕 Boston Dynamics**: Vision-guided locomotion
-        - **⚕️ Surgical Robots**: da Vinci precision guidance
-        - **🌾 Agricultural Robots**: Automated crop monitoring
-        
-        **🛠️ Popular Frameworks:**
-        - **ROS**: Robot Operating System (industry standard)
-        - **OpenCV**: Essential computer vision processing
-        - **PyBullet**: Physics simulation for testing
-        - **MoveIt**: Motion planning for robotic arms
-        
-        **🚀 Getting Started with Robotics + NAVADA:**
-        1. **Hardware**: Camera + actuators + microcontroller
-        2. **Software**: NAVADA 2.0 + ROS + hardware drivers
-        3. **Training**: Collect task-specific object data
-        4. **Integration**: Connect detection → robot control
-        """)
-        
-        st.info("💡 **Pro Tip**: NAVADA 2.0 demonstrates key CV concepts - object detection, face recognition, and custom training!")
-    
-    st.markdown("---")
-    
-    # Face database addition
-    st.markdown("### 👤 Add Face to Database")
-    face_name = st.text_input("Enter person's name:", key="face_name")
-    if st.button("👤 Add Face", key="add_face"):
-        if st.session_state.get('current_image') is not None and face_name:
-            if recognition_system:
-                success = recognition_system.add_new_face(
-                    np.array(st.session_state.current_image), face_name
-                )
-                if success:
-                    st.success(f"✅ Added {face_name} to face database!")
-                    st.rerun()
-                else:
-                    st.error("❌ Failed to add face. Please ensure a clear face is visible.")
-            else:
-                st.error("Recognition system not available")
-        else:
-            st.warning("Please upload an image and enter a name first.")
-    
-    st.markdown("---")
-    
-    # Live Session Statistics
-    st.markdown("### 📈 Live Session Stats")
-    
-    # Session metrics in a compact format
-    session_col1, session_col2 = st.columns(2)
-    with session_col1:
-        st.metric("🖼️ This Session", 
-                 st.session_state.get('images_processed', 0), 
-                 delta=None,
-                 delta_color="normal")
-        
-        total_objects_detected = 0
-        if 'last_results' in st.session_state and st.session_state.last_results:
-            detected_objects = st.session_state.last_results[2]
-            total_objects_detected = len(detected_objects) if detected_objects else 0
-        
-        st.metric("🎯 Objects Found", 
-                 total_objects_detected,
-                 delta=None)
-    
-    with session_col2:
-        processing_time = 0
-        if 'start_time' in st.session_state:
-            processing_time = time.time() - st.session_state.start_time
-        
-        st.metric("⚡ Last Process", 
-                 f"{processing_time:.1f}s" if processing_time > 0 else "0.0s",
-                 delta=None)
-        
-        accuracy_score = 0
-        if total_objects_detected > 0:
-            accuracy_score = min(95, 85 + total_objects_detected * 2)
-        
-        st.metric("📊 Accuracy", 
-                 f"{accuracy_score}%" if accuracy_score > 0 else "0%",
-                 delta=None)
-    
-    # Session progress bar
-    session_target = 10  # Target images for session
-    current_progress = min(st.session_state.get('images_processed', 0) / session_target, 1.0)
-    st.progress(current_progress, text=f"Session Progress: {st.session_state.get('images_processed', 0)}/{session_target}")
-    
-    st.markdown("---")
-    
-    # Custom object addition
-    st.markdown("### 🏷️ Add Custom Object")
-    object_label = st.text_input("Object label:", key="object_label")
-    object_category = st.text_input("Category (optional):", key="object_category")
-    if st.button("🏷️ Add Object", key="add_object"):
-        if st.session_state.get('current_image') is not None and object_label:
-            if recognition_system:
-                success = recognition_system.add_custom_object(
-                    np.array(st.session_state.current_image), 
-                    object_label, 
-                    object_category or "general"
-                )
-                if success:
-                    st.success(f"✅ Added '{object_label}' to object database!")
-                    st.rerun()
-                else:
-                    st.error("❌ Failed to add object.")
-            else:
-                st.error("Recognition system not available")
-        else:
-            st.warning("Please upload an image and enter a label first.")
-
-# Main content area
-col1, col2 = st.columns([2, 1])
-
-with col1:
-    # Image input tabs
-    tab1, tab2 = st.tabs(["📁 Upload Image", "📸 Camera Capture"])
-    
-    with tab1:
-        uploaded_file = st.file_uploader(
-            "Choose an image file",
-            type=['png', 'jpg', 'jpeg'],
-            help="Upload an image for AI analysis"
-        )
-        
-        if uploaded_file is not None:
-            image = Image.open(uploaded_file)
-            st.session_state.current_image = image
-            st.image(image, caption="Uploaded Image", use_container_width=True)
-    
-    with tab2:
-        camera_image = st.camera_input("📸 Take a picture")
-        
-        if camera_image is not None:
-            image = Image.open(camera_image)
-            st.session_state.current_image = image
-            st.image(image, caption="Captured Image", use_container_width=True)
-
-with col2:
-    # Processing options
-    st.markdown("### ⚙️ Processing Options")
-    
-    # Model information
-    model_info = two_stage_inference.get_model_info()
-    if model_info.get('custom_model_loaded'):
-        st.success(f"🧠 Custom Model Active: {model_info.get('num_custom_classes', 0)} trained classes")
-        with st.expander("📋 Model Details"):
-            st.text(f"Custom Classes: {', '.join(model_info.get('custom_classes', []))}")
-            st.text(f"Training Samples: {model_info.get('training_samples', 0)}")
-            st.text(f"Device: {model_info.get('device', 'unknown')}")
-    else:
-        st.info("🤖 Using YOLO only - Train custom model by providing corrections!")
-    
-    # Enhanced accuracy controls
-    st.markdown("#### 🎯 Accuracy Settings")
-    use_enhanced = st.checkbox("**Use Enhanced Detection** (Better Accuracy)", value=True, help="Uses advanced model with color detection and custom training")
-    confidence_threshold = st.slider("Detection Confidence", 0.1, 0.9, 0.5, 0.05, help="Higher = fewer but more accurate detections")
-    
-    # Make voice option more prominent
-    st.markdown("#### 🔊 Audio Features")
-    enable_voice = st.checkbox("**Enable Voice Narration** (OpenAI TTS)", value=False, help="Generate AI voice explanation of detected objects")
-    
-    st.markdown("#### 🧠 AI Features") 
-    enable_face_detection = st.checkbox("👤 Enable Face Detection", value=True)
-    enable_recognition = st.checkbox("🧠 Enable Smart Recognition", value=True)
-    
-    # Launch button
-    if st.button("🚀 LAUNCH ANALYSIS", key="launch", type="primary"):
-        if 'current_image' in st.session_state:
-            # Track processing start time
-            st.session_state.start_time = time.time()
-            
-            # Update session counters
-            st.session_state.images_processed = st.session_state.get('images_processed', 0) + 1
-            
-            with st.spinner("🔄 Processing with NAVADA 2.0..."):
-                results = process_image(
-                    st.session_state.current_image,
-                    enable_voice,
-                    enable_face_detection,
-                    enable_recognition,
-                    use_enhanced,
-                    confidence_threshold
-                )
-                st.session_state.last_results = results
-                st.session_state.processing_complete = True
-        else:
-            st.warning("Please upload an image or take a photo first!")
-
-# Results section
-if st.session_state.processing_complete and st.session_state.last_results:
-    # Unpack results - handle both old and new format
-    if len(st.session_state.last_results) == 7:
-        detected_img, ai_explanation, detected_objects, face_stats, face_matches, audio_file, detailed_attributes = st.session_state.last_results
-    else:
-        detected_img, ai_explanation, detected_objects, face_stats, face_matches, audio_file = st.session_state.last_results
-        detailed_attributes = None
-    
-    st.markdown("---")
-    st.markdown("## 🎯 Analysis Results")
-    
-    # Display processed image
-    if detected_img is not None:
-        st.image(detected_img, caption="🔍 Processed Image with Detections", use_container_width=True)
-    
-    # Results in two columns
-    res_col1, res_col2 = st.columns([3, 2])
-    
-    with res_col1:
-        # AI explanation
-        st.markdown("### 🤖 AI Analysis")
-        st.markdown(ai_explanation)
-        
-        # Audio playback
-        if audio_file:
-            st.markdown("### 🔊 Voice Narration")
-            st.audio(audio_file)
-        
-        # Comprehensive App Statistics Section
-        st.markdown("---")
-        st.markdown("## 📊 NAVADA 2.0 Analytics Dashboard")
-        
-        # Get processing stats for current session
-        processing_time = time.time() - st.session_state.get('start_time', time.time())
-        
-        # Create statistics tabs
-        stats_tab1, stats_tab2, stats_tab3, stats_tab4 = st.tabs([
-            "🚀 Performance", "📈 Usage Metrics", "🎯 Detection Stats", "🧠 AI Insights"
-        ])
-        
-        with stats_tab1:
-            # Performance Metrics
-            col1, col2, col3 = st.columns(3)
-            
-            with col1:
-                st.metric("⚡ Processing Speed", f"{processing_time:.2f}s", 
-                         delta=f"-{max(0, 2.5-processing_time):.1f}s vs avg")
-            
-            with col2:
-                inference_time = 0.25 if detected_objects else 0.0  # Approximate from logs
-                st.metric("🧠 AI Inference", f"{inference_time*1000:.0f}ms", 
-                         delta=f"{inference_time*1000-200:.0f}ms")
-            
-            with col3:
-                accuracy = min(95, 85 + len(detected_objects) * 2) if detected_objects else 0
-                st.metric("🎯 Detection Accuracy", f"{accuracy}%", 
-                         delta=f"+{accuracy-85}%" if accuracy > 85 else "0%")
-            
-            # Performance trend chart
-            performance_data = {
-                'Metric': ['Preprocessing', 'Inference', 'Postprocessing', 'Face Detection', 'Recognition'],
-                'Time (ms)': [16, 250, 18, 45, 120],
-                'Efficiency': [95, 88, 92, 87, 91]
-            }
-            
-            perf_chart = go.Figure()
-            perf_chart.add_trace(go.Bar(
-                x=performance_data['Metric'],
-                y=performance_data['Time (ms)'],
-                name='Processing Time (ms)',
-                marker_color='#FF6B6B'
-            ))
-            
-            perf_chart.update_layout(
-                title="⚡ NAVADA 2.0 Performance Breakdown",
-                xaxis_title="Processing Stage",
-                yaxis_title="Time (milliseconds)",
-                height=350,
-                template="plotly_dark"
-            )
-            st.plotly_chart(perf_chart, use_container_width=True)
-        
-        with stats_tab2:
-            # Usage Analytics
-            col1, col2, col3, col4 = st.columns(4)
-            
-            db_stats = get_database_stats()
-            
-            with col1:
-                st.metric("📸 Images Processed", 
-                         st.session_state.get('images_processed', 1), 
-                         delta="+1")
-            
-            with col2:
-                st.metric("👥 Faces Trained", 
-                         db_stats.get('faces', 0), 
-                         delta="+0")
-            
-            with col3:
-                st.metric("🏷️ Objects Trained", 
-                         db_stats.get('objects', 0), 
-                         delta="+0")
-            
-            with col4:
-                st.metric("🎯 Total Detections", 
-                         db_stats.get('total_detections', 0), 
-                         delta="+0")
-            
-            # Usage trend over time (simulated data)
-            import datetime
-            dates = [datetime.datetime.now() - datetime.timedelta(days=x) for x in range(7, 0, -1)]
-            usage_data = {
-                'Date': dates,
-                'Detections': [12, 18, 25, 31, 28, 35, 42],
-                'Accuracy': [87, 89, 91, 93, 92, 94, 95]
-            }
-            
-            usage_chart = go.Figure()
-            usage_chart.add_trace(go.Scatter(
-                x=usage_data['Date'],
-                y=usage_data['Detections'],
-                mode='lines+markers',
-                name='Daily Detections',
-                line=dict(color='#4ECDC4', width=3),
-                marker=dict(size=8)
-            ))
-            
-            usage_chart.add_trace(go.Scatter(
-                x=usage_data['Date'],
-                y=usage_data['Accuracy'],
-                mode='lines+markers',
-                name='Accuracy %',
-                yaxis='y2',
-                line=dict(color='#45B7D1', width=3),
-                marker=dict(size=8)
-            ))
-            
-            usage_chart.update_layout(
-                title="📈 NAVADA 2.0 Weekly Performance Trends",
-                xaxis_title="Date",
-                yaxis_title="Number of Detections",
-                yaxis2=dict(
-                    title="Accuracy (%)",
-                    overlaying='y',
-                    side='right'
-                ),
-                height=400,
-                template="plotly_dark",
-                hovermode='x unified'
-            )
-            st.plotly_chart(usage_chart, use_container_width=True)
-        
-        with stats_tab3:
-            # Detection Statistics
-            if detected_objects:
-                # Object category distribution
-                object_categories = {
-                    'Animals': ['bird', 'dog', 'cat', 'horse', 'elephant', 'bear', 'zebra', 'giraffe'],
-                    'Vehicles': ['car', 'truck', 'bus', 'motorcycle', 'bicycle', 'airplane', 'boat'],
-                    'People': ['person'],
-                    'Objects': ['bottle', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'book', 'laptop']
-                }
-                
-                category_counts = {}
-                for obj in detected_objects:
-                    for category, items in object_categories.items():
-                        if obj in items:
-                            category_counts[category] = category_counts.get(category, 0) + 1
-                            break
-                    else:
-                        category_counts['Other'] = category_counts.get('Other', 0) + 1
-                
-                # Category pie chart
-                if category_counts:
-                    category_chart = go.Figure(data=[go.Pie(
-                        labels=list(category_counts.keys()),
-                        values=list(category_counts.values()),
-                        hole=.4,
-                        marker_colors=['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FECA57', '#FF9FF3']
-                    )])
-                    
-                    category_chart.update_layout(
-                        title="🎯 Object Categories Detected",
-                        height=350,
-                        template="plotly_dark"
-                    )
-                    st.plotly_chart(category_chart, use_container_width=True)
-                
-                # Confidence levels radar chart
-                confidence_levels = {
-                    'High Confidence (>90%)': len([obj for obj in detected_objects]) * 0.7,
-                    'Medium Confidence (70-90%)': len([obj for obj in detected_objects]) * 0.25,
-                    'Low Confidence (<70%)': len([obj for obj in detected_objects]) * 0.05
-                }
-                
-                confidence_chart = go.Figure()
-                confidence_chart.add_trace(go.Bar(
-                    x=list(confidence_levels.keys()),
-                    y=list(confidence_levels.values()),
-                    marker_color=['#4CAF50', '#FFC107', '#FF5722']
-                ))
-                
-                confidence_chart.update_layout(
-                    title="🎯 Detection Confidence Distribution",
-                    xaxis_title="Confidence Level",
-                    yaxis_title="Number of Detections",
-                    height=300,
-                    template="plotly_dark"
-                )
-                st.plotly_chart(confidence_chart, use_container_width=True)
-            
-            else:
-                st.info("📸 Upload an image to see detection statistics!")
-        
-        with stats_tab4:
-            # AI Insights and Model Information
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                st.markdown("### 🧠 AI Model Information")
-                model_info = {
-                    "🏗️ Architecture": "YOLOv8 + Custom Recognition",
-                    "📊 Model Size": "6.2 MB (YOLOv8n)",
-                    "🎯 Classes": "80+ COCO Objects",
-                    "👥 Custom Faces": f"{db_stats.get('faces', 0)} trained",
-                    "🏷️ Custom Objects": f"{db_stats.get('objects', 0)} trained",
-                    "🧠 AI Engine": "OpenAI GPT-4o-mini",
-                    "🔊 TTS Engine": "OpenAI TTS-1",
-                    "💾 Database": "SQLite + RAG"
-                }
-                
-                for key, value in model_info.items():
-                    st.markdown(f"**{key}**: {value}")
-            
-            with col2:
-                # Model comparison chart
-                models_comparison = {
-                    'Model': ['NAVADA 2.0', 'YOLOv8', 'Standard CV', 'Basic Detection'],
-                    'Accuracy': [94, 89, 82, 75],
-                    'Speed (ms)': [280, 250, 400, 350],
-                    'Features': [15, 8, 5, 3]
-                }
-                
-                comparison_chart = go.Figure()
-                comparison_chart.add_trace(go.Scatterpolar(
-                    r=[94, 95, 90, 98],  # NAVADA 2.0 capabilities
-                    theta=['Accuracy', 'Speed', 'Features', 'Innovation'],
-                    fill='toself',
-                    name='NAVADA 2.0',
-                    line=dict(color='#4ECDC4')
-                ))
-                comparison_chart.add_trace(go.Scatterpolar(
-                    r=[89, 92, 60, 70],  # Standard models
-                    theta=['Accuracy', 'Speed', 'Features', 'Innovation'],
-                    fill='toself',
-                    name='Standard Models',
-                    line=dict(color='#FF6B6B')
-                ))
-                
-                comparison_chart.update_layout(
-                    title="🚀 NAVADA 2.0 vs Standard Models",
-                    polar=dict(
-                        radialaxis=dict(
-                            visible=True,
-                            range=[0, 100]
-                        )),
-                    height=350,
-                    template="plotly_dark"
-                )
-                st.plotly_chart(comparison_chart, use_container_width=True)
-            
-            # System capabilities matrix
-            st.markdown("### ⚡ System Capabilities")
-            
-            # Create manual table to avoid pandas import
-            st.markdown("""
-            | 🎯 Feature | 📊 Status | ⚡ Performance |
-            |------------|-----------|----------------|
-            | Object Detection | ✅ Active | 94% |
-            | Face Recognition | ✅ Active | 91% |
-            | Custom Training | ✅ Active | 89% |
-            | Voice Narration | ✅ Active | 96% |
-            | RAG Analysis | ✅ Active | 87% |
-            | Real-time Processing | ✅ Active | 92% |
-            """)
-    
-    with res_col2:
-        # Charts
-        if detected_objects:
-            # Detection chart
-            detection_chart = create_detection_chart(detected_objects, face_stats, face_matches)
-            st.plotly_chart(detection_chart, use_container_width=True)
-            
-            # Confidence pie chart
-            confidence_chart = create_confidence_pie_chart(detected_objects, face_matches)
-            if confidence_chart:
-                st.plotly_chart(confidence_chart, use_container_width=True)
-        
-        # Detection summary
-        st.markdown("### 📋 Detection Summary")
-        if detected_objects:
-            st.success(f"🎯 Found {len(detected_objects)} objects!")
-            for obj in set(detected_objects):
-                count = detected_objects.count(obj)
-                st.markdown(f"• **{obj}**: {count}")
-        else:
-            st.warning("No objects detected in this image")
-        
-        if face_matches:
-            st.markdown("### 👥 Face Recognition") 
-            for match in face_matches:
-                name = match['name']
-                similarity = match.get('similarity', 0)
-                if name != 'Unknown':
-                    st.markdown(f"• **{name}**: {similarity:.2f} confidence")
-                else:
-                    st.markdown(f"• **{name}**: New face detected")
-        
-        # Training Feedback Section
-        st.markdown('<h3><i class="fas fa-brain fa-primary fa-icon"></i>Help Improve Detection Accuracy</h3>', unsafe_allow_html=True)
-        st.markdown("Found an incorrect detection? Help train the AI by providing corrections!")
-        
-        # Show corrections interface if we have detailed attributes
-        if detailed_attributes and st.session_state.get('current_image'):
-            # Create dropdown selection for cleaner UI
-            detection_options = [f"Detection #{i+1}: {attr['label']} ({attr['confidence']}) - {attr['position']}" 
-                               for i, attr in enumerate(detailed_attributes)]
-            
-            selected_detection = st.selectbox(
-                "Select detection to correct:",
-                options=range(len(detailed_attributes)),
-                format_func=lambda x: detection_options[x],
-                key="selected_detection"
-            )
-            
-            if selected_detection is not None:
-                attr = detailed_attributes[selected_detection]
-                i = selected_detection
-                
-                # Show selected detection details in expander
-                with st.expander(f"🔧 Correcting: {attr['label']} ({attr['confidence']})", expanded=True):
-                    col1, col2 = st.columns(2)
-                    
-                    with col1:
-                        st.markdown("**Detection Details:**")
-                        st.write(f"🏷️ **Label:** {attr['label']}")
-                        st.write(f"🎯 **Confidence:** {attr['confidence']}")
-                        st.write(f"🎨 **Colors:** {', '.join(attr['colors'][:2])}")
-                        st.write(f"📍 **Position:** {attr['position']}")
-                        st.write(f"📏 **Size:** {attr['size']}")
-                    
-                    with col2:
-                        st.markdown("**Provide Correction:**")
-                        # Correction input
-                        correct_label = st.text_input(
-                            "Correct label:", 
-                            key=f"correct_{i}",
-                            placeholder="e.g., rabbit, dog, car"
-                        )
-                        
-                        feedback_text = st.text_area(
-                            "Feedback (optional):", 
-                            key=f"feedback_{i}",
-                            placeholder="Why was this wrong?",
-                            height=68
-                        )
-                        
-                        if st.button("✅ Submit Correction", key=f"submit_correction_{i}", use_container_width=True, type="primary"):
-                            st.markdown('<i class="fas fa-spinner fa-spin fa-primary fa-icon"></i>Processing...', unsafe_allow_html=True)
-                            if correct_label.strip():
-                                # Extract object region from image
-                                image_array = np.array(st.session_state.current_image)
-                                
-                                # Get bounding box coordinates from detailed attributes
-                                bbox_coords = attr.get('bbox', [100, 100, 200, 200])  # [x1, y1, x2, y2]
-                                
-                                # Extract object crop
-                                x1, y1, x2, y2 = bbox_coords
-                                object_crop = image_array[max(0, int(y1)):min(image_array.shape[0], int(y2)),
-                                                        max(0, int(x1)):min(image_array.shape[1], int(x2))]
-                                
-                                if object_crop.size > 0:
-                                    # Save correction to database
-                                    try:
-                                        success = db.save_correction(
-                                            image_crop=object_crop,
-                                            bbox_coords=bbox_coords,
-                                            yolo_prediction=attr['label'],
-                                            yolo_confidence=float(attr['confidence'].rstrip('%')) / 100.0,
-                                            correct_label=correct_label.strip(),
-                                            user_feedback=feedback_text.strip(),
-                                            session_id=st.session_state.get('session_id', '')
-                                        )
-                                        
-                                        if success:
-                                            st.markdown('<div class="fa-success"><i class="fas fa-check-circle fa-success fa-icon"></i>Successfully saved correction!</div>', unsafe_allow_html=True)
-                                            st.balloons()
-                                            
-                                            # Update training stats
-                                            if 'training_corrections' not in st.session_state:
-                                                st.session_state.training_corrections = 0
-                                            st.session_state.training_corrections += 1
-                                        else:
-                                            st.markdown('<div class="fa-error"><i class="fas fa-times-circle fa-error fa-icon"></i>Failed to save correction.</div>', unsafe_allow_html=True)
-                                    except Exception as e:
-                                        st.markdown(f'<div class="fa-error"><i class="fas fa-times-circle fa-error fa-icon"></i>Error: {e}</div>', unsafe_allow_html=True)
-                                else:
-                                    st.markdown('<div class="fa-error"><i class="fas fa-times-circle fa-error fa-icon"></i>Could not extract object.</div>', unsafe_allow_html=True)
-                            else:
-                                st.markdown('<div class="fa-warning"><i class="fas fa-exclamation-triangle fa-warning fa-icon"></i>Please enter correct label.</div>', unsafe_allow_html=True)
-        
-        # Training Statistics
-        if db:
-            training_stats = db.get_training_stats()
-            if training_stats.get('total_corrections', 0) > 0:
-                st.markdown("### 📊 Training Progress")
-                
-                col1, col2, col3, col4 = st.columns(4)
-                with col1:
-                    st.metric("Total Corrections", training_stats.get('total_corrections', 0))
-                with col2:
-                    st.metric("Unique Classes", training_stats.get('unique_classes', 0))
-                with col3:
-                    st.metric("Recent (7 days)", training_stats.get('recent_corrections', 0))
-                with col4:
-                    st.metric("Avg Difficulty", f"{training_stats.get('average_difficulty', 0):.2f}")
-                
-                # Show class distribution
-                if training_stats.get('class_distribution'):
-                    st.markdown("**Class Distribution:**")
-                    for class_name, count in list(training_stats['class_distribution'].items())[:5]:
-                        st.text(f"• {class_name}: {count} samples")
-                
-                # Training trigger
-                if training_stats.get('total_corrections', 0) >= 10:
-                    if st.button("🚀 Train Custom Model", key="train_model"):
-                        with st.spinner("Training custom classifier... This may take a few minutes."):
-                            # Import training module
-                            from backend.custom_trainer import custom_trainer
-                            
-                            # Get training data
-                            training_data = db.get_training_data(limit=1000)
-                            
-                            if len(training_data) >= 10:
-                                # Train model
-                                result = custom_trainer.train_model(training_data, epochs=10, batch_size=8)
-                                
-                                if result['success']:
-                                    st.success(f"✅ Model trained successfully! Accuracy: {result['best_accuracy']:.2%}")
-                                    st.info("The new model will be used for future detections.")
-                                    
-                                    # Save model info to database (implement this method)
-                                    # db.save_model_version(result)
-                                else:
-                                    st.error(f"❌ Training failed: {result.get('error', 'Unknown error')}")
-                            else:
-                                st.warning("⚠️ Need at least 10 corrections to start training.")
-        
-        # Debug information
-        with st.expander("🔍 Debug Information"):
-            st.text(f"Detected objects list: {detected_objects}")
-            st.text(f"Face stats: {face_stats}")
-            st.text(f"Face matches: {face_matches}")
-            if detailed_attributes:
-                st.text(f"Detailed attributes: {detailed_attributes}")
-    
-    # AI Chat Agent Section
-    st.markdown("---")
-    st.markdown("## 💬 AI Chat Assistant")
-    st.markdown("Ask questions about the detected objects or have a conversation about the image!")
-    
-    # Chat interface
-    chat_col1, chat_col2 = st.columns([4, 1])
-    
-    with chat_col1:
-        user_message = st.text_input("Your message:", key="chat_input", placeholder="Ask about colors, positions, objects...")
-    
-    with chat_col2:
-        col1, col2 = st.columns(2)
-        with col1:
-            send_button = st.button("Send 💬", key="send_chat")
-        with col2:
-            clear_button = st.button("Clear 🔄", key="clear_chat")
-    
-    # Voice option for chat
-    enable_chat_voice = st.checkbox("🔊 Enable voice responses for chat", value=True, key="chat_voice")
-    
-    # Process chat
-    if send_button and user_message:
-        with st.spinner("Thinking..."):
-            # Update chat agent with current detection context
-            if 'last_results' in st.session_state and st.session_state.last_results:
-                if len(st.session_state.last_results) == 7:
-                    _, _, detected_objs, _, _, _, detailed_attrs = st.session_state.last_results
-                    response, voice_file = chat_with_agent(
-                        user_message, 
-                        detected_objs, 
-                        detailed_attrs, 
-                        enable_chat_voice
-                    )
-                else:
-                    response, voice_file = chat_with_agent(user_message, include_voice=enable_chat_voice)
-            else:
-                response, voice_file = chat_with_agent(user_message, include_voice=enable_chat_voice)
-            
-            # Add to chat history
-            st.session_state.chat_messages.append({"role": "user", "content": user_message})
-            st.session_state.chat_messages.append({"role": "assistant", "content": response, "voice": voice_file})
-    
-    if clear_button:
-        st.session_state.chat_messages = []
-        reset_chat()
-        st.rerun()
-    
-    # Display chat history
-    if st.session_state.chat_messages:
-        st.markdown("### 💭 Conversation")
-        for msg in st.session_state.chat_messages:
-            if msg["role"] == "user":
-                st.markdown(f"**You:** {msg['content']}")
-            else:
-                st.markdown(f"**NAVADA:** {msg['content']}")
-                if msg.get("voice"):
-                    st.audio(msg["voice"], format="audio/mp3")
-
-# Footer
-st.markdown("---")
-st.markdown("""
-<div style="text-align: center; padding: 2rem; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 10px; color: white; margin-top: 2rem;">
-    <h3>🎉 Experience the Future of Computer Vision</h3>
-    <p><strong>⭐ Built with passion and innovation by Lee Akpareva | © 2024 AI Innovation Lab ⭐</strong></p>
-    <p>🚀 <em>From concept to deployment in 15 minutes - now with intelligent learning capabilities!</em></p>
-    <p>🔗 <strong>Deployed on Hugging Face Spaces for seamless AI model demonstration</strong></p>
-</div>
-""", unsafe_allow_html=True)
+"""
+🚀 NAVADA 2.0 - Advanced AI Computer Vision Application (Lite Version)
+Streamlit Version for Hugging Face Spaces Deployment
+
+Enhanced Edition by Lee Akpareva | AI Consultant & Computer Vision Specialist
+"""
+
+import streamlit as st
+import time
+from datetime import datetime
+import plotly.graph_objects as go
+import plotly.express as px
+from PIL import Image
+import numpy as np
+import os
+
+# Configure Streamlit page (MUST be first!)
+st.set_page_config(
+    page_title="🚀 NAVADA 2.0 - AI Computer Vision",
+    page_icon="🚀",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Backend imports - Lite version (no face recognition)
+try:
+    from backend.yolo import detect_objects
+    from backend.openai_client import explain_detection
+except ImportError as e:
+    st.error(f"⚠️ Import error: {e}")
+    st.error("📦 Please install dependencies: pip install -r requirements.txt")
+    st.stop()
+
+# Custom CSS for enhanced styling
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+
+    .feature-card {
+        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+        padding: 1.5rem;
+        border-radius: 10px;
+        color: white;
+        margin: 1rem 0;
+    }
+
+    .stats-card {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+        padding: 1rem;
+        border-radius: 8px;
+        color: white;
+        text-align: center;
+        margin: 0.5rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def create_detection_chart(detected_objects):
+    """Create an interactive chart showing detection statistics"""
+
+    # Count object types
+    object_counts = {}
+    for obj in detected_objects:
+        object_counts[obj] = object_counts.get(obj, 0) + 1
+
+    if not object_counts:
+        # Create empty chart
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No objects detected",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=20, color="gray")
+        )
+        fig.update_layout(
+            height=300,
+            showlegend=False,
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)'
+        )
+        return fig
+
+    # Create bar chart
+    objects = list(object_counts.keys())
+    counts = list(object_counts.values())
+
+    fig = go.Figure(data=[
+        go.Bar(
+            x=objects,
+            y=counts,
+            marker_color='rgba(50, 171, 96, 0.6)',
+            marker_line_color='rgba(50, 171, 96, 1.0)',
+            marker_line_width=2,
+            text=counts,
+            textposition='auto'
+        )
+    ])
+
+    fig.update_layout(
+        title="Detected Objects",
+        xaxis_title="Object Type",
+        yaxis_title="Count",
+        height=400,
+        showlegend=False,
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)'
+    )
+
+    return fig
+
+def main():
+    # Main header
+    st.markdown("""
+    <div class="main-header">
+        <h1>🚀 NAVADA 2.0 - Advanced AI Computer Vision</h1>
+        <p><strong>Lite Version - Object Detection & AI Analysis</strong></p>
+        <p>Built with YOLOv8 • OpenAI • Streamlit</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Sidebar
+    with st.sidebar:
+        st.markdown("### 🎯 Detection Settings")
+
+        # Detection confidence threshold
+        confidence = st.slider(
+            "Detection Confidence",
+            min_value=0.1,
+            max_value=1.0,
+            value=0.5,
+            step=0.05,
+            help="Minimum confidence for object detection"
+        )
+
+        st.markdown("### 📊 Features")
+        st.markdown("""
+        - 🎯 **Object Detection**: YOLOv8 powered
+        - 🤖 **AI Explanations**: OpenAI integration
+        - 📈 **Interactive Charts**: Real-time analytics
+        - 🎨 **Visual Results**: Annotated images
+        """)
+
+        st.markdown("### ℹ️ About")
+        st.markdown("""
+        This is the **Lite Version** optimized for Hugging Face Spaces.
+
+        **Created by:** Lee Akpareva
+        **AI Consultant & Computer Vision Specialist**
+        """)
+
+    # Main content
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        st.markdown("### 📸 Upload Image for Analysis")
+
+        uploaded_file = st.file_uploader(
+            "Choose an image...",
+            type=['png', 'jpg', 'jpeg'],
+            help="Upload an image to detect objects and get AI analysis"
+        )
+
+        if uploaded_file is not None:
+            # Display uploaded image
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Uploaded Image", use_column_width=True)
+
+            # Analysis button
+            if st.button("🚀 Analyze Image", type="primary"):
+                with st.spinner("🔍 Detecting objects..."):
+                    # Perform object detection
+                    results = detect_objects(image, confidence_threshold=confidence)
+
+                    if results and len(results['detections']) > 0:
+                        # Extract detected objects
+                        detected_objects = [det['class'] for det in results['detections']]
+
+                        # Display results
+                        st.success(f"✅ Detected {len(detected_objects)} objects!")
+
+                        # Show annotated image
+                        st.markdown("### 🎯 Detection Results")
+                        if 'annotated_image' in results:
+                            st.image(results['annotated_image'], caption="Detected Objects", use_column_width=True)
+
+                        # Show detection details
+                        st.markdown("### 📋 Detected Objects")
+                        for i, detection in enumerate(results['detections']):
+                            col_a, col_b, col_c = st.columns(3)
+                            with col_a:
+                                st.metric("Object", detection['class'])
+                            with col_b:
+                                st.metric("Confidence", f"{detection['confidence']:.2%}")
+                            with col_c:
+                                st.metric("Count", f"#{i+1}")
+
+                        # AI Explanation
+                        if os.getenv("OPENAI_API_KEY"):
+                            st.markdown("### 🤖 AI Analysis")
+                            with st.spinner("🧠 Generating AI explanation..."):
+                                try:
+                                    explanation = explain_detection(detected_objects)
+                                    st.markdown(f"**AI Insight:** {explanation}")
+                                except Exception as e:
+                                    st.warning(f"AI analysis unavailable: {str(e)}")
+                        else:
+                            st.warning("🔑 Add OPENAI_API_KEY in settings for AI explanations")
+
+                    else:
+                        st.warning("❌ No objects detected. Try adjusting the confidence threshold.")
+
+    with col2:
+        st.markdown("### 📊 Detection Statistics")
+
+        # Sample chart (will be updated with real data)
+        sample_data = {
+            'Object': ['Person', 'Car', 'Dog', 'Cat'],
+            'Count': [3, 2, 1, 1]
+        }
+
+        fig = px.bar(
+            sample_data,
+            x='Object',
+            y='Count',
+            title="Sample Detection Results",
+            color='Count',
+            color_continuous_scale='Viridis'
+        )
+        fig.update_layout(height=300)
+        st.plotly_chart(fig, use_container_width=True)
+
+        # Feature highlights
+        st.markdown("### ✨ Key Features")
+
+        features = [
+            ("🎯", "Object Detection", "Advanced YOLOv8 model"),
+            ("🤖", "AI Analysis", "OpenAI explanations"),
+            ("📊", "Real-time Charts", "Interactive visualizations"),
+            ("🚀", "Fast Processing", "Optimized for speed")
+        ]
+
+        for icon, title, desc in features:
+            st.markdown(f"""
+            <div style="display: flex; align-items: center; margin: 1rem 0; padding: 0.5rem; background: #f0f2f6; border-radius: 5px;">
+                <div style="font-size: 1.5rem; margin-right: 1rem;">{icon}</div>
+                <div>
+                    <strong>{title}</strong><br>
+                    <small>{desc}</small>
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style="text-align: center; padding: 2rem; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 10px; color: white; margin-top: 2rem;">
+        <h3>🎉 Experience Advanced Computer Vision</h3>
+        <p><strong>⭐ Built by Lee Akpareva | AI Consultant & Computer Vision Specialist ⭐</strong></p>
+        <p>🚀 <em>Powered by YOLOv8 • OpenAI • Streamlit</em></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

app_lite.py

@@ -0,0 +1,271 @@
+"""
+🚀 NAVADA 2.0 - Advanced AI Computer Vision Application (Lite Version)
+Streamlit Version for Hugging Face Spaces Deployment
+
+Enhanced Edition by Lee Akpareva | AI Consultant & Computer Vision Specialist
+"""
+
+import streamlit as st
+import time
+from datetime import datetime
+import plotly.graph_objects as go
+import plotly.express as px
+from PIL import Image
+import numpy as np
+import os
+
+# Configure Streamlit page (MUST be first!)
+st.set_page_config(
+    page_title="🚀 NAVADA 2.0 - AI Computer Vision",
+    page_icon="🚀",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Backend imports - Lite version (no face recognition)
+try:
+    from backend.yolo import detect_objects
+    from backend.openai_client import explain_detection
+except ImportError as e:
+    st.error(f"⚠️ Import error: {e}")
+    st.error("📦 Please install dependencies: pip install -r requirements.txt")
+    st.stop()
+
+# Custom CSS for enhanced styling
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+
+    .feature-card {
+        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+        padding: 1.5rem;
+        border-radius: 10px;
+        color: white;
+        margin: 1rem 0;
+    }
+
+    .stats-card {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+        padding: 1rem;
+        border-radius: 8px;
+        color: white;
+        text-align: center;
+        margin: 0.5rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def create_detection_chart(detected_objects):
+    """Create an interactive chart showing detection statistics"""
+
+    # Count object types
+    object_counts = {}
+    for obj in detected_objects:
+        object_counts[obj] = object_counts.get(obj, 0) + 1
+
+    if not object_counts:
+        # Create empty chart
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No objects detected",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=20, color="gray")
+        )
+        fig.update_layout(
+            height=300,
+            showlegend=False,
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)'
+        )
+        return fig
+
+    # Create bar chart
+    objects = list(object_counts.keys())
+    counts = list(object_counts.values())
+
+    fig = go.Figure(data=[
+        go.Bar(
+            x=objects,
+            y=counts,
+            marker_color='rgba(50, 171, 96, 0.6)',
+            marker_line_color='rgba(50, 171, 96, 1.0)',
+            marker_line_width=2,
+            text=counts,
+            textposition='auto'
+        )
+    ])
+
+    fig.update_layout(
+        title="Detected Objects",
+        xaxis_title="Object Type",
+        yaxis_title="Count",
+        height=400,
+        showlegend=False,
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)'
+    )
+
+    return fig
+
+def main():
+    # Main header
+    st.markdown("""
+    <div class="main-header">
+        <h1>🚀 NAVADA 2.0 - Advanced AI Computer Vision</h1>
+        <p><strong>Lite Version - Object Detection & AI Analysis</strong></p>
+        <p>Built with YOLOv8 • OpenAI • Streamlit</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Sidebar
+    with st.sidebar:
+        st.markdown("### 🎯 Detection Settings")
+
+        # Detection confidence threshold
+        confidence = st.slider(
+            "Detection Confidence",
+            min_value=0.1,
+            max_value=1.0,
+            value=0.5,
+            step=0.05,
+            help="Minimum confidence for object detection"
+        )
+
+        st.markdown("### 📊 Features")
+        st.markdown("""
+        - 🎯 **Object Detection**: YOLOv8 powered
+        - 🤖 **AI Explanations**: OpenAI integration
+        - 📈 **Interactive Charts**: Real-time analytics
+        - 🎨 **Visual Results**: Annotated images
+        """)
+
+        st.markdown("### ℹ️ About")
+        st.markdown("""
+        This is the **Lite Version** optimized for Hugging Face Spaces.
+
+        **Created by:** Lee Akpareva
+        **AI Consultant & Computer Vision Specialist**
+        """)
+
+    # Main content
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        st.markdown("### 📸 Upload Image for Analysis")
+
+        uploaded_file = st.file_uploader(
+            "Choose an image...",
+            type=['png', 'jpg', 'jpeg'],
+            help="Upload an image to detect objects and get AI analysis"
+        )
+
+        if uploaded_file is not None:
+            # Display uploaded image
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Uploaded Image", use_column_width=True)
+
+            # Analysis button
+            if st.button("🚀 Analyze Image", type="primary"):
+                with st.spinner("🔍 Detecting objects..."):
+                    # Perform object detection
+                    results = detect_objects(image, confidence_threshold=confidence)
+
+                    if results and len(results['detections']) > 0:
+                        # Extract detected objects
+                        detected_objects = [det['class'] for det in results['detections']]
+
+                        # Display results
+                        st.success(f"✅ Detected {len(detected_objects)} objects!")
+
+                        # Show annotated image
+                        st.markdown("### 🎯 Detection Results")
+                        if 'annotated_image' in results:
+                            st.image(results['annotated_image'], caption="Detected Objects", use_column_width=True)
+
+                        # Show detection details
+                        st.markdown("### 📋 Detected Objects")
+                        for i, detection in enumerate(results['detections']):
+                            col_a, col_b, col_c = st.columns(3)
+                            with col_a:
+                                st.metric("Object", detection['class'])
+                            with col_b:
+                                st.metric("Confidence", f"{detection['confidence']:.2%}")
+                            with col_c:
+                                st.metric("Count", f"#{i+1}")
+
+                        # AI Explanation
+                        if os.getenv("OPENAI_API_KEY"):
+                            st.markdown("### 🤖 AI Analysis")
+                            with st.spinner("🧠 Generating AI explanation..."):
+                                try:
+                                    explanation = explain_detection(detected_objects)
+                                    st.markdown(f"**AI Insight:** {explanation}")
+                                except Exception as e:
+                                    st.warning(f"AI analysis unavailable: {str(e)}")
+                        else:
+                            st.warning("🔑 Add OPENAI_API_KEY in settings for AI explanations")
+
+                    else:
+                        st.warning("❌ No objects detected. Try adjusting the confidence threshold.")
+
+    with col2:
+        st.markdown("### 📊 Detection Statistics")
+
+        # Sample chart (will be updated with real data)
+        sample_data = {
+            'Object': ['Person', 'Car', 'Dog', 'Cat'],
+            'Count': [3, 2, 1, 1]
+        }
+
+        fig = px.bar(
+            sample_data,
+            x='Object',
+            y='Count',
+            title="Sample Detection Results",
+            color='Count',
+            color_continuous_scale='Viridis'
+        )
+        fig.update_layout(height=300)
+        st.plotly_chart(fig, use_container_width=True)
+
+        # Feature highlights
+        st.markdown("### ✨ Key Features")
+
+        features = [
+            ("🎯", "Object Detection", "Advanced YOLOv8 model"),
+            ("🤖", "AI Analysis", "OpenAI explanations"),
+            ("📊", "Real-time Charts", "Interactive visualizations"),
+            ("🚀", "Fast Processing", "Optimized for speed")
+        ]
+
+        for icon, title, desc in features:
+            st.markdown(f"""
+            <div style="display: flex; align-items: center; margin: 1rem 0; padding: 0.5rem; background: #f0f2f6; border-radius: 5px;">
+                <div style="font-size: 1.5rem; margin-right: 1rem;">{icon}</div>
+                <div>
+                    <strong>{title}</strong><br>
+                    <small>{desc}</small>
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style="text-align: center; padding: 2rem; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 10px; color: white; margin-top: 2rem;">
+        <h3>🎉 Experience Advanced Computer Vision</h3>
+        <p><strong>⭐ Built by Lee Akpareva | AI Consultant & Computer Vision Specialist ⭐</strong></p>
+        <p>🚀 <em>Powered by YOLOv8 • OpenAI • Streamlit</em></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

backend/chat_agent.py

@@ -1,189 +1,189 @@
-"""
-AI Chat Agent with conversation memory and text-to-speech capabilities
-"""
-import os
-from openai import OpenAI # type: ignore
-import tempfile
-from datetime import datetime
-import json
-
-# Initialize OpenAI client
-api_key = os.getenv("OPENAI_API_KEY")
-if not api_key:
-    raise ValueError("OPENAI_API_KEY environment variable is required")
-client = OpenAI(api_key=api_key)
-
-class ChatAgent:
-    def __init__(self):
-        """Initialize the chat agent with conversation memory"""
-        self.conversation_history = []
-        self.system_prompt = """You are NAVADA Assistant, an intelligent AI companion for computer vision analysis. 
-        You help users understand what's in their images, answer questions about detected objects, 
-        and provide insights about visual content. You're friendly, helpful, and knowledgeable about 
-        computer vision, image analysis, and can discuss colors, positions, sizes, and relationships 
-        between objects in images. You have access to detailed detection results including object colors, 
-        positions, sizes, and confidence scores."""
-        
-        # Add system message to history
-        self.conversation_history.append({
-            "role": "system",
-            "content": self.system_prompt
-        })
-        
-        # Store context about current image analysis
-        self.current_image_context = None
-        
-    def update_image_context(self, detected_objects, detailed_attributes=None):
-        """Update the agent's knowledge about the current image"""
-        context = f"Current image analysis shows: {', '.join(detected_objects) if detected_objects else 'no objects detected'}."
-        
-        if detailed_attributes:
-            context += "\n\nDetailed analysis:"
-            for attr in detailed_attributes:
-                colors = " and ".join(attr.get('colors', ['unknown'])[:2])
-                context += f"\n- {attr['label']}: {colors} color(s), {attr.get('size', 'unknown')} size, located at {attr.get('position', 'unknown')} (confidence: {attr.get('confidence', 'unknown')})"
-        
-        self.current_image_context = context
-        
-        # Add context to conversation as a system message
-        self.conversation_history.append({
-            "role": "system",
-            "content": f"Image context update: {context}"
-        })
-    
-    def chat(self, user_message, include_voice=True):
-        """
-        Process user message and return response with optional voice
-        
-        Args:
-            user_message: The user's input message
-            include_voice: Whether to generate voice response
-            
-        Returns:
-            tuple: (text_response, voice_file_path or None)
-        """
-        # Add user message to history
-        self.conversation_history.append({
-            "role": "user",
-            "content": user_message
-        })
-        
-        # Keep conversation history manageable (last 20 messages)
-        if len(self.conversation_history) > 20:
-            # Keep system prompt and current context, remove old messages
-            system_messages = [msg for msg in self.conversation_history if msg["role"] == "system"]
-            recent_messages = self.conversation_history[-15:]
-            self.conversation_history = system_messages + recent_messages
-        
-        try:
-            # Get response from OpenAI
-            response = client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=self.conversation_history,
-                temperature=0.7,
-                max_tokens=500
-            )
-            
-            text_response = response.choices[0].message.content
-            
-            # Add assistant response to history
-            self.conversation_history.append({
-                "role": "assistant",
-                "content": text_response
-            })
-            
-            # Generate voice if requested
-            voice_file = None
-            if include_voice:
-                voice_file = self.generate_voice(text_response)
-            
-            return text_response, voice_file
-            
-        except Exception as e:
-            error_msg = f"Chat error: {str(e)}"
-            return error_msg, None
-    
-    def generate_voice(self, text):
-        """Generate voice narration for text using OpenAI TTS"""
-        try:
-            # Generate speech using OpenAI TTS
-            response = client.audio.speech.create(
-                model="tts-1",
-                voice="nova",  # Options: alloy, echo, fable, onyx, nova, shimmer
-                input=text,
-                response_format="mp3"
-            )
-            
-            # Save to temporary file
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
-                temp_audio.write(response.content)
-                return temp_audio.name
-                
-        except Exception as e:
-            print(f"Voice generation error: {e}")
-            return None
-    
-    def get_conversation_summary(self):
-        """Get a summary of the conversation"""
-        messages = [msg for msg in self.conversation_history if msg["role"] in ["user", "assistant"]]
-        return messages
-    
-    def reset_conversation(self):
-        """Reset conversation history while keeping system prompt"""
-        self.conversation_history = [{
-            "role": "system",
-            "content": self.system_prompt
-        }]
-        self.current_image_context = None
-    
-    def save_conversation(self, filepath=None):
-        """Save conversation history to file"""
-        if filepath is None:
-            filepath = f"conversation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-        
-        with open(filepath, 'w') as f:
-            json.dump({
-                'timestamp': datetime.now().isoformat(),
-                'conversation': self.conversation_history,
-                'image_context': self.current_image_context
-            }, f, indent=2)
-        
-        return filepath
-    
-    def load_conversation(self, filepath):
-        """Load conversation history from file"""
-        with open(filepath, 'r') as f:
-            data = json.load(f)
-            self.conversation_history = data['conversation']
-            self.current_image_context = data.get('image_context')
-
-# Create a global chat agent instance
-chat_agent = ChatAgent()
-
-# Helper functions for easy integration
-def chat_with_agent(message, detected_objects=None, detailed_attributes=None, include_voice=True):
-    """
-    Simple interface to chat with the agent
-    
-    Args:
-        message: User's message
-        detected_objects: List of detected objects (optional)
-        detailed_attributes: Detailed attributes from enhanced detection (optional)
-        include_voice: Whether to generate voice response
-        
-    Returns:
-        tuple: (text_response, voice_file_path or None)
-    """
-    # Update context if new detection results provided
-    if detected_objects is not None:
-        chat_agent.update_image_context(detected_objects, detailed_attributes)
-    
-    return chat_agent.chat(message, include_voice)
-
-def reset_chat():
-    """Reset the chat conversation"""
-    chat_agent.reset_conversation()
-
-def get_chat_history():
-    """Get the current chat history"""
+"""
+AI Chat Agent with conversation memory and text-to-speech capabilities
+"""
+import os
+from openai import OpenAI # type: ignore
+import tempfile
+from datetime import datetime
+import json
+
+# Initialize OpenAI client
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    raise ValueError("OPENAI_API_KEY environment variable is required")
+client = OpenAI(api_key=api_key)
+
+class ChatAgent:
+    def __init__(self):
+        """Initialize the chat agent with conversation memory"""
+        self.conversation_history = []
+        self.system_prompt = """You are NAVADA Assistant, an intelligent AI companion for computer vision analysis. 
+        You help users understand what's in their images, answer questions about detected objects, 
+        and provide insights about visual content. You're friendly, helpful, and knowledgeable about 
+        computer vision, image analysis, and can discuss colors, positions, sizes, and relationships 
+        between objects in images. You have access to detailed detection results including object colors, 
+        positions, sizes, and confidence scores."""
+        
+        # Add system message to history
+        self.conversation_history.append({
+            "role": "system",
+            "content": self.system_prompt
+        })
+        
+        # Store context about current image analysis
+        self.current_image_context = None
+        
+    def update_image_context(self, detected_objects, detailed_attributes=None):
+        """Update the agent's knowledge about the current image"""
+        context = f"Current image analysis shows: {', '.join(detected_objects) if detected_objects else 'no objects detected'}."
+        
+        if detailed_attributes:
+            context += "\n\nDetailed analysis:"
+            for attr in detailed_attributes:
+                colors = " and ".join(attr.get('colors', ['unknown'])[:2])
+                context += f"\n- {attr['label']}: {colors} color(s), {attr.get('size', 'unknown')} size, located at {attr.get('position', 'unknown')} (confidence: {attr.get('confidence', 'unknown')})"
+        
+        self.current_image_context = context
+        
+        # Add context to conversation as a system message
+        self.conversation_history.append({
+            "role": "system",
+            "content": f"Image context update: {context}"
+        })
+    
+    def chat(self, user_message, include_voice=True):
+        """
+        Process user message and return response with optional voice
+        
+        Args:
+            user_message: The user's input message
+            include_voice: Whether to generate voice response
+            
+        Returns:
+            tuple: (text_response, voice_file_path or None)
+        """
+        # Add user message to history
+        self.conversation_history.append({
+            "role": "user",
+            "content": user_message
+        })
+        
+        # Keep conversation history manageable (last 20 messages)
+        if len(self.conversation_history) > 20:
+            # Keep system prompt and current context, remove old messages
+            system_messages = [msg for msg in self.conversation_history if msg["role"] == "system"]
+            recent_messages = self.conversation_history[-15:]
+            self.conversation_history = system_messages + recent_messages
+        
+        try:
+            # Get response from OpenAI
+            response = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=self.conversation_history,
+                temperature=0.7,
+                max_tokens=500
+            )
+            
+            text_response = response.choices[0].message.content
+            
+            # Add assistant response to history
+            self.conversation_history.append({
+                "role": "assistant",
+                "content": text_response
+            })
+            
+            # Generate voice if requested
+            voice_file = None
+            if include_voice:
+                voice_file = self.generate_voice(text_response)
+            
+            return text_response, voice_file
+            
+        except Exception as e:
+            error_msg = f"Chat error: {str(e)}"
+            return error_msg, None
+    
+    def generate_voice(self, text):
+        """Generate voice narration for text using OpenAI TTS"""
+        try:
+            # Generate speech using OpenAI TTS
+            response = client.audio.speech.create(
+                model="tts-1",
+                voice="nova",  # Options: alloy, echo, fable, onyx, nova, shimmer
+                input=text,
+                response_format="mp3"
+            )
+            
+            # Save to temporary file
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
+                temp_audio.write(response.content)
+                return temp_audio.name
+                
+        except Exception as e:
+            print(f"Voice generation error: {e}")
+            return None
+    
+    def get_conversation_summary(self):
+        """Get a summary of the conversation"""
+        messages = [msg for msg in self.conversation_history if msg["role"] in ["user", "assistant"]]
+        return messages
+    
+    def reset_conversation(self):
+        """Reset conversation history while keeping system prompt"""
+        self.conversation_history = [{
+            "role": "system",
+            "content": self.system_prompt
+        }]
+        self.current_image_context = None
+    
+    def save_conversation(self, filepath=None):
+        """Save conversation history to file"""
+        if filepath is None:
+            filepath = f"conversation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        
+        with open(filepath, 'w') as f:
+            json.dump({
+                'timestamp': datetime.now().isoformat(),
+                'conversation': self.conversation_history,
+                'image_context': self.current_image_context
+            }, f, indent=2)
+        
+        return filepath
+    
+    def load_conversation(self, filepath):
+        """Load conversation history from file"""
+        with open(filepath, 'r') as f:
+            data = json.load(f)
+            self.conversation_history = data['conversation']
+            self.current_image_context = data.get('image_context')
+
+# Create a global chat agent instance
+chat_agent = ChatAgent()
+
+# Helper functions for easy integration
+def chat_with_agent(message, detected_objects=None, detailed_attributes=None, include_voice=True):
+    """
+    Simple interface to chat with the agent
+    
+    Args:
+        message: User's message
+        detected_objects: List of detected objects (optional)
+        detailed_attributes: Detailed attributes from enhanced detection (optional)
+        include_voice: Whether to generate voice response
+        
+    Returns:
+        tuple: (text_response, voice_file_path or None)
+    """
+    # Update context if new detection results provided
+    if detected_objects is not None:
+        chat_agent.update_image_context(detected_objects, detailed_attributes)
+    
+    return chat_agent.chat(message, include_voice)
+
+def reset_chat():
+    """Reset the chat conversation"""
+    chat_agent.reset_conversation()
+
+def get_chat_history():
+    """Get the current chat history"""
     return chat_agent.get_conversation_summary()

backend/custom_trainer.py

@@ -1,399 +1,399 @@
-"""
-Custom Object Classifier Training Module
-Implements transfer learning for user feedback corrections
-"""
-import torch
-import torch.nn as nn
-import torchvision.transforms as transforms
-from torchvision import models
-import numpy as np
-import cv2
-from torch.utils.data import Dataset, DataLoader
-# from sklearn.model_selection import train_test_split  # Temporarily disabled due to numpy compatibility
-# from sklearn.metrics import accuracy_score, precision_recall_fscore_support  # Temporarily disabled
-import pickle
-import json
-from typing import List, Dict, Tuple, Optional
-from datetime import datetime
-import logging
-from pathlib import Path
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-class CustomObjectDataset(Dataset):
-    """Dataset class for custom object training"""
-    
-    def __init__(self, data: List[Dict], transform=None):
-        """
-        Initialize dataset with training data
-        
-        Args:
-            data: List of training samples from database
-            transform: Image transformations
-        """
-        self.data = data
-        self.transform = transform
-        
-        # Create label mapping
-        unique_labels = list(set([sample['correct_label'] for sample in data]))
-        self.label_to_idx = {label: idx for idx, label in enumerate(unique_labels)}
-        self.idx_to_label = {idx: label for label, idx in self.label_to_idx.items()}
-        self.num_classes = len(unique_labels)
-    
-    def __len__(self):
-        return len(self.data)
-    
-    def __getitem__(self, idx):
-        sample = self.data[idx]
-        image = sample['image']
-        label = sample['correct_label']
-        
-        # Convert BGR to RGB
-        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-        
-        if self.transform:
-            image = self.transform(image)
-        
-        label_idx = self.label_to_idx[label]
-        
-        return {
-            'image': image,
-            'label': label_idx,
-            'original_label': label,
-            'yolo_prediction': sample['yolo_prediction'],
-            'confidence': sample['yolo_confidence'],
-            'difficulty': sample['difficulty_score']
-        }
-
-class CustomClassifier(nn.Module):
-    """Custom classifier built on pre-trained backbone"""
-    
-    def __init__(self, num_classes: int, backbone='resnet18', pretrained=True):
-        """
-        Initialize custom classifier
-        
-        Args:
-            num_classes: Number of output classes
-            backbone: Backbone architecture (resnet18, resnet50, efficientnet_b0)
-            pretrained: Use pre-trained weights
-        """
-        super(CustomClassifier, self).__init__()
-        
-        self.num_classes = num_classes
-        self.backbone = backbone
-        
-        if backbone == 'resnet18':
-            self.model = models.resnet18(pretrained=pretrained)
-            self.model.fc = nn.Linear(self.model.fc.in_features, num_classes)
-        elif backbone == 'resnet50':
-            self.model = models.resnet50(pretrained=pretrained)
-            self.model.fc = nn.Linear(self.model.fc.in_features, num_classes)
-        elif backbone == 'efficientnet_b0':
-            self.model = models.efficientnet_b0(pretrained=pretrained)
-            self.model.classifier[1] = nn.Linear(self.model.classifier[1].in_features, num_classes)
-        else:
-            raise ValueError(f"Unsupported backbone: {backbone}")
-    
-    def forward(self, x):
-        return self.model(x)
-
-class CustomTrainer:
-    """Trainer class for custom object classification"""
-    
-    def __init__(self, model_dir='models/', device=None):
-        """
-        Initialize trainer
-        
-        Args:
-            model_dir: Directory to save models
-            device: Training device (cuda/cpu)
-        """
-        self.model_dir = Path(model_dir)
-        self.model_dir.mkdir(exist_ok=True)
-        
-        self.device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
-        logger.info(f"Using device: {self.device}")
-        
-        # Image transformations
-        self.train_transform = transforms.Compose([
-            transforms.ToPILImage(),
-            transforms.Resize((224, 224)),
-            transforms.RandomHorizontalFlip(0.5),
-            transforms.RandomRotation(10),
-            transforms.ColorJitter(brightness=0.2, contrast=0.2),
-            transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-        ])
-        
-        self.val_transform = transforms.Compose([
-            transforms.ToPILImage(),
-            transforms.Resize((224, 224)),
-            transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-        ])
-    
-    def prepare_data(self, training_data: List[Dict], test_size=0.2, min_samples_per_class=5):
-        """
-        Prepare training and validation data
-        
-        Args:
-            training_data: List of training samples from database
-            test_size: Fraction for validation split
-            min_samples_per_class: Minimum samples required per class
-            
-        Returns:
-            Tuple of (train_dataset, val_dataset, class_info)
-        """
-        # Filter classes with insufficient samples
-        class_counts = {}
-        for sample in training_data:
-            label = sample['correct_label']
-            class_counts[label] = class_counts.get(label, 0) + 1
-        
-        # Remove classes with insufficient samples
-        valid_classes = {label for label, count in class_counts.items() 
-                        if count >= min_samples_per_class}
-        
-        filtered_data = [sample for sample in training_data 
-                        if sample['correct_label'] in valid_classes]
-        
-        if len(filtered_data) < 10:
-            raise ValueError(f"Insufficient training data: {len(filtered_data)} samples")
-        
-        if len(valid_classes) < 2:
-            raise ValueError(f"Need at least 2 classes, got {len(valid_classes)}")
-        
-        # Simple train/val split without sklearn
-        np.random.seed(42)
-        indices = np.random.permutation(len(filtered_data))
-        split_idx = int(len(filtered_data) * (1 - test_size))
-        
-        train_indices = indices[:split_idx]
-        val_indices = indices[split_idx:]
-        
-        train_data = [filtered_data[i] for i in train_indices]
-        val_data = [filtered_data[i] for i in val_indices]
-        
-        # Create datasets
-        train_dataset = CustomObjectDataset(train_data, self.train_transform)
-        val_dataset = CustomObjectDataset(val_data, self.val_transform)
-        
-        # Ensure same label mapping
-        val_dataset.label_to_idx = train_dataset.label_to_idx
-        val_dataset.idx_to_label = train_dataset.idx_to_label
-        val_dataset.num_classes = train_dataset.num_classes
-        
-        class_info = {
-            'num_classes': train_dataset.num_classes,
-            'label_to_idx': train_dataset.label_to_idx,
-            'idx_to_label': train_dataset.idx_to_label,
-            'class_counts': class_counts,
-            'valid_classes': list(valid_classes),
-            'train_samples': len(train_data),
-            'val_samples': len(val_data)
-        }
-        
-        return train_dataset, val_dataset, class_info
-    
-    def train_model(self, training_data: List[Dict], 
-                   epochs=20, batch_size=16, learning_rate=0.001,
-                   backbone='resnet18', patience=5) -> Dict:
-        """
-        Train custom classifier
-        
-        Args:
-            training_data: Training samples from database
-            epochs: Number of training epochs
-            batch_size: Batch size for training
-            learning_rate: Learning rate
-            backbone: Model backbone architecture
-            patience: Early stopping patience
-            
-        Returns:
-            Training results and metrics
-        """
-        try:
-            # Prepare data
-            train_dataset, val_dataset, class_info = self.prepare_data(training_data)
-            
-            # Create data loaders
-            train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
-            val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
-            
-            # Initialize model
-            model = CustomClassifier(class_info['num_classes'], backbone)
-            model = model.to(self.device)
-            
-            # Loss and optimizer
-            criterion = nn.CrossEntropyLoss()
-            optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
-            scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
-            
-            # Training history
-            history = {
-                'train_loss': [],
-                'train_acc': [],
-                'val_loss': [],
-                'val_acc': []
-            }
-            
-            best_val_acc = 0.0
-            patience_counter = 0
-            
-            logger.info(f"Starting training: {epochs} epochs, {class_info['num_classes']} classes")
-            
-            for epoch in range(epochs):
-                # Training phase
-                model.train()
-                train_loss = 0.0
-                train_correct = 0
-                train_total = 0
-                
-                for batch in train_loader:
-                    images = batch['image'].to(self.device)
-                    labels = batch['label'].to(self.device)
-                    
-                    optimizer.zero_grad()
-                    outputs = model(images)
-                    loss = criterion(outputs, labels)
-                    loss.backward()
-                    optimizer.step()
-                    
-                    train_loss += loss.item()
-                    _, predicted = torch.max(outputs.data, 1)
-                    train_total += labels.size(0)
-                    train_correct += (predicted == labels).sum().item()
-                
-                train_acc = train_correct / train_total
-                avg_train_loss = train_loss / len(train_loader)
-                
-                # Validation phase
-                model.eval()
-                val_loss = 0.0
-                val_correct = 0
-                val_total = 0
-                
-                with torch.no_grad():
-                    for batch in val_loader:
-                        images = batch['image'].to(self.device)
-                        labels = batch['label'].to(self.device)
-                        
-                        outputs = model(images)
-                        loss = criterion(outputs, labels)
-                        
-                        val_loss += loss.item()
-                        _, predicted = torch.max(outputs.data, 1)
-                        val_total += labels.size(0)
-                        val_correct += (predicted == labels).sum().item()
-                
-                val_acc = val_correct / val_total
-                avg_val_loss = val_loss / len(val_loader)
-                
-                # Update history
-                history['train_loss'].append(avg_train_loss)
-                history['train_acc'].append(train_acc)
-                history['val_loss'].append(avg_val_loss)
-                history['val_acc'].append(val_acc)
-                
-                logger.info(f"Epoch {epoch+1}/{epochs}: "
-                          f"Train Loss: {avg_train_loss:.4f}, Train Acc: {train_acc:.4f}, "
-                          f"Val Loss: {avg_val_loss:.4f}, Val Acc: {val_acc:.4f}")
-                
-                # Early stopping
-                if val_acc > best_val_acc:
-                    best_val_acc = val_acc
-                    patience_counter = 0
-                    # Save best model
-                    torch.save(model.state_dict(), self.model_dir / 'best_model.pth')
-                else:
-                    patience_counter += 1
-                
-                if patience_counter >= patience:
-                    logger.info(f"Early stopping at epoch {epoch+1}")
-                    break
-                
-                scheduler.step()
-            
-            # Load best model
-            model.load_state_dict(torch.load(self.model_dir / 'best_model.pth'))
-            
-            # Final evaluation
-            final_metrics = self.evaluate_model(model, val_loader, class_info)
-            
-            # Save model and metadata
-            model_info = {
-                'model_state': model.state_dict(),
-                'class_info': class_info,
-                'training_config': {
-                    'backbone': backbone,
-                    'epochs': epochs,
-                    'batch_size': batch_size,
-                    'learning_rate': learning_rate
-                },
-                'history': history,
-                'metrics': final_metrics,
-                'timestamp': datetime.now().isoformat()
-            }
-            
-            # Save complete model info
-            model_path = self.model_dir / f'custom_classifier_{datetime.now().strftime("%Y%m%d_%H%M%S")}.pkl'
-            with open(model_path, 'wb') as f:
-                pickle.dump(model_info, f)
-            
-            logger.info(f"Training completed. Best validation accuracy: {best_val_acc:.4f}")
-            logger.info(f"Model saved to: {model_path}")
-            
-            return {
-                'success': True,
-                'model_path': str(model_path),
-                'best_accuracy': best_val_acc,
-                'final_metrics': final_metrics,
-                'class_info': class_info,
-                'history': history
-            }
-            
-        except Exception as e:
-            logger.error(f"Training failed: {e}")
-            return {
-                'success': False,
-                'error': str(e)
-            }
-    
-    def evaluate_model(self, model, val_loader, class_info) -> Dict:
-        """Evaluate model performance"""
-        model.eval()
-        all_predictions = []
-        all_labels = []
-        all_confidences = []
-        
-        with torch.no_grad():
-            for batch in val_loader:
-                images = batch['image'].to(self.device)
-                labels = batch['label']
-                
-                outputs = model(images)
-                probabilities = torch.softmax(outputs, dim=1)
-                confidences, predicted = torch.max(probabilities, 1)
-                
-                all_predictions.extend(predicted.cpu().numpy())
-                all_labels.extend(labels.numpy())
-                all_confidences.extend(confidences.cpu().numpy())
-        
-        # Calculate metrics manually without sklearn
-        accuracy = sum(1 for true, pred in zip(all_labels, all_predictions) if true == pred) / len(all_labels)
-        
-        # Simple precision/recall calculation
-        precision = recall = f1 = accuracy  # Simplified for now
-        
-        return {
-            'accuracy': float(accuracy),
-            'precision': float(precision),
-            'recall': float(recall),
-            'f1_score': float(f1),
-            'avg_confidence': float(np.mean(all_confidences)),
-            'num_samples': len(all_labels)
-        }
-
-# Global trainer instance
+"""
+Custom Object Classifier Training Module
+Implements transfer learning for user feedback corrections
+"""
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+from torchvision import models
+import numpy as np
+import cv2
+from torch.utils.data import Dataset, DataLoader
+# from sklearn.model_selection import train_test_split  # Temporarily disabled due to numpy compatibility
+# from sklearn.metrics import accuracy_score, precision_recall_fscore_support  # Temporarily disabled
+import pickle
+import json
+from typing import List, Dict, Tuple, Optional
+from datetime import datetime
+import logging
+from pathlib import Path
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class CustomObjectDataset(Dataset):
+    """Dataset class for custom object training"""
+    
+    def __init__(self, data: List[Dict], transform=None):
+        """
+        Initialize dataset with training data
+        
+        Args:
+            data: List of training samples from database
+            transform: Image transformations
+        """
+        self.data = data
+        self.transform = transform
+        
+        # Create label mapping
+        unique_labels = list(set([sample['correct_label'] for sample in data]))
+        self.label_to_idx = {label: idx for idx, label in enumerate(unique_labels)}
+        self.idx_to_label = {idx: label for label, idx in self.label_to_idx.items()}
+        self.num_classes = len(unique_labels)
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        sample = self.data[idx]
+        image = sample['image']
+        label = sample['correct_label']
+        
+        # Convert BGR to RGB
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        if self.transform:
+            image = self.transform(image)
+        
+        label_idx = self.label_to_idx[label]
+        
+        return {
+            'image': image,
+            'label': label_idx,
+            'original_label': label,
+            'yolo_prediction': sample['yolo_prediction'],
+            'confidence': sample['yolo_confidence'],
+            'difficulty': sample['difficulty_score']
+        }
+
+class CustomClassifier(nn.Module):
+    """Custom classifier built on pre-trained backbone"""
+    
+    def __init__(self, num_classes: int, backbone='resnet18', pretrained=True):
+        """
+        Initialize custom classifier
+        
+        Args:
+            num_classes: Number of output classes
+            backbone: Backbone architecture (resnet18, resnet50, efficientnet_b0)
+            pretrained: Use pre-trained weights
+        """
+        super(CustomClassifier, self).__init__()
+        
+        self.num_classes = num_classes
+        self.backbone = backbone
+        
+        if backbone == 'resnet18':
+            self.model = models.resnet18(pretrained=pretrained)
+            self.model.fc = nn.Linear(self.model.fc.in_features, num_classes)
+        elif backbone == 'resnet50':
+            self.model = models.resnet50(pretrained=pretrained)
+            self.model.fc = nn.Linear(self.model.fc.in_features, num_classes)
+        elif backbone == 'efficientnet_b0':
+            self.model = models.efficientnet_b0(pretrained=pretrained)
+            self.model.classifier[1] = nn.Linear(self.model.classifier[1].in_features, num_classes)
+        else:
+            raise ValueError(f"Unsupported backbone: {backbone}")
+    
+    def forward(self, x):
+        return self.model(x)
+
+class CustomTrainer:
+    """Trainer class for custom object classification"""
+    
+    def __init__(self, model_dir='models/', device=None):
+        """
+        Initialize trainer
+        
+        Args:
+            model_dir: Directory to save models
+            device: Training device (cuda/cpu)
+        """
+        self.model_dir = Path(model_dir)
+        self.model_dir.mkdir(exist_ok=True)
+        
+        self.device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
+        logger.info(f"Using device: {self.device}")
+        
+        # Image transformations
+        self.train_transform = transforms.Compose([
+            transforms.ToPILImage(),
+            transforms.Resize((224, 224)),
+            transforms.RandomHorizontalFlip(0.5),
+            transforms.RandomRotation(10),
+            transforms.ColorJitter(brightness=0.2, contrast=0.2),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+        
+        self.val_transform = transforms.Compose([
+            transforms.ToPILImage(),
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+    
+    def prepare_data(self, training_data: List[Dict], test_size=0.2, min_samples_per_class=5):
+        """
+        Prepare training and validation data
+        
+        Args:
+            training_data: List of training samples from database
+            test_size: Fraction for validation split
+            min_samples_per_class: Minimum samples required per class
+            
+        Returns:
+            Tuple of (train_dataset, val_dataset, class_info)
+        """
+        # Filter classes with insufficient samples
+        class_counts = {}
+        for sample in training_data:
+            label = sample['correct_label']
+            class_counts[label] = class_counts.get(label, 0) + 1
+        
+        # Remove classes with insufficient samples
+        valid_classes = {label for label, count in class_counts.items() 
+                        if count >= min_samples_per_class}
+        
+        filtered_data = [sample for sample in training_data 
+                        if sample['correct_label'] in valid_classes]
+        
+        if len(filtered_data) < 10:
+            raise ValueError(f"Insufficient training data: {len(filtered_data)} samples")
+        
+        if len(valid_classes) < 2:
+            raise ValueError(f"Need at least 2 classes, got {len(valid_classes)}")
+        
+        # Simple train/val split without sklearn
+        np.random.seed(42)
+        indices = np.random.permutation(len(filtered_data))
+        split_idx = int(len(filtered_data) * (1 - test_size))
+        
+        train_indices = indices[:split_idx]
+        val_indices = indices[split_idx:]
+        
+        train_data = [filtered_data[i] for i in train_indices]
+        val_data = [filtered_data[i] for i in val_indices]
+        
+        # Create datasets
+        train_dataset = CustomObjectDataset(train_data, self.train_transform)
+        val_dataset = CustomObjectDataset(val_data, self.val_transform)
+        
+        # Ensure same label mapping
+        val_dataset.label_to_idx = train_dataset.label_to_idx
+        val_dataset.idx_to_label = train_dataset.idx_to_label
+        val_dataset.num_classes = train_dataset.num_classes
+        
+        class_info = {
+            'num_classes': train_dataset.num_classes,
+            'label_to_idx': train_dataset.label_to_idx,
+            'idx_to_label': train_dataset.idx_to_label,
+            'class_counts': class_counts,
+            'valid_classes': list(valid_classes),
+            'train_samples': len(train_data),
+            'val_samples': len(val_data)
+        }
+        
+        return train_dataset, val_dataset, class_info
+    
+    def train_model(self, training_data: List[Dict], 
+                   epochs=20, batch_size=16, learning_rate=0.001,
+                   backbone='resnet18', patience=5) -> Dict:
+        """
+        Train custom classifier
+        
+        Args:
+            training_data: Training samples from database
+            epochs: Number of training epochs
+            batch_size: Batch size for training
+            learning_rate: Learning rate
+            backbone: Model backbone architecture
+            patience: Early stopping patience
+            
+        Returns:
+            Training results and metrics
+        """
+        try:
+            # Prepare data
+            train_dataset, val_dataset, class_info = self.prepare_data(training_data)
+            
+            # Create data loaders
+            train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+            val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
+            
+            # Initialize model
+            model = CustomClassifier(class_info['num_classes'], backbone)
+            model = model.to(self.device)
+            
+            # Loss and optimizer
+            criterion = nn.CrossEntropyLoss()
+            optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+            scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
+            
+            # Training history
+            history = {
+                'train_loss': [],
+                'train_acc': [],
+                'val_loss': [],
+                'val_acc': []
+            }
+            
+            best_val_acc = 0.0
+            patience_counter = 0
+            
+            logger.info(f"Starting training: {epochs} epochs, {class_info['num_classes']} classes")
+            
+            for epoch in range(epochs):
+                # Training phase
+                model.train()
+                train_loss = 0.0
+                train_correct = 0
+                train_total = 0
+                
+                for batch in train_loader:
+                    images = batch['image'].to(self.device)
+                    labels = batch['label'].to(self.device)
+                    
+                    optimizer.zero_grad()
+                    outputs = model(images)
+                    loss = criterion(outputs, labels)
+                    loss.backward()
+                    optimizer.step()
+                    
+                    train_loss += loss.item()
+                    _, predicted = torch.max(outputs.data, 1)
+                    train_total += labels.size(0)
+                    train_correct += (predicted == labels).sum().item()
+                
+                train_acc = train_correct / train_total
+                avg_train_loss = train_loss / len(train_loader)
+                
+                # Validation phase
+                model.eval()
+                val_loss = 0.0
+                val_correct = 0
+                val_total = 0
+                
+                with torch.no_grad():
+                    for batch in val_loader:
+                        images = batch['image'].to(self.device)
+                        labels = batch['label'].to(self.device)
+                        
+                        outputs = model(images)
+                        loss = criterion(outputs, labels)
+                        
+                        val_loss += loss.item()
+                        _, predicted = torch.max(outputs.data, 1)
+                        val_total += labels.size(0)
+                        val_correct += (predicted == labels).sum().item()
+                
+                val_acc = val_correct / val_total
+                avg_val_loss = val_loss / len(val_loader)
+                
+                # Update history
+                history['train_loss'].append(avg_train_loss)
+                history['train_acc'].append(train_acc)
+                history['val_loss'].append(avg_val_loss)
+                history['val_acc'].append(val_acc)
+                
+                logger.info(f"Epoch {epoch+1}/{epochs}: "
+                          f"Train Loss: {avg_train_loss:.4f}, Train Acc: {train_acc:.4f}, "
+                          f"Val Loss: {avg_val_loss:.4f}, Val Acc: {val_acc:.4f}")
+                
+                # Early stopping
+                if val_acc > best_val_acc:
+                    best_val_acc = val_acc
+                    patience_counter = 0
+                    # Save best model
+                    torch.save(model.state_dict(), self.model_dir / 'best_model.pth')
+                else:
+                    patience_counter += 1
+                
+                if patience_counter >= patience:
+                    logger.info(f"Early stopping at epoch {epoch+1}")
+                    break
+                
+                scheduler.step()
+            
+            # Load best model
+            model.load_state_dict(torch.load(self.model_dir / 'best_model.pth'))
+            
+            # Final evaluation
+            final_metrics = self.evaluate_model(model, val_loader, class_info)
+            
+            # Save model and metadata
+            model_info = {
+                'model_state': model.state_dict(),
+                'class_info': class_info,
+                'training_config': {
+                    'backbone': backbone,
+                    'epochs': epochs,
+                    'batch_size': batch_size,
+                    'learning_rate': learning_rate
+                },
+                'history': history,
+                'metrics': final_metrics,
+                'timestamp': datetime.now().isoformat()
+            }
+            
+            # Save complete model info
+            model_path = self.model_dir / f'custom_classifier_{datetime.now().strftime("%Y%m%d_%H%M%S")}.pkl'
+            with open(model_path, 'wb') as f:
+                pickle.dump(model_info, f)
+            
+            logger.info(f"Training completed. Best validation accuracy: {best_val_acc:.4f}")
+            logger.info(f"Model saved to: {model_path}")
+            
+            return {
+                'success': True,
+                'model_path': str(model_path),
+                'best_accuracy': best_val_acc,
+                'final_metrics': final_metrics,
+                'class_info': class_info,
+                'history': history
+            }
+            
+        except Exception as e:
+            logger.error(f"Training failed: {e}")
+            return {
+                'success': False,
+                'error': str(e)
+            }
+    
+    def evaluate_model(self, model, val_loader, class_info) -> Dict:
+        """Evaluate model performance"""
+        model.eval()
+        all_predictions = []
+        all_labels = []
+        all_confidences = []
+        
+        with torch.no_grad():
+            for batch in val_loader:
+                images = batch['image'].to(self.device)
+                labels = batch['label']
+                
+                outputs = model(images)
+                probabilities = torch.softmax(outputs, dim=1)
+                confidences, predicted = torch.max(probabilities, 1)
+                
+                all_predictions.extend(predicted.cpu().numpy())
+                all_labels.extend(labels.numpy())
+                all_confidences.extend(confidences.cpu().numpy())
+        
+        # Calculate metrics manually without sklearn
+        accuracy = sum(1 for true, pred in zip(all_labels, all_predictions) if true == pred) / len(all_labels)
+        
+        # Simple precision/recall calculation
+        precision = recall = f1 = accuracy  # Simplified for now
+        
+        return {
+            'accuracy': float(accuracy),
+            'precision': float(precision),
+            'recall': float(recall),
+            'f1_score': float(f1),
+            'avg_confidence': float(np.mean(all_confidences)),
+            'num_samples': len(all_labels)
+        }
+
+# Global trainer instance
 custom_trainer = CustomTrainer()

backend/database.py

@@ -1,678 +1,678 @@
-"""
-Database Module for NAVADA - SQLite storage for faces and objects
-Handles storage, retrieval, and management of custom recognition data
-"""
-
-import sqlite3
-import numpy as np
-import cv2
-from datetime import datetime
-import json
-import base64
-from typing import List, Dict, Optional, Tuple
-import logging
-from pathlib import Path
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-class NAVADADatabase:
-    """Database manager for storing faces, objects, and recognition data"""
-    
-    def __init__(self, db_path: str = "navada_recognition.db"):
-        """
-        Initialize database connection and create tables
-        
-        Args:
-            db_path: Path to SQLite database file
-        """
-        self.db_path = db_path
-        self.init_database()
-    
-    def init_database(self):
-        """Create database tables if they don't exist"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                
-                # Create faces table
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS faces (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        name TEXT NOT NULL,
-                        encoding BLOB NOT NULL,
-                        image_data BLOB,
-                        confidence REAL DEFAULT 0.0,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        metadata TEXT,
-                        is_active BOOLEAN DEFAULT 1
-                    )
-                """)
-                
-                # Create objects table
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS objects (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        label TEXT NOT NULL,
-                        category TEXT,
-                        features BLOB,
-                        image_data BLOB,
-                        bounding_box TEXT,
-                        confidence REAL DEFAULT 0.0,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        metadata TEXT,
-                        is_active BOOLEAN DEFAULT 1
-                    )
-                """)
-                
-                # Create detection history table
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS detection_history (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        session_id TEXT,
-                        image_data BLOB,
-                        detections TEXT,
-                        face_matches TEXT,
-                        object_matches TEXT,
-                        confidence_scores TEXT,
-                        processing_time REAL,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        metadata TEXT
-                    )
-                """)
-                
-                # Create knowledge base for RAG
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS knowledge_base (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        entity_type TEXT NOT NULL,
-                        entity_id INTEGER NOT NULL,
-                        content TEXT NOT NULL,
-                        embedding BLOB,
-                        keywords TEXT,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                """)
-                
-                # Create training corrections table for active learning
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS training_corrections (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        image_path TEXT,
-                        image_crop BLOB NOT NULL,
-                        bbox_coords TEXT NOT NULL,
-                        yolo_prediction TEXT NOT NULL,
-                        yolo_confidence REAL NOT NULL,
-                        correct_label TEXT NOT NULL,
-                        user_feedback TEXT,
-                        difficulty_score REAL DEFAULT 0.0,
-                        validated BOOLEAN DEFAULT 0,
-                        used_for_training BOOLEAN DEFAULT 0,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        session_id TEXT,
-                        metadata TEXT
-                    )
-                """)
-                
-                # Create custom model versions table
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS model_versions (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        version_name TEXT NOT NULL UNIQUE,
-                        model_path TEXT NOT NULL,
-                        accuracy REAL,
-                        precision_score REAL,
-                        recall_score REAL,
-                        f1_score REAL,
-                        training_samples INTEGER DEFAULT 0,
-                        validation_samples INTEGER DEFAULT 0,
-                        training_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        is_active BOOLEAN DEFAULT 0,
-                        performance_metrics TEXT,
-                        training_config TEXT,
-                        notes TEXT
-                    )
-                """)
-                
-                # Create custom classes mapping
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS custom_classes (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        class_name TEXT NOT NULL UNIQUE,
-                        yolo_class TEXT,
-                        sample_count INTEGER DEFAULT 0,
-                        confidence_threshold REAL DEFAULT 0.5,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        is_active BOOLEAN DEFAULT 1,
-                        description TEXT
-                    )
-                """)
-                
-                # Create indexes for better performance
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_faces_name ON faces(name)")
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_objects_label ON objects(label)")
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_history_session ON detection_history(session_id)")
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_entity ON knowledge_base(entity_type, entity_id)")
-                
-                conn.commit()
-                logger.info("Database initialized successfully")
-                
-        except Exception as e:
-            logger.error(f"Database initialization failed: {e}")
-            raise
-    
-    def add_face(self, name: str, face_encoding: np.ndarray, image: np.ndarray, 
-                 confidence: float = 0.0, metadata: Dict = None) -> int:
-        """
-        Add a new face to the database
-        
-        Args:
-            name: Person's name
-            face_encoding: Face encoding vector
-            image: Face image array
-            confidence: Recognition confidence
-            metadata: Additional metadata
-            
-        Returns:
-            Face ID in database
-        """
-        try:
-            # Encode image to base64
-            _, buffer = cv2.imencode('.jpg', image)
-            image_data = base64.b64encode(buffer).decode('utf-8')
-            
-            # Serialize face encoding
-            encoding_data = face_encoding.tobytes()
-            
-            # Convert metadata to JSON
-            metadata_json = json.dumps(metadata) if metadata else None
-            
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    INSERT INTO faces (name, encoding, image_data, confidence, metadata)
-                    VALUES (?, ?, ?, ?, ?)
-                """, (name, encoding_data, image_data, confidence, metadata_json))
-                
-                face_id = cursor.lastrowid
-                conn.commit()
-                
-                # Add to knowledge base
-                self.add_knowledge_entry("face", face_id, f"Person named {name}")
-                
-                logger.info(f"Added face for {name} with ID {face_id}")
-                return face_id
-                
-        except Exception as e:
-            logger.error(f"Failed to add face: {e}")
-            raise
-    
-    def add_object(self, label: str, category: str, features: np.ndarray, 
-                   image: np.ndarray, bounding_box: Tuple, confidence: float = 0.0, 
-                   metadata: Dict = None) -> int:
-        """
-        Add a new custom object to the database
-        
-        Args:
-            label: Object label/name
-            category: Object category
-            features: Feature vector
-            image: Object image
-            bounding_box: (x, y, w, h) bounding box
-            confidence: Detection confidence
-            metadata: Additional metadata
-            
-        Returns:
-            Object ID in database
-        """
-        try:
-            # Encode image to base64
-            _, buffer = cv2.imencode('.jpg', image)
-            image_data = base64.b64encode(buffer).decode('utf-8')
-            
-            # Serialize features
-            features_data = features.tobytes() if features is not None else None
-            
-            # Serialize bounding box
-            bbox_json = json.dumps(bounding_box)
-            
-            # Convert metadata to JSON
-            metadata_json = json.dumps(metadata) if metadata else None
-            
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    INSERT INTO objects (label, category, features, image_data, 
-                                       bounding_box, confidence, metadata)
-                    VALUES (?, ?, ?, ?, ?, ?, ?)
-                """, (label, category, features_data, image_data, bbox_json, 
-                      confidence, metadata_json))
-                
-                object_id = cursor.lastrowid
-                conn.commit()
-                
-                # Add to knowledge base
-                self.add_knowledge_entry("object", object_id, 
-                                       f"{label} - {category} object")
-                
-                logger.info(f"Added object {label} with ID {object_id}")
-                return object_id
-                
-        except Exception as e:
-            logger.error(f"Failed to add object: {e}")
-            raise
-    
-    def get_faces(self, active_only: bool = True) -> List[Dict]:
-        """Get all faces from database"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                query = "SELECT * FROM faces"
-                if active_only:
-                    query += " WHERE is_active = 1"
-                
-                cursor.execute(query)
-                rows = cursor.fetchall()
-                
-                faces = []
-                for row in rows:
-                    face = {
-                        'id': row[0],
-                        'name': row[1],
-                        'encoding': np.frombuffer(row[2], dtype=np.float64),
-                        'confidence': row[4],
-                        'created_at': row[5],
-                        'metadata': json.loads(row[7]) if row[7] else {}
-                    }
-                    faces.append(face)
-                
-                return faces
-                
-        except Exception as e:
-            logger.error(f"Failed to get faces: {e}")
-            return []
-    
-    def get_objects(self, category: str = None, active_only: bool = True) -> List[Dict]:
-        """Get objects from database"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                query = "SELECT * FROM objects"
-                params = []
-                
-                conditions = []
-                if active_only:
-                    conditions.append("is_active = 1")
-                if category:
-                    conditions.append("category = ?")
-                    params.append(category)
-                
-                if conditions:
-                    query += " WHERE " + " AND ".join(conditions)
-                
-                cursor.execute(query, params)
-                rows = cursor.fetchall()
-                
-                objects = []
-                for row in rows:
-                    obj = {
-                        'id': row[0],
-                        'label': row[1],
-                        'category': row[2],
-                        'features': np.frombuffer(row[3], dtype=np.float64) if row[3] else None,
-                        'bounding_box': json.loads(row[5]) if row[5] else None,
-                        'confidence': row[6],
-                        'created_at': row[7],
-                        'metadata': json.loads(row[9]) if row[9] else {}
-                    }
-                    objects.append(obj)
-                
-                return objects
-                
-        except Exception as e:
-            logger.error(f"Failed to get objects: {e}")
-            return []
-    
-    def save_detection_history(self, session_id: str, image: np.ndarray, 
-                             detections: List, face_matches: List = None, 
-                             object_matches: List = None, confidence_scores: Dict = None,
-                             processing_time: float = 0.0, metadata: Dict = None) -> int:
-        """Save detection results to history"""
-        try:
-            # Encode image
-            _, buffer = cv2.imencode('.jpg', image)
-            image_data = base64.b64encode(buffer).decode('utf-8')
-            
-            # Serialize data
-            detections_json = json.dumps(detections)
-            face_matches_json = json.dumps(face_matches) if face_matches else None
-            object_matches_json = json.dumps(object_matches) if object_matches else None
-            confidence_json = json.dumps(confidence_scores) if confidence_scores else None
-            metadata_json = json.dumps(metadata) if metadata else None
-            
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    INSERT INTO detection_history 
-                    (session_id, image_data, detections, face_matches, object_matches,
-                     confidence_scores, processing_time, metadata)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                """, (session_id, image_data, detections_json, face_matches_json,
-                      object_matches_json, confidence_json, processing_time, metadata_json))
-                
-                history_id = cursor.lastrowid
-                conn.commit()
-                
-                logger.info(f"Saved detection history with ID {history_id}")
-                return history_id
-                
-        except Exception as e:
-            logger.error(f"Failed to save detection history: {e}")
-            raise
-    
-    def add_knowledge_entry(self, entity_type: str, entity_id: int, content: str, 
-                          keywords: List[str] = None):
-        """Add entry to knowledge base for RAG"""
-        try:
-            keywords_json = json.dumps(keywords) if keywords else None
-            
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    INSERT INTO knowledge_base (entity_type, entity_id, content, keywords)
-                    VALUES (?, ?, ?, ?)
-                """, (entity_type, entity_id, content, keywords_json))
-                conn.commit()
-                
-        except Exception as e:
-            logger.error(f"Failed to add knowledge entry: {e}")
-    
-    def search_knowledge(self, query: str, entity_type: str = None) -> List[Dict]:
-        """Search knowledge base for RAG"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                
-                # Simple text search (can be enhanced with embeddings)
-                search_query = f"%{query.lower()}%"
-                
-                if entity_type:
-                    cursor.execute("""
-                        SELECT * FROM knowledge_base 
-                        WHERE entity_type = ? AND LOWER(content) LIKE ?
-                        ORDER BY created_at DESC LIMIT 10
-                    """, (entity_type, search_query))
-                else:
-                    cursor.execute("""
-                        SELECT * FROM knowledge_base 
-                        WHERE LOWER(content) LIKE ?
-                        ORDER BY created_at DESC LIMIT 10
-                    """, (search_query,))
-                
-                rows = cursor.fetchall()
-                results = []
-                
-                for row in rows:
-                    result = {
-                        'id': row[0],
-                        'entity_type': row[1],
-                        'entity_id': row[2],
-                        'content': row[3],
-                        'keywords': json.loads(row[5]) if row[5] else [],
-                        'created_at': row[6]
-                    }
-                    results.append(result)
-                
-                return results
-                
-        except Exception as e:
-            logger.error(f"Knowledge search failed: {e}")
-            return []
-    
-    def get_stats(self) -> Dict:
-        """Get database statistics"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                
-                # Count faces
-                cursor.execute("SELECT COUNT(*) FROM faces WHERE is_active = 1")
-                face_count = cursor.fetchone()[0]
-                
-                # Count objects
-                cursor.execute("SELECT COUNT(*) FROM objects WHERE is_active = 1")
-                object_count = cursor.fetchone()[0]
-                
-                # Count history entries
-                cursor.execute("SELECT COUNT(*) FROM detection_history")
-                history_count = cursor.fetchone()[0]
-                
-                # Get recent activity
-                cursor.execute("""
-                    SELECT COUNT(*) FROM detection_history 
-                    WHERE created_at > datetime('now', '-7 days')
-                """)
-                recent_detections = cursor.fetchone()[0]
-                
-                return {
-                    'faces': face_count,
-                    'objects': object_count,
-                    'total_detections': history_count,
-                    'recent_detections': recent_detections,
-                    'database_size': Path(self.db_path).stat().st_size if Path(self.db_path).exists() else 0
-                }
-                
-        except Exception as e:
-            logger.error(f"Failed to get stats: {e}")
-            return {}
-    
-    # Training Corrections Methods for Active Learning
-    
-    def save_correction(self, image_crop: np.ndarray, bbox_coords: List[float], 
-                       yolo_prediction: str, yolo_confidence: float, 
-                       correct_label: str, user_feedback: str = "", 
-                       session_id: str = "") -> bool:
-        """
-        Save a user correction for training
-        
-        Args:
-            image_crop: Cropped image of the detected object
-            bbox_coords: [x1, y1, x2, y2] bounding box coordinates
-            yolo_prediction: Original YOLO predicted label
-            yolo_confidence: Original YOLO confidence score
-            correct_label: User-provided correct label
-            user_feedback: Optional user feedback text
-            session_id: Session identifier
-            
-        Returns:
-            bool: Success status
-        """
-        try:
-            # Convert image to bytes
-            _, buffer = cv2.imencode('.jpg', image_crop)
-            image_bytes = buffer.tobytes()
-            
-            # Calculate difficulty score (lower confidence = higher difficulty)
-            difficulty_score = 1.0 - yolo_confidence
-            
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                
-                cursor.execute("""
-                    INSERT INTO training_corrections 
-                    (image_crop, bbox_coords, yolo_prediction, yolo_confidence, 
-                     correct_label, user_feedback, difficulty_score, session_id, metadata)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """, (
-                    image_bytes,
-                    json.dumps(bbox_coords),
-                    yolo_prediction,
-                    yolo_confidence,
-                    correct_label,
-                    user_feedback,
-                    difficulty_score,
-                    session_id,
-                    json.dumps({
-                        'timestamp': datetime.now().isoformat(),
-                        'image_shape': image_crop.shape,
-                        'correction_type': 'user_feedback'
-                    })
-                ))
-                
-                # Update or create custom class entry
-                cursor.execute("""
-                    INSERT OR IGNORE INTO custom_classes (class_name, yolo_class, sample_count)
-                    VALUES (?, ?, 0)
-                """, (correct_label, yolo_prediction))
-                
-                cursor.execute("""
-                    UPDATE custom_classes 
-                    SET sample_count = sample_count + 1 
-                    WHERE class_name = ?
-                """, (correct_label,))
-                
-                return True
-                
-        except Exception as e:
-            logger.error(f"Failed to save correction: {e}")
-            return False
-    
-    def get_training_data(self, class_name: str = None, limit: int = 1000, 
-                         validated_only: bool = False) -> List[Dict]:
-        """
-        Retrieve training data for model training
-        
-        Args:
-            class_name: Filter by specific class (optional)
-            limit: Maximum number of samples to return
-            validated_only: Only return validated corrections
-            
-        Returns:
-            List of training samples
-        """
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                
-                query = """
-                    SELECT id, image_crop, bbox_coords, yolo_prediction, 
-                           yolo_confidence, correct_label, difficulty_score, 
-                           created_at, metadata
-                    FROM training_corrections 
-                    WHERE 1=1
-                """
-                params = []
-                
-                if class_name:
-                    query += " AND correct_label = ?"
-                    params.append(class_name)
-                
-                if validated_only:
-                    query += " AND validated = 1"
-                
-                query += " ORDER BY difficulty_score DESC, created_at DESC LIMIT ?"
-                params.append(limit)
-                
-                cursor.execute(query, params)
-                rows = cursor.fetchall()
-                
-                training_data = []
-                for row in rows:
-                    # Decode image
-                    image_bytes = row[1]
-                    image_array = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_COLOR)
-                    
-                    training_data.append({
-                        'id': row[0],
-                        'image': image_array,
-                        'bbox_coords': json.loads(row[2]),
-                        'yolo_prediction': row[3],
-                        'yolo_confidence': row[4],
-                        'correct_label': row[5],
-                        'difficulty_score': row[6],
-                        'created_at': row[7],
-                        'metadata': json.loads(row[8]) if row[8] else {}
-                    })
-                
-                return training_data
-                
-        except Exception as e:
-            logger.error(f"Failed to get training data: {e}")
-            return []
-    
-    def get_training_stats(self) -> Dict:
-        """Get statistics about training corrections"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                
-                # Total corrections
-                cursor.execute("SELECT COUNT(*) FROM training_corrections")
-                total_corrections = cursor.fetchone()[0]
-                
-                # Corrections by class
-                cursor.execute("""
-                    SELECT correct_label, COUNT(*) as count
-                    FROM training_corrections 
-                    GROUP BY correct_label 
-                    ORDER BY count DESC
-                """)
-                class_counts = dict(cursor.fetchall())
-                
-                # Validated corrections
-                cursor.execute("SELECT COUNT(*) FROM training_corrections WHERE validated = 1")
-                validated_count = cursor.fetchone()[0]
-                
-                # Recent corrections (last 7 days)
-                cursor.execute("""
-                    SELECT COUNT(*) FROM training_corrections 
-                    WHERE created_at > datetime('now', '-7 days')
-                """)
-                recent_corrections = cursor.fetchone()[0]
-                
-                # Average difficulty score
-                cursor.execute("SELECT AVG(difficulty_score) FROM training_corrections")
-                avg_difficulty = cursor.fetchone()[0] or 0.0
-                
-                return {
-                    'total_corrections': total_corrections,
-                    'validated_corrections': validated_count,
-                    'recent_corrections': recent_corrections,
-                    'class_distribution': class_counts,
-                    'average_difficulty': round(avg_difficulty, 3),
-                    'unique_classes': len(class_counts)
-                }
-                
-        except Exception as e:
-            logger.error(f"Failed to get training stats: {e}")
-            return {}
-    
-    def mark_corrections_used(self, correction_ids: List[int]) -> bool:
-        """Mark corrections as used for training"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                
-                placeholders = ','.join(['?'] * len(correction_ids))
-                cursor.execute(f"""
-                    UPDATE training_corrections 
-                    SET used_for_training = 1 
-                    WHERE id IN ({placeholders})
-                """, correction_ids)
-                
-                return True
-                
-        except Exception as e:
-            logger.error(f"Failed to mark corrections as used: {e}")
-            return False
-
-# Global database instance
-try:
-    db = NAVADADatabase()
-    logger.info("Database instance created successfully")
-except Exception as e:
-    logger.error(f"Failed to create database instance: {e}")
+"""
+Database Module for NAVADA - SQLite storage for faces and objects
+Handles storage, retrieval, and management of custom recognition data
+"""
+
+import sqlite3
+import numpy as np
+import cv2
+from datetime import datetime
+import json
+import base64
+from typing import List, Dict, Optional, Tuple
+import logging
+from pathlib import Path
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class NAVADADatabase:
+    """Database manager for storing faces, objects, and recognition data"""
+    
+    def __init__(self, db_path: str = "navada_recognition.db"):
+        """
+        Initialize database connection and create tables
+        
+        Args:
+            db_path: Path to SQLite database file
+        """
+        self.db_path = db_path
+        self.init_database()
+    
+    def init_database(self):
+        """Create database tables if they don't exist"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                
+                # Create faces table
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS faces (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        name TEXT NOT NULL,
+                        encoding BLOB NOT NULL,
+                        image_data BLOB,
+                        confidence REAL DEFAULT 0.0,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        metadata TEXT,
+                        is_active BOOLEAN DEFAULT 1
+                    )
+                """)
+                
+                # Create objects table
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS objects (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        label TEXT NOT NULL,
+                        category TEXT,
+                        features BLOB,
+                        image_data BLOB,
+                        bounding_box TEXT,
+                        confidence REAL DEFAULT 0.0,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        metadata TEXT,
+                        is_active BOOLEAN DEFAULT 1
+                    )
+                """)
+                
+                # Create detection history table
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS detection_history (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        session_id TEXT,
+                        image_data BLOB,
+                        detections TEXT,
+                        face_matches TEXT,
+                        object_matches TEXT,
+                        confidence_scores TEXT,
+                        processing_time REAL,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        metadata TEXT
+                    )
+                """)
+                
+                # Create knowledge base for RAG
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS knowledge_base (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        entity_type TEXT NOT NULL,
+                        entity_id INTEGER NOT NULL,
+                        content TEXT NOT NULL,
+                        embedding BLOB,
+                        keywords TEXT,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                """)
+                
+                # Create training corrections table for active learning
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS training_corrections (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        image_path TEXT,
+                        image_crop BLOB NOT NULL,
+                        bbox_coords TEXT NOT NULL,
+                        yolo_prediction TEXT NOT NULL,
+                        yolo_confidence REAL NOT NULL,
+                        correct_label TEXT NOT NULL,
+                        user_feedback TEXT,
+                        difficulty_score REAL DEFAULT 0.0,
+                        validated BOOLEAN DEFAULT 0,
+                        used_for_training BOOLEAN DEFAULT 0,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        session_id TEXT,
+                        metadata TEXT
+                    )
+                """)
+                
+                # Create custom model versions table
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS model_versions (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        version_name TEXT NOT NULL UNIQUE,
+                        model_path TEXT NOT NULL,
+                        accuracy REAL,
+                        precision_score REAL,
+                        recall_score REAL,
+                        f1_score REAL,
+                        training_samples INTEGER DEFAULT 0,
+                        validation_samples INTEGER DEFAULT 0,
+                        training_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        is_active BOOLEAN DEFAULT 0,
+                        performance_metrics TEXT,
+                        training_config TEXT,
+                        notes TEXT
+                    )
+                """)
+                
+                # Create custom classes mapping
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS custom_classes (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        class_name TEXT NOT NULL UNIQUE,
+                        yolo_class TEXT,
+                        sample_count INTEGER DEFAULT 0,
+                        confidence_threshold REAL DEFAULT 0.5,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        is_active BOOLEAN DEFAULT 1,
+                        description TEXT
+                    )
+                """)
+                
+                # Create indexes for better performance
+                cursor.execute("CREATE INDEX IF NOT EXISTS idx_faces_name ON faces(name)")
+                cursor.execute("CREATE INDEX IF NOT EXISTS idx_objects_label ON objects(label)")
+                cursor.execute("CREATE INDEX IF NOT EXISTS idx_history_session ON detection_history(session_id)")
+                cursor.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_entity ON knowledge_base(entity_type, entity_id)")
+                
+                conn.commit()
+                logger.info("Database initialized successfully")
+                
+        except Exception as e:
+            logger.error(f"Database initialization failed: {e}")
+            raise
+    
+    def add_face(self, name: str, face_encoding: np.ndarray, image: np.ndarray, 
+                 confidence: float = 0.0, metadata: Dict = None) -> int:
+        """
+        Add a new face to the database
+        
+        Args:
+            name: Person's name
+            face_encoding: Face encoding vector
+            image: Face image array
+            confidence: Recognition confidence
+            metadata: Additional metadata
+            
+        Returns:
+            Face ID in database
+        """
+        try:
+            # Encode image to base64
+            _, buffer = cv2.imencode('.jpg', image)
+            image_data = base64.b64encode(buffer).decode('utf-8')
+            
+            # Serialize face encoding
+            encoding_data = face_encoding.tobytes()
+            
+            # Convert metadata to JSON
+            metadata_json = json.dumps(metadata) if metadata else None
+            
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    INSERT INTO faces (name, encoding, image_data, confidence, metadata)
+                    VALUES (?, ?, ?, ?, ?)
+                """, (name, encoding_data, image_data, confidence, metadata_json))
+                
+                face_id = cursor.lastrowid
+                conn.commit()
+                
+                # Add to knowledge base
+                self.add_knowledge_entry("face", face_id, f"Person named {name}")
+                
+                logger.info(f"Added face for {name} with ID {face_id}")
+                return face_id
+                
+        except Exception as e:
+            logger.error(f"Failed to add face: {e}")
+            raise
+    
+    def add_object(self, label: str, category: str, features: np.ndarray, 
+                   image: np.ndarray, bounding_box: Tuple, confidence: float = 0.0, 
+                   metadata: Dict = None) -> int:
+        """
+        Add a new custom object to the database
+        
+        Args:
+            label: Object label/name
+            category: Object category
+            features: Feature vector
+            image: Object image
+            bounding_box: (x, y, w, h) bounding box
+            confidence: Detection confidence
+            metadata: Additional metadata
+            
+        Returns:
+            Object ID in database
+        """
+        try:
+            # Encode image to base64
+            _, buffer = cv2.imencode('.jpg', image)
+            image_data = base64.b64encode(buffer).decode('utf-8')
+            
+            # Serialize features
+            features_data = features.tobytes() if features is not None else None
+            
+            # Serialize bounding box
+            bbox_json = json.dumps(bounding_box)
+            
+            # Convert metadata to JSON
+            metadata_json = json.dumps(metadata) if metadata else None
+            
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    INSERT INTO objects (label, category, features, image_data, 
+                                       bounding_box, confidence, metadata)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                """, (label, category, features_data, image_data, bbox_json, 
+                      confidence, metadata_json))
+                
+                object_id = cursor.lastrowid
+                conn.commit()
+                
+                # Add to knowledge base
+                self.add_knowledge_entry("object", object_id, 
+                                       f"{label} - {category} object")
+                
+                logger.info(f"Added object {label} with ID {object_id}")
+                return object_id
+                
+        except Exception as e:
+            logger.error(f"Failed to add object: {e}")
+            raise
+    
+    def get_faces(self, active_only: bool = True) -> List[Dict]:
+        """Get all faces from database"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                query = "SELECT * FROM faces"
+                if active_only:
+                    query += " WHERE is_active = 1"
+                
+                cursor.execute(query)
+                rows = cursor.fetchall()
+                
+                faces = []
+                for row in rows:
+                    face = {
+                        'id': row[0],
+                        'name': row[1],
+                        'encoding': np.frombuffer(row[2], dtype=np.float64),
+                        'confidence': row[4],
+                        'created_at': row[5],
+                        'metadata': json.loads(row[7]) if row[7] else {}
+                    }
+                    faces.append(face)
+                
+                return faces
+                
+        except Exception as e:
+            logger.error(f"Failed to get faces: {e}")
+            return []
+    
+    def get_objects(self, category: str = None, active_only: bool = True) -> List[Dict]:
+        """Get objects from database"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                query = "SELECT * FROM objects"
+                params = []
+                
+                conditions = []
+                if active_only:
+                    conditions.append("is_active = 1")
+                if category:
+                    conditions.append("category = ?")
+                    params.append(category)
+                
+                if conditions:
+                    query += " WHERE " + " AND ".join(conditions)
+                
+                cursor.execute(query, params)
+                rows = cursor.fetchall()
+                
+                objects = []
+                for row in rows:
+                    obj = {
+                        'id': row[0],
+                        'label': row[1],
+                        'category': row[2],
+                        'features': np.frombuffer(row[3], dtype=np.float64) if row[3] else None,
+                        'bounding_box': json.loads(row[5]) if row[5] else None,
+                        'confidence': row[6],
+                        'created_at': row[7],
+                        'metadata': json.loads(row[9]) if row[9] else {}
+                    }
+                    objects.append(obj)
+                
+                return objects
+                
+        except Exception as e:
+            logger.error(f"Failed to get objects: {e}")
+            return []
+    
+    def save_detection_history(self, session_id: str, image: np.ndarray, 
+                             detections: List, face_matches: List = None, 
+                             object_matches: List = None, confidence_scores: Dict = None,
+                             processing_time: float = 0.0, metadata: Dict = None) -> int:
+        """Save detection results to history"""
+        try:
+            # Encode image
+            _, buffer = cv2.imencode('.jpg', image)
+            image_data = base64.b64encode(buffer).decode('utf-8')
+            
+            # Serialize data
+            detections_json = json.dumps(detections)
+            face_matches_json = json.dumps(face_matches) if face_matches else None
+            object_matches_json = json.dumps(object_matches) if object_matches else None
+            confidence_json = json.dumps(confidence_scores) if confidence_scores else None
+            metadata_json = json.dumps(metadata) if metadata else None
+            
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    INSERT INTO detection_history 
+                    (session_id, image_data, detections, face_matches, object_matches,
+                     confidence_scores, processing_time, metadata)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """, (session_id, image_data, detections_json, face_matches_json,
+                      object_matches_json, confidence_json, processing_time, metadata_json))
+                
+                history_id = cursor.lastrowid
+                conn.commit()
+                
+                logger.info(f"Saved detection history with ID {history_id}")
+                return history_id
+                
+        except Exception as e:
+            logger.error(f"Failed to save detection history: {e}")
+            raise
+    
+    def add_knowledge_entry(self, entity_type: str, entity_id: int, content: str, 
+                          keywords: List[str] = None):
+        """Add entry to knowledge base for RAG"""
+        try:
+            keywords_json = json.dumps(keywords) if keywords else None
+            
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    INSERT INTO knowledge_base (entity_type, entity_id, content, keywords)
+                    VALUES (?, ?, ?, ?)
+                """, (entity_type, entity_id, content, keywords_json))
+                conn.commit()
+                
+        except Exception as e:
+            logger.error(f"Failed to add knowledge entry: {e}")
+    
+    def search_knowledge(self, query: str, entity_type: str = None) -> List[Dict]:
+        """Search knowledge base for RAG"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                
+                # Simple text search (can be enhanced with embeddings)
+                search_query = f"%{query.lower()}%"
+                
+                if entity_type:
+                    cursor.execute("""
+                        SELECT * FROM knowledge_base 
+                        WHERE entity_type = ? AND LOWER(content) LIKE ?
+                        ORDER BY created_at DESC LIMIT 10
+                    """, (entity_type, search_query))
+                else:
+                    cursor.execute("""
+                        SELECT * FROM knowledge_base 
+                        WHERE LOWER(content) LIKE ?
+                        ORDER BY created_at DESC LIMIT 10
+                    """, (search_query,))
+                
+                rows = cursor.fetchall()
+                results = []
+                
+                for row in rows:
+                    result = {
+                        'id': row[0],
+                        'entity_type': row[1],
+                        'entity_id': row[2],
+                        'content': row[3],
+                        'keywords': json.loads(row[5]) if row[5] else [],
+                        'created_at': row[6]
+                    }
+                    results.append(result)
+                
+                return results
+                
+        except Exception as e:
+            logger.error(f"Knowledge search failed: {e}")
+            return []
+    
+    def get_stats(self) -> Dict:
+        """Get database statistics"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                
+                # Count faces
+                cursor.execute("SELECT COUNT(*) FROM faces WHERE is_active = 1")
+                face_count = cursor.fetchone()[0]
+                
+                # Count objects
+                cursor.execute("SELECT COUNT(*) FROM objects WHERE is_active = 1")
+                object_count = cursor.fetchone()[0]
+                
+                # Count history entries
+                cursor.execute("SELECT COUNT(*) FROM detection_history")
+                history_count = cursor.fetchone()[0]
+                
+                # Get recent activity
+                cursor.execute("""
+                    SELECT COUNT(*) FROM detection_history 
+                    WHERE created_at > datetime('now', '-7 days')
+                """)
+                recent_detections = cursor.fetchone()[0]
+                
+                return {
+                    'faces': face_count,
+                    'objects': object_count,
+                    'total_detections': history_count,
+                    'recent_detections': recent_detections,
+                    'database_size': Path(self.db_path).stat().st_size if Path(self.db_path).exists() else 0
+                }
+                
+        except Exception as e:
+            logger.error(f"Failed to get stats: {e}")
+            return {}
+    
+    # Training Corrections Methods for Active Learning
+    
+    def save_correction(self, image_crop: np.ndarray, bbox_coords: List[float], 
+                       yolo_prediction: str, yolo_confidence: float, 
+                       correct_label: str, user_feedback: str = "", 
+                       session_id: str = "") -> bool:
+        """
+        Save a user correction for training
+        
+        Args:
+            image_crop: Cropped image of the detected object
+            bbox_coords: [x1, y1, x2, y2] bounding box coordinates
+            yolo_prediction: Original YOLO predicted label
+            yolo_confidence: Original YOLO confidence score
+            correct_label: User-provided correct label
+            user_feedback: Optional user feedback text
+            session_id: Session identifier
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            # Convert image to bytes
+            _, buffer = cv2.imencode('.jpg', image_crop)
+            image_bytes = buffer.tobytes()
+            
+            # Calculate difficulty score (lower confidence = higher difficulty)
+            difficulty_score = 1.0 - yolo_confidence
+            
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                
+                cursor.execute("""
+                    INSERT INTO training_corrections 
+                    (image_crop, bbox_coords, yolo_prediction, yolo_confidence, 
+                     correct_label, user_feedback, difficulty_score, session_id, metadata)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    image_bytes,
+                    json.dumps(bbox_coords),
+                    yolo_prediction,
+                    yolo_confidence,
+                    correct_label,
+                    user_feedback,
+                    difficulty_score,
+                    session_id,
+                    json.dumps({
+                        'timestamp': datetime.now().isoformat(),
+                        'image_shape': image_crop.shape,
+                        'correction_type': 'user_feedback'
+                    })
+                ))
+                
+                # Update or create custom class entry
+                cursor.execute("""
+                    INSERT OR IGNORE INTO custom_classes (class_name, yolo_class, sample_count)
+                    VALUES (?, ?, 0)
+                """, (correct_label, yolo_prediction))
+                
+                cursor.execute("""
+                    UPDATE custom_classes 
+                    SET sample_count = sample_count + 1 
+                    WHERE class_name = ?
+                """, (correct_label,))
+                
+                return True
+                
+        except Exception as e:
+            logger.error(f"Failed to save correction: {e}")
+            return False
+    
+    def get_training_data(self, class_name: str = None, limit: int = 1000, 
+                         validated_only: bool = False) -> List[Dict]:
+        """
+        Retrieve training data for model training
+        
+        Args:
+            class_name: Filter by specific class (optional)
+            limit: Maximum number of samples to return
+            validated_only: Only return validated corrections
+            
+        Returns:
+            List of training samples
+        """
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                
+                query = """
+                    SELECT id, image_crop, bbox_coords, yolo_prediction, 
+                           yolo_confidence, correct_label, difficulty_score, 
+                           created_at, metadata
+                    FROM training_corrections 
+                    WHERE 1=1
+                """
+                params = []
+                
+                if class_name:
+                    query += " AND correct_label = ?"
+                    params.append(class_name)
+                
+                if validated_only:
+                    query += " AND validated = 1"
+                
+                query += " ORDER BY difficulty_score DESC, created_at DESC LIMIT ?"
+                params.append(limit)
+                
+                cursor.execute(query, params)
+                rows = cursor.fetchall()
+                
+                training_data = []
+                for row in rows:
+                    # Decode image
+                    image_bytes = row[1]
+                    image_array = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_COLOR)
+                    
+                    training_data.append({
+                        'id': row[0],
+                        'image': image_array,
+                        'bbox_coords': json.loads(row[2]),
+                        'yolo_prediction': row[3],
+                        'yolo_confidence': row[4],
+                        'correct_label': row[5],
+                        'difficulty_score': row[6],
+                        'created_at': row[7],
+                        'metadata': json.loads(row[8]) if row[8] else {}
+                    })
+                
+                return training_data
+                
+        except Exception as e:
+            logger.error(f"Failed to get training data: {e}")
+            return []
+    
+    def get_training_stats(self) -> Dict:
+        """Get statistics about training corrections"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                
+                # Total corrections
+                cursor.execute("SELECT COUNT(*) FROM training_corrections")
+                total_corrections = cursor.fetchone()[0]
+                
+                # Corrections by class
+                cursor.execute("""
+                    SELECT correct_label, COUNT(*) as count
+                    FROM training_corrections 
+                    GROUP BY correct_label 
+                    ORDER BY count DESC
+                """)
+                class_counts = dict(cursor.fetchall())
+                
+                # Validated corrections
+                cursor.execute("SELECT COUNT(*) FROM training_corrections WHERE validated = 1")
+                validated_count = cursor.fetchone()[0]
+                
+                # Recent corrections (last 7 days)
+                cursor.execute("""
+                    SELECT COUNT(*) FROM training_corrections 
+                    WHERE created_at > datetime('now', '-7 days')
+                """)
+                recent_corrections = cursor.fetchone()[0]
+                
+                # Average difficulty score
+                cursor.execute("SELECT AVG(difficulty_score) FROM training_corrections")
+                avg_difficulty = cursor.fetchone()[0] or 0.0
+                
+                return {
+                    'total_corrections': total_corrections,
+                    'validated_corrections': validated_count,
+                    'recent_corrections': recent_corrections,
+                    'class_distribution': class_counts,
+                    'average_difficulty': round(avg_difficulty, 3),
+                    'unique_classes': len(class_counts)
+                }
+                
+        except Exception as e:
+            logger.error(f"Failed to get training stats: {e}")
+            return {}
+    
+    def mark_corrections_used(self, correction_ids: List[int]) -> bool:
+        """Mark corrections as used for training"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                
+                placeholders = ','.join(['?'] * len(correction_ids))
+                cursor.execute(f"""
+                    UPDATE training_corrections 
+                    SET used_for_training = 1 
+                    WHERE id IN ({placeholders})
+                """, correction_ids)
+                
+                return True
+                
+        except Exception as e:
+            logger.error(f"Failed to mark corrections as used: {e}")
+            return False
+
+# Global database instance
+try:
+    db = NAVADADatabase()
+    logger.info("Database instance created successfully")
+except Exception as e:
+    logger.error(f"Failed to create database instance: {e}")
     db = None

backend/face_detection.py

@@ -1,299 +1,299 @@
-"""
-Face Detection Module for NAVADA
-This module provides face detection capabilities using OpenCV's Haar Cascades.
-It can detect faces, eyes, and smiles in images and return detailed statistics.
-"""
-
-import cv2  # OpenCV library for computer vision tasks
-import numpy as np  # NumPy for numerical operations on arrays
-from typing import Tuple, List, Dict, Optional, Union  # Type hints for better code documentation
-import os  # Operating system interface for file path operations
-import logging  # Logging module for error tracking
-
-# Configure logging for this module
-logger = logging.getLogger(__name__)
-
-
-class FaceDetector:
-    """
-    A class to handle face detection using OpenCV's Haar Cascade classifiers.
-    This detector can identify faces, eyes, and smiles in images.
-    """
-    
-    def __init__(self):
-        """
-        Initialize the FaceDetector with pre-trained Haar Cascade classifiers.
-        Loads classifiers for face, eye, and smile detection.
-        """
-        try:
-            # Load the pre-trained Haar Cascade classifier for frontal face detection
-            # This XML file contains trained patterns for detecting frontal faces
-            self.face_cascade = cv2.CascadeClassifier(
-                cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
-            )
-            
-            # Load the classifier for eye detection
-            # This works best when applied to face regions
-            self.eye_cascade = cv2.CascadeClassifier(
-                cv2.data.haarcascades + 'haarcascade_eye.xml'
-            )
-            
-            # Load the classifier for smile detection
-            # This detects smiling expressions in face regions
-            self.smile_cascade = cv2.CascadeClassifier(
-                cv2.data.haarcascades + 'haarcascade_smile.xml'
-            )
-            
-            # Verify that classifiers loaded successfully
-            if self.face_cascade.empty():
-                raise ValueError("Failed to load face cascade classifier")
-            if self.eye_cascade.empty():
-                raise ValueError("Failed to load eye cascade classifier")
-            if self.smile_cascade.empty():
-                raise ValueError("Failed to load smile cascade classifier")
-                
-            logger.info("Face detection classifiers loaded successfully")
-            
-        except Exception as e:
-            logger.error(f"Error initializing face detector: {str(e)}")
-            raise
-        
-    def detect_faces(self, image: Optional[np.ndarray]) -> Tuple[np.ndarray, Dict]:
-        """
-        Detect faces in an image and return an annotated image with statistics.
-        
-        Parameters:
-        -----------
-        image : np.ndarray
-            Input image as a NumPy array (can be grayscale or color)
-            
-        Returns:
-        --------
-        Tuple[np.ndarray, Dict]
-            - Annotated image with face detection boxes and labels
-            - Dictionary containing detection statistics and face details
-        """
-        # Input validation - check if image is provided and valid
-        if image is None:
-            logger.warning("No image provided for face detection")
-            return np.zeros((480, 640, 3), dtype=np.uint8), {
-                'total_faces': 0,
-                'faces': [],
-                'detection_method': 'Haar Cascade',
-                'features_detected': {'eyes': 0, 'smiles': 0}
-            }
-            
-        # Ensure image is a numpy array
-        if not isinstance(image, np.ndarray):
-            logger.error("Image must be a numpy array")
-            raise TypeError("Image must be a numpy array")
-            
-        # Check if image is empty
-        if image.size == 0:
-            logger.warning("Empty image provided")
-            return image, {
-                'total_faces': 0,
-                'faces': [],
-                'detection_method': 'Haar Cascade',
-                'features_detected': {'eyes': 0, 'smiles': 0}
-            }
-        
-        # Convert grayscale images to RGB for consistent output
-        # Check the number of dimensions to determine if image is grayscale
-        if len(image.shape) == 2:  # Grayscale image (height, width)
-            img_rgb = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-        elif len(image.shape) == 3:  # Color image (height, width, channels)
-            img_rgb = image.copy()  # Create a copy to avoid modifying original
-        else:
-            logger.error(f"Invalid image shape: {image.shape}")
-            raise ValueError(f"Invalid image shape: {image.shape}")
-            
-        # Convert to grayscale for detection algorithms
-        # Haar Cascades work on grayscale images for better performance
-        try:
-            gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
-        except cv2.error as e:
-            logger.error(f"Error converting image to grayscale: {str(e)}")
-            return img_rgb, {
-                'total_faces': 0,
-                'faces': [],
-                'detection_method': 'Haar Cascade',
-                'features_detected': {'eyes': 0, 'smiles': 0}
-            }
-        
-        # Detect faces using the Haar Cascade classifier
-        # Parameters control detection sensitivity and performance
-        faces = self.face_cascade.detectMultiScale(
-            gray,  # Grayscale image to search
-            scaleFactor=1.1,  # Image pyramid scaling factor (1.1 = 10% reduction each level)
-            minNeighbors=5,  # Minimum neighbors for detection confidence
-            minSize=(30, 30)  # Minimum face size in pixels
-        )
-        
-        # List to store detailed information about each detected face
-        face_details = []
-        
-        # Process each detected face
-        for idx, (x, y, w, h) in enumerate(faces):
-            # Draw a magenta rectangle around the detected face
-            # Parameters: image, top-left corner, bottom-right corner, color (BGR), thickness
-            cv2.rectangle(img_rgb, (x, y), (x+w, y+h), (255, 0, 255), 3)
-            
-            # Add a label above each face
-            # Parameters: image, text, position, font, scale, color, thickness
-            cv2.putText(
-                img_rgb, 
-                f"Face {idx+1}",  # Label text
-                (x, y-10),  # Position (above the rectangle)
-                cv2.FONT_HERSHEY_SIMPLEX,  # Font type
-                0.7,  # Font scale
-                (255, 0, 255),  # Color (magenta in RGB)
-                2  # Thickness
-            )
-            
-            # Extract Region of Interest (ROI) for face area
-            # This isolates the face region for feature detection
-            roi_gray = gray[y:y+h, x:x+w]  # Grayscale ROI for detection
-            roi_color = img_rgb[y:y+h, x:x+w]  # Color ROI for drawing
-            
-            # Detect eyes within the face region
-            # Using different parameters for eye detection (more sensitive)
-            eyes = self.eye_cascade.detectMultiScale(
-                roi_gray,
-                scaleFactor=1.05,  # Smaller scale factor for finer detection
-                minNeighbors=3  # Fewer neighbors required
-            )
-            eye_count = len(eyes)  # Count the number of detected eyes
-            
-            # Draw green rectangles around detected eyes
-            for (ex, ey, ew, eh) in eyes:
-                cv2.rectangle(
-                    roi_color,  # Draw on the color ROI
-                    (ex, ey),  # Top-left corner
-                    (ex+ew, ey+eh),  # Bottom-right corner
-                    (0, 255, 0),  # Green color in RGB
-                    2  # Thickness
-                )
-            
-            # Detect smiles within the face region
-            # Smile detection requires different parameters
-            smiles = self.smile_cascade.detectMultiScale(
-                roi_gray,
-                scaleFactor=1.8,  # Larger scale factor for smile detection
-                minNeighbors=20  # More neighbors required for confidence
-            )
-            has_smile = len(smiles) > 0  # Boolean flag for smile presence
-            
-            # Draw yellow rectangles around detected smiles
-            for (sx, sy, sw, sh) in smiles:
-                cv2.rectangle(
-                    roi_color,  # Draw on the color ROI
-                    (sx, sy),  # Top-left corner
-                    (sx+sw, sy+sh),  # Bottom-right corner
-                    (0, 255, 255),  # Yellow color in RGB
-                    2  # Thickness
-                )
-            
-            # Store detailed information about this face
-            face_details.append({
-                'face_id': idx + 1,  # Sequential face ID starting from 1
-                'position': {  # Face bounding box coordinates
-                    'x': int(x),  # X coordinate of top-left corner
-                    'y': int(y),  # Y coordinate of top-left corner
-                    'width': int(w),  # Width of face bounding box
-                    'height': int(h)  # Height of face bounding box
-                },
-                'eyes_detected': eye_count,  # Number of eyes detected
-                'smile_detected': has_smile,  # Whether a smile was detected
-                'confidence': 0.95  # Placeholder confidence score
-            })
-        
-        # Compile comprehensive statistics about all detected faces
-        stats = {
-            'total_faces': len(faces),  # Total number of faces detected
-            'faces': face_details,  # List of detailed face information
-            'detection_method': 'Haar Cascade',  # Method used for detection
-            'features_detected': {  # Aggregate feature statistics
-                'eyes': sum(f['eyes_detected'] for f in face_details),  # Total eyes
-                'smiles': sum(1 for f in face_details if f['smile_detected'])  # Total smiles
-            }
-        }
-        
-        return img_rgb, stats  # Return annotated image and statistics
-
-    def analyze_demographics(self, face_stats: Optional[Dict]) -> str:
-        """
-        Create a demographic analysis report based on face detection statistics.
-        
-        Parameters:
-        -----------
-        face_stats : Dict
-            Dictionary containing face detection statistics
-            
-        Returns:
-        --------
-        str
-            Formatted text analysis of detected faces and their features
-        """
-        # Handle case where no statistics are provided
-        if not face_stats:
-            return "No face detection data available."
-            
-        # Handle case where no faces were detected
-        if face_stats.get('total_faces', 0) == 0:
-            return "No faces detected in the image."
-        
-        # Build analysis report
-        analysis = []  # List to accumulate analysis text
-        
-        # Add header with total face count
-        analysis.append(f"👥 Detected {face_stats['total_faces']} face(s) in the image\n")
-        
-        # Add detailed information for each face
-        for face in face_stats.get('faces', []):
-            # Create description for individual face
-            face_desc = f"\n**Face {face['face_id']}:**"
-            
-            # Add position information
-            pos = face.get('position', {})
-            face_desc += f"\n  • Position: ({pos.get('x', 0)}, {pos.get('y', 0)})"
-            
-            # Add size information
-            face_desc += f"\n  • Size: {pos.get('width', 0)}x{pos.get('height', 0)} pixels"
-            
-            # Add eye detection information if eyes were found
-            if face.get('eyes_detected', 0) > 0:
-                face_desc += f"\n  • Eyes detected: {face['eyes_detected']}"
-            
-            # Add smile detection information
-            if face.get('smile_detected', False):
-                face_desc += "\n  • 😊 Smile detected!"
-            
-            analysis.append(face_desc)  # Add face description to analysis
-        
-        # Add summary statistics if smiles were detected
-        features = face_stats.get('features_detected', {})
-        smile_count = features.get('smiles', 0)
-        
-        if smile_count > 0:
-            # Calculate percentage of faces that are smiling
-            smile_ratio = (smile_count / face_stats['total_faces']) * 100
-            
-            # Add overall analysis section
-            analysis.append(f"\n\n📊 **Overall Analysis:**")
-            analysis.append(f"\n  • {smile_ratio:.0f}% of faces are smiling")
-            analysis.append(f"\n  • Total eyes detected: {features.get('eyes', 0)}")
-        
-        # Join all analysis parts and return
-        return "".join(analysis)
-
-
-# Create a global instance of FaceDetector for use throughout the application
-# This avoids reloading classifiers multiple times
-try:
-    face_detector = FaceDetector()
-    logger.info("Global face detector initialized successfully")
-except Exception as e:
-    logger.error(f"Failed to initialize global face detector: {str(e)}")
-    # Create a dummy detector that returns empty results
+"""
+Face Detection Module for NAVADA
+This module provides face detection capabilities using OpenCV's Haar Cascades.
+It can detect faces, eyes, and smiles in images and return detailed statistics.
+"""
+
+import cv2  # OpenCV library for computer vision tasks
+import numpy as np  # NumPy for numerical operations on arrays
+from typing import Tuple, List, Dict, Optional, Union  # Type hints for better code documentation
+import os  # Operating system interface for file path operations
+import logging  # Logging module for error tracking
+
+# Configure logging for this module
+logger = logging.getLogger(__name__)
+
+
+class FaceDetector:
+    """
+    A class to handle face detection using OpenCV's Haar Cascade classifiers.
+    This detector can identify faces, eyes, and smiles in images.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the FaceDetector with pre-trained Haar Cascade classifiers.
+        Loads classifiers for face, eye, and smile detection.
+        """
+        try:
+            # Load the pre-trained Haar Cascade classifier for frontal face detection
+            # This XML file contains trained patterns for detecting frontal faces
+            self.face_cascade = cv2.CascadeClassifier(
+                cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
+            )
+            
+            # Load the classifier for eye detection
+            # This works best when applied to face regions
+            self.eye_cascade = cv2.CascadeClassifier(
+                cv2.data.haarcascades + 'haarcascade_eye.xml'
+            )
+            
+            # Load the classifier for smile detection
+            # This detects smiling expressions in face regions
+            self.smile_cascade = cv2.CascadeClassifier(
+                cv2.data.haarcascades + 'haarcascade_smile.xml'
+            )
+            
+            # Verify that classifiers loaded successfully
+            if self.face_cascade.empty():
+                raise ValueError("Failed to load face cascade classifier")
+            if self.eye_cascade.empty():
+                raise ValueError("Failed to load eye cascade classifier")
+            if self.smile_cascade.empty():
+                raise ValueError("Failed to load smile cascade classifier")
+                
+            logger.info("Face detection classifiers loaded successfully")
+            
+        except Exception as e:
+            logger.error(f"Error initializing face detector: {str(e)}")
+            raise
+        
+    def detect_faces(self, image: Optional[np.ndarray]) -> Tuple[np.ndarray, Dict]:
+        """
+        Detect faces in an image and return an annotated image with statistics.
+        
+        Parameters:
+        -----------
+        image : np.ndarray
+            Input image as a NumPy array (can be grayscale or color)
+            
+        Returns:
+        --------
+        Tuple[np.ndarray, Dict]
+            - Annotated image with face detection boxes and labels
+            - Dictionary containing detection statistics and face details
+        """
+        # Input validation - check if image is provided and valid
+        if image is None:
+            logger.warning("No image provided for face detection")
+            return np.zeros((480, 640, 3), dtype=np.uint8), {
+                'total_faces': 0,
+                'faces': [],
+                'detection_method': 'Haar Cascade',
+                'features_detected': {'eyes': 0, 'smiles': 0}
+            }
+            
+        # Ensure image is a numpy array
+        if not isinstance(image, np.ndarray):
+            logger.error("Image must be a numpy array")
+            raise TypeError("Image must be a numpy array")
+            
+        # Check if image is empty
+        if image.size == 0:
+            logger.warning("Empty image provided")
+            return image, {
+                'total_faces': 0,
+                'faces': [],
+                'detection_method': 'Haar Cascade',
+                'features_detected': {'eyes': 0, 'smiles': 0}
+            }
+        
+        # Convert grayscale images to RGB for consistent output
+        # Check the number of dimensions to determine if image is grayscale
+        if len(image.shape) == 2:  # Grayscale image (height, width)
+            img_rgb = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+        elif len(image.shape) == 3:  # Color image (height, width, channels)
+            img_rgb = image.copy()  # Create a copy to avoid modifying original
+        else:
+            logger.error(f"Invalid image shape: {image.shape}")
+            raise ValueError(f"Invalid image shape: {image.shape}")
+            
+        # Convert to grayscale for detection algorithms
+        # Haar Cascades work on grayscale images for better performance
+        try:
+            gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
+        except cv2.error as e:
+            logger.error(f"Error converting image to grayscale: {str(e)}")
+            return img_rgb, {
+                'total_faces': 0,
+                'faces': [],
+                'detection_method': 'Haar Cascade',
+                'features_detected': {'eyes': 0, 'smiles': 0}
+            }
+        
+        # Detect faces using the Haar Cascade classifier
+        # Parameters control detection sensitivity and performance
+        faces = self.face_cascade.detectMultiScale(
+            gray,  # Grayscale image to search
+            scaleFactor=1.1,  # Image pyramid scaling factor (1.1 = 10% reduction each level)
+            minNeighbors=5,  # Minimum neighbors for detection confidence
+            minSize=(30, 30)  # Minimum face size in pixels
+        )
+        
+        # List to store detailed information about each detected face
+        face_details = []
+        
+        # Process each detected face
+        for idx, (x, y, w, h) in enumerate(faces):
+            # Draw a magenta rectangle around the detected face
+            # Parameters: image, top-left corner, bottom-right corner, color (BGR), thickness
+            cv2.rectangle(img_rgb, (x, y), (x+w, y+h), (255, 0, 255), 3)
+            
+            # Add a label above each face
+            # Parameters: image, text, position, font, scale, color, thickness
+            cv2.putText(
+                img_rgb, 
+                f"Face {idx+1}",  # Label text
+                (x, y-10),  # Position (above the rectangle)
+                cv2.FONT_HERSHEY_SIMPLEX,  # Font type
+                0.7,  # Font scale
+                (255, 0, 255),  # Color (magenta in RGB)
+                2  # Thickness
+            )
+            
+            # Extract Region of Interest (ROI) for face area
+            # This isolates the face region for feature detection
+            roi_gray = gray[y:y+h, x:x+w]  # Grayscale ROI for detection
+            roi_color = img_rgb[y:y+h, x:x+w]  # Color ROI for drawing
+            
+            # Detect eyes within the face region
+            # Using different parameters for eye detection (more sensitive)
+            eyes = self.eye_cascade.detectMultiScale(
+                roi_gray,
+                scaleFactor=1.05,  # Smaller scale factor for finer detection
+                minNeighbors=3  # Fewer neighbors required
+            )
+            eye_count = len(eyes)  # Count the number of detected eyes
+            
+            # Draw green rectangles around detected eyes
+            for (ex, ey, ew, eh) in eyes:
+                cv2.rectangle(
+                    roi_color,  # Draw on the color ROI
+                    (ex, ey),  # Top-left corner
+                    (ex+ew, ey+eh),  # Bottom-right corner
+                    (0, 255, 0),  # Green color in RGB
+                    2  # Thickness
+                )
+            
+            # Detect smiles within the face region
+            # Smile detection requires different parameters
+            smiles = self.smile_cascade.detectMultiScale(
+                roi_gray,
+                scaleFactor=1.8,  # Larger scale factor for smile detection
+                minNeighbors=20  # More neighbors required for confidence
+            )
+            has_smile = len(smiles) > 0  # Boolean flag for smile presence
+            
+            # Draw yellow rectangles around detected smiles
+            for (sx, sy, sw, sh) in smiles:
+                cv2.rectangle(
+                    roi_color,  # Draw on the color ROI
+                    (sx, sy),  # Top-left corner
+                    (sx+sw, sy+sh),  # Bottom-right corner
+                    (0, 255, 255),  # Yellow color in RGB
+                    2  # Thickness
+                )
+            
+            # Store detailed information about this face
+            face_details.append({
+                'face_id': idx + 1,  # Sequential face ID starting from 1
+                'position': {  # Face bounding box coordinates
+                    'x': int(x),  # X coordinate of top-left corner
+                    'y': int(y),  # Y coordinate of top-left corner
+                    'width': int(w),  # Width of face bounding box
+                    'height': int(h)  # Height of face bounding box
+                },
+                'eyes_detected': eye_count,  # Number of eyes detected
+                'smile_detected': has_smile,  # Whether a smile was detected
+                'confidence': 0.95  # Placeholder confidence score
+            })
+        
+        # Compile comprehensive statistics about all detected faces
+        stats = {
+            'total_faces': len(faces),  # Total number of faces detected
+            'faces': face_details,  # List of detailed face information
+            'detection_method': 'Haar Cascade',  # Method used for detection
+            'features_detected': {  # Aggregate feature statistics
+                'eyes': sum(f['eyes_detected'] for f in face_details),  # Total eyes
+                'smiles': sum(1 for f in face_details if f['smile_detected'])  # Total smiles
+            }
+        }
+        
+        return img_rgb, stats  # Return annotated image and statistics
+
+    def analyze_demographics(self, face_stats: Optional[Dict]) -> str:
+        """
+        Create a demographic analysis report based on face detection statistics.
+        
+        Parameters:
+        -----------
+        face_stats : Dict
+            Dictionary containing face detection statistics
+            
+        Returns:
+        --------
+        str
+            Formatted text analysis of detected faces and their features
+        """
+        # Handle case where no statistics are provided
+        if not face_stats:
+            return "No face detection data available."
+            
+        # Handle case where no faces were detected
+        if face_stats.get('total_faces', 0) == 0:
+            return "No faces detected in the image."
+        
+        # Build analysis report
+        analysis = []  # List to accumulate analysis text
+        
+        # Add header with total face count
+        analysis.append(f"👥 Detected {face_stats['total_faces']} face(s) in the image\n")
+        
+        # Add detailed information for each face
+        for face in face_stats.get('faces', []):
+            # Create description for individual face
+            face_desc = f"\n**Face {face['face_id']}:**"
+            
+            # Add position information
+            pos = face.get('position', {})
+            face_desc += f"\n  • Position: ({pos.get('x', 0)}, {pos.get('y', 0)})"
+            
+            # Add size information
+            face_desc += f"\n  • Size: {pos.get('width', 0)}x{pos.get('height', 0)} pixels"
+            
+            # Add eye detection information if eyes were found
+            if face.get('eyes_detected', 0) > 0:
+                face_desc += f"\n  • Eyes detected: {face['eyes_detected']}"
+            
+            # Add smile detection information
+            if face.get('smile_detected', False):
+                face_desc += "\n  • 😊 Smile detected!"
+            
+            analysis.append(face_desc)  # Add face description to analysis
+        
+        # Add summary statistics if smiles were detected
+        features = face_stats.get('features_detected', {})
+        smile_count = features.get('smiles', 0)
+        
+        if smile_count > 0:
+            # Calculate percentage of faces that are smiling
+            smile_ratio = (smile_count / face_stats['total_faces']) * 100
+            
+            # Add overall analysis section
+            analysis.append(f"\n\n📊 **Overall Analysis:**")
+            analysis.append(f"\n  • {smile_ratio:.0f}% of faces are smiling")
+            analysis.append(f"\n  • Total eyes detected: {features.get('eyes', 0)}")
+        
+        # Join all analysis parts and return
+        return "".join(analysis)
+
+
+# Create a global instance of FaceDetector for use throughout the application
+# This avoids reloading classifiers multiple times
+try:
+    face_detector = FaceDetector()
+    logger.info("Global face detector initialized successfully")
+except Exception as e:
+    logger.error(f"Failed to initialize global face detector: {str(e)}")
+    # Create a dummy detector that returns empty results
     face_detector = None

backend/openai_client.py

@@ -1,65 +1,65 @@
-import os
-from openai import OpenAI  # type: ignore
-import tempfile
-
-# Lazily initialized OpenAI client to avoid import-time errors when the
-# API key isn't configured. Previously this module attempted to create the
-# client on import and raised a ``ValueError`` if ``OPENAI_API_KEY`` was
-# missing, which prevented the rest of the application from running (and
-# broke tests that don't require the API). The client is now created only
-# when needed.
-_client: OpenAI | None = None
-
-
-def _get_client() -> OpenAI:
-    """Return a cached OpenAI client instance.
-
-    Raises:
-        ValueError: If the ``OPENAI_API_KEY`` environment variable is not set.
-    """
-    global _client
-    if _client is None:
-        api_key = os.getenv("OPENAI_API_KEY")
-        if not api_key:
-            raise ValueError("OPENAI_API_KEY environment variable is required but not set")
-        _client = OpenAI(api_key=api_key)
-    return _client
-
-
-def explain_detection(objects_list):
-    """Send detected objects to OpenAI and return an explanation."""
-    if not objects_list:
-        return "No objects detected."
-
-    prompt = f"Explain these detected objects in simple terms: {objects_list}"
-
-    client = _get_client()
-    response = client.chat.completions.create(
-        model="gpt-4o-mini",  # new lightweight chat model
-        messages=[{"role": "user", "content": prompt}],
-    )
-
-    return response.choices[0].message.content
-
-
-def generate_voice(text):
-    """Generate voice narration using OpenAI's TTS service."""
-    try:
-        client = _get_client()
-
-        # Generate speech using OpenAI TTS
-        response = client.audio.speech.create(
-            model="tts-1",
-            voice="alloy",  # You can change this to: alloy, echo, fable, onyx, nova, or shimmer
-            input=text,
-            response_format="mp3",
-        )
-
-        # Save the audio to a temporary file
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
-            temp_audio.write(response.content)
-            return temp_audio.name
-
-    except Exception as e:
-        print(f"Voice generation error: {e}")
-        return None
+import os
+from openai import OpenAI  # type: ignore
+import tempfile
+
+# Lazily initialized OpenAI client to avoid import-time errors when the
+# API key isn't configured. Previously this module attempted to create the
+# client on import and raised a ``ValueError`` if ``OPENAI_API_KEY`` was
+# missing, which prevented the rest of the application from running (and
+# broke tests that don't require the API). The client is now created only
+# when needed.
+_client: OpenAI | None = None
+
+
+def _get_client() -> OpenAI:
+    """Return a cached OpenAI client instance.
+
+    Raises:
+        ValueError: If the ``OPENAI_API_KEY`` environment variable is not set.
+    """
+    global _client
+    if _client is None:
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY environment variable is required but not set")
+        _client = OpenAI(api_key=api_key)
+    return _client
+
+
+def explain_detection(objects_list):
+    """Send detected objects to OpenAI and return an explanation."""
+    if not objects_list:
+        return "No objects detected."
+
+    prompt = f"Explain these detected objects in simple terms: {objects_list}"
+
+    client = _get_client()
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",  # new lightweight chat model
+        messages=[{"role": "user", "content": prompt}],
+    )
+
+    return response.choices[0].message.content
+
+
+def generate_voice(text):
+    """Generate voice narration using OpenAI's TTS service."""
+    try:
+        client = _get_client()
+
+        # Generate speech using OpenAI TTS
+        response = client.audio.speech.create(
+            model="tts-1",
+            voice="alloy",  # You can change this to: alloy, echo, fable, onyx, nova, or shimmer
+            input=text,
+            response_format="mp3",
+        )
+
+        # Save the audio to a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
+            temp_audio.write(response.content)
+            return temp_audio.name
+
+    except Exception as e:
+        print(f"Voice generation error: {e}")
+        return None

backend/prisma_client.py

@@ -1,400 +1,400 @@
-"""
-Prisma Client Integration for NAVADA 2.0
-Provides enhanced database operations with Prisma ORM
-"""
-
-import asyncio
-import json
-import base64
-import logging
-from typing import List, Dict, Optional, Any
-from datetime import datetime
-import numpy as np
-import cv2
-
-logger = logging.getLogger(__name__)
-
-class PrismaManager:
-    """Enhanced database manager using Prisma ORM"""
-
-    def __init__(self):
-        self.client = None
-        self._init_client()
-
-    def _init_client(self):
-        """Initialize Prisma client"""
-        try:
-            # Import Prisma client (needs to be generated first)
-            # from prisma import Prisma
-            # self.client = Prisma()
-            logger.info("Prisma client initialized")
-        except ImportError:
-            logger.warning("Prisma client not available - run 'npm run prisma:generate'")
-            self.client = None
-        except Exception as e:
-            logger.error(f"Failed to initialize Prisma client: {e}")
-            self.client = None
-
-    async def connect(self):
-        """Connect to database"""
-        if self.client:
-            try:
-                await self.client.connect()
-                logger.info("Connected to database via Prisma")
-                return True
-            except Exception as e:
-                logger.error(f"Failed to connect to database: {e}")
-                return False
-        return False
-
-    async def disconnect(self):
-        """Disconnect from database"""
-        if self.client:
-            try:
-                await self.client.disconnect()
-                logger.info("Disconnected from database")
-            except Exception as e:
-                logger.error(f"Error disconnecting: {e}")
-
-    # Document Management for Knowledge Retrieval
-    async def add_document(self, title: str, content: str, content_type: str = "text",
-                          tags: List[str] = None, category: str = None,
-                          image_data: bytes = None, image_url: str = None) -> Optional[int]:
-        """
-        Add document for knowledge retrieval
-
-        Args:
-            title: Document title
-            content: Document content (text)
-            content_type: "text", "image", "mixed"
-            tags: List of tags
-            category: Document category
-            image_data: Binary image data
-            image_url: URL to image
-
-        Returns:
-            Document ID if successful
-        """
-        if not self.client:
-            return None
-
-        try:
-            tags_str = json.dumps(tags) if tags else None
-
-            document = await self.client.document.create(
-                data={
-                    'title': title,
-                    'content': content,
-                    'contentType': content_type,
-                    'tags': tags_str,
-                    'category': category,
-                    'imageData': image_data,
-                    'imageUrl': image_url
-                }
-            )
-
-            # Create document chunks for better retrieval
-            await self._create_document_chunks(document.id, content)
-
-            logger.info(f"Added document: {title} (ID: {document.id})")
-            return document.id
-
-        except Exception as e:
-            logger.error(f"Failed to add document: {e}")
-            return None
-
-    async def _create_document_chunks(self, document_id: int, content: str, chunk_size: int = 500):
-        """Create chunks from document content for better retrieval"""
-        if not self.client:
-            return
-
-        try:
-            # Split content into chunks
-            chunks = [content[i:i+chunk_size] for i in range(0, len(content), chunk_size)]
-
-            for i, chunk in enumerate(chunks):
-                await self.client.documentchunk.create(
-                    data={
-                        'documentId': document_id,
-                        'chunkIndex': i,
-                        'content': chunk
-                    }
-                )
-
-        except Exception as e:
-            logger.error(f"Failed to create document chunks: {e}")
-
-    async def search_documents(self, query: str, content_type: str = None,
-                             category: str = None, limit: int = 10) -> List[Dict]:
-        """
-        Search documents by content, tags, or category
-
-        Args:
-            query: Search query
-            content_type: Filter by content type
-            category: Filter by category
-            limit: Maximum results
-
-        Returns:
-            List of matching documents
-        """
-        if not self.client:
-            return []
-
-        try:
-            where_clause = {
-                'isActive': True,
-                'OR': [
-                    {'title': {'contains': query}},
-                    {'content': {'contains': query}},
-                    {'tags': {'contains': query}}
-                ]
-            }
-
-            if content_type:
-                where_clause['contentType'] = content_type
-            if category:
-                where_clause['category'] = category
-
-            documents = await self.client.document.find_many(
-                where=where_clause,
-                take=limit,
-                order_by={'createdAt': 'desc'}
-            )
-
-            return [self._document_to_dict(doc) for doc in documents]
-
-        except Exception as e:
-            logger.error(f"Document search failed: {e}")
-            return []
-
-    def _document_to_dict(self, document) -> Dict:
-        """Convert Prisma document to dictionary"""
-        return {
-            'id': document.id,
-            'title': document.title,
-            'content': document.content,
-            'content_type': document.contentType,
-            'tags': json.loads(document.tags) if document.tags else [],
-            'category': document.category,
-            'image_url': document.imageUrl,
-            'created_at': document.createdAt,
-            'updated_at': document.updatedAt
-        }
-
-    # Media File Management
-    async def add_media_file(self, filename: str, filepath: str, mime_type: str,
-                           file_size: int, image_data: bytes = None,
-                           description: str = None, tags: List[str] = None) -> Optional[int]:
-        """Add media file to database"""
-        if not self.client:
-            return None
-
-        try:
-            tags_str = json.dumps(tags) if tags else None
-
-            media_file = await self.client.mediafile.create(
-                data={
-                    'filename': filename,
-                    'filepath': filepath,
-                    'mimeType': mime_type,
-                    'fileSize': file_size,
-                    'imageData': image_data,
-                    'description': description,
-                    'tags': tags_str
-                }
-            )
-
-            logger.info(f"Added media file: {filename} (ID: {media_file.id})")
-            return media_file.id
-
-        except Exception as e:
-            logger.error(f"Failed to add media file: {e}")
-            return None
-
-    async def get_media_files(self, tags: List[str] = None, mime_type: str = None,
-                            limit: int = 50) -> List[Dict]:
-        """Get media files with optional filtering"""
-        if not self.client:
-            return []
-
-        try:
-            where_clause = {'isActive': True}
-
-            if mime_type:
-                where_clause['mimeType'] = {'contains': mime_type}
-
-            if tags:
-                # Search for any of the provided tags
-                tag_conditions = [{'tags': {'contains': tag}} for tag in tags]
-                where_clause['OR'] = tag_conditions
-
-            media_files = await self.client.mediafile.find_many(
-                where=where_clause,
-                take=limit,
-                order_by={'createdAt': 'desc'}
-            )
-
-            return [self._media_file_to_dict(file) for file in media_files]
-
-        except Exception as e:
-            logger.error(f"Failed to get media files: {e}")
-            return []
-
-    def _media_file_to_dict(self, media_file) -> Dict:
-        """Convert Prisma media file to dictionary"""
-        return {
-            'id': media_file.id,
-            'filename': media_file.filename,
-            'filepath': media_file.filepath,
-            'mime_type': media_file.mimeType,
-            'file_size': media_file.fileSize,
-            'description': media_file.description,
-            'tags': json.loads(media_file.tags) if media_file.tags else [],
-            'created_at': media_file.createdAt
-        }
-
-    # Enhanced Knowledge Base Operations
-    async def add_knowledge_entry(self, entity_type: str, entity_id: int, content: str,
-                                title: str = None, description: str = None,
-                                tags: List[str] = None, category: str = None,
-                                image_url: str = None, text_content: str = None) -> Optional[int]:
-        """Add enhanced knowledge base entry"""
-        if not self.client:
-            return None
-
-        try:
-            keywords_str = json.dumps(tags) if tags else None
-
-            knowledge_entry = await self.client.knowledgebase.create(
-                data={
-                    'entityType': entity_type,
-                    'entityId': entity_id,
-                    'content': content,
-                    'title': title,
-                    'description': description,
-                    'keywords': keywords_str,
-                    'category': category,
-                    'imageUrl': image_url,
-                    'textContent': text_content
-                }
-            )
-
-            logger.info(f"Added knowledge entry: {title or content[:50]}")
-            return knowledge_entry.id
-
-        except Exception as e:
-            logger.error(f"Failed to add knowledge entry: {e}")
-            return None
-
-    async def search_knowledge(self, query: str, entity_type: str = None,
-                             category: str = None, limit: int = 10) -> List[Dict]:
-        """Enhanced knowledge search"""
-        if not self.client:
-            return []
-
-        try:
-            where_clause = {
-                'OR': [
-                    {'content': {'contains': query}},
-                    {'title': {'contains': query}},
-                    {'description': {'contains': query}},
-                    {'keywords': {'contains': query}},
-                    {'textContent': {'contains': query}}
-                ]
-            }
-
-            if entity_type:
-                where_clause['entityType'] = entity_type
-            if category:
-                where_clause['category'] = category
-
-            entries = await self.client.knowledgebase.find_many(
-                where=where_clause,
-                take=limit,
-                order_by={'createdAt': 'desc'}
-            )
-
-            return [self._knowledge_to_dict(entry) for entry in entries]
-
-        except Exception as e:
-            logger.error(f"Knowledge search failed: {e}")
-            return []
-
-    def _knowledge_to_dict(self, entry) -> Dict:
-        """Convert Prisma knowledge entry to dictionary"""
-        return {
-            'id': entry.id,
-            'entity_type': entry.entityType,
-            'entity_id': entry.entityId,
-            'content': entry.content,
-            'title': entry.title,
-            'description': entry.description,
-            'keywords': json.loads(entry.keywords) if entry.keywords else [],
-            'category': entry.category,
-            'image_url': entry.imageUrl,
-            'text_content': entry.textContent,
-            'created_at': entry.createdAt,
-            'updated_at': entry.updatedAt
-        }
-
-    # Statistics and Analytics
-    async def get_enhanced_stats(self) -> Dict:
-        """Get comprehensive database statistics"""
-        if not self.client:
-            return {}
-
-        try:
-            stats = {}
-
-            # Basic counts
-            stats['faces'] = await self.client.face.count(where={'isActive': True})
-            stats['objects'] = await self.client.object.count(where={'isActive': True})
-            stats['documents'] = await self.client.document.count(where={'isActive': True})
-            stats['media_files'] = await self.client.mediafile.count(where={'isActive': True})
-            stats['knowledge_entries'] = await self.client.knowledgebase.count()
-            stats['training_corrections'] = await self.client.trainingcorrection.count()
-
-            # Recent activity (last 7 days)
-            seven_days_ago = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-            stats['recent_detections'] = await self.client.detectionhistory.count(
-                where={'createdAt': {'gte': seven_days_ago}}
-            )
-
-            return stats
-
-        except Exception as e:
-            logger.error(f"Failed to get enhanced stats: {e}")
-            return {}
-
-# Global Prisma manager instance
-prisma_manager = PrismaManager()
-
-# Helper functions for async operations in Streamlit
-def run_async(coro):
-    """Run async function in Streamlit"""
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-
-    return loop.run_until_complete(coro)
-
-# Convenience functions
-def add_document_sync(title: str, content: str, **kwargs) -> Optional[int]:
-    """Synchronous wrapper for adding documents"""
-    return run_async(prisma_manager.add_document(title, content, **kwargs))
-
-def search_documents_sync(query: str, **kwargs) -> List[Dict]:
-    """Synchronous wrapper for searching documents"""
-    return run_async(prisma_manager.search_documents(query, **kwargs))
-
-def add_media_file_sync(filename: str, filepath: str, mime_type: str,
-                       file_size: int, **kwargs) -> Optional[int]:
-    """Synchronous wrapper for adding media files"""
-    return run_async(prisma_manager.add_media_file(filename, filepath, mime_type, file_size, **kwargs))
-
-def get_enhanced_stats_sync() -> Dict:
-    """Synchronous wrapper for getting stats"""
+"""
+Prisma Client Integration for NAVADA 2.0
+Provides enhanced database operations with Prisma ORM
+"""
+
+import asyncio
+import json
+import base64
+import logging
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+import numpy as np
+import cv2
+
+logger = logging.getLogger(__name__)
+
+class PrismaManager:
+    """Enhanced database manager using Prisma ORM"""
+
+    def __init__(self):
+        self.client = None
+        self._init_client()
+
+    def _init_client(self):
+        """Initialize Prisma client"""
+        try:
+            # Import Prisma client (needs to be generated first)
+            # from prisma import Prisma
+            # self.client = Prisma()
+            logger.info("Prisma client initialized")
+        except ImportError:
+            logger.warning("Prisma client not available - run 'npm run prisma:generate'")
+            self.client = None
+        except Exception as e:
+            logger.error(f"Failed to initialize Prisma client: {e}")
+            self.client = None
+
+    async def connect(self):
+        """Connect to database"""
+        if self.client:
+            try:
+                await self.client.connect()
+                logger.info("Connected to database via Prisma")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to connect to database: {e}")
+                return False
+        return False
+
+    async def disconnect(self):
+        """Disconnect from database"""
+        if self.client:
+            try:
+                await self.client.disconnect()
+                logger.info("Disconnected from database")
+            except Exception as e:
+                logger.error(f"Error disconnecting: {e}")
+
+    # Document Management for Knowledge Retrieval
+    async def add_document(self, title: str, content: str, content_type: str = "text",
+                          tags: List[str] = None, category: str = None,
+                          image_data: bytes = None, image_url: str = None) -> Optional[int]:
+        """
+        Add document for knowledge retrieval
+
+        Args:
+            title: Document title
+            content: Document content (text)
+            content_type: "text", "image", "mixed"
+            tags: List of tags
+            category: Document category
+            image_data: Binary image data
+            image_url: URL to image
+
+        Returns:
+            Document ID if successful
+        """
+        if not self.client:
+            return None
+
+        try:
+            tags_str = json.dumps(tags) if tags else None
+
+            document = await self.client.document.create(
+                data={
+                    'title': title,
+                    'content': content,
+                    'contentType': content_type,
+                    'tags': tags_str,
+                    'category': category,
+                    'imageData': image_data,
+                    'imageUrl': image_url
+                }
+            )
+
+            # Create document chunks for better retrieval
+            await self._create_document_chunks(document.id, content)
+
+            logger.info(f"Added document: {title} (ID: {document.id})")
+            return document.id
+
+        except Exception as e:
+            logger.error(f"Failed to add document: {e}")
+            return None
+
+    async def _create_document_chunks(self, document_id: int, content: str, chunk_size: int = 500):
+        """Create chunks from document content for better retrieval"""
+        if not self.client:
+            return
+
+        try:
+            # Split content into chunks
+            chunks = [content[i:i+chunk_size] for i in range(0, len(content), chunk_size)]
+
+            for i, chunk in enumerate(chunks):
+                await self.client.documentchunk.create(
+                    data={
+                        'documentId': document_id,
+                        'chunkIndex': i,
+                        'content': chunk
+                    }
+                )
+
+        except Exception as e:
+            logger.error(f"Failed to create document chunks: {e}")
+
+    async def search_documents(self, query: str, content_type: str = None,
+                             category: str = None, limit: int = 10) -> List[Dict]:
+        """
+        Search documents by content, tags, or category
+
+        Args:
+            query: Search query
+            content_type: Filter by content type
+            category: Filter by category
+            limit: Maximum results
+
+        Returns:
+            List of matching documents
+        """
+        if not self.client:
+            return []
+
+        try:
+            where_clause = {
+                'isActive': True,
+                'OR': [
+                    {'title': {'contains': query}},
+                    {'content': {'contains': query}},
+                    {'tags': {'contains': query}}
+                ]
+            }
+
+            if content_type:
+                where_clause['contentType'] = content_type
+            if category:
+                where_clause['category'] = category
+
+            documents = await self.client.document.find_many(
+                where=where_clause,
+                take=limit,
+                order_by={'createdAt': 'desc'}
+            )
+
+            return [self._document_to_dict(doc) for doc in documents]
+
+        except Exception as e:
+            logger.error(f"Document search failed: {e}")
+            return []
+
+    def _document_to_dict(self, document) -> Dict:
+        """Convert Prisma document to dictionary"""
+        return {
+            'id': document.id,
+            'title': document.title,
+            'content': document.content,
+            'content_type': document.contentType,
+            'tags': json.loads(document.tags) if document.tags else [],
+            'category': document.category,
+            'image_url': document.imageUrl,
+            'created_at': document.createdAt,
+            'updated_at': document.updatedAt
+        }
+
+    # Media File Management
+    async def add_media_file(self, filename: str, filepath: str, mime_type: str,
+                           file_size: int, image_data: bytes = None,
+                           description: str = None, tags: List[str] = None) -> Optional[int]:
+        """Add media file to database"""
+        if not self.client:
+            return None
+
+        try:
+            tags_str = json.dumps(tags) if tags else None
+
+            media_file = await self.client.mediafile.create(
+                data={
+                    'filename': filename,
+                    'filepath': filepath,
+                    'mimeType': mime_type,
+                    'fileSize': file_size,
+                    'imageData': image_data,
+                    'description': description,
+                    'tags': tags_str
+                }
+            )
+
+            logger.info(f"Added media file: {filename} (ID: {media_file.id})")
+            return media_file.id
+
+        except Exception as e:
+            logger.error(f"Failed to add media file: {e}")
+            return None
+
+    async def get_media_files(self, tags: List[str] = None, mime_type: str = None,
+                            limit: int = 50) -> List[Dict]:
+        """Get media files with optional filtering"""
+        if not self.client:
+            return []
+
+        try:
+            where_clause = {'isActive': True}
+
+            if mime_type:
+                where_clause['mimeType'] = {'contains': mime_type}
+
+            if tags:
+                # Search for any of the provided tags
+                tag_conditions = [{'tags': {'contains': tag}} for tag in tags]
+                where_clause['OR'] = tag_conditions
+
+            media_files = await self.client.mediafile.find_many(
+                where=where_clause,
+                take=limit,
+                order_by={'createdAt': 'desc'}
+            )
+
+            return [self._media_file_to_dict(file) for file in media_files]
+
+        except Exception as e:
+            logger.error(f"Failed to get media files: {e}")
+            return []
+
+    def _media_file_to_dict(self, media_file) -> Dict:
+        """Convert Prisma media file to dictionary"""
+        return {
+            'id': media_file.id,
+            'filename': media_file.filename,
+            'filepath': media_file.filepath,
+            'mime_type': media_file.mimeType,
+            'file_size': media_file.fileSize,
+            'description': media_file.description,
+            'tags': json.loads(media_file.tags) if media_file.tags else [],
+            'created_at': media_file.createdAt
+        }
+
+    # Enhanced Knowledge Base Operations
+    async def add_knowledge_entry(self, entity_type: str, entity_id: int, content: str,
+                                title: str = None, description: str = None,
+                                tags: List[str] = None, category: str = None,
+                                image_url: str = None, text_content: str = None) -> Optional[int]:
+        """Add enhanced knowledge base entry"""
+        if not self.client:
+            return None
+
+        try:
+            keywords_str = json.dumps(tags) if tags else None
+
+            knowledge_entry = await self.client.knowledgebase.create(
+                data={
+                    'entityType': entity_type,
+                    'entityId': entity_id,
+                    'content': content,
+                    'title': title,
+                    'description': description,
+                    'keywords': keywords_str,
+                    'category': category,
+                    'imageUrl': image_url,
+                    'textContent': text_content
+                }
+            )
+
+            logger.info(f"Added knowledge entry: {title or content[:50]}")
+            return knowledge_entry.id
+
+        except Exception as e:
+            logger.error(f"Failed to add knowledge entry: {e}")
+            return None
+
+    async def search_knowledge(self, query: str, entity_type: str = None,
+                             category: str = None, limit: int = 10) -> List[Dict]:
+        """Enhanced knowledge search"""
+        if not self.client:
+            return []
+
+        try:
+            where_clause = {
+                'OR': [
+                    {'content': {'contains': query}},
+                    {'title': {'contains': query}},
+                    {'description': {'contains': query}},
+                    {'keywords': {'contains': query}},
+                    {'textContent': {'contains': query}}
+                ]
+            }
+
+            if entity_type:
+                where_clause['entityType'] = entity_type
+            if category:
+                where_clause['category'] = category
+
+            entries = await self.client.knowledgebase.find_many(
+                where=where_clause,
+                take=limit,
+                order_by={'createdAt': 'desc'}
+            )
+
+            return [self._knowledge_to_dict(entry) for entry in entries]
+
+        except Exception as e:
+            logger.error(f"Knowledge search failed: {e}")
+            return []
+
+    def _knowledge_to_dict(self, entry) -> Dict:
+        """Convert Prisma knowledge entry to dictionary"""
+        return {
+            'id': entry.id,
+            'entity_type': entry.entityType,
+            'entity_id': entry.entityId,
+            'content': entry.content,
+            'title': entry.title,
+            'description': entry.description,
+            'keywords': json.loads(entry.keywords) if entry.keywords else [],
+            'category': entry.category,
+            'image_url': entry.imageUrl,
+            'text_content': entry.textContent,
+            'created_at': entry.createdAt,
+            'updated_at': entry.updatedAt
+        }
+
+    # Statistics and Analytics
+    async def get_enhanced_stats(self) -> Dict:
+        """Get comprehensive database statistics"""
+        if not self.client:
+            return {}
+
+        try:
+            stats = {}
+
+            # Basic counts
+            stats['faces'] = await self.client.face.count(where={'isActive': True})
+            stats['objects'] = await self.client.object.count(where={'isActive': True})
+            stats['documents'] = await self.client.document.count(where={'isActive': True})
+            stats['media_files'] = await self.client.mediafile.count(where={'isActive': True})
+            stats['knowledge_entries'] = await self.client.knowledgebase.count()
+            stats['training_corrections'] = await self.client.trainingcorrection.count()
+
+            # Recent activity (last 7 days)
+            seven_days_ago = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+            stats['recent_detections'] = await self.client.detectionhistory.count(
+                where={'createdAt': {'gte': seven_days_ago}}
+            )
+
+            return stats
+
+        except Exception as e:
+            logger.error(f"Failed to get enhanced stats: {e}")
+            return {}
+
+# Global Prisma manager instance
+prisma_manager = PrismaManager()
+
+# Helper functions for async operations in Streamlit
+def run_async(coro):
+    """Run async function in Streamlit"""
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    return loop.run_until_complete(coro)
+
+# Convenience functions
+def add_document_sync(title: str, content: str, **kwargs) -> Optional[int]:
+    """Synchronous wrapper for adding documents"""
+    return run_async(prisma_manager.add_document(title, content, **kwargs))
+
+def search_documents_sync(query: str, **kwargs) -> List[Dict]:
+    """Synchronous wrapper for searching documents"""
+    return run_async(prisma_manager.search_documents(query, **kwargs))
+
+def add_media_file_sync(filename: str, filepath: str, mime_type: str,
+                       file_size: int, **kwargs) -> Optional[int]:
+    """Synchronous wrapper for adding media files"""
+    return run_async(prisma_manager.add_media_file(filename, filepath, mime_type, file_size, **kwargs))
+
+def get_enhanced_stats_sync() -> Dict:
+    """Synchronous wrapper for getting stats"""
     return run_async(prisma_manager.get_enhanced_stats())

backend/recognition.py

@@ -1,367 +1,367 @@
-"""
-Advanced Recognition Module for NAVADA
-Handles face recognition, custom object detection, and RAG-enhanced identification
-"""
-
-import cv2
-import numpy as np
-from typing import List, Dict, Tuple, Optional
-import logging
-from .database import db
-from .face_detection import face_detector
-import time
-import uuid
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-class NAVADARecognition:
-    """Advanced recognition system with database integration"""
-    
-    def __init__(self):
-        """Initialize recognition system"""
-        self.face_threshold = 0.6  # Face recognition threshold
-        self.object_threshold = 0.5  # Object recognition threshold
-        self.session_id = str(uuid.uuid4())
-        
-    def extract_face_encoding(self, face_image: np.ndarray) -> Optional[np.ndarray]:
-        """
-        Extract face encoding for recognition
-        This is a simplified version - in production, use face_recognition library
-        """
-        try:
-            # Convert to grayscale and resize
-            gray = cv2.cvtColor(face_image, cv2.COLOR_RGB2GRAY)
-            resized = cv2.resize(gray, (128, 128))
-            
-            # Flatten and normalize as simple encoding
-            encoding = resized.flatten().astype(np.float64)
-            encoding = encoding / np.linalg.norm(encoding)  # Normalize
-            
-            return encoding
-            
-        except Exception as e:
-            logger.error(f"Face encoding extraction failed: {e}")
-            return None
-    
-    def compare_face_encodings(self, encoding1: np.ndarray, encoding2: np.ndarray) -> float:
-        """Compare two face encodings and return similarity score"""
-        try:
-            # Calculate cosine similarity
-            similarity = np.dot(encoding1, encoding2) / (
-                np.linalg.norm(encoding1) * np.linalg.norm(encoding2)
-            )
-            return float(similarity)
-            
-        except Exception as e:
-            logger.error(f"Face comparison failed: {e}")
-            return 0.0
-    
-    def recognize_faces(self, image: np.ndarray) -> Tuple[np.ndarray, List[Dict]]:
-        """
-        Recognize faces in image against database
-        
-        Returns:
-            Annotated image and list of recognition results
-        """
-        try:
-            if not db:
-                return image, []
-            
-            # Detect faces first
-            annotated_img, face_stats = face_detector.detect_faces(image)
-            
-            # Get known faces from database
-            known_faces = db.get_faces()
-            
-            recognition_results = []
-            
-            if face_stats and face_stats['faces']:
-                for face_info in face_stats['faces']:
-                    # Extract face region
-                    pos = face_info['position']
-                    x, y, w, h = pos['x'], pos['y'], pos['width'], pos['height']
-                    face_region = image[y:y+h, x:x+w]
-                    
-                    if face_region.size > 0:
-                        # Extract face encoding
-                        face_encoding = self.extract_face_encoding(face_region)
-                        
-                        if face_encoding is not None:
-                            # Compare with known faces
-                            best_match = None
-                            best_similarity = 0.0
-                            
-                            for known_face in known_faces:
-                                similarity = self.compare_face_encodings(
-                                    face_encoding, known_face['encoding']
-                                )
-                                
-                                if similarity > best_similarity and similarity > self.face_threshold:
-                                    best_similarity = similarity
-                                    best_match = known_face
-                            
-                            # Add recognition result
-                            if best_match:
-                                # Draw name on image
-                                name = best_match['name']
-                                cv2.putText(annotated_img, f"{name} ({best_similarity:.2f})", 
-                                          (x, y-30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, 
-                                          (0, 255, 0), 2)
-                                
-                                recognition_results.append({
-                                    'face_id': face_info['face_id'],
-                                    'name': name,
-                                    'similarity': best_similarity,
-                                    'position': pos,
-                                    'database_id': best_match['id']
-                                })
-                            else:
-                                # Unknown face
-                                cv2.putText(annotated_img, "Unknown", 
-                                          (x, y-30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, 
-                                          (0, 0, 255), 2)
-                                
-                                recognition_results.append({
-                                    'face_id': face_info['face_id'],
-                                    'name': 'Unknown',
-                                    'similarity': 0.0,
-                                    'position': pos,
-                                    'database_id': None
-                                })
-            
-            return annotated_img, recognition_results
-            
-        except Exception as e:
-            logger.error(f"Face recognition failed: {e}")
-            return image, []
-    
-    def add_new_face(self, image: np.ndarray, name: str, face_region: Tuple = None) -> bool:
-        """
-        Add a new face to the database
-        
-        Args:
-            image: Full image containing the face
-            name: Person's name
-            face_region: Optional (x, y, w, h) region, if None will detect automatically
-            
-        Returns:
-            Success status
-        """
-        try:
-            if not db:
-                logger.error("Database not available")
-                return False
-            
-            if face_region:
-                # Use provided region
-                x, y, w, h = face_region
-                face_img = image[y:y+h, x:x+w]
-            else:
-                # Detect face automatically
-                _, face_stats = face_detector.detect_faces(image)
-                
-                if not face_stats or not face_stats['faces']:
-                    logger.error("No face detected in image")
-                    return False
-                
-                # Use first detected face
-                pos = face_stats['faces'][0]['position']
-                x, y, w, h = pos['x'], pos['y'], pos['width'], pos['height']
-                face_img = image[y:y+h, x:x+w]
-            
-            # Extract encoding
-            encoding = self.extract_face_encoding(face_img)
-            if encoding is None:
-                logger.error("Failed to extract face encoding")
-                return False
-            
-            # Add to database
-            face_id = db.add_face(
-                name=name,
-                face_encoding=encoding,
-                image=face_img,
-                confidence=0.9,
-                metadata={
-                    'source': 'user_added',
-                    'session_id': self.session_id,
-                    'timestamp': time.time()
-                }
-            )
-            
-            logger.info(f"Added new face '{name}' with ID {face_id}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to add new face: {e}")
-            return False
-    
-    def add_custom_object(self, image: np.ndarray, label: str, category: str, 
-                         bbox: Tuple = None) -> bool:
-        """
-        Add a custom object to the database
-        
-        Args:
-            image: Full image containing the object
-            label: Object label/name
-            category: Object category
-            bbox: Optional (x, y, w, h) bounding box
-            
-        Returns:
-            Success status
-        """
-        try:
-            if not db:
-                logger.error("Database not available")
-                return False
-            
-            if bbox:
-                # Use provided bounding box
-                x, y, w, h = bbox
-                object_img = image[y:y+h, x:x+w]
-            else:
-                # Use entire image as object
-                object_img = image
-                bbox = (0, 0, image.shape[1], image.shape[0])
-            
-            # Extract simple features (can be enhanced with deep learning)
-            features = self.extract_object_features(object_img)
-            
-            # Add to database
-            object_id = db.add_object(
-                label=label,
-                category=category,
-                features=features,
-                image=object_img,
-                bounding_box=bbox,
-                confidence=0.8,
-                metadata={
-                    'source': 'user_added',
-                    'session_id': self.session_id,
-                    'timestamp': time.time()
-                }
-            )
-            
-            logger.info(f"Added custom object '{label}' with ID {object_id}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to add custom object: {e}")
-            return False
-    
-    def extract_object_features(self, object_img: np.ndarray) -> np.ndarray:
-        """Extract features from object image (simplified implementation)"""
-        try:
-            # Convert to grayscale and resize
-            gray = cv2.cvtColor(object_img, cv2.COLOR_RGB2GRAY)
-            resized = cv2.resize(gray, (64, 64))
-            
-            # Extract histogram features
-            hist = cv2.calcHist([resized], [0], None, [256], [0, 256])
-            hist_normalized = hist.flatten() / hist.sum()
-            
-            # Extract edge features
-            edges = cv2.Canny(resized, 50, 150)
-            edge_density = edges.sum() / edges.size
-            
-            # Combine features
-            features = np.concatenate([hist_normalized, [edge_density]])
-            
-            return features.astype(np.float64)
-            
-        except Exception as e:
-            logger.error(f"Feature extraction failed: {e}")
-            return np.array([])
-    
-    def enhance_with_rag(self, detections: List, face_matches: List = None) -> str:
-        """
-        Use RAG to enhance detection results with context
-        
-        Args:
-            detections: List of detected objects
-            face_matches: List of face recognition results
-            
-        Returns:
-            Enhanced description with context
-        """
-        try:
-            if not db:
-                return "Enhanced analysis not available (database offline)"
-            
-            # Build search queries from detections
-            queries = []
-            
-            # Add object queries
-            for detection in detections:
-                queries.append(detection)
-            
-            # Add face queries
-            if face_matches:
-                for match in face_matches:
-                    if match['name'] != 'Unknown':
-                        queries.append(match['name'])
-            
-            # Search knowledge base
-            knowledge_results = []
-            for query in queries:
-                results = db.search_knowledge(query)
-                knowledge_results.extend(results)
-            
-            # Build enhanced description
-            if knowledge_results:
-                enhanced_desc = "🧠 **Enhanced Analysis with Context:**\n\n"
-                
-                # Group by entity type
-                face_context = [r for r in knowledge_results if r['entity_type'] == 'face']
-                object_context = [r for r in knowledge_results if r['entity_type'] == 'object']
-                
-                if face_context:
-                    enhanced_desc += "👥 **Known Individuals:**\n"
-                    for ctx in face_context[:3]:  # Limit to 3 results
-                        enhanced_desc += f"  • {ctx['content']}\n"
-                    enhanced_desc += "\n"
-                
-                if object_context:
-                    enhanced_desc += "🏷️ **Recognized Objects:**\n"
-                    for ctx in object_context[:3]:  # Limit to 3 results
-                        enhanced_desc += f"  • {ctx['content']}\n"
-                    enhanced_desc += "\n"
-                
-                enhanced_desc += "📊 **Context Insights:**\n"
-                enhanced_desc += f"  • Found {len(knowledge_results)} relevant knowledge entries\n"
-                enhanced_desc += f"  • Analysis includes both detected and learned objects\n"
-                
-                return enhanced_desc
-            else:
-                return "🔍 **Context Analysis:** No additional context found in knowledge base."
-                
-        except Exception as e:
-            logger.error(f"RAG enhancement failed: {e}")
-            return "❌ Enhanced analysis unavailable due to processing error."
-    
-    def save_session_data(self, image: np.ndarray, detections: List, 
-                         face_matches: List = None, processing_time: float = 0.0):
-        """Save current session data to database"""
-        try:
-            if db:
-                db.save_detection_history(
-                    session_id=self.session_id,
-                    image=image,
-                    detections=detections,
-                    face_matches=face_matches,
-                    processing_time=processing_time,
-                    metadata={
-                        'timestamp': time.time(),
-                        'version': '2.0'
-                    }
-                )
-        except Exception as e:
-            logger.error(f"Failed to save session data: {e}")
-
-# Global recognition instance
-try:
-    recognition_system = NAVADARecognition()
-    logger.info("Recognition system initialized successfully")
-except Exception as e:
-    logger.error(f"Failed to initialize recognition system: {e}")
+"""
+Advanced Recognition Module for NAVADA
+Handles face recognition, custom object detection, and RAG-enhanced identification
+"""
+
+import cv2
+import numpy as np
+from typing import List, Dict, Tuple, Optional
+import logging
+from .database import db
+from .face_detection import face_detector
+import time
+import uuid
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class NAVADARecognition:
+    """Advanced recognition system with database integration"""
+    
+    def __init__(self):
+        """Initialize recognition system"""
+        self.face_threshold = 0.6  # Face recognition threshold
+        self.object_threshold = 0.5  # Object recognition threshold
+        self.session_id = str(uuid.uuid4())
+        
+    def extract_face_encoding(self, face_image: np.ndarray) -> Optional[np.ndarray]:
+        """
+        Extract face encoding for recognition
+        This is a simplified version - in production, use face_recognition library
+        """
+        try:
+            # Convert to grayscale and resize
+            gray = cv2.cvtColor(face_image, cv2.COLOR_RGB2GRAY)
+            resized = cv2.resize(gray, (128, 128))
+            
+            # Flatten and normalize as simple encoding
+            encoding = resized.flatten().astype(np.float64)
+            encoding = encoding / np.linalg.norm(encoding)  # Normalize
+            
+            return encoding
+            
+        except Exception as e:
+            logger.error(f"Face encoding extraction failed: {e}")
+            return None
+    
+    def compare_face_encodings(self, encoding1: np.ndarray, encoding2: np.ndarray) -> float:
+        """Compare two face encodings and return similarity score"""
+        try:
+            # Calculate cosine similarity
+            similarity = np.dot(encoding1, encoding2) / (
+                np.linalg.norm(encoding1) * np.linalg.norm(encoding2)
+            )
+            return float(similarity)
+            
+        except Exception as e:
+            logger.error(f"Face comparison failed: {e}")
+            return 0.0
+    
+    def recognize_faces(self, image: np.ndarray) -> Tuple[np.ndarray, List[Dict]]:
+        """
+        Recognize faces in image against database
+        
+        Returns:
+            Annotated image and list of recognition results
+        """
+        try:
+            if not db:
+                return image, []
+            
+            # Detect faces first
+            annotated_img, face_stats = face_detector.detect_faces(image)
+            
+            # Get known faces from database
+            known_faces = db.get_faces()
+            
+            recognition_results = []
+            
+            if face_stats and face_stats['faces']:
+                for face_info in face_stats['faces']:
+                    # Extract face region
+                    pos = face_info['position']
+                    x, y, w, h = pos['x'], pos['y'], pos['width'], pos['height']
+                    face_region = image[y:y+h, x:x+w]
+                    
+                    if face_region.size > 0:
+                        # Extract face encoding
+                        face_encoding = self.extract_face_encoding(face_region)
+                        
+                        if face_encoding is not None:
+                            # Compare with known faces
+                            best_match = None
+                            best_similarity = 0.0
+                            
+                            for known_face in known_faces:
+                                similarity = self.compare_face_encodings(
+                                    face_encoding, known_face['encoding']
+                                )
+                                
+                                if similarity > best_similarity and similarity > self.face_threshold:
+                                    best_similarity = similarity
+                                    best_match = known_face
+                            
+                            # Add recognition result
+                            if best_match:
+                                # Draw name on image
+                                name = best_match['name']
+                                cv2.putText(annotated_img, f"{name} ({best_similarity:.2f})", 
+                                          (x, y-30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, 
+                                          (0, 255, 0), 2)
+                                
+                                recognition_results.append({
+                                    'face_id': face_info['face_id'],
+                                    'name': name,
+                                    'similarity': best_similarity,
+                                    'position': pos,
+                                    'database_id': best_match['id']
+                                })
+                            else:
+                                # Unknown face
+                                cv2.putText(annotated_img, "Unknown", 
+                                          (x, y-30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, 
+                                          (0, 0, 255), 2)
+                                
+                                recognition_results.append({
+                                    'face_id': face_info['face_id'],
+                                    'name': 'Unknown',
+                                    'similarity': 0.0,
+                                    'position': pos,
+                                    'database_id': None
+                                })
+            
+            return annotated_img, recognition_results
+            
+        except Exception as e:
+            logger.error(f"Face recognition failed: {e}")
+            return image, []
+    
+    def add_new_face(self, image: np.ndarray, name: str, face_region: Tuple = None) -> bool:
+        """
+        Add a new face to the database
+        
+        Args:
+            image: Full image containing the face
+            name: Person's name
+            face_region: Optional (x, y, w, h) region, if None will detect automatically
+            
+        Returns:
+            Success status
+        """
+        try:
+            if not db:
+                logger.error("Database not available")
+                return False
+            
+            if face_region:
+                # Use provided region
+                x, y, w, h = face_region
+                face_img = image[y:y+h, x:x+w]
+            else:
+                # Detect face automatically
+                _, face_stats = face_detector.detect_faces(image)
+                
+                if not face_stats or not face_stats['faces']:
+                    logger.error("No face detected in image")
+                    return False
+                
+                # Use first detected face
+                pos = face_stats['faces'][0]['position']
+                x, y, w, h = pos['x'], pos['y'], pos['width'], pos['height']
+                face_img = image[y:y+h, x:x+w]
+            
+            # Extract encoding
+            encoding = self.extract_face_encoding(face_img)
+            if encoding is None:
+                logger.error("Failed to extract face encoding")
+                return False
+            
+            # Add to database
+            face_id = db.add_face(
+                name=name,
+                face_encoding=encoding,
+                image=face_img,
+                confidence=0.9,
+                metadata={
+                    'source': 'user_added',
+                    'session_id': self.session_id,
+                    'timestamp': time.time()
+                }
+            )
+            
+            logger.info(f"Added new face '{name}' with ID {face_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to add new face: {e}")
+            return False
+    
+    def add_custom_object(self, image: np.ndarray, label: str, category: str, 
+                         bbox: Tuple = None) -> bool:
+        """
+        Add a custom object to the database
+        
+        Args:
+            image: Full image containing the object
+            label: Object label/name
+            category: Object category
+            bbox: Optional (x, y, w, h) bounding box
+            
+        Returns:
+            Success status
+        """
+        try:
+            if not db:
+                logger.error("Database not available")
+                return False
+            
+            if bbox:
+                # Use provided bounding box
+                x, y, w, h = bbox
+                object_img = image[y:y+h, x:x+w]
+            else:
+                # Use entire image as object
+                object_img = image
+                bbox = (0, 0, image.shape[1], image.shape[0])
+            
+            # Extract simple features (can be enhanced with deep learning)
+            features = self.extract_object_features(object_img)
+            
+            # Add to database
+            object_id = db.add_object(
+                label=label,
+                category=category,
+                features=features,
+                image=object_img,
+                bounding_box=bbox,
+                confidence=0.8,
+                metadata={
+                    'source': 'user_added',
+                    'session_id': self.session_id,
+                    'timestamp': time.time()
+                }
+            )
+            
+            logger.info(f"Added custom object '{label}' with ID {object_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to add custom object: {e}")
+            return False
+    
+    def extract_object_features(self, object_img: np.ndarray) -> np.ndarray:
+        """Extract features from object image (simplified implementation)"""
+        try:
+            # Convert to grayscale and resize
+            gray = cv2.cvtColor(object_img, cv2.COLOR_RGB2GRAY)
+            resized = cv2.resize(gray, (64, 64))
+            
+            # Extract histogram features
+            hist = cv2.calcHist([resized], [0], None, [256], [0, 256])
+            hist_normalized = hist.flatten() / hist.sum()
+            
+            # Extract edge features
+            edges = cv2.Canny(resized, 50, 150)
+            edge_density = edges.sum() / edges.size
+            
+            # Combine features
+            features = np.concatenate([hist_normalized, [edge_density]])
+            
+            return features.astype(np.float64)
+            
+        except Exception as e:
+            logger.error(f"Feature extraction failed: {e}")
+            return np.array([])
+    
+    def enhance_with_rag(self, detections: List, face_matches: List = None) -> str:
+        """
+        Use RAG to enhance detection results with context
+        
+        Args:
+            detections: List of detected objects
+            face_matches: List of face recognition results
+            
+        Returns:
+            Enhanced description with context
+        """
+        try:
+            if not db:
+                return "Enhanced analysis not available (database offline)"
+            
+            # Build search queries from detections
+            queries = []
+            
+            # Add object queries
+            for detection in detections:
+                queries.append(detection)
+            
+            # Add face queries
+            if face_matches:
+                for match in face_matches:
+                    if match['name'] != 'Unknown':
+                        queries.append(match['name'])
+            
+            # Search knowledge base
+            knowledge_results = []
+            for query in queries:
+                results = db.search_knowledge(query)
+                knowledge_results.extend(results)
+            
+            # Build enhanced description
+            if knowledge_results:
+                enhanced_desc = "🧠 **Enhanced Analysis with Context:**\n\n"
+                
+                # Group by entity type
+                face_context = [r for r in knowledge_results if r['entity_type'] == 'face']
+                object_context = [r for r in knowledge_results if r['entity_type'] == 'object']
+                
+                if face_context:
+                    enhanced_desc += "👥 **Known Individuals:**\n"
+                    for ctx in face_context[:3]:  # Limit to 3 results
+                        enhanced_desc += f"  • {ctx['content']}\n"
+                    enhanced_desc += "\n"
+                
+                if object_context:
+                    enhanced_desc += "🏷️ **Recognized Objects:**\n"
+                    for ctx in object_context[:3]:  # Limit to 3 results
+                        enhanced_desc += f"  • {ctx['content']}\n"
+                    enhanced_desc += "\n"
+                
+                enhanced_desc += "📊 **Context Insights:**\n"
+                enhanced_desc += f"  • Found {len(knowledge_results)} relevant knowledge entries\n"
+                enhanced_desc += f"  • Analysis includes both detected and learned objects\n"
+                
+                return enhanced_desc
+            else:
+                return "🔍 **Context Analysis:** No additional context found in knowledge base."
+                
+        except Exception as e:
+            logger.error(f"RAG enhancement failed: {e}")
+            return "❌ Enhanced analysis unavailable due to processing error."
+    
+    def save_session_data(self, image: np.ndarray, detections: List, 
+                         face_matches: List = None, processing_time: float = 0.0):
+        """Save current session data to database"""
+        try:
+            if db:
+                db.save_detection_history(
+                    session_id=self.session_id,
+                    image=image,
+                    detections=detections,
+                    face_matches=face_matches,
+                    processing_time=processing_time,
+                    metadata={
+                        'timestamp': time.time(),
+                        'version': '2.0'
+                    }
+                )
+        except Exception as e:
+            logger.error(f"Failed to save session data: {e}")
+
+# Global recognition instance
+try:
+    recognition_system = NAVADARecognition()
+    logger.info("Recognition system initialized successfully")
+except Exception as e:
+    logger.error(f"Failed to initialize recognition system: {e}")
     recognition_system = None

backend/two_stage_inference.py

@@ -1,285 +1,285 @@
-"""
-Two-Stage Inference System
-Combines YOLO detection with custom classifier for improved accuracy
-"""
-import torch
-import torchvision.transforms as transforms
-import numpy as np
-import cv2
-from typing import List, Dict, Tuple, Optional
-import pickle
-from pathlib import Path
-import logging
-
-from .yolo_enhanced import detect_objects_enhanced, model as yolo_model
-from .custom_trainer import CustomClassifier
-
-logger = logging.getLogger(__name__)
-
-class TwoStageInference:
-    """Two-stage detection and classification system"""
-    
-    def __init__(self, models_dir='models/'):
-        """
-        Initialize two-stage inference system
-        
-        Args:
-            models_dir: Directory containing trained custom models
-        """
-        self.models_dir = Path(models_dir)
-        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        
-        # Load active custom model if available
-        self.custom_model = None
-        self.class_info = None
-        self.load_active_model()
-        
-        # Image preprocessing for custom classifier
-        self.preprocess = transforms.Compose([
-            transforms.ToPILImage(),
-            transforms.Resize((224, 224)),
-            transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-        ])
-    
-    def load_active_model(self):
-        """Load the most recent trained custom model"""
-        try:
-            # Find latest model file
-            model_files = list(self.models_dir.glob('custom_classifier_*.pkl'))
-            if not model_files:
-                logger.info("No custom models found. Using YOLO only.")
-                return
-            
-            # Get most recent model
-            latest_model = max(model_files, key=lambda x: x.stat().st_mtime)
-            
-            # Load model info
-            with open(latest_model, 'rb') as f:
-                model_info = pickle.load(f)
-            
-            self.class_info = model_info['class_info']
-            
-            # Initialize and load custom model
-            self.custom_model = CustomClassifier(
-                num_classes=self.class_info['num_classes'],
-                backbone=model_info['training_config']['backbone']
-            )
-            self.custom_model.load_state_dict(model_info['model_state'])
-            self.custom_model = self.custom_model.to(self.device)
-            self.custom_model.eval()
-            
-            logger.info(f"Loaded custom model: {latest_model.name}")
-            logger.info(f"Custom classes: {list(self.class_info['idx_to_label'].values())}")
-            
-        except Exception as e:
-            logger.error(f"Failed to load custom model: {e}")
-            self.custom_model = None
-            self.class_info = None
-    
-    def classify_object(self, object_crop: np.ndarray) -> Tuple[str, float]:
-        """
-        Classify object crop using custom model
-        
-        Args:
-            object_crop: Cropped image region
-            
-        Returns:
-            Tuple of (predicted_label, confidence)
-        """
-        if self.custom_model is None:
-            return None, 0.0
-        
-        try:
-            # Preprocess image
-            if object_crop.size == 0:
-                return None, 0.0
-            
-            # Convert BGR to RGB
-            if len(object_crop.shape) == 3 and object_crop.shape[2] == 3:
-                object_crop = cv2.cvtColor(object_crop, cv2.COLOR_BGR2RGB)
-            
-            # Preprocess for model
-            input_tensor = self.preprocess(object_crop).unsqueeze(0).to(self.device)
-            
-            # Inference
-            with torch.no_grad():
-                outputs = self.custom_model(input_tensor)
-                probabilities = torch.softmax(outputs, dim=1)
-                confidence, predicted = torch.max(probabilities, 1)
-                
-                predicted_idx = predicted.item()
-                confidence_score = confidence.item()
-                
-                # Convert to label
-                predicted_label = self.class_info['idx_to_label'][predicted_idx]
-                
-                return predicted_label, confidence_score
-            
-        except Exception as e:
-            logger.error(f"Custom classification failed: {e}")
-            return None, 0.0
-    
-    def should_override_yolo(self, yolo_label: str, yolo_confidence: float,
-                           custom_label: str, custom_confidence: float) -> bool:
-        """
-        Decide whether to override YOLO prediction with custom model
-        
-        Args:
-            yolo_label: YOLO predicted label
-            yolo_confidence: YOLO confidence
-            custom_label: Custom model predicted label
-            custom_confidence: Custom model confidence
-            
-        Returns:
-            True if should use custom model prediction
-        """
-        # Don't override if custom model not confident enough
-        if custom_confidence < 0.7:
-            return False
-        
-        # Always override if YOLO has low confidence and custom has high
-        if yolo_confidence < 0.5 and custom_confidence > 0.8:
-            return True
-        
-        # Override if custom model is significantly more confident
-        if custom_confidence > yolo_confidence + 0.2:
-            return True
-        
-        # Override if we have training data for this custom class
-        if custom_label in self.class_info.get('valid_classes', []):
-            return True
-        
-        return False
-    
-    def detect_with_custom_model(self, image: np.ndarray, confidence_threshold: float = 0.5) -> Tuple[np.ndarray, List[str], List[Dict]]:
-        """
-        Two-stage detection: YOLO + Custom Classification
-        
-        Args:
-            image: Input image
-            confidence_threshold: YOLO confidence threshold
-            
-        Returns:
-            Tuple of (annotated_image, detected_objects, detailed_attributes)
-        """
-        # Stage 1: YOLO Detection
-        try:
-            annotated_img, detected_objects, detailed_attributes = detect_objects_enhanced(
-                image, confidence_threshold
-            )
-        except:
-            # Fallback to basic YOLO
-            from .yolo import detect_objects
-            annotated_img, detected_objects = detect_objects(image)
-            detailed_attributes = []
-        
-        # Stage 2: Custom Classification (if model available)
-        if self.custom_model is None or not detailed_attributes:
-            return annotated_img, detected_objects, detailed_attributes
-        
-        # Process each detection with custom model
-        enhanced_attributes = []
-        enhanced_objects = []
-        
-        for i, attr in enumerate(detailed_attributes):
-            yolo_label = attr['label']
-            yolo_confidence = float(attr['confidence'].rstrip('%')) / 100.0
-            bbox = attr.get('bbox', [0, 0, 100, 100])
-            
-            # Extract object region
-            x1, y1, x2, y2 = [int(coord) for coord in bbox]
-            object_crop = image[max(0, y1):min(image.shape[0], y2),
-                              max(0, x1):min(image.shape[1], x2)]
-            
-            # Classify with custom model
-            custom_label, custom_confidence = self.classify_object(object_crop)
-            
-            # Decide which prediction to use
-            if custom_label and self.should_override_yolo(yolo_label, yolo_confidence, 
-                                                        custom_label, custom_confidence):
-                # Use custom model prediction
-                final_label = custom_label
-                final_confidence = custom_confidence
-                attr['prediction_source'] = 'custom_model'
-                attr['original_yolo'] = {'label': yolo_label, 'confidence': yolo_confidence}
-            else:
-                # Use YOLO prediction
-                final_label = yolo_label
-                final_confidence = yolo_confidence
-                attr['prediction_source'] = 'yolo'
-                if custom_label:
-                    attr['custom_alternative'] = {'label': custom_label, 'confidence': custom_confidence}
-            
-            # Update attributes
-            attr['label'] = final_label
-            attr['confidence'] = f"{final_confidence:.2%}"
-            
-            enhanced_attributes.append(attr)
-            enhanced_objects.append(final_label)
-        
-        # Update annotated image if we made changes
-        if any(attr.get('prediction_source') == 'custom_model' for attr in enhanced_attributes):
-            # Re-annotate image with updated predictions
-            annotated_img = self.annotate_image_with_predictions(image, enhanced_attributes)
-        
-        return annotated_img, enhanced_objects, enhanced_attributes
-    
-    def annotate_image_with_predictions(self, image: np.ndarray, attributes: List[Dict]) -> np.ndarray:
-        """
-        Annotate image with updated predictions
-        
-        Args:
-            image: Original image
-            attributes: Detection attributes with updated labels
-            
-        Returns:
-            Annotated image
-        """
-        annotated = image.copy()
-        
-        for attr in attributes:
-            bbox = attr.get('bbox', [0, 0, 100, 100])
-            label = attr['label']
-            confidence = attr['confidence']
-            source = attr.get('prediction_source', 'yolo')
-            
-            x1, y1, x2, y2 = [int(coord) for coord in bbox]
-            
-            # Choose color based on source
-            if source == 'custom_model':
-                color = (0, 255, 0)  # Green for custom model
-                label_text = f"{label} {confidence} (Custom)"
-            else:
-                color = (255, 0, 0)  # Red for YOLO
-                label_text = f"{label} {confidence}"
-            
-            # Draw bounding box
-            cv2.rectangle(annotated, (x1, y1), (x2, y2), color, 2)
-            
-            # Draw label
-            cv2.putText(annotated, label_text, (x1, y1-10), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
-        
-        return annotated
-    
-    def get_model_info(self) -> Dict:
-        """Get information about loaded models"""
-        info = {
-            'yolo_model': 'YOLOv8m',
-            'custom_model_loaded': self.custom_model is not None,
-            'device': self.device
-        }
-        
-        if self.custom_model is not None and self.class_info is not None:
-            info.update({
-                'custom_classes': list(self.class_info['idx_to_label'].values()),
-                'num_custom_classes': self.class_info['num_classes'],
-                'training_samples': self.class_info.get('train_samples', 0),
-                'validation_samples': self.class_info.get('val_samples', 0)
-            })
-        
-        return info
-
-# Global two-stage inference instance
+"""
+Two-Stage Inference System
+Combines YOLO detection with custom classifier for improved accuracy
+"""
+import torch
+import torchvision.transforms as transforms
+import numpy as np
+import cv2
+from typing import List, Dict, Tuple, Optional
+import pickle
+from pathlib import Path
+import logging
+
+from .yolo_enhanced import detect_objects_enhanced, model as yolo_model
+from .custom_trainer import CustomClassifier
+
+logger = logging.getLogger(__name__)
+
+class TwoStageInference:
+    """Two-stage detection and classification system"""
+    
+    def __init__(self, models_dir='models/'):
+        """
+        Initialize two-stage inference system
+        
+        Args:
+            models_dir: Directory containing trained custom models
+        """
+        self.models_dir = Path(models_dir)
+        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        
+        # Load active custom model if available
+        self.custom_model = None
+        self.class_info = None
+        self.load_active_model()
+        
+        # Image preprocessing for custom classifier
+        self.preprocess = transforms.Compose([
+            transforms.ToPILImage(),
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+    
+    def load_active_model(self):
+        """Load the most recent trained custom model"""
+        try:
+            # Find latest model file
+            model_files = list(self.models_dir.glob('custom_classifier_*.pkl'))
+            if not model_files:
+                logger.info("No custom models found. Using YOLO only.")
+                return
+            
+            # Get most recent model
+            latest_model = max(model_files, key=lambda x: x.stat().st_mtime)
+            
+            # Load model info
+            with open(latest_model, 'rb') as f:
+                model_info = pickle.load(f)
+            
+            self.class_info = model_info['class_info']
+            
+            # Initialize and load custom model
+            self.custom_model = CustomClassifier(
+                num_classes=self.class_info['num_classes'],
+                backbone=model_info['training_config']['backbone']
+            )
+            self.custom_model.load_state_dict(model_info['model_state'])
+            self.custom_model = self.custom_model.to(self.device)
+            self.custom_model.eval()
+            
+            logger.info(f"Loaded custom model: {latest_model.name}")
+            logger.info(f"Custom classes: {list(self.class_info['idx_to_label'].values())}")
+            
+        except Exception as e:
+            logger.error(f"Failed to load custom model: {e}")
+            self.custom_model = None
+            self.class_info = None
+    
+    def classify_object(self, object_crop: np.ndarray) -> Tuple[str, float]:
+        """
+        Classify object crop using custom model
+        
+        Args:
+            object_crop: Cropped image region
+            
+        Returns:
+            Tuple of (predicted_label, confidence)
+        """
+        if self.custom_model is None:
+            return None, 0.0
+        
+        try:
+            # Preprocess image
+            if object_crop.size == 0:
+                return None, 0.0
+            
+            # Convert BGR to RGB
+            if len(object_crop.shape) == 3 and object_crop.shape[2] == 3:
+                object_crop = cv2.cvtColor(object_crop, cv2.COLOR_BGR2RGB)
+            
+            # Preprocess for model
+            input_tensor = self.preprocess(object_crop).unsqueeze(0).to(self.device)
+            
+            # Inference
+            with torch.no_grad():
+                outputs = self.custom_model(input_tensor)
+                probabilities = torch.softmax(outputs, dim=1)
+                confidence, predicted = torch.max(probabilities, 1)
+                
+                predicted_idx = predicted.item()
+                confidence_score = confidence.item()
+                
+                # Convert to label
+                predicted_label = self.class_info['idx_to_label'][predicted_idx]
+                
+                return predicted_label, confidence_score
+            
+        except Exception as e:
+            logger.error(f"Custom classification failed: {e}")
+            return None, 0.0
+    
+    def should_override_yolo(self, yolo_label: str, yolo_confidence: float,
+                           custom_label: str, custom_confidence: float) -> bool:
+        """
+        Decide whether to override YOLO prediction with custom model
+        
+        Args:
+            yolo_label: YOLO predicted label
+            yolo_confidence: YOLO confidence
+            custom_label: Custom model predicted label
+            custom_confidence: Custom model confidence
+            
+        Returns:
+            True if should use custom model prediction
+        """
+        # Don't override if custom model not confident enough
+        if custom_confidence < 0.7:
+            return False
+        
+        # Always override if YOLO has low confidence and custom has high
+        if yolo_confidence < 0.5 and custom_confidence > 0.8:
+            return True
+        
+        # Override if custom model is significantly more confident
+        if custom_confidence > yolo_confidence + 0.2:
+            return True
+        
+        # Override if we have training data for this custom class
+        if custom_label in self.class_info.get('valid_classes', []):
+            return True
+        
+        return False
+    
+    def detect_with_custom_model(self, image: np.ndarray, confidence_threshold: float = 0.5) -> Tuple[np.ndarray, List[str], List[Dict]]:
+        """
+        Two-stage detection: YOLO + Custom Classification
+        
+        Args:
+            image: Input image
+            confidence_threshold: YOLO confidence threshold
+            
+        Returns:
+            Tuple of (annotated_image, detected_objects, detailed_attributes)
+        """
+        # Stage 1: YOLO Detection
+        try:
+            annotated_img, detected_objects, detailed_attributes = detect_objects_enhanced(
+                image, confidence_threshold
+            )
+        except:
+            # Fallback to basic YOLO
+            from .yolo import detect_objects
+            annotated_img, detected_objects = detect_objects(image)
+            detailed_attributes = []
+        
+        # Stage 2: Custom Classification (if model available)
+        if self.custom_model is None or not detailed_attributes:
+            return annotated_img, detected_objects, detailed_attributes
+        
+        # Process each detection with custom model
+        enhanced_attributes = []
+        enhanced_objects = []
+        
+        for i, attr in enumerate(detailed_attributes):
+            yolo_label = attr['label']
+            yolo_confidence = float(attr['confidence'].rstrip('%')) / 100.0
+            bbox = attr.get('bbox', [0, 0, 100, 100])
+            
+            # Extract object region
+            x1, y1, x2, y2 = [int(coord) for coord in bbox]
+            object_crop = image[max(0, y1):min(image.shape[0], y2),
+                              max(0, x1):min(image.shape[1], x2)]
+            
+            # Classify with custom model
+            custom_label, custom_confidence = self.classify_object(object_crop)
+            
+            # Decide which prediction to use
+            if custom_label and self.should_override_yolo(yolo_label, yolo_confidence, 
+                                                        custom_label, custom_confidence):
+                # Use custom model prediction
+                final_label = custom_label
+                final_confidence = custom_confidence
+                attr['prediction_source'] = 'custom_model'
+                attr['original_yolo'] = {'label': yolo_label, 'confidence': yolo_confidence}
+            else:
+                # Use YOLO prediction
+                final_label = yolo_label
+                final_confidence = yolo_confidence
+                attr['prediction_source'] = 'yolo'
+                if custom_label:
+                    attr['custom_alternative'] = {'label': custom_label, 'confidence': custom_confidence}
+            
+            # Update attributes
+            attr['label'] = final_label
+            attr['confidence'] = f"{final_confidence:.2%}"
+            
+            enhanced_attributes.append(attr)
+            enhanced_objects.append(final_label)
+        
+        # Update annotated image if we made changes
+        if any(attr.get('prediction_source') == 'custom_model' for attr in enhanced_attributes):
+            # Re-annotate image with updated predictions
+            annotated_img = self.annotate_image_with_predictions(image, enhanced_attributes)
+        
+        return annotated_img, enhanced_objects, enhanced_attributes
+    
+    def annotate_image_with_predictions(self, image: np.ndarray, attributes: List[Dict]) -> np.ndarray:
+        """
+        Annotate image with updated predictions
+        
+        Args:
+            image: Original image
+            attributes: Detection attributes with updated labels
+            
+        Returns:
+            Annotated image
+        """
+        annotated = image.copy()
+        
+        for attr in attributes:
+            bbox = attr.get('bbox', [0, 0, 100, 100])
+            label = attr['label']
+            confidence = attr['confidence']
+            source = attr.get('prediction_source', 'yolo')
+            
+            x1, y1, x2, y2 = [int(coord) for coord in bbox]
+            
+            # Choose color based on source
+            if source == 'custom_model':
+                color = (0, 255, 0)  # Green for custom model
+                label_text = f"{label} {confidence} (Custom)"
+            else:
+                color = (255, 0, 0)  # Red for YOLO
+                label_text = f"{label} {confidence}"
+            
+            # Draw bounding box
+            cv2.rectangle(annotated, (x1, y1), (x2, y2), color, 2)
+            
+            # Draw label
+            cv2.putText(annotated, label_text, (x1, y1-10), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+        
+        return annotated
+    
+    def get_model_info(self) -> Dict:
+        """Get information about loaded models"""
+        info = {
+            'yolo_model': 'YOLOv8m',
+            'custom_model_loaded': self.custom_model is not None,
+            'device': self.device
+        }
+        
+        if self.custom_model is not None and self.class_info is not None:
+            info.update({
+                'custom_classes': list(self.class_info['idx_to_label'].values()),
+                'num_custom_classes': self.class_info['num_classes'],
+                'training_samples': self.class_info.get('train_samples', 0),
+                'validation_samples': self.class_info.get('val_samples', 0)
+            })
+        
+        return info
+
+# Global two-stage inference instance
 two_stage_inference = TwoStageInference()

backend/yolo.py

@@ -1,34 +1,34 @@
-from ultralytics import YOLO # type: ignore
-import cv2
-import numpy as np
-
-# Load a pre-trained YOLOv8 model (nano version = small & fast)
-model = YOLO("yolov8n.pt")
-
-def detect_objects(image):
-    """
-    Run YOLO on the input image.
-    Returns:
-      - annotated image with bounding boxes
-      - list of detected object names
-    """
-    # Handle different image formats and channel counts
-    if isinstance(image, np.ndarray):
-        # If image has 4 channels (RGBA), convert to RGB
-        if image.shape[-1] == 4:
-            image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
-        # If image has 1 channel (grayscale), convert to RGB
-        elif len(image.shape) == 2 or image.shape[-1] == 1:
-            image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-    
-    results = model(image)
-    annotated_img = results[0].plot()
-
-    # Extract detected object names
-    detected_objects = []
-    for box in results[0].boxes:
-        cls_id = int(box.cls[0].item())  # class ID
-        label = results[0].names[cls_id]  # class name
-        detected_objects.append(label)
-
-    return annotated_img, detected_objects
+from ultralytics import YOLO # type: ignore
+import cv2
+import numpy as np
+
+# Load a pre-trained YOLOv8 model (nano version = small & fast)
+model = YOLO("yolov8n.pt")
+
+def detect_objects(image):
+    """
+    Run YOLO on the input image.
+    Returns:
+      - annotated image with bounding boxes
+      - list of detected object names
+    """
+    # Handle different image formats and channel counts
+    if isinstance(image, np.ndarray):
+        # If image has 4 channels (RGBA), convert to RGB
+        if image.shape[-1] == 4:
+            image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
+        # If image has 1 channel (grayscale), convert to RGB
+        elif len(image.shape) == 2 or image.shape[-1] == 1:
+            image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+    
+    results = model(image)
+    annotated_img = results[0].plot()
+
+    # Extract detected object names
+    detected_objects = []
+    for box in results[0].boxes:
+        cls_id = int(box.cls[0].item())  # class ID
+        label = results[0].names[cls_id]  # class name
+        detected_objects.append(label)
+
+    return annotated_img, detected_objects

backend/yolo_enhanced.py

@@ -1,231 +1,231 @@
-"""
-Enhanced YOLO detection with improved accuracy, color detection, and detailed attributes
-"""
-from ultralytics import YOLO # type: ignore
-import cv2 # type: ignore
-import numpy as np # type: ignore
-from collections import Counter
-import webcolors # type: ignore
-# from sklearn.cluster import KMeans # type: ignore  # Temporarily disabled due to numpy compatibility
-import torch # type: ignore
-
-# Load a more accurate YOLO model
-# For better accuracy, use yolov8m.pt or yolov8l.pt instead of yolov8n.pt
-model_size = 'yolov8m.pt'  # Medium model for better accuracy vs speed balance
-model = YOLO(model_size)
-
-# Set higher confidence threshold for better accuracy
-CONFIDENCE_THRESHOLD = 0.5  # Increase this for fewer but more accurate detections
-NMS_THRESHOLD = 0.45  # Non-maximum suppression threshold
-
-def get_dominant_colors(image, n_colors=3):
-    """
-    Extract dominant colors from an image region using simple averaging
-    (K-means temporarily disabled due to numpy compatibility)
-    """
-    try:
-        # Simple color detection without sklearn
-        # Get average color
-        avg_color = np.mean(image.reshape(-1, 3), axis=0).astype(int)
-        
-        # Get corners for variety
-        h, w = image.shape[:2]
-        corners = [
-            image[0, 0],  # Top-left
-            image[0, w-1] if w > 0 else image[0, 0],  # Top-right
-            image[h-1, 0] if h > 0 else image[0, 0],  # Bottom-left
-            image[h//2, w//2] if h > 0 and w > 0 else image[0, 0]  # Center
-        ]
-        
-        color_names = []
-        # Add average color
-        try:
-            color_names.append(get_color_name(avg_color))
-        except:
-            color_names.append(f"RGB({avg_color[0]},{avg_color[1]},{avg_color[2]})")
-        
-        # Add dominant corner color if different
-        for corner in corners[:n_colors-1]:
-            try:
-                name = get_color_name(corner)
-                if name not in color_names:
-                    color_names.append(name)
-                    if len(color_names) >= n_colors:
-                        break
-            except:
-                pass
-        
-        return color_names if color_names else ["Unknown"]
-    except:
-        return ["Unknown"]
-
-def get_color_name(rgb_color):
-    """
-    Convert RGB values to a human-readable color name
-    """
-    min_colors = {}
-    for key, name in webcolors.CSS3_HEX_TO_NAMES.items():
-        r_c, g_c, b_c = webcolors.hex_to_rgb(key)
-        rd = (r_c - rgb_color[0]) ** 2
-        gd = (g_c - rgb_color[1]) ** 2
-        bd = (b_c - rgb_color[2]) ** 2
-        min_colors[(rd + gd + bd)] = name
-    return min_colors[min(min_colors.keys())]
-
-def analyze_object_attributes(image, box, label):
-    """
-    Analyze detailed attributes of detected objects
-    """
-    x1, y1, x2, y2 = box
-    object_region = image[int(y1):int(y2), int(x1):int(x2)]
-    
-    attributes = {
-        'label': label,
-        'position': get_position_description(x1, y1, x2, y2, image.shape),
-        'size': get_size_description(x2-x1, y2-y1, image.shape),
-        'colors': get_dominant_colors(object_region, n_colors=2),
-        'confidence': None,  # Will be set from detection
-        'bbox': [float(x1), float(y1), float(x2), float(y2)]  # Add bounding box coordinates
-    }
-    
-    return attributes
-
-def get_position_description(x1, y1, x2, y2, image_shape):
-    """
-    Describe object position in human terms
-    """
-    h, w = image_shape[:2]
-    center_x = (x1 + x2) / 2
-    center_y = (y1 + y2) / 2
-    
-    # Horizontal position
-    if center_x < w / 3:
-        h_pos = "left"
-    elif center_x > 2 * w / 3:
-        h_pos = "right"
-    else:
-        h_pos = "center"
-    
-    # Vertical position
-    if center_y < h / 3:
-        v_pos = "top"
-    elif center_y > 2 * h / 3:
-        v_pos = "bottom"
-    else:
-        v_pos = "middle"
-    
-    if h_pos == "center" and v_pos == "middle":
-        return "center"
-    elif v_pos == "middle":
-        return h_pos
-    elif h_pos == "center":
-        return v_pos
-    else:
-        return f"{v_pos}-{h_pos}"
-
-def get_size_description(width, height, image_shape):
-    """
-    Describe object size relative to image
-    """
-    img_area = image_shape[0] * image_shape[1]
-    obj_area = width * height
-    ratio = obj_area / img_area
-    
-    if ratio > 0.5:
-        return "very large"
-    elif ratio > 0.25:
-        return "large"
-    elif ratio > 0.1:
-        return "medium"
-    elif ratio > 0.05:
-        return "small"
-    else:
-        return "tiny"
-
-def detect_objects_enhanced(image, confidence_threshold=CONFIDENCE_THRESHOLD):
-    """
-    Enhanced YOLO detection with improved accuracy and detailed attributes
-    Returns:
-      - annotated image with bounding boxes
-      - list of detected object names
-      - detailed attributes for each detection
-    """
-    # Handle different image formats
-    if isinstance(image, np.ndarray):
-        if image.shape[-1] == 4:
-            image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
-        elif len(image.shape) == 2 or image.shape[-1] == 1:
-            image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-    
-    # Run YOLO with custom parameters for better accuracy
-    results = model(
-        image,
-        conf=confidence_threshold,  # Confidence threshold
-        iou=NMS_THRESHOLD,  # NMS IoU threshold
-        imgsz=640,  # Image size (can increase for better accuracy)
-        device='cuda' if torch.cuda.is_available() else 'cpu'
-    )
-    
-    # Get annotated image
-    annotated_img = results[0].plot(
-        conf=True,  # Show confidence scores
-        line_width=2,
-        font_size=10
-    )
-    
-    # Extract detailed information
-    detected_objects = []
-    detailed_attributes = []
-    
-    for box in results[0].boxes:
-        if box.conf[0] >= confidence_threshold:  # Double-check confidence
-            cls_id = int(box.cls[0].item())
-            label = results[0].names[cls_id]
-            confidence = float(box.conf[0].item())
-            
-            # Get box coordinates
-            xyxy = box.xyxy[0].tolist()
-            
-            # Analyze attributes
-            attributes = analyze_object_attributes(image, xyxy, label)
-            attributes['confidence'] = f"{confidence:.2%}"
-            
-            detected_objects.append(label)
-            detailed_attributes.append(attributes)
-    
-    return annotated_img, detected_objects, detailed_attributes
-
-def get_intelligence_report(detailed_attributes):
-    """
-    Generate an intelligent report about detected objects
-    """
-    if not detailed_attributes:
-        return "No objects detected in the image."
-    
-    report = []
-    report.append(f"Detected {len(detailed_attributes)} object(s):")
-    
-    for attr in detailed_attributes:
-        colors_str = " and ".join(attr['colors'][:2]) if attr['colors'] else "unknown colors"
-        report.append(
-            f"- A {attr['size']} {colors_str} {attr['label']} "
-            f"in the {attr['position']} of the image "
-            f"(confidence: {attr['confidence']})"
-        )
-    
-    # Add summary statistics
-    object_types = Counter([attr['label'] for attr in detailed_attributes])
-    if len(object_types) > 1:
-        report.append("\nSummary:")
-        for obj_type, count in object_types.most_common():
-            report.append(f"  • {count} {obj_type}(s)")
-    
-    return "\n".join(report)
-
-# Backward compatibility wrapper
-def detect_objects(image):
-    """
-    Wrapper for backward compatibility with original function
-    """
-    annotated_img, detected_objects, _ = detect_objects_enhanced(image)
+"""
+Enhanced YOLO detection with improved accuracy, color detection, and detailed attributes
+"""
+from ultralytics import YOLO # type: ignore
+import cv2 # type: ignore
+import numpy as np # type: ignore
+from collections import Counter
+import webcolors # type: ignore
+# from sklearn.cluster import KMeans # type: ignore  # Temporarily disabled due to numpy compatibility
+import torch # type: ignore
+
+# Load a more accurate YOLO model
+# For better accuracy, use yolov8m.pt or yolov8l.pt instead of yolov8n.pt
+model_size = 'yolov8m.pt'  # Medium model for better accuracy vs speed balance
+model = YOLO(model_size)
+
+# Set higher confidence threshold for better accuracy
+CONFIDENCE_THRESHOLD = 0.5  # Increase this for fewer but more accurate detections
+NMS_THRESHOLD = 0.45  # Non-maximum suppression threshold
+
+def get_dominant_colors(image, n_colors=3):
+    """
+    Extract dominant colors from an image region using simple averaging
+    (K-means temporarily disabled due to numpy compatibility)
+    """
+    try:
+        # Simple color detection without sklearn
+        # Get average color
+        avg_color = np.mean(image.reshape(-1, 3), axis=0).astype(int)
+        
+        # Get corners for variety
+        h, w = image.shape[:2]
+        corners = [
+            image[0, 0],  # Top-left
+            image[0, w-1] if w > 0 else image[0, 0],  # Top-right
+            image[h-1, 0] if h > 0 else image[0, 0],  # Bottom-left
+            image[h//2, w//2] if h > 0 and w > 0 else image[0, 0]  # Center
+        ]
+        
+        color_names = []
+        # Add average color
+        try:
+            color_names.append(get_color_name(avg_color))
+        except:
+            color_names.append(f"RGB({avg_color[0]},{avg_color[1]},{avg_color[2]})")
+        
+        # Add dominant corner color if different
+        for corner in corners[:n_colors-1]:
+            try:
+                name = get_color_name(corner)
+                if name not in color_names:
+                    color_names.append(name)
+                    if len(color_names) >= n_colors:
+                        break
+            except:
+                pass
+        
+        return color_names if color_names else ["Unknown"]
+    except:
+        return ["Unknown"]
+
+def get_color_name(rgb_color):
+    """
+    Convert RGB values to a human-readable color name
+    """
+    min_colors = {}
+    for key, name in webcolors.CSS3_HEX_TO_NAMES.items():
+        r_c, g_c, b_c = webcolors.hex_to_rgb(key)
+        rd = (r_c - rgb_color[0]) ** 2
+        gd = (g_c - rgb_color[1]) ** 2
+        bd = (b_c - rgb_color[2]) ** 2
+        min_colors[(rd + gd + bd)] = name
+    return min_colors[min(min_colors.keys())]
+
+def analyze_object_attributes(image, box, label):
+    """
+    Analyze detailed attributes of detected objects
+    """
+    x1, y1, x2, y2 = box
+    object_region = image[int(y1):int(y2), int(x1):int(x2)]
+    
+    attributes = {
+        'label': label,
+        'position': get_position_description(x1, y1, x2, y2, image.shape),
+        'size': get_size_description(x2-x1, y2-y1, image.shape),
+        'colors': get_dominant_colors(object_region, n_colors=2),
+        'confidence': None,  # Will be set from detection
+        'bbox': [float(x1), float(y1), float(x2), float(y2)]  # Add bounding box coordinates
+    }
+    
+    return attributes
+
+def get_position_description(x1, y1, x2, y2, image_shape):
+    """
+    Describe object position in human terms
+    """
+    h, w = image_shape[:2]
+    center_x = (x1 + x2) / 2
+    center_y = (y1 + y2) / 2
+    
+    # Horizontal position
+    if center_x < w / 3:
+        h_pos = "left"
+    elif center_x > 2 * w / 3:
+        h_pos = "right"
+    else:
+        h_pos = "center"
+    
+    # Vertical position
+    if center_y < h / 3:
+        v_pos = "top"
+    elif center_y > 2 * h / 3:
+        v_pos = "bottom"
+    else:
+        v_pos = "middle"
+    
+    if h_pos == "center" and v_pos == "middle":
+        return "center"
+    elif v_pos == "middle":
+        return h_pos
+    elif h_pos == "center":
+        return v_pos
+    else:
+        return f"{v_pos}-{h_pos}"
+
+def get_size_description(width, height, image_shape):
+    """
+    Describe object size relative to image
+    """
+    img_area = image_shape[0] * image_shape[1]
+    obj_area = width * height
+    ratio = obj_area / img_area
+    
+    if ratio > 0.5:
+        return "very large"
+    elif ratio > 0.25:
+        return "large"
+    elif ratio > 0.1:
+        return "medium"
+    elif ratio > 0.05:
+        return "small"
+    else:
+        return "tiny"
+
+def detect_objects_enhanced(image, confidence_threshold=CONFIDENCE_THRESHOLD):
+    """
+    Enhanced YOLO detection with improved accuracy and detailed attributes
+    Returns:
+      - annotated image with bounding boxes
+      - list of detected object names
+      - detailed attributes for each detection
+    """
+    # Handle different image formats
+    if isinstance(image, np.ndarray):
+        if image.shape[-1] == 4:
+            image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
+        elif len(image.shape) == 2 or image.shape[-1] == 1:
+            image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+    
+    # Run YOLO with custom parameters for better accuracy
+    results = model(
+        image,
+        conf=confidence_threshold,  # Confidence threshold
+        iou=NMS_THRESHOLD,  # NMS IoU threshold
+        imgsz=640,  # Image size (can increase for better accuracy)
+        device='cuda' if torch.cuda.is_available() else 'cpu'
+    )
+    
+    # Get annotated image
+    annotated_img = results[0].plot(
+        conf=True,  # Show confidence scores
+        line_width=2,
+        font_size=10
+    )
+    
+    # Extract detailed information
+    detected_objects = []
+    detailed_attributes = []
+    
+    for box in results[0].boxes:
+        if box.conf[0] >= confidence_threshold:  # Double-check confidence
+            cls_id = int(box.cls[0].item())
+            label = results[0].names[cls_id]
+            confidence = float(box.conf[0].item())
+            
+            # Get box coordinates
+            xyxy = box.xyxy[0].tolist()
+            
+            # Analyze attributes
+            attributes = analyze_object_attributes(image, xyxy, label)
+            attributes['confidence'] = f"{confidence:.2%}"
+            
+            detected_objects.append(label)
+            detailed_attributes.append(attributes)
+    
+    return annotated_img, detected_objects, detailed_attributes
+
+def get_intelligence_report(detailed_attributes):
+    """
+    Generate an intelligent report about detected objects
+    """
+    if not detailed_attributes:
+        return "No objects detected in the image."
+    
+    report = []
+    report.append(f"Detected {len(detailed_attributes)} object(s):")
+    
+    for attr in detailed_attributes:
+        colors_str = " and ".join(attr['colors'][:2]) if attr['colors'] else "unknown colors"
+        report.append(
+            f"- A {attr['size']} {colors_str} {attr['label']} "
+            f"in the {attr['position']} of the image "
+            f"(confidence: {attr['confidence']})"
+        )
+    
+    # Add summary statistics
+    object_types = Counter([attr['label'] for attr in detailed_attributes])
+    if len(object_types) > 1:
+        report.append("\nSummary:")
+        for obj_type, count in object_types.most_common():
+            report.append(f"  • {count} {obj_type}(s)")
+    
+    return "\n".join(report)
+
+# Backward compatibility wrapper
+def detect_objects(image):
+    """
+    Wrapper for backward compatibility with original function
+    """
+    annotated_img, detected_objects, _ = detect_objects_enhanced(image)
     return annotated_img, detected_objects

packages.txt

@@ -1,5 +1,5 @@
-ffmpeg
-libsm6
-libxext6
-libxrender-dev
+ffmpeg
+libsm6
+libxext6
+libxrender-dev
 libglib2.0-0

requirements.txt

@@ -1,16 +1,13 @@
-streamlit>=1.28.0
-ultralytics>=8.0.0
-openai>=1.0.0
-opencv-python-headless>=4.8.0
-pillow>=10.0.0
-numpy>=1.24.0,<2.0.0
-torch>=2.0.0
-torchvision>=0.15.0
-python-dotenv>=1.0.0
-plotly>=5.17.0
-kaleido>=0.2.1
-requests>=2.31.0
-pandas>=1.5.0,<2.1.0
-webcolors>=1.13
-face-recognition>=1.3.0
-dlib>=19.24.0
+streamlit>=1.28.0
+ultralytics>=8.0.0
+openai>=1.0.0
+opencv-python-headless>=4.8.0
+pillow>=10.0.0
+numpy>=1.24.0,<2.0.0
+torch>=2.0.0,<2.5.0
+torchvision>=0.15.0,<0.20.0
+python-dotenv>=1.0.0
+plotly>=5.17.0
+requests>=2.31.0
+pandas>=1.5.0,<2.1.0
+webcolors>=1.13

requirements_lite.txt

@@ -0,0 +1,14 @@
+streamlit>=1.28.0
+ultralytics>=8.0.0
+openai>=1.0.0
+opencv-python-headless>=4.8.0
+pillow>=10.0.0
+numpy>=1.24.0,<2.0.0
+torch>=2.0.0
+torchvision>=0.15.0
+python-dotenv>=1.0.0
+plotly>=5.17.0
+kaleido>=0.2.1
+requests>=2.31.0
+pandas>=1.5.0,<2.1.0
+webcolors>=1.13