app.py

from flask import Flask, render_template, request, redirect, url_for, flash, send_file, jsonify
import cv2
import numpy as np
import pickle
import pandas as pd
import os
from datetime import datetime
from werkzeug.utils import secure_filename
import base64

# Try to import InsightFace
try:
    import insightface
    from insightface.app import FaceAnalysis
    INSIGHTFACE_AVAILABLE = True
    print("✓ InsightFace library is available - Professional grade accuracy!")
except ImportError:
    INSIGHTFACE_AVAILABLE = False
    print("⚠ InsightFace not available, falling back to OpenCV")

app = Flask(__name__)
app.secret_key = 'smart_attendance_system_2025_insightface'

# Configuration
UPLOAD_FOLDER = 'static/uploads'
DATABASE_FOLDER = 'database'
ATTENDANCE_FOLDER = 'attendance'
ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg'}

# Ensure directories exist
for folder in [UPLOAD_FOLDER, DATABASE_FOLDER, ATTENDANCE_FOLDER, 'static', 'templates']:
    os.makedirs(folder, exist_ok=True)

app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size

# Initialize InsightFace model
face_app = None
if INSIGHTFACE_AVAILABLE:
    try:
        face_app = FaceAnalysis(providers=['CPUExecutionProvider'])
        face_app.prepare(ctx_id=0, det_size=(640, 640))
        print("✓ InsightFace model loaded successfully!")
    except Exception as e:
        print(f"⚠ InsightFace model loading failed: {e}")
        INSIGHTFACE_AVAILABLE = False

def allowed_file(filename):
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS

def load_face_data():
    """Load face data from pickle file"""
    try:
        if INSIGHTFACE_AVAILABLE:
            with open(os.path.join(DATABASE_FOLDER, 'face_embeddings_insightface.pkl'), 'rb') as f:
                return pickle.load(f)
        else:
            # Fallback to OpenCV data
            with open(os.path.join(DATABASE_FOLDER, 'face_data_opencv.pkl'), 'rb') as f:
                return pickle.load(f)
    except FileNotFoundError:
        if INSIGHTFACE_AVAILABLE:
            return {'embeddings': [], 'names': [], 'roll_numbers': []}
        else:
            return {'images': [], 'names': [], 'roll_numbers': []}

def save_face_data(data):
    """Save face data to pickle file"""
    if INSIGHTFACE_AVAILABLE:
        with open(os.path.join(DATABASE_FOLDER, 'face_embeddings_insightface.pkl'), 'wb') as f:
            pickle.dump(data, f)
    else:
        with open(os.path.join(DATABASE_FOLDER, 'face_data_opencv.pkl'), 'wb') as f:
            pickle.dump(data, f)

def get_face_embedding_insightface(image_path):
    """Get face embedding using InsightFace"""
    try:
        img = cv2.imread(image_path)
        faces = face_app.get(img)
        
        if len(faces) == 0:
            return None
        
        # Get the largest face (most prominent)
        largest_face = max(faces, key=lambda x: (x.bbox[2] - x.bbox[0]) * (x.bbox[3] - x.bbox[1]))
        return largest_face.embedding
    except Exception as e:
        print(f"Error getting face embedding: {e}")
        return None

def compare_faces_insightface(known_embedding, unknown_embedding, threshold=0.5):
    """Compare face embeddings using cosine similarity"""
    try:
        # Calculate cosine similarity
        dot_product = np.dot(known_embedding, unknown_embedding)
        norm_a = np.linalg.norm(known_embedding)
        norm_b = np.linalg.norm(unknown_embedding)
        similarity = dot_product / (norm_a * norm_b)
        
        return similarity > threshold, similarity
    except Exception as e:
        print(f"Error comparing faces: {e}")
        return False, 0.0

