Update anti_spoofing.py

anti_spoofing.py

@@ -5,7 +5,6 @@ import os
 import time
 import mediapipe as mp
 from skimage import feature
-import gradio as gr
 
 class AntiSpoofingSystem:
     def __init__(self):
@@ -96,6 +95,49 @@ class AntiSpoofingSystem:
         self.frame_count += 1
         self.smartphone_detected = False
 
+    def access_verified_image(self):
+        ret, frame = self.cap.read()
+        if not ret:
+            return None
+
+        # Perform anti-spoofing checks
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        faces = self.detector(gray)
+        
+        # Check if a face is detected
+        if len(faces) == 0:
+            return None
+        
+        # Assume the first detected face is the subject
+        face = faces[0]
+        landmarks = self.predictor(gray, face)
+        
+        # Check for blink detection (assuming you have this method correctly implemented)
+        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 not self.detect_blink(ear_left, ear_right):
+            return None
+
+        # Check for hand gesture (assuming you have this method correctly implemented)
+        if not self.detect_hand_gesture(frame):
+            return None
+
+        # Check if a smartphone is detected
+        self.detect_smartphone(frame)
+        if self.smartphone_detected:
+            return None
+        
+        # Check texture for liveness (assuming you have this method correctly implemented)
+        (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])]
+        if not self.analyze_texture(expanded_region):
+            return None
+
+        return frame
+
     def detect_blink(self, left_ear, right_ear):
         if self.smartphone_detected:
             self.left_eye_state = False
@@ -163,35 +205,20 @@ class AntiSpoofingSystem:
         return frame
 
     def save_image(self, frame):
+        # Implement logic to save the frame as an image
         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 interface
+    def get_captured_image(self):
+        # Return the captured image with preprocessing applied (if necessary)
+        captured_frame = self.captured_image
+        if captured_frame is not None:
+            return captured_frame
+        return None
+
 if __name__ == "__main__":
-    interface.launch()
+    anti_spoofing_system = AntiSpoofingSystem()
+    anti_spoofing_system.run()