anti_spoofing.py

# Import all the libraries
import cv2
import dlib
import numpy as np
import os
import time
import mediapipe as mp
from skimage import feature

# I'm setting up the face and hand detectors here.
class AntiSpoofingSystem:
    def __init__(self):
        self.detector = dlib.get_frontal_face_detector()
        self.predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")

        # Here I initialize MediaPipe for hand gesture detection.
        self.mp_hands = mp.solutions.hands
        self.hands = self.mp_hands.Hands(static_image_mode=False, max_num_hands=1, min_detection_confidence=0.7)


        # This code is for Webcam if you have Jetson kit change value from 0 to 1.
        self.cap = cv2.VideoCapture(0)
        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)

        # I create a directory to save the captured images if it doesn't exist.
        self.save_directory = "Person"
        if not os.path.exists(self.save_directory):
            os.makedirs(self.save_directory)


        # Iam loading the Pre-trained model to detect smartphones.
        self.net_smartphone = cv2.dnn.readNet('yolov4.weights', 'PreTrained_yolov4.cfg')
        with open('PreTrained_coco.names', 'r') as f:
            self.classes_smartphone = f.read().strip().split('\n')


        # Setting some thresholds for eye aspect ratio to detect blinks.
        self.EAR_THRESHOLD = 0.2
        self.BLINK_CONSEC_FRAMES = 4

        # Initializing some variables to keep track of eye states and blink counts.
        self.left_eye_state = False
        self.right_eye_state = False
        self.left_blink_counter = 0
        self.right_blink_counter = 0

        # Variables to manage smartphone detection.
        self.smartphone_detected = False
        self.smartphone_detection_frame_interval = 10
        self.frame_count = 0

        # New attributes for student data
        self.student_id = None
        self.student_name = None


    # It is calculating the eye aspect ratio to detect blinks.
    def calculate_ear(self, eye):
        A = np.linalg.norm(eye[1] - eye[5])
        B = np.linalg.norm(eye[2] - eye[4])
        C = np.linalg.norm(eye[0] - eye[3])
        return (A + B) / (2.0 * C)


    # Analyzing the texture of the face to check for liveness.
    def analyze_texture(self, face_region):
        gray_face = cv2.cvtColor(face_region, cv2.COLOR_BGR2GRAY)
        lbp = feature.local_binary_pattern(gray_face, P=8, R=1, method="uniform")
        lbp_hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, 58), range=(0, 58))
        lbp_hist = lbp_hist.astype("float")
        lbp_hist /= (lbp_hist.sum() + 1e-5)
        return np.sum(lbp_hist[:10]) > 0.3

    # Detecting hand using MediaPipe.
    def detect_hand_gesture(self, frame):
        results = self.hands.process(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
        return results.multi_hand_landmarks is not None

    # Detecting smartphones in the frame to prevent System Bypass.
    def detect_smartphone(self, frame):
        if self.frame_count % self.smartphone_detection_frame_interval == 0:
            blob = cv2.dnn.blobFromImage(frame, 1 / 255.0, (224, 224), swapRB=True, crop=False)
            self.net_smartphone.setInput(blob)
            output_layers_names = self.net_smartphone.getUnconnectedOutLayersNames()
            detections = self.net_smartphone.forward(output_layers_names)

            for detection in detections:
                for obj in detection:
                    scores = obj[5:]
                    class_id = np.argmax(scores)
                    confidence = scores[class_id]
                    if confidence > 0.3 and self.classes_smartphone[class_id] == 'cell phone':
                        center_x = int(obj[0] * frame.shape[1])
                        center_y = int(obj[1] * frame.shape[0])
                        width = int(obj[2] * frame.shape[1])
                        height = int(obj[3] * frame.shape[0])
                        left = int(center_x - width / 2)
                        top = int(center_y - height / 2)

                        cv2.rectangle(frame, (left, top), (left + width, top + height), (0, 0, 255), 2)
                        cv2.putText(frame, 'Smartphone Detected', (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
                        
                        self.smartphone_detected = True
                        self.left_blink_counter = 0
                        self.right_blink_counter = 0
                        return

        self.frame_count += 1
        self.smartphone_detected = False
    
    # Checking if the user blinked to confirm their presence.
    def detect_blink(self, left_ear, right_ear):
        if self.smartphone_detected:
            self.left_eye_state = False
            self.right_eye_state = False
            self.left_blink_counter = 0
            self.right_blink_counter = 0
            return False

        # Incrementing blink counter if a blink is detected.
        if left_ear < self.EAR_THRESHOLD:
            if not self.left_eye_state:
                self.left_eye_state = True
        else:
            if self.left_eye_state:
                self.left_eye_state = False
                self.left_blink_counter += 1

        if right_ear < self.EAR_THRESHOLD:
            if not self.right_eye_state:
                self.right_eye_state = True
        else:
            if self.right_eye_state:
                self.right_eye_state = False
                self.right_blink_counter += 1


        # Resetting blink counters after a successful blink detection.
        if self.left_blink_counter > 0 and self.right_blink_counter > 0:
            self.left_blink_counter = 0
            self.right_blink_counter = 0
            return True
        else:
            return False

    # Main loop to process the video feed.
    def run(self, update_frame_callback=None):
        blink_count = 0
        hand_gesture_detected = False
        image_captured = False
        last_event_time = time.time()
        event_timeout = 60
        message_displayed = False

        while True:
            ret, frame = self.cap.read()
            if not ret:
                break
            
            # Detecting smartphones in the frame.   
            self.detect_smartphone(frame)

            # Displaying a warning if a smartphone is detected.
            if self.smartphone_detected:
                cv2.putText(frame, "Mobile phone detected, can't record attendance", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
                blink_count = 0

            # Processing each frame to detect faces, blinks, and hand gestures.
            if not self.smartphone_detected:
                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                faces = self.detector(gray)

                for face in faces:
                    landmarks = self.predictor(gray, face)
                    leftEye = np.array([(landmarks.part(n).x, landmarks.part(n).y) for n in range(36, 42)])
                    rightEye = np.array([(landmarks.part(n).x, landmarks.part(n).y) for n in range(42, 48)])

                    ear_left = self.calculate_ear(leftEye)
                    ear_right = self.calculate_ear(rightEye)

                    if self.detect_blink(ear_left, ear_right):
                        blink_count += 1

                    # Prionting and Incrementing blink Count
                    cv2.putText(frame, f"Blink Count: {blink_count}", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)

                    hand_gesture_detected = self.detect_hand_gesture(frame)

                    # Indicating when a hand gesture is detected.
                    if hand_gesture_detected:
                        cv2.putText(frame, "Hand Gesture Detected", (10, 100), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)

                    (x, y, w, h) = (face.left(), face.top(), face.width(), face.height())
                    expanded_region = frame[max(y - h // 2, 0):min(y + 3 * h // 2, frame.shape[0]),
                                            max(x - w // 2, 0):min(x + 3 * w // 2, frame.shape[1])]

                    # Checking if the conditions are met to capture the image.
                    if blink_count >= 5 and hand_gesture_detected and self.analyze_texture(expanded_region) and not message_displayed:
                        cv2.putText(frame, "Please hold still for 2 seconds...", (10, 150), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
                        cv2.imshow("Frame", frame)
                        cv2.waitKey(1)
                        time.sleep(2)
                        message_displayed = True

                    if message_displayed and not image_captured:
                        timestamp = int(time.time())
                        picture_name = f"{self.student_id}_{timestamp}.jpg"
                        cv2.imwrite(os.path.join(self.save_directory, picture_name), expanded_region)
                        image_captured = True

            if update_frame_callback:
                update_frame_callback(frame)

            cv2.imshow("Frame", frame)
            if image_captured or (time.time() - last_event_time > event_timeout and not hand_gesture_detected):
                break
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break

        self.cap.release()
        cv2.destroyAllWindows()

        #If person if real and did all the required features then his attendance will be marked if not then it will print no person detected.
        if image_captured:
            print(f"Person detected. Face image captured and saved as {picture_name}.")
        elif not hand_gesture_detected:
            print("No real person detected")

if __name__ == "__main__":
    anti_spoofing_system = AntiSpoofingSystem()
    anti_spoofing_system.run()