RSK World - Face Recognition Dataset - Project Files Browser | RSK World

example_usage.py

"""
Example Usage Script for Face Recognition Dataset

This script demonstrates how to use the face recognition system.

Project Information:
- Project ID: 22
- Title: Face Recognition Dataset
- Category: Image Data
- Technologies: PNG, JPG, NumPy, OpenCV, Face Recognition
- Difficulty: Intermediate

Contact Information:
RSK World
Founder: Molla Samser
Designer & Tester: Rima Khatun
Email: help@rskworld.in
Phone: +91 93305 39277
Address: Nutanhat, Mongolkote, Purba Burdwan, West Bengal, India, 713147
Website: https://rskworld.in/
Year: 2026
"""

import os
import cv2
import numpy as np
import config
from scripts.load_dataset import FaceDatasetLoader
from scripts.preprocess import preprocess_faces, get_face_encoding
from scripts.recognize_faces import FaceRecognizer


def example_load_dataset():
    """Example: Loading the dataset."""
    print("\n" + "=" * 60)
    print("Example 1: Loading Dataset")
    print("=" * 60)
    
    loader = FaceDatasetLoader(config.TRAIN_DIR)
    images, labels, label_mapping = loader.load()
    
    print(f"Loaded {len(images)} images")
    print(f"Number of identities: {len(label_mapping)}")
    print("\nLabel mapping:")
    for label, name in sorted(label_mapping.items()):
        print(f"  {label}: {name}")
    
    # Get statistics
    stats = loader.get_statistics()
    print("\nDataset Statistics:")
    for key, value in stats.items():
        if key != 'images_per_person':
            print(f"  {key}: {value}")


def example_preprocess():
    """Example: Preprocessing images."""
    print("\n" + "=" * 60)
    print("Example 2: Preprocessing Images")
    print("=" * 60)
    
    processed_images, processed_labels = preprocess_faces(config.TRAIN_DIR)
    
    print(f"\nPreprocessed {len(processed_images)} face images")
    print(f"Image shape: {processed_images[0].shape}")
    print(f"Image dtype: {processed_images[0].dtype}")
    print(f"Number of unique labels: {len(np.unique(processed_labels))}")


def example_train_and_recognize():
    """Example: Training and recognizing faces."""
    print("\n" + "=" * 60)
    print("Example 3: Training and Recognition")
    print("=" * 60)
    
    # Initialize recognizer
    recognizer = FaceRecognizer()
    
    # Train the model
    print("\nTraining the model...")
    recognizer.train(config.TRAIN_DIR, save_model=True)
    
    # Example: Recognize faces in a test image (if available)
    if os.path.exists(config.TEST_DIR):
        test_images = []
        for root, dirs, files in os.walk(config.TEST_DIR):
            for file in files:
                if any(file.lower().endswith(ext) for ext in config.IMAGE_EXTENSIONS):
                    test_images.append(os.path.join(root, file))
                    break  # Just use first image found
        
        if test_images:
            test_image_path = test_images[0]
            print(f"\nRecognizing faces in: {test_image_path}")
            results = recognizer.recognize(test_image_path)
            
            for i, result in enumerate(results):
                print(f"\nFace {i + 1}:")
                print(f"  Name: {result['name']}")
                print(f"  Confidence: {result['confidence']:.2%}")
                if result['distance'] is not None:
                    print(f"  Distance: {result['distance']:.4f}")


def example_face_encoding():
    """Example: Getting face encodings."""
    print("\n" + "=" * 60)
    print("Example 4: Face Encoding")
    print("=" * 60)
    
    loader = FaceDatasetLoader(config.TRAIN_DIR)
    images, labels, label_mapping = loader.load()
    
    if len(images) > 0:
        # Get encoding for first image
        encoding = get_face_encoding(images[0])
        
        if encoding is not None:
            print(f"Face encoding shape: {encoding.shape}")
            print(f"Face encoding dtype: {encoding.dtype}")
            print(f"Encoding sample (first 5 values): {encoding[:5]}")
        else:
            print("No face detected in the first image")


def main():
    """Run all examples."""
    print("=" * 60)
    print("Face Recognition Dataset - Example Usage")
    print("=" * 60)
    print(f"Project: Face Recognition Dataset (ID: 22)")
    print(f"RSK World - https://rskworld.in/")
    print("=" * 60)
    
    # Check if training directory exists
    if not os.path.exists(config.TRAIN_DIR):
        print(f"\nError: Training directory not found: {config.TRAIN_DIR}")
        print("Please ensure the dataset is properly organized.")
        return
    
    try:
        example_load_dataset()
        example_preprocess()
        example_face_encoding()
        example_train_and_recognize()
        
        print("\n" + "=" * 60)
        print("All examples completed!")
        print("=" * 60)
        
    except Exception as e:
        print(f"\nError: {e}")
        import traceback
        traceback.print_exc()


if __name__ == "__main__":
    main()

160 lines•5 KB

python

scripts/api_server.py

Raw Download

"""
REST API Server for Face Recognition

This module provides a Flask-based REST API for face recognition services.

Project Information:
- Project ID: 22
- Title: Face Recognition Dataset
- Category: Image Data
- Technologies: PNG, JPG, NumPy, OpenCV, Face Recognition

Contact Information:
RSK World
Founder: Molla Samser
Designer & Tester: Rima Khatun
Email: help@rskworld.in
Phone: +91 93305 39277
Address: Nutanhat, Mongolkote, Purba Burdwan, West Bengal, India, 713147
Website: https://rskworld.in/
Year: 2026
"""

from flask import Flask, request, jsonify
import cv2
import numpy as np
from PIL import Image
import io
import base64
from scripts.recognize_faces import FaceRecognizer
import config
import os

