Upload 13 files

.gitignore

@@ -12,4 +12,4 @@ env/
 
 # تجاهل ملفات النظام
 .DS_Store
-Thumbs.db
+Thumbs.db.env

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tamer ELGOHARY
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -127,4 +127,4 @@ streamlit run main.py
 
 ## الاتصال
 
-للاستفسارات أو الدعم، يرجى التواصل عبر البريد الإلكتروني: support@example.com
+للاستفسارات أو الدعم، يرجى التواصل عبر البريد الإلكتروني: tgohary@sajco.com.sa

app.py

@@ -1,277 +1,475 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
 """
-نظام تحليل المناقصات وسلاسل الإمداد والتوقعات المستقبلية
-تطبيق خاص بشركة شبه الجزيرة للمقاولات
+Hybrid Face Environment System
 
-مهندس التطوير: م. تامر الجوهري
+This module integrates multiple face recognition and analysis techniques
+into a comprehensive system capable of performing 2D and 3D face recognition,
+landmark detection, pose estimation, and emotion analysis.
 """
 
 import os
 import sys
-import yaml
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-
-import streamlit as st
-
-# إعداد الصفحة مسبقًا (يجب أن يكون هذا أول أمر في Streamlit)
-st.set_page_config(
-    page_title="نظام تحليل المناقصات - شركة شبه الجزيرة للمقاولات",
-    page_icon="📊",
-    layout="wide",
-    initial_sidebar_state="expanded",
-)
-
-# استيراد باقي المكتبات (بعد set_page_config)
-import pandas as pd
+import cv2
 import numpy as np
-import plotly.express as px
-import plotly.graph_objects as go
-
-# إضافة المجلد الرئيسي للمسار
-current_dir = Path(__file__).parent
-sys.path.append(str(current_dir))
-
-# استيراد المكونات الضرورية
-from web.pages.home import show_home_page
-from web.pages.tender_analysis import show_tender_analysis
-from web.pages.requirements_analysis import show_requirements_analysis
-from web.pages.cost_estimation import show_cost_estimation
-from web.pages.risk_analysis import show_risk_analysis
-from web.pages.timeline import show_timeline
-from web.pages.local_content import show_local_content
-from web.pages.supply_chain import show_supply_chain
-from web.pages.procurement import show_procurement
-from web.pages.vendors import show_vendors
-from web.pages.future_projects import show_future_projects
-from web.pages.success_prediction import show_success_prediction
-from web.pages.reports import show_reports
-from web.pages.ai_settings import show_ai_settings
-
-from web.components.sidebar import create_sidebar
-from web.components.header import create_header
-
-from utils.file_handler import setup_logging
-from utils.permissions import initialize_permissions
-from utils.ai_helper import initialize_ai_helper
+import logging
+from typing import Dict, List, Tuple, Union, Optional, Any
 
-# إعداد التسجيل
-setup_logging()
-logger = logging.getLogger("TenderAnalysisSystem")
+# Import component modules
+from face_detector import FaceDetector
+from feature_extractor import FeatureExtractor
+from image_preprocessor import ImagePreprocessor
+from face_recognition_2d import FaceRecognition2D
+from face_recognition_3d import FaceRecognition3D
+from landmark_detector import LandmarkDetector
+from pose_estimator import PoseEstimator
+from emotion_analyzer import EmotionAnalyzer
+from database_manager import DatabaseManager
 
-# تحميل الإعدادات
-def load_config():
-    config_path = os.path.join(current_dir, "config", "config.yaml")
-    if os.path.exists(config_path):
-        with open(config_path, 'r', encoding='utf-8') as f:
-            return yaml.safe_load(f)
-    return {}
 
-# تهيئة حالة الجلسة
-def initialize_session():
-    if 'config' not in st.session_state:
-        st.session_state.config = load_config()
-    
-    if 'page' not in st.session_state:
-        st.session_state.page = "الرئيسية"
-    
-    if 'uploaded_files' not in st.session_state:
-        st.session_state.uploaded_files = []
-    
-    if 'analysis_results' not in st.session_state:
-        st.session_state.analysis_results = {}
+class HybridFaceSystem:
+    """
+    Main class that integrates all components of the hybrid face recognition system.
     
-    if 'current_tender' not in st.session_state:
-        st.session_state.current_tender = None
+    This system combines 2D and 3D face recognition techniques with landmark detection,
+    pose estimation, and emotion analysis for a comprehensive face analysis solution.
+    """
     
