first commit

.gitattributes

@@ -0,0 +1 @@
+*.onnx filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,38 @@
+# Face Recognition Service
+
+This is a FastAPI-based microservice for face detection and verification using DeepFace.
+
+## Prerequisites
+
+- Python 3.8+
+- pip
+
+## Installation
+
+1. Navigate to this directory:
+   ```bash
+   cd face-recognition-service
+   ```
+
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+   *Note: DeepFace may require additional system dependencies depending on your OS.*
+
+## Running the Service
+
+Start the server using uvicorn:
+
+```bash
+uvicorn face_service:app --reload --port 8000
+```
+
+The service will be available at `http://localhost:8000`.
+
+## API Endpoints
+
+- `GET /` - Health check.
+- `POST /detect` - Detect faces in a base64 encoded image.
+- `POST /verify` - Verify a live face against a list of stored face images.

face_service.py

@@ -0,0 +1,131 @@
+from typing import Optional
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+import base64
+import cv2
+import numpy as np
+from deepface import DeepFace
+import os
+import tempfile
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+class VerifyRequest(BaseModel):
+    live: str
+    stored: list[str] = []
+
+def base64_to_image(b64_string):
+    try:
+        if "," in b64_string:
+            b64_string = b64_string.split(",")[1]
+        
+        # Decode base64 string to bytes
+        img_bytes = base64.b64decode(b64_string)
+        
+        # Convert bytes to numpy array
+        nparr = np.frombuffer(img_bytes, np.uint8)
+        
+        # Decode image
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        return img
+    except Exception as e:
+        logger.error(f"Error converting base64 to image: {str(e)}")
+        return None
+
+@app.post("/detect")
+def detect_face(data: VerifyRequest):
+    # We use the 'live' image from request for detection check
+    # We can reuse VerifyRequest or make a new one. VerifyRequest has 'stored' too.
+    # Let's handle generic inputs or just ignore 'stored'.
+    try:
+        img = base64_to_image(data.live)
+        if img is None:
+             raise HTTPException(status_code=400, detail="Invalid image")
+
+        # extract_faces returns a list of detected faces
+        # enforce_detection=True is default. If no face, it raises ValueError
+        faces = DeepFace.extract_faces(img_path=img, detector_backend="opencv", enforce_detection=True)
+        return {"detected": True, "count": len(faces)}
+    except ValueError:
+        return {"detected": False, "count": 0}
+    except Exception as e:
+        logger.error(f"Detection error: {str(e)}")
+        # If error is generic, return false
+        return {"detected": False, "error": str(e)}
+
+@app.post("/verify")
+def verify_face(data: VerifyRequest):
+    try:
+        img_live = base64_to_image(data.live)
+        if img_live is None:
+             raise HTTPException(status_code=400, detail="Invalid live image")
+
+        if not data.stored:
+             raise HTTPException(status_code=400, detail="No stored images for verification")
+
+        best_result = None
+        best_distance = float('inf')
+
+        # Check against stored images
+        # Optimization: Return immediately if we find a match (Early Exit)
+        for stored_b64 in data.stored:
+            img_stored = base64_to_image(stored_b64)
+            if img_stored is None:
+                continue
+
+            try:
+                result = DeepFace.verify(
+                    img1_path=img_live,
+                    img2_path=img_stored,
+                    model_name="VGG-Face",
+                    enforce_detection=False,
+                    detector_backend="opencv"
+                )
+                
+                # If verified, return immediately (Speed optimization)
+                if result['verified']:
+                    logger.info(f"Match found! Early exit. Distance: {result['distance']}")
+                    return {
+                        "verified": True,
+                        "distance": float(result['distance']),
+                        "threshold": float(result['threshold']),
+                        "model": "VGG-Face"
+                    }
+                    
+                # Keep the best match (lowest distance) just in case none pass 'verified' check
+                # but we want to return the closest failure? Or just fail.
+                if result['distance'] < best_distance:
+                    best_distance = result['distance']
+                    best_result = result
+            except Exception as match_error:
+                logger.error(f"Single pair verification failed: {match_error}")
+                continue
+        
+        if not best_result:
+             raise HTTPException(status_code=400, detail="Verification failed for all images (or no valid stored images)")
+
+        logger.info(f"Best verification result: {best_result}")
+        
+        return {
+            "verified": bool(best_result['verified']),
+            "distance": float(best_result['distance']),
+            "threshold": float(best_result['threshold']),
+            "model": "VGG-Face"
+        }
+
+    except Exception as e:
+        logger.error(f"Verification error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/")
+def home():
+    return {"status": "Face Service is running"}
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+pydantic
+numpy
+opencv-python
+deepface

setup.md

@@ -0,0 +1,101 @@
+# SIH Project Setup Guide
+
+## Quick Start
+
+### 1. Backend Server Setup
+```bash
+cd server
+npm install
+# Create .env file with:
+# PORT=5000
+# MONGODB_URI=mongodb://localhost:27017/sih_attendance
+npm run dev
+```
+
+### 2. Student Mobile App Setup
+```bash
+cd app
+npm install
+npx expo start
+# Scan QR code with Expo Go app
+```
+
+### 3. Admin Web App Setup
+```bash
+cd admin
+npm install
+npm start
+# Open http://localhost:3000
+```
+
+### 4. Face Recognition Service Setup
+```bash
+cd face-recognition-service
+pip install -r requirements.txt
+python face_service.py
+# Reference Server runs on http://localhost:8000
+```
+
+## Demo Credentials
+
+### Student Login
+- Student ID: STU001
+- Password: password123
+
+### Admin Login
+- Username: admin
+- Password: admin123
+
+## Features Implemented
+
+✅ Student login with dummy authentication
+✅ Profile page with navigation
+✅ QR code scanner for attendance (expo-camera)
+✅ Attendance percentage view
+✅ Timetable view with API integration
+✅ Free time slot suggestions
+✅ Tests/Exams view with dummy data
+✅ AsyncStorage for device ID storage
+✅ Axios for API calls
+✅ Admin login (dummy)
+✅ QR code generation with auto-refresh
+✅ Attendance list management
+✅ Timetable management
+✅ Express API routes for all features
+✅ MongoDB models and integration
+✅ Dummy data for 2 students with complete schedules
+
+## API Endpoints
+
+- POST /api/auth/login
+- POST /api/attendance/generate-qr
+- POST /api/attendance/mark
+- GET /api/attendance/:studentId
+- GET /api/timetable/:studentId
+- GET /api/freetime/:studentId
+- GET /api/tests/:studentId
+
+## Project Structure
+
+```
+SIH/
+├── app/                    # Expo React Native App
+│   ├── src/
+│   │   ├── screens/        # All app screens
+│   │   ├── services/       # API services
+│   │   └── context/        # Auth context
+│   └── package.json
+├── admin/                  # React Web App
+│   ├── src/
+│   │   ├── components/     # React components
+│   │   └── services/       # API services
+│   └── package.json
+└── server/                 # Node.js Backend
+    ├── models/             # MongoDB models
+    ├── server.js           # Main server file
+    └── package.json
+```
+
+## Ready to Use!
+
+The project is fully functional with all requested features implemented. Start the backend server first, then the admin app, and finally the mobile app to test the complete system.