# Try to import advanced features (optional)
try:
    from scripts.advanced_features import FaceVerifier, FaceClustering, FaceQualityAssessment
    ADVANCED_FEATURES_AVAILABLE = True
except ImportError:
    ADVANCED_FEATURES_AVAILABLE = False
    print("Warning: Advanced features not available. Some API endpoints may not work.")

app = Flask(__name__)

# Initialize recognizer
recognizer = None
verifier = None
quality_assessor = None

if ADVANCED_FEATURES_AVAILABLE:
    verifier = FaceVerifier()
    quality_assessor = FaceQualityAssessment()


def init_recognizer():
    """Initialize the face recognizer."""
    global recognizer
    recognizer = FaceRecognizer()
    if os.path.exists(recognizer.model_path):
        recognizer.load_model()
    else:
        recognizer.train(config.TRAIN_DIR, save_model=True)


def decode_image(image_data: str) -> np.ndarray:
    """
    Decode base64 image data.
    
    Args:
        image_data: Base64 encoded image string
        
    Returns:
        Decoded image as numpy array
    """
    if ',' in image_data:
        image_data = image_data.split(',')[1]
    
    image_bytes = base64.b64decode(image_data)
    image = Image.open(io.BytesIO(image_bytes))
    return np.array(image)


@app.route('/api/health', methods=['GET'])
def health():
    """Health check endpoint."""
    return jsonify({
        'status': 'healthy',
        'service': 'Face Recognition API',
        'version': '1.0.0'
    })


@app.route('/api/recognize', methods=['POST'])
def recognize():
    """
    Recognize faces in an image.
    
    Request body:
    {
        "image": "base64_encoded_image"
    }
    """
    try:
        data = request.json
        if 'image' not in data:
            return jsonify({'error': 'No image provided'}), 400
        
        image = decode_image(data['image'])
        # PIL images are already in RGB format, no conversion needed
        rgb_image = image
        
        if recognizer is None:
            init_recognizer()
        
        results = recognizer.recognize_from_array(rgb_image)
        
        return jsonify({
            'success': True,
            'faces_detected': len(results),
            'results': results
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/verify', methods=['POST'])
def verify():
    """
    Verify if two images contain the same person.
    
    Request body:
    {
        "image1": "base64_encoded_image1",
        "image2": "base64_encoded_image2"
    }
    """
    if not ADVANCED_FEATURES_AVAILABLE or verifier is None:
        return jsonify({'error': 'Face verification feature not available'}), 503
    
    try:
        data = request.json
        if 'image1' not in data or 'image2' not in data:
            return jsonify({'error': 'Both images required'}), 400
        
        image1 = decode_image(data['image1'])
        image2 = decode_image(data['image2'])
        
        # PIL images are already in RGB format, no conversion needed
        rgb1 = image1
        rgb2 = image2
        
        from scripts.preprocess import get_face_encoding
        
        encoding1 = get_face_encoding(rgb1)
        encoding2 = get_face_encoding(rgb2)
        
        if encoding1 is None or encoding2 is None:
            return jsonify({'error': 'Could not detect face in one or both images'}), 400
        
        result = verifier.verify(encoding1, encoding2)
        
        return jsonify({
            'success': True,
            'result': result
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/quality', methods=['POST'])
def assess_quality():
    """
    Assess quality of face image.
    
    Request body:
    {
        "image": "base64_encoded_image"
    }
    """
    if not ADVANCED_FEATURES_AVAILABLE or quality_assessor is None:
        return jsonify({'error': 'Quality assessment feature not available'}), 503
    
    try:
        data = request.json
        if 'image' not in data:
            return jsonify({'error': 'No image provided'}), 400
        
        image = decode_image(data['image'])
        # PIL images are already in RGB format, no conversion needed
        rgb_image = image
        
        from scripts.preprocess import detect_faces
        
        face_locations = detect_faces(rgb_image)
        
        if len(face_locations) == 0:
            return jsonify({'error': 'No face detected'}), 400
        
        quality = quality_assessor.assess(rgb_image, face_locations[0])
        
        return jsonify({
            'success': True,
            'quality': quality
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/cluster', methods=['POST'])
def cluster():
    """
    Cluster multiple face encodings.
    
    Request body:
    {
        "encodings": [[...], [...], ...]
    }
    """
    if not ADVANCED_FEATURES_AVAILABLE:
        return jsonify({'error': 'Face clustering feature not available'}), 503
    
    try:
        data = request.json
        if 'encodings' not in data:
            return jsonify({'error': 'No encodings provided'}), 400
        
        encodings = [np.array(e) for e in data['encodings']]
        
        clusterer = FaceClustering()
        result = clusterer.cluster(encodings)
        
        return jsonify({
            'success': True,
            'result': result
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


if __name__ == '__main__':
    print("=" * 60)
    print("Face Recognition API Server")
    print("=" * 60)
    print(f"Project: Face Recognition Dataset (ID: 22)")
    print(f"RSK World - https://rskworld.in/")
    print("=" * 60)
    print("\nInitializing recognizer...")
    init_recognizer()
    print("\nStarting server on http://localhost:5000")
    print("API endpoints:")
    print("  GET  /api/health - Health check")
    print("  POST /api/recognize - Recognize faces")
    print("  POST /api/verify - Verify two faces")
    print("  POST /api/quality - Assess image quality")
    print("  POST /api/cluster - Cluster face encodings")
    print("=" * 60)
    
    app.run(host='0.0.0.0', port=5000, debug=True)

258 lines•7.1 KB

python

Theme Settings

Color Scheme

Display Options

Font Size