-    if 'user_info' not in st.session_state:
-        st.session_state.user_info = {
-            "company": "شركة شبه الجزيرة للمقاولات",
-            "user_name": "المستخدم الحالي",
-            "role": "مدير النظام"  # تغيير الدور الافتراضي إلى مدير النظام للوصول إلى جميع الصلاحيات
+    def __init__(self, config: Dict = None):
+        """
+        Initialize the hybrid face system with configuration parameters.
+        
+        Args:
+            config: Dictionary containing configuration parameters for the system
+        """
+        # Setup logging
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        self.logger = logging.getLogger("HybridFaceSystem")
+        self.logger.info("Initializing Hybrid Face System...")
+        
+        # Set default configuration if none provided
+        self.config = config or {
+            'min_face_size': (60, 60),
+            'confidence_threshold': 0.7,
+            'use_gpu': True,
+            'recognition_mode': 'hybrid',  # Options: '2d', '3d', 'hybrid'
+            'fusion_weights': {'2d': 0.4, '3d': 0.6},
+            'database_path': 'face_database',
         }
-    
-    if 'latest_predictions' not in st.session_state:
-        st.session_state.latest_predictions = None
-    
-    # نطاق التاريخ الافتراضي
-    if 'date_range' not in st.session_state:
-        today = datetime.today()
-        st.session_state.date_range = {
-            "start_date": today.replace(month=1, day=1),
-            "end_date": today
+        
+        # Initialize components
+        self._init_components()
+        
+        self.logger.info("Hybrid Face System initialized successfully")
+    
+    def _init_components(self):
+        """Initialize all system components with appropriate configurations."""
+        try:
+            # Initialize preprocessing component
+            self.preprocessor = ImagePreprocessor(
+                target_size=(224, 224),
+                normalize=True,
+                augmentation_enabled=False
+            )
+            
+            # Initialize face detection component
+            self.face_detector = FaceDetector(
+                min_size=self.config['min_face_size'],
+                use_gpu=self.config['use_gpu']
+            )
+            
+            # Initialize facial landmark detection
+            self.landmark_detector = LandmarkDetector(
+                model_type='deep',
+                num_landmarks=68
+            )
+            
+            # Initialize feature extraction
+            self.feature_extractor = FeatureExtractor(
+                embedding_size=512,
+                use_deep_features=True
+            )
+            
+            # Initialize pose estimation
+            self.pose_estimator = PoseEstimator(
+                landmark_detector=self.landmark_detector
+            )
+            
+            # Initialize emotion analysis
+            self.emotion_analyzer = EmotionAnalyzer(
+                model_path='models/emotion_model.h5'
+            )
+            
+            # Initialize database manager
+            self.db_manager = DatabaseManager(
+                database_path=self.config['database_path']
+            )
+            
+            # Initialize recognition systems
+            self.face_recognition_2d = FaceRecognition2D(
+                feature_extractor=self.feature_extractor,
+                db_manager=self.db_manager
+            )
+            
+            self.face_recognition_3d = FaceRecognition3D(
+                feature_extractor=self.feature_extractor,
+                db_manager=self.db_manager
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Error initializing components: {str(e)}")
+            raise
+    
+    def process_image(self, image: np.ndarray, depth_data: Optional[np.ndarray] = None) -> Dict:
+        """
+        Process an input image through the hybrid face recognition pipeline.
+        
+        Args:
+            image: Input RGB image as numpy array
+            depth_data: Optional depth data for 3D recognition
+            
+        Returns:
+            Dictionary containing recognition results and analysis data
+        """
+        try:
+            # Step 1: Preprocess the image
+            preprocessed_image = self.preprocessor.preprocess(image)
+            
+            # Step 2: Detect faces
+            faces = self.face_detector.detect(preprocessed_image)
+            
+            if not faces:
+                return {'status': 'no_face_detected'}
+            
+            results = []
+            for face_idx, face_data in enumerate(faces):
+                result = self._process_single_face(
+                    image=preprocessed_image,
+                    face_data=face_data,
+                    depth_data=depth_data,
+                    face_idx=face_idx
+                )
+                results.append(result)
+            
+            return {
+                'status': 'success',
+                'num_faces': len(faces),
+                'results': results
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error processing image: {str(e)}")
+            return {'status': 'error', 'message': str(e)}
+    
+    def _process_single_face(self, image: np.ndarray, face_data: Dict, 
+                            depth_data: Optional[np.ndarray], face_idx: int) -> Dict:
+        """
+        Process a single detected face through the recognition pipeline.
+        
+        Args:
+            image: Preprocessed image
+            face_data: Dictionary with face detection results
+            depth_data: Optional depth data for 3D recognition
+            face_idx: Index of the face in the image
+            
+        Returns:
+            Dictionary with recognition and analysis results for this face
+        """
+        # Extract face region
+        face_img = face_data['face_image']
+        
+        # Step 3: Detect landmarks
+        landmarks = self.landmark_detector.detect_landmarks(face_img)
+        
+        # Step 4: Calculate pose
+        pose = self.pose_estimator.estimate_pose(face_img, landmarks)
+        
+        # Step 5: Analyze emotion
+        emotion = self.emotion_analyzer.analyze(face_img, landmarks)
+        
+        # Step 6: Extract features
+        features_2d = self.feature_extractor.extract_features(face_img, mode='2d')
+        
+        # Step 7: Perform recognition based on config
+        recognition_results = {}
+        confidence = 0.0
+        person_id = None
+        
+        # 2D recognition
+        if self.config['recognition_mode'] in ['2d', 'hybrid']:
+            recognition_2d = self.face_recognition_2d.recognize(features_2d)
+            recognition_results['2d'] = recognition_2d
+            
+            if self.config['recognition_mode'] == '2d':
+                confidence = recognition_2d['confidence']
+                person_id = recognition_2d['person_id']
+        
+        # 3D recognition (if depth data available)
+        if self.config['recognition_mode'] in ['3d', 'hybrid'] and depth_data is not None:
+            # Extract depth data for this face
+            face_depth = self._extract_face_depth(depth_data, face_data['bbox'])
+            
+            # Extract 3D features and perform recognition
+            features_3d = self.feature_extractor.extract_features(
+                face_img, depth_data=face_depth, mode='3d'
+            )
+            recognition_3d = self.face_recognition_3d.recognize(features_3d)
+            recognition_results['3d'] = recognition_3d
+            
+            if self.config['recognition_mode'] == '3d':
+                confidence = recognition_3d['confidence']
+                person_id = recognition_3d['person_id']
+        
+        # Perform fusion for hybrid mode
+        if self.config['recognition_mode'] == 'hybrid' and '2d' in recognition_results and '3d' in recognition_results:
+            fusion_result = self._fuse_recognition_results(
+                recognition_results['2d'], 
+                recognition_results['3d']
+            )
+            confidence = fusion_result['confidence']
+            person_id = fusion_result['person_id']
+        
+        # Step 8: Compile results
+        return {
+            'face_id': face_idx,
+            'bbox': face_data['bbox'],
+            'landmarks': landmarks,
+            'pose': pose,
+            'emotion': emotion,
+            'person_id': person_id,
+            'confidence': confidence,
+            'recognition_details': recognition_results
         }
     
-    # تهيئة نظام الصلاحيات
-    initialize_permissions()
-    
-    # تهيئة مساعد الذكاء الاصطناعي
-    initialize_ai_helper()
-    
-    # تحديد ما إذا كان الجهاز موبايل
-    if 'is_mobile' not in st.session_state:
-        st.session_state.is_mobile = False
-
-# إضافة دعم الموبايل
-def setup_mobile_support():
-    # إضافة CSS للموبايل
-    mobile_css_path = os.path.join(current_dir, "web", "styles", "mobile.css")
-    if os.path.exists(mobile_css_path):
-        with open(mobile_css_path) as f:
-            st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
-    
-    # إضافة سكريبت للكشف عن الموبايل وإضافة القائمة
-    mobile_script = """
-    <script>
-    // الكشف عن الموبايل
-    function detectMobile() {
-        return (window.innerWidth <= 768) || 
-               (navigator.userAgent.match(/Android/i) ||
-                navigator.userAgent.match(/webOS/i) ||
-                navigator.userAgent.match(/iPhone/i) ||
-                navigator.userAgent.match(/iPad/i) ||
-                navigator.userAgent.match(/iPod/i) ||
-                navigator.userAgent.match(/BlackBerry/i) ||
-                navigator.userAgent.match(/Windows Phone/i));
-    }
-    
-    // إرسال حالة الموبايل إلى Streamlit
-    if (detectMobile()) {
-        const data = {
-            is_mobile: true
-        };
-        window.parent.postMessage({
-            type: "streamlit:setComponentValue",
-            value: data
-        }, "*");
-    }
-    </script>
-    """
-    st.markdown(mobile_script, unsafe_allow_html=True)
-    
-    # إضافة سكريبت القائمة للموبايل
-    mobile_menu_path = os.path.join(current_dir, "web", "scripts", "mobile_menu.js")
-    if os.path.exists(mobile_menu_path):
-        with open(mobile_menu_path) as f:
-            st.markdown(f"<script>{f.read()}</script>", unsafe_allow_html=True)
-
-# التطبيق الرئيسي
-def main():
-    # تهيئة الجلسة
-    initialize_session()
-    
-    # إضافة CSS المخصص
-    with open(os.path.join(current_dir, "web", "styles", "main.css")) as f:
-        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
-    
-    # إضافة CSS للغة العربية
-    with open(os.path.join(current_dir, "web", "styles", "rtl.css")) as f:
-        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
-    
-    # إضافة دعم الموبايل
-    setup_mobile_support()
-    
-    # إضافة متغير من نوع Streamlit Component لقراءة حالة الموبايل
-    mobile_detector = st.empty()
-    mobile_data = mobile_detector.text_input("", key="mobile_detector", label_visibility="collapsed")
-    
-    try:
-        if mobile_data:
-            mobile_data_json = json.loads(mobile_data)
-            st.session_state.is_mobile = mobile_data_json.get('is_mobile', False)
-    except:
-        pass
-    
-    # إنشاء الشريط الجانبي
-    selected_page = create_sidebar()
-    
-    # إنشاء رأس الصفحة
-    create_header()
-    
-    # إضافة زر القائمة للموبايل في حالة تم الكشف عن جهاز موبايل
-    if st.session_state.is_mobile:
-        st.markdown('<div id="mobile-menu-container"></div>', unsafe_allow_html=True)
-    
-    # عرض الصفحة المحددة
-    if selected_page == "الرئيسية":
-        show_home_page()
-    
-    elif selected_page == "تحليل المناقصات":
-        show_tender_analysis()
-    
-    elif selected_page == "تحليل المتطلبات":
-        show_requirements_analysis()
-    
-    elif selected_page == "تقدير التكاليف":
-        show_cost_estimation()
-    
-    elif selected_page == "تحليل المخاطر":
-        show_risk_analysis()
-    
-    elif selected_page == "الجدول الزمني":
-        show_timeline()
-    
-    elif selected_page == "المحتوى المحلي":
-        show_local_content()
-    
-    elif selected_page == "سلاسل الإمداد":
-        show_supply_chain()
-    
-    elif selected_page == "المشتريات":
-        show_procurement()
-    
-    elif selected_page == "الموردون والمقاولون":
-        show_vendors()
-    
-    elif selected_page == "المشاريع المستقبلية":
-        show_future_projects()
-    
-    elif selected_page == "توقع احتمالية النجاح":
-        from utils.permissions import check_permission
-        if check_permission("access_ai"):
-            show_success_prediction()
+    def _extract_face_depth(self, depth_data: np.ndarray, bbox: Tuple[int, int, int, int]) -> np.ndarray:
+        """
+        Extract depth data for a specific face region.
+        
+        Args:
+            depth_data: Full depth map
+            bbox: Bounding box of the face (x, y, width, height)
+            
+        Returns:
+            Depth data corresponding to the face region
+        """
+        x, y, w, h = bbox
+        
+        # Ensure coordinates are within bounds
+        x = max(0, x)
+        y = max(0, y)
+        
+        # Extract depth data for the face region
+        face_depth = depth_data[y:y+h, x:x+w]
+        return face_depth
+    
+    def _fuse_recognition_results(self, result_2d: Dict, result_3d: Dict) -> Dict:
+        """
+        Fuse 2D and 3D recognition results using weighted confidence.
+        
+        Args:
+            result_2d: Results from 2D recognition
+            result_3d: Results from 3D recognition
+            
+        Returns:
+            Dictionary with fused recognition results
+        """
+        # Get weights from config
+        w_2d = self.config['fusion_weights']['2d']
+        w_3d = self.config['fusion_weights']['3d']
+        
+        # Extract confidences
+        conf_2d = result_2d['confidence']
+        conf_3d = result_3d['confidence']
+        
+        # Extract person IDs
+        id_2d = result_2d['person_id']
+        id_3d = result_3d['person_id']
+        
+        # Check if the IDs match
+        if id_2d == id_3d:
+            # Same person identified by both methods
+            fused_confidence = (w_2d * conf_2d + w_3d * conf_3d) / (w_2d + w_3d)
+            fused_id = id_2d
         else:
-            st.error("ليس لديك صلاحية للوصول إلى هذه الصفحة")
-    
-    elif selected_page == "التقارير":
-        show_reports()
-    
-    elif selected_page == "إعدادات الذكاء الاصطناعي":
-        from utils.permissions import check_permission
-        if check_permission("configure_system"):
-            show_ai_settings()
-        else:
-            st.error("ليس لديك صلاحية للوصول إلى هذه الصفحة")
+            # Different persons identified, use the one with higher weighted confidence
+            weighted_conf_2d = w_2d * conf_2d
+            weighted_conf_3d = w_3d * conf_3d
+            
+            if weighted_conf_2d > weighted_conf_3d:
+                fused_confidence = conf_2d
+                fused_id = id_2d
+            else:
+                fused_confidence = conf_3d
+                fused_id = id_3d
+        
+        return {
+            'person_id': fused_id,
+            'confidence': fused_confidence,
+            'method': 'hybrid_fusion'
+        }
     
-    # إضافة أيقونة تبديل وضع الموبايل/سطح المكتب
-    if st.session_state.is_mobile:
-        st.markdown(
-            """
-            <style>
-            .desktop-switch {
-                position: fixed;
-                bottom: 10px;
-                right: 10px;
-                background-color: #4a86e8;
-                color: white;
-                width: 40px;
-                height: 40px;
-                border-radius: 50%;
-                text-align: center;
-                line-height: 40px;
-                box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
-                z-index: 9999;
-                cursor: pointer;
+    def register_face(self, image: np.ndarray, person_id: str, 
+                     depth_data: Optional[np.ndarray] = None) -> Dict:
+        """
+        Register a new face in the database.
+        
+        Args:
+            image: Input image containing the face
+            person_id: Unique identifier for the person
+            depth_data: Optional depth data for 3D registration
+            
+        Returns:
+            Dictionary indicating registration status
+        """
+        try:
+            # Preprocess the image
+            preprocessed_image = self.preprocessor.preprocess(image)
+            
+            # Detect face
+            faces = self.face_detector.detect(preprocessed_image)
+            
+            if not faces:
+                return {'status': 'error', 'message': 'No face detected for registration'}
+            
+            # Use the largest face if multiple are detected
+            face_data = max(faces, key=lambda x: x['face_area'])
+            face_img = face_data['face_image']
+            
+            # Extract landmarks
+            landmarks = self.landmark_detector.detect_landmarks(face_img)
+            
+            # Extract 2D features
+            features_2d = self.feature_extractor.extract_features(face_img, mode='2d')
+            
+            # Register in 2D database
+            self.db_manager.add_face(person_id, features_2d, '2d', metadata={
+                'landmarks': landmarks,
+                'registration_time': self.db_manager.get_current_timestamp()
+            })
+            
+            # If depth data is available, also register in 3D database
+            if depth_data is not None:
+                face_depth = self._extract_face_depth(depth_data, face_data['bbox'])
+                features_3d = self.feature_extractor.extract_features(
+                    face_img, depth_data=face_depth, mode='3d'
+                )
+                self.db_manager.add_face(person_id, features_3d, '3d', metadata={
+                    'landmarks': landmarks,
+                    'registration_time': self.db_manager.get_current_timestamp()
+                })
+                
+                return {
+                    'status': 'success', 
+                    'message': 'Face registered in both 2D and 3D databases',
+                    'person_id': person_id
+                }
+            else:
+                return {
+                    'status': 'partial_success', 
+                    'message': 'Face registered in 2D database only (no depth data provided)',
+                    'person_id': person_id
+                }
+                
+        except Exception as e:
+            self.logger.error(f"Error registering face: {str(e)}")
+            return {'status': 'error', 'message': str(e)}
+    
+    def update_model(self, model_type: str = 'all') -> Dict:
+        """
+        Update/retrain the recognition models with the current database.
+        
+        Args:
+            model_type: Type of model to update ('2d', '3d', or 'all')
+            
+        Returns:
+            Dictionary with update status
+        """
+        try:
+            if model_type in ['2d', 'all']:
+                self.face_recognition_2d.update_model()
+                
+            if model_type in ['3d', 'all']:
+                self.face_recognition_3d.update_model()
+                
+            return {
+                'status': 'success',
+                'message': f'Successfully updated {model_type} recognition models'
             }
-            </style>
-            <div class="desktop-switch" onclick="window.open(window.location.href, '_blank')">🖥️</div>
-            """,
-            unsafe_allow_html=True
-        )
-    
-    # تسجيل زيارة الصفحة
-    logger.info(f"تمت زيارة صفحة {selected_page}")
+            
+        except Exception as e:
+            self.logger.error(f"Error updating models: {str(e)}")
+            return {'status': 'error', 'message': str(e)}
+    
+    def get_system_info(self) -> Dict:
+        """Get information about the current system configuration and status."""
+        return {
+            'system_name': 'Hybrid Face Recognition System',
+            'version': '1.0.0',
+            'recognition_mode': self.config['recognition_mode'],
+            'fusion_weights': self.config['fusion_weights'],
+            'database_status': self.db_manager.get_database_stats(),
+            'components': {
+                'face_detector': self.face_detector.get_info(),
+                'landmark_detector': self.landmark_detector.get_info(),
+                'feature_extractor': self.feature_extractor.get_info(),
+                '2d_recognition': self.face_recognition_2d.get_info(),
+                '3d_recognition': self.face_recognition_3d.get_info(),
+            }
+        }
+
+
+def demo():
+    """Simple demonstration of the hybrid face system."""
+    # Initialize the system
+    system = HybridFaceSystem()
+    
+    # Load a test image
+    image_path = "test_data/sample_face.jpg"
+    if not os.path.exists(image_path):
+        print(f"Error: Test image not found at {image_path}")
+        return
+    
+    image = cv2.imread(image_path)
+    if image is None:
+        print(f"Error: Could not load image from {image_path}")
+        return
+    
+    # For demo purposes, we'll use a dummy depth map
+    # In a real application, this would come from a depth sensor
+    depth_data = np.random.rand(*image.shape[:2]) * 255
+    depth_data = depth_data.astype(np.uint8)
+    
+    # Process the image
+    results = system.process_image(image, depth_data)
+    
+    # Print results
+    print("Hybrid Face System Demo Results:")
+    print(f"Status: {results['status']}")
+    
+    if results['status'] == 'success':
+        print(f"Number of faces detected: {results['num_faces']}")
+        
+        for i, face_result in enumerate(results['results']):
+            print(f"\nFace #{i+1}:")
+            print(f"  Bounding Box: {face_result['bbox']}")
+            print(f"  Person ID: {face_result['person_id']}")
+            print(f"  Confidence: {face_result['confidence']:.2f}")
+            print(f"  Emotion: {face_result['emotion']}")
+            print(f"  Head Pose: Pitch={face_result['pose']['pitch']:.2f}°, "
+                  f"Yaw={face_result['pose']['yaw']:.2f}°, "
+                  f"Roll={face_result['pose']['roll']:.2f}°")
+    
+    # Display system info
+    system_info = system.get_system_info()
+    print("\nSystem Information:")
+    print(f"  System Name: {system_info['system_name']}")
+    print(f"  Version: {system_info['version']}")
+    print(f"  Recognition Mode: {system_info['recognition_mode']}")
+
 
 if __name__ == "__main__":
-    main()
+    demo()