def detect_faces_opencv(image_path):
    """Fallback face detection using OpenCV"""
    try:
        image = cv2.imread(image_path)
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
        
        if len(faces) == 0:
            return None
        
        x, y, w, h = faces[0]
        face_region = gray[y:y+h, x:x+w]
        return face_region
    except Exception as e:
        print(f"Error in OpenCV face detection: {e}")
        return None

def compare_faces_opencv(known_face, unknown_face, threshold=0.6):
    """Simple face comparison using template matching"""
    try:
        known_face = cv2.resize(known_face, (100, 100))
        unknown_face = cv2.resize(unknown_face, (100, 100))
        
        result = cv2.matchTemplate(known_face, unknown_face, cv2.TM_CCOEFF_NORMED)
        _, max_val, _, _ = cv2.minMaxLoc(result)
        
        return max_val > threshold
    except Exception as e:
        print(f"Error comparing faces with OpenCV: {e}")
        return False

def save_attendance(attendance_data):
    """Save attendance to CSV file"""
    today = datetime.now().strftime('%Y-%m-%d')
    filename = f"attendance_{today}.csv"
    filepath = os.path.join(ATTENDANCE_FOLDER, filename)
    
    df = pd.DataFrame(attendance_data)
    df.to_csv(filepath, index=False)
    return filename

@app.route('/')
def index():
    return render_template('index.html', 
                         insightface_available=INSIGHTFACE_AVAILABLE,
                         method="InsightFace" if INSIGHTFACE_AVAILABLE else "OpenCV")

@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'POST':
        try:
            name = request.form['name']
            roll_number = request.form['roll_number']
            
            if 'photo' not in request.files:
                flash('No photo uploaded!', 'error')
                return redirect(request.url)
            
            photo = request.files['photo']
            
            if photo.filename == '':
                flash('No photo selected!', 'error')
                return redirect(request.url)
            
            if photo and allowed_file(photo.filename):
                # Save the uploaded photo
                filename = secure_filename(f"{roll_number}_{photo.filename}")
                photo_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
                photo.save(photo_path)
                
                # Load existing data
                data = load_face_data()
                
                # Check if student already exists
                if roll_number in data['roll_numbers']:
                    flash('Student with this roll number already exists!', 'error')
                    os.remove(photo_path)
                    return redirect(request.url)
                
                if INSIGHTFACE_AVAILABLE:
                    # Use InsightFace for better accuracy
                    embedding = get_face_embedding_insightface(photo_path)
                    
                    if embedding is None:
                        flash('No face detected in the photo! Please try again with a clear front-facing photo.', 'error')
                        os.remove(photo_path)
                        return redirect(request.url)
                    
                    # Add new student data
                    data['embeddings'].append(embedding)
                    data['names'].append(name)
                    data['roll_numbers'].append(roll_number)
                    
                    method = "InsightFace (99% accuracy)"
                else:
                    # Use OpenCV fallback
                    face_region = detect_faces_opencv(photo_path)
                    
                    if face_region is None:
                        flash('No face detected in the photo! Please try again.', 'error')
                        os.remove(photo_path)
                        return redirect(request.url)
                    
                    # Add new student data
                    data['images'].append(face_region)
                    data['names'].append(name)
                    data['roll_numbers'].append(roll_number)
                    
                    method = "OpenCV (basic detection)"
                
                # Save updated data
                save_face_data(data)
                
                flash(f'✅ Student {name} (Roll: {roll_number}) registered successfully using {method}!', 'success')
                return redirect(url_for('register'))
            
            else:
                flash('Invalid file format! Please upload JPG, JPEG, or PNG.', 'error')
                
        except Exception as e:
            flash(f'Error occurred: {str(e)}', 'error')
    
    return render_template('register.html', 
                         insightface_available=INSIGHTFACE_AVAILABLE)

@app.route('/attendance', methods=['GET', 'POST'])
def attendance():
    if request.method == 'POST':
        try:
            if 'group_photo' not in request.files:
                flash('No photo uploaded!', 'error')
                return redirect(request.url)
            
            photo = request.files['group_photo']
            
            if photo.filename == '':
                flash('No photo selected!', 'error')
                return redirect(request.url)
            
            if photo and allowed_file(photo.filename):
                # Save the uploaded photo
                filename = secure_filename(f"group_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{photo.filename}")
                photo_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
                photo.save(photo_path)
                
                # Load stored face data
                stored_data = load_face_data()
                
                if INSIGHTFACE_AVAILABLE:
                    if not stored_data['embeddings']:
                        flash('No students registered yet! Please register students first.', 'error')
                        return redirect(request.url)
                else:
                    if not stored_data['images']:
                        flash('No students registered yet! Please register students first.', 'error')
                        return redirect(request.url)
                
                # Mark attendance
                present_students = []
                attendance_data = []
                confidence_scores = {}
                
                if INSIGHTFACE_AVAILABLE:
                    # Use InsightFace for attendance marking
                    img = cv2.imread(photo_path)
                    faces = face_app.get(img)
                    
                    if len(faces) == 0:
                        flash('No faces detected in the group photo!', 'error')
                        return redirect(request.url)
                    
                    print(f"Detected {len(faces)} faces in group photo")
                    
                    # Check each detected face against stored embeddings
                    for face in faces:
                        unknown_embedding = face.embedding
                        best_match = None
                        best_similarity = 0.0
                        
                        for i, known_embedding in enumerate(stored_data['embeddings']):
                            is_match, similarity = compare_faces_insightface(known_embedding, unknown_embedding)
                            
                            if is_match and similarity > best_similarity:
                                best_similarity = similarity
                                best_match = i
                        
                        if best_match is not None:
                            roll_number = stored_data['roll_numbers'][best_match]
                            name = stored_data['names'][best_match]
                            
                            if roll_number not in present_students:
                                present_students.append(roll_number)
                                confidence_scores[roll_number] = f"{best_similarity:.2f}"
                                print(f"Matched: {name} ({roll_number}) - Confidence: {best_similarity:.2f}")
                
                else:
                    # Use OpenCV fallback
                    image = cv2.imread(photo_path)
                    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
                    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
                    faces = face_cascade.detectMultiScale(gray, 1.1, 4)
                    
                    if len(faces) == 0:
                        flash('No faces detected in the group photo!', 'error')
                        return redirect(request.url)
                    
                    for (x, y, w, h) in faces:
                        face_region = gray[y:y+h, x:x+w]
                        
                        for i, stored_face in enumerate(stored_data['images']):
                            if compare_faces_opencv(stored_face, face_region):
                                roll_number = stored_data['roll_numbers'][i]
                                name = stored_data['names'][i]
                                
                                if roll_number not in present_students:
                                    present_students.append(roll_number)
                                break
                
                # Create attendance data for present students
                for roll_number in present_students:
                    idx = stored_data['roll_numbers'].index(roll_number)
                    attendance_record = {
                        'Roll_Number': roll_number,
                        'Name': stored_data['names'][idx],
                        'Date': datetime.now().strftime('%Y-%m-%d'),
                        'Time': datetime.now().strftime('%H:%M:%S'),
                        'Status': 'Present'
                    }
                    if INSIGHTFACE_AVAILABLE and roll_number in confidence_scores:
                        attendance_record['Confidence'] = confidence_scores[roll_number]
                    
                    attendance_data.append(attendance_record)
                
                # Mark absent students
                for i, roll_number in enumerate(stored_data['roll_numbers']):
                    if roll_number not in present_students:
                        attendance_record = {
                            'Roll_Number': roll_number,
                            'Name': stored_data['names'][i],
                            'Date': datetime.now().strftime('%Y-%m-%d'),
                            'Time': datetime.now().strftime('%H:%M:%S'),
                            'Status': 'Absent'
                        }
                        if INSIGHTFACE_AVAILABLE:
                            attendance_record['Confidence'] = 'N/A'
                        
                        attendance_data.append(attendance_record)
                
                # Save attendance
                filename = save_attendance(attendance_data)
                
                method = "InsightFace (Professional)" if INSIGHTFACE_AVAILABLE else "OpenCV (Basic)"
                flash(f'✅ Attendance marked successfully using {method}! {len(present_students)} students present.', 'success')
                
                return render_template('attendance_result.html', 
                                     attendance_data=attendance_data, 
                                     filename=filename,
                                     total_students=len(stored_data['names']),
                                     present_count=len(present_students),
                                     method=method,
                                     insightface_available=INSIGHTFACE_AVAILABLE)
            
            else:
                flash('Invalid file format! Please upload JPG, JPEG, or PNG.', 'error')
                
        except Exception as e:
            flash(f'Error occurred: {str(e)}', 'error')
            print(f"Attendance error: {e}")
    
    return render_template('attendance.html', 
                         insightface_available=INSIGHTFACE_AVAILABLE)

@app.route('/records')
def records():
    try:
        files = []
        if os.path.exists(ATTENDANCE_FOLDER):
            for filename in os.listdir(ATTENDANCE_FOLDER):
                if filename.endswith('.csv'):
                    filepath = os.path.join(ATTENDANCE_FOLDER, filename)
                    files.append({
                        'name': filename,
                        'date': datetime.fromtimestamp(os.path.getctime(filepath)).strftime('%Y-%m-%d %H:%M:%S'),
                        'size': f"{os.path.getsize(filepath) / 1024:.1f} KB"
                    })
        
        files.sort(key=lambda x: x['date'], reverse=True)
        return render_template('records.html', files=files)
    
    except Exception as e:
        flash(f'Error loading records: {str(e)}', 'error')
        return render_template('records.html', files=[])

@app.route('/download/<filename>')
def download_file(filename):
    try:
        return send_file(os.path.join(ATTENDANCE_FOLDER, filename), as_attachment=True)
    except Exception as e:
        flash(f'Error downloading file: {str(e)}', 'error')
        return redirect(url_for('records'))

@app.route('/view_attendance/<filename>')
def view_attendance(filename):
    try:
        filepath = os.path.join(ATTENDANCE_FOLDER, filename)
        df = pd.read_csv(filepath)
        attendance_data = df.to_dict('records')
        
        return render_template('view_attendance.html', 
                             attendance_data=attendance_data,
                             filename=filename)
    except Exception as e:
        flash(f'Error viewing attendance: {str(e)}', 'error')
        return redirect(url_for('records'))

@app.route('/students')
def students():
    try:
        data = load_face_data()
        students = []
        for i in range(len(data['names'])):
            students.append({
                'name': data['names'][i],
                'roll_number': data['roll_numbers'][i]
            })
        
        return render_template('students.html', students=students)
    except Exception as e:
        flash(f'Error loading students: {str(e)}', 'error')
        return render_template('students.html', students=[])

@app.route('/status')
def status():
    """Status endpoint to check which libraries are available"""
    return jsonify({
        'insightface_available': INSIGHTFACE_AVAILABLE,
        'opencv_available': True,
        'method': 'InsightFace' if INSIGHTFACE_AVAILABLE else 'OpenCV',
        'accuracy': '99%+' if INSIGHTFACE_AVAILABLE else '60-70%'
    })

if __name__ == '__main__':
    print("\n" + "="*60)
    print("🚀 Smart Attendance System with InsightFace Starting...")
    print("="*60)
    if INSIGHTFACE_AVAILABLE:
        print("✅ Using InsightFace - Professional Grade (99%+ accuracy)")
        print("✅ Advanced face recognition with confidence scoring")
        print("✅ Multiple face detection in group photos")
    else:
        print("⚠️  InsightFace not available, using OpenCV fallback")
        print("   To get 99% accuracy, install: pip install insightface onnxruntime")
    print("="*60)
    print("🌐 Access your app at: http://localhost:5000")
    print("="*60)
    
    app.run(debug=True, host='0.0.0.0', port=5000)