Update anti_spoofing.py

anti_spoofing.py

@@ -1,15 +1,51 @@
-import gradio as gr
 import cv2
 import dlib
 import numpy as np
+import os
+import time
+import mediapipe as mp
 from skimage import feature
+import gradio as gr
 
-# Initialize your AntiSpoofingSystem class as previously defined
 class AntiSpoofingSystem:
     def __init__(self):
         self.detector = dlib.get_frontal_face_detector()
+        self.anti_spoofing_completed = False
+        self.blink_count = 0
+        self.image_captured = False
+        self.captured_image = None
         self.predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
+
+        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)
+
+        self.cap = cv2.VideoCapture(0)
+        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
+        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
+
+        self.save_directory = "Person"
+        if not os.path.exists(self.save_directory):
+            os.makedirs(self.save_directory)
+
+        self.net_smartphone = cv2.dnn.readNet('yolov4.weights', 'Pretrained_yolov4 (1).cfg')
+        with open('PreTrained_coco.names', 'r') as f:
+            self.classes_smartphone = f.read().strip().split('\n')
+
         self.EAR_THRESHOLD = 0.25
+        self.BLINK_CONSEC_FRAMES = 4
+
+        self.left_eye_state = False
+        self.right_eye_state = False
+        self.left_blink_counter = 0
+        self.right_blink_counter = 0
+
+        self.smartphone_detected = False
+        self.smartphone_detection_frame_interval = 30
+        self.frame_count = 0
+
+        # New attributes for student data
+        self.student_id = None
+        self.student_name = None
 
     def calculate_ear(self, eye):
         A = np.linalg.norm(eye[1] - eye[5])
@@ -25,42 +61,137 @@ class AntiSpoofingSystem:
         lbp_hist /= (lbp_hist.sum() + 1e-5)
         return np.sum(lbp_hist[:10]) > 0.3
 
-    def process_image(self, image):
-        # Convert the image to grayscale and detect faces
-        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        faces = self.detector(gray)
+    def detect_hand_gesture(self, frame):
+        results = self.hands.process(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        return results.multi_hand_landmarks is not None
 
-        # If no face is detected, return a message
-        if len(faces) == 0:
-            return "No face detected. Please try again."
+    def detect_smartphone(self, frame):
+        if self.frame_count % self.smartphone_detection_frame_interval == 0:
+            blob = cv2.dnn.blobFromImage(frame, 1 / 255.0, (416, 416), swapRB=True, crop=False)
+            self.net_smartphone.setInput(blob)
+            output_layers_names = self.net_smartphone.getUnconnectedOutLayersNames()
+            detections = self.net_smartphone.forward(output_layers_names)
 
-        # Process the first detected face
-        face = faces[0]
-        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)
+            for detection in detections:
+                for obj in detection:
+                    scores = obj[5:]
+                    class_id = np.argmax(scores)
+                    confidence = scores[class_id]
+                    if confidence > 0.5 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)
 
-        # Determine if a blink is detected
-        blink_detected = (ear_left < self.EAR_THRESHOLD and ear_right < self.EAR_THRESHOLD)
-        return "Blink detected!" if blink_detected else "No blink detected."
+                        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
 
-# Define the Gradio interface
-anti_spoofing_system = AntiSpoofingSystem()
+        self.frame_count += 1
+        self.smartphone_detected = False
+
+    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
+
+        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
 
-def detect_blink(image):
-    result = anti_spoofing_system.process_image(image)
-    return result
+        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
 
-iface = gr.Interface(
-    fn=detect_blink,
-    inputs=gr.Image(shape=(720, 1280)),
-    outputs="text",
-    title="Anti-Spoofing Detection System",
-    description="Upload an image with a face to detect if a blink is detected."
+        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
+
+    def run(self):
+        ret, frame = self.cap.read()
+        if not ret:
+            return None
+
+        # Detect smartphone in the frame
+        self.detect_smartphone(frame)
+
+        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)
+        else:
+            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):
+                    self.blink_count += 1
+                    cv2.putText(frame, f"Blink Count: {self.blink_count}", (10, 70), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+
+                # Check if conditions for image capture are met
+                if self.blink_count >= 5 and not self.image_captured:
+                    # Capture the image and reset blink count
+                    self.save_image(frame)
+                    self.blink_count = 0
+                    self.image_captured = True
+
+        return frame
+
+    def save_image(self, frame):
+        timestamp = int(time.time())
+        image_name = f"captured_{timestamp}.png"
+        cv2.imwrite(os.path.join(self.save_directory, image_name), frame)
+        self.captured_image = frame
+        print(f"Image captured and saved as {image_name}")
+
+    def run_gradio(self):
+        # Capture a frame, perform anti-spoofing, and return the result
+        frame = self.run()
+        if frame is None:
+            return "No frame detected", None
+        
+        # Convert frame for Gradio to display
+        _, buffer = cv2.imencode('.png', frame)
+        return "Anti-spoofing check completed", buffer.tobytes()
+
+# Initialize the anti-spoofing system
+anti_spoofing_system = AntiSpoofingSystem()
+
+# Define the Gradio interface
+interface = gr.Interface(
+    fn=anti_spoofing_system.run_gradio,
+    inputs=[],
+    outputs=["text", "image"],
+    live=True,
+    title="Anti-Spoofing System",
+    description="This application performs an anti-spoofing check."
 )
 
-# Launch the Gradio interface
-iface.launch()
+# Launch the interface
+if __name__ == "__main__":
+    interface.launch()