def process_livenessdetection(): cam_index = 0 cam_resolution = RESOLUTION_QVGA # model_detector=FaceDetectorModels.HAARCASCADE model_detector = FaceDetectorModels.DLIBHOG # model_detector=FaceDetectorModels.DLIBCNN # model_detector=FaceDetectorModels.SSDRESNET # model_detector=FaceDetectorModels.MTCNN # model_detector=FaceDetectorModels.FACENET # model_recognizer=FaceEncoderModels.LBPH # model_recognizer=FaceEncoderModels.OPENFACE model_recognizer = FaceEncoderModels.DLIBRESNET # model_recognizer=FaceEncoderModels.FACENET #liveness=FaceLivenessModels.EYESBLINK_MOUTHOPEN liveness = FaceLivenessModels.COLORSPACE_YCRCBLUV # Initialize the camera camera = cam_init(cam_index, cam_resolution[0], cam_resolution[1]) check = int( input( "Enter number 1 if you want to show live video and vice versa: ")) try: # Initialize face detection face_detector = FaceDetector(model=model_detector, path=INPUT_DIR_MODEL_DETECTION) # Initialize face recognizer face_encoder = FaceEncoder(model=model_recognizer, path=INPUT_DIR_MODEL_ENCODING, path_training=INPUT_DIR_MODEL_TRAINING, training=False) # Initialize face liveness detection face_liveness = FaceLiveness( model=FaceLivenessModels.EYESBLINK_MOUTHOPEN, path=INPUT_DIR_MODEL_LIVENESS) face_liveness2 = FaceLiveness( model=FaceLivenessModels.COLORSPACE_YCRCBLUV, path=INPUT_DIR_MODEL_LIVENESS) except: #face_encoder = None print("Warning, check if models and trained dataset models exists!") return face_id, confidence = (None, 0) ##edit eyes_close, eyes_ratio = (False, 0) total_eye_blinks, eye_counter, eye_continuous_close = ( 0, 0, 1) # eye_continuous_close should depend on frame rate mouth_open, mouth_ratio = (False, 0) total_mouth_opens, mouth_counter, mouth_continuous_open = ( 0, 0, 1) # eye_continuous_close should depend on frame rate time_start = time() time_elapsed = 0 frame_count = 0 identified_unique_faces = {} # dictionary runtime = 1000 # monitor for 10 seconds only is_fake_count_print = 0 is_fake_count_replay = 0 face_count = 0 ##edit time_recognition = 5 checkface = False print("Note: this will run for {} seconds only".format(runtime)) while (time_elapsed < runtime): # Capture frame from webcam ret, frame = camera.read() if frame is None: print("Error, check if camera is connected!") break ## Detect and identify faces in the frame #faces = face_detector.detect(frame) #for (index, face) in enumerate(faces): #(x, y, w, h) = face ## Indentify face based on trained dataset (note: should run facial_recognition_training.py) #if face_encoder is not None: #face_id, confidence = face_encoder.identify(frame, (x, y, w, h)) ## Set text and bounding box on face #label_face(frame, (x, y, w, h), face_id, confidence) # Process 1 face only #break # Detect and identify faces in the frame # Indentify face based on trained dataset (note: should run facial_recognition_training.py) faces = face_detector.detect(frame) for (index, face) in enumerate(faces): # Check if eyes are close and if mouth is open eyes_close, eyes_ratio = face_liveness.is_eyes_close(frame, face) mouth_open, mouth_ratio = face_liveness.is_mouth_open(frame, face) #print("eyes_close={}, eyes_ratio ={:.2f}".format(mouth_open, mouth_ratio)) #print("mouth_open={}, mouth_ratio={:.2f}".format(mouth_open, mouth_ratio)) # Detect if frame is a print attack or replay attack based on colorspace is_fake_print = face_liveness2.is_fake(frame, face) is_fake_replay = face_liveness2.is_fake(frame, face, flag=1) # Identify face only if it is not fake and eyes are open and mouth is close if is_fake_print: is_fake_count_print += 1 face_id, confidence = ("Fake", None) elif is_fake_replay: is_fake_count_replay += 1 face_id, confidence = ("Fake", None) elif not eyes_close and not mouth_open: face_id, confidence = face_encoder.identify(frame, face) if (face_id not in identified_unique_faces) & (confidence > 50): identified_unique_faces[face_id] = 1 elif (face_id in identified_unique_faces) & (confidence > 50): identified_unique_faces[face_id] += 1 if (face_count > 100) | (face_id == "Fake"): face_count = 0 elif (face_id != "Fake") & (confidence > 50): face_count += 1 print("Identifying: {:.2f} %".format((face_count / 100) * 100)) label_face(frame, face, face_id, confidence) # Set text and bounding box on face break # Process 1 face only # Monitor eye blinking and mouth opening for liveness detection total_eye_blinks, eye_counter = monitor_eye_blinking( eyes_close, eyes_ratio, total_eye_blinks, eye_counter, eye_continuous_close) total_mouth_opens, mouth_counter = monitor_mouth_opening( mouth_open, mouth_ratio, total_mouth_opens, mouth_counter, mouth_continuous_open) # Update frame count frame_count += 1 time_elapsed = time() - time_start #cv2.imshow(WINDOW_NAME, frame) if face_count > 99: checkface = True break else: checkface = False # Display updated frame to web app if check == 1: yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + cv2.imencode('.jpg', frame)[1].tobytes() + b'\r\n\r\n') if checkface == True: print("Hello {}!!!".format( max(identified_unique_faces, key=identified_unique_faces.get))) else: print("Can not indentify your face, please try again!") # Release the camera camera.release() cv2.destroyAllWindows()
def process_livenessdetection(model_detector, model_recognizer, model_liveness, cam_index, cam_resolution): # Initialize the camera camera = cam_init(cam_index, cam_resolution[0], cam_resolution[1]) ##input check = int( input( "Enter number 1 if you want to show live video and vice versa: ")) try: # Initialize face detection face_detector = FaceDetector(model=model_detector, path=INPUT_DIR_MODEL_DETECTION) # Initialize face recognizer face_encoder = FaceEncoder(model=model_recognizer, path=INPUT_DIR_MODEL_ENCODING, path_training=INPUT_DIR_MODEL_TRAINING, training=False) # Initialize face liveness detection face_liveness = FaceLiveness( model=FaceLivenessModels.EYESBLINK_MOUTHOPEN, path=INPUT_DIR_MODEL_LIVENESS) face_liveness2 = FaceLiveness( model=FaceLivenessModels.COLORSPACE_YCRCBLUV, path=INPUT_DIR_MODEL_LIVENESS) except: print("Error, check if models and trained dataset models exists!") return face_id, confidence = (None, 0) eyes_close, eyes_ratio = (False, 0) total_eye_blinks, eye_counter, eye_continuous_close = ( 0, 0, 1) # eye_continuous_close should depend on frame rate mouth_open, mouth_ratio = (False, 0) total_mouth_opens, mouth_counter, mouth_continuous_open = ( 0, 0, 1) # eye_continuous_close should depend on frame rate time_start = time() time_elapsed = 0 frame_count = 0 identified_unique_faces = {} # dictionary runtime = 60 # monitor for 10 seconds only is_fake_count_print = 0 is_fake_count_replay = 0 face_count = 0 ##edit time_recognition = 5 checkface = False print("Note: this will run for {} seconds only".format(runtime)) while (time_elapsed < runtime): # Capture frame from webcam ret, frame = camera.read() if frame is None: print("Error, check if camera is connected!") break # Detect and identify faces in the frame # Indentify face based on trained dataset (note: should run facial_recognition_training.py) faces = face_detector.detect(frame) for (index, face) in enumerate(faces): # Check if eyes are close and if mouth is open eyes_close, eyes_ratio = face_liveness.is_eyes_close(frame, face) mouth_open, mouth_ratio = face_liveness.is_mouth_open(frame, face) #print("eyes_close={}, eyes_ratio ={:.2f}".format(mouth_open, mouth_ratio)) #print("mouth_open={}, mouth_ratio={:.2f}".format(mouth_open, mouth_ratio)) # Detect if frame is a print attack or replay attack based on colorspace is_fake_print = face_liveness2.is_fake(frame, face) is_fake_replay = face_liveness2.is_fake(frame, face, flag=1) # Identify face only if it is not fake and eyes are open and mouth is close if is_fake_print: is_fake_count_print += 1 face_id, confidence = ("Fake", None) elif is_fake_replay: is_fake_count_replay += 1 face_id, confidence = ("Fake", None) elif not eyes_close and not mouth_open: face_id, confidence = face_encoder.identify(frame, face) if (face_id not in identified_unique_faces) & (confidence > 50): identified_unique_faces[face_id] = 1 elif (face_id in identified_unique_faces) & (confidence > 50): identified_unique_faces[face_id] += 1 if (face_count > 100) | (face_id == "Fake"): face_count = 0 elif (face_id != "Fake") & (confidence > 50): face_count += 1 print("Identifying: {:.2f} %".format((face_count / 31) * 100)) label_face(frame, face, face_id, confidence) # Set text and bounding box on face break # Process 1 face only # Monitor eye blinking and mouth opening for liveness detection total_eye_blinks, eye_counter = monitor_eye_blinking( eyes_close, eyes_ratio, total_eye_blinks, eye_counter, eye_continuous_close) total_mouth_opens, mouth_counter = monitor_mouth_opening( mouth_open, mouth_ratio, total_mouth_opens, mouth_counter, mouth_continuous_open) # Update frame count frame_count += 1 time_elapsed = time() - time_start # Display updated frame if check == 1: cv2.imshow(WINDOW_NAME, frame) # Check for user actions if cv2.waitKey(1) & 0xFF == 27: # ESC break if face_count > 30: checkface = True break else: checkface = False print("Note: this will run for {} seconds only".format(runtime)) # Determining if face is alive can depend on the following factors and more: time_elapsed = int(time() - time_start) print("\n") print("Face Liveness Data:") print("time_elapsed = {}".format(time_elapsed) ) # recognition will run for specific time (ex. 3 seconds) print("frame_count = {}".format( frame_count)) # can be used for averaging print("total_eye_blinks = {}".format( total_eye_blinks)) # fake face if 0 print("total_mouth_opens = {}".format( total_mouth_opens)) # fake face if 0 print("is_fake_count_print = {}".format( is_fake_count_print)) # fake face if not 0 print("is_fake_count_replay = {}".format( is_fake_count_replay)) # fake face if not 0 print("identified_unique_faces = {}".format( identified_unique_faces)) # fake face if recognized more than 1 face print("Todo: determine if face is alive using this data.") print("\n") if checkface == True: print("Hello {}!!!".format( max(identified_unique_faces, key=identified_unique_faces.get))) else: print("Can not indentify your face, please try again!") #print("{}".format(face_id)) # Release the camera camera.release() cv2.destroyAllWindows()
def login(): windowname = "Result" INPUT_DIR_DATASET = "datasets" INPUT_DIR_MODEL_DETECTION = "models/detection/" INPUT_DIR_MODEL_ENCODING = "models/encoding/" INPUT_DIR_MODEL_TRAINING = "models/training/" INPUT_DIR_MODEL_ESTIMATION = "models/estimation/" INPUT_DIR_MODEL_LIVENESS = "models/liveness/" # Set width and height RESOLUTION_QVGA = (320, 240) #cap = cv2.VideoCapture(0) # cam_index = 0 cam_resolution = RESOLUTION_QVGA # detector = FaceDetectorModels.HAARCASCADE # detector=FaceDetectorModels.DLIBHOG # detector=FaceDetectorModels.DLIBCNN # detector=FaceDetectorModels.SSDRESNET # detector=FaceDetectorModels.MTCNN detector = FaceDetectorModels.FACENET # encoder = FaceEncoderModels.LBPH # encoder=FaceEncoderModels.OPENFACE # encoder=FaceEncoderModels.DLIBRESNET encoder = FaceEncoderModels.FACENET liveness = FaceLivenessModels.EYESBLINK_MOUTHOPEN # liveness=FaceLivenessModels.COLORSPACE_YCRCBLUV # Initialize the camera #camera = cam_init(cam_resolution[0], cam_resolution[1]) try: # Initialize face detection face_detector = FaceDetector(model=detector, path=INPUT_DIR_MODEL_DETECTION) # Initialize face recognizer face_encoder = FaceEncoder(model=encoder, path=INPUT_DIR_MODEL_ENCODING, path_training=INPUT_DIR_MODEL_TRAINING, training=False) # Initialize face liveness detection face_liveness = FaceLiveness(model=liveness, path=INPUT_DIR_MODEL_LIVENESS) face_liveness2 = FaceLiveness( model=FaceLivenessModels.COLORSPACE_YCRCBLUV, path=INPUT_DIR_MODEL_LIVENESS) except: print("Error, check if models and trained dataset models exists!") return face_id, confidence = (None, 0) eyes_close, eyes_ratio = (False, 0) total_eye_blinks, eye_counter, eye_continuous_close = ( 0, 0, 1) # eye_continuous_close should depend on frame rate mouth_open, mouth_ratio = (False, 0) total_mouth_opens, mouth_counter, mouth_continuous_open = ( 0, 0, 1) # eye_continuous_close should depend on frame rate time_start = time() time_elapsed = 0 frame_count = 0 identified_unique_faces = {} # dictionary runtime = 10 # monitor for 10 seconds only is_fake_count_print = 0 # print("Note: this will run for {} seconds only".format(runtime)) while (True): # Capture frame from webcam if flask.request.method == "POST": # image = request.get("image") # read the image in PIL format image = request.files["image"] print("image :", type(image)) npimg = np.fromfile(image, np.uint8) print("npimg :", type(npimg)) file = cv2.imdecode(npimg, cv2.IMREAD_COLOR) print("file :", type(file)) # pil_image = Image.open(image) #img = np.array(Image.open(io.BytesIO(image))) # save the image on server side # cv2.imwrite('saved_image/new.jpg', cv2.cvtColor(img, cv2.COLOR_RGB2BGR)) frame = file if frame is None: print("Error, check if camera is connected!") break # Detect and identify faces in the frame # Indentify face based on trained dataset (note: should run facial_recognition_training.py) faces = face_detector.detect(frame) for (index, face) in enumerate(faces): # Check if eyes are close and if mouth is open eyes_close, eyes_ratio = face_liveness.is_eyes_close( frame, face) mouth_open, mouth_ratio = face_liveness.is_mouth_open( frame, face) print("eyes_close={}, eyes_ratio ={:.2f}".format( mouth_open, mouth_ratio)) print("mouth_open={}, mouth_ratio={:.2f}".format( mouth_open, mouth_ratio)) # print("confidence: " , confidence) # Detect if frame is a print attack or replay attack based on colorspace is_fake_print = face_liveness2.is_fake(frame, face) # is_fake_replay = face_liveness2.is_fake(frame, face, flag=1) # Identify face only if it is not fake and eyes are open and mouth is close if is_fake_print: is_fake_count_print += 1 face_id, confidence = ("Fake", None) elif not eyes_close and not mouth_open: face_id, confidence = face_encoder.identify(frame, face) if face_id not in identified_unique_faces: identified_unique_faces[face_id] = 1 else: identified_unique_faces[face_id] += 1 label_face(frame, face, face_id, confidence) # Set text and bounding box on face #cv2.imshow(windowname,frame) #cv2.waitKey(1) conf = confidence id = face_id print("confidence :", confidence) print("faceid :", face_id) '''if face_id in identified_unique_faces: return render_template('success.html') else: return render_template('result_F.html')''' '''POST_USERNAME = str(request.form['name']) if POST_USERNAME==id: return render_template('success.html') else: return render_template('result_F.html')''' #yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + cv2.imencode('.jpg', frame)[1].tobytes() + b'\r\n\r\n') # Monitor eye blinking and mouth opening for liveness detection total_eye_blinks, eye_counter = monitor_eye_blinking( eyes_close, eyes_ratio, total_eye_blinks, eye_counter, eye_continuous_close) total_mouth_opens, mouth_counter = monitor_mouth_opening( mouth_open, mouth_ratio, total_mouth_opens, mouth_counter, mouth_continuous_open) # Update frame count frame_count += 1
def process_facerecognition_livenessdetection_poseagegenderemotion( cam_resolution, out_resolution, framecount, image=None, model_detector=0, model_recognizer=0): from libfaceid.liveness import FaceLivenessDetectorModels, FaceLiveness from libfaceid.pose import FacePoseEstimatorModels, FacePoseEstimator from libfaceid.age import FaceAgeEstimatorModels, FaceAgeEstimator from libfaceid.gender import FaceGenderEstimatorModels, FaceGenderEstimator from libfaceid.emotion import FaceEmotionEstimatorModels, FaceEmotionEstimator model_poseestimator = FacePoseEstimatorModels.DEFAULT model_ageestimator = FaceAgeEstimatorModels.DEFAULT model_genderestimator = FaceGenderEstimatorModels.DEFAULT model_emotionestimator = FaceEmotionEstimatorModels.DEFAULT # Initialize the camera if image is not None: cap = cv2.VideoCapture(image) else: cap = cam_init(cam_resolution[0], cam_resolution[1]) ############################################################################### # FACE DETECTION ############################################################################### # Initialize face detection face_detector = FaceDetector( model=model_detector, path=INPUT_DIR_MODEL_DETECTION) #, optimize=True) ############################################################################### # FACE RECOGNITION ############################################################################### # Initialize face recognizer face_encoder = FaceEncoder(model=model_recognizer, path=INPUT_DIR_MODEL_ENCODING, path_training=INPUT_DIR_MODEL_TRAINING, training=False) ############################################################################### # EYE BLINKING DETECTOR ############################################################################### # Initialize detector for blinking eyes face_liveness = FaceLiveness(model=FaceLivenessDetectorModels.EYEBLINKING, path=INPUT_DIR_MODEL_ESTIMATION) face_liveness.initialize() (eye_counter, total_eye_blinks) = (0, 0) ############################################################################### # FACE POSE/AGE/GENDER/EMOTION ESTIMATION ############################################################################### # Initialize pose/age/gender/emotion estimation if model_poseestimator is not None: face_pose_estimator = FacePoseEstimator( model=model_poseestimator, path=INPUT_DIR_MODEL_ESTIMATION) if model_ageestimator is not None: face_age_estimator = FaceAgeEstimator(model=model_ageestimator, path=INPUT_DIR_MODEL_ESTIMATION) if model_genderestimator is not None: face_gender_estimator = FaceGenderEstimator( model=model_genderestimator, path=INPUT_DIR_MODEL_ESTIMATION) if model_emotionestimator is not None: face_emotion_estimator = FaceEmotionEstimator( model=model_emotionestimator, path=INPUT_DIR_MODEL_ESTIMATION) (age, gender, emotion) = (None, None, None) # Initialize fps counter fps_frames = 0 fps_start = time() fps = 0 saveVideo = False out = None while (True): # Capture frame-by-frame ret, frame = cap.read() if ret == 0: print("Unexpected error! " + image) break ############################################################################### # FACE DETECTION and FACE RECOGNITION ############################################################################### # Detect and recognize each face in the images # Resize to QVGA so that RPI we can have acceptable fps if out_resolution is not None: #frame = imutils.resize(frame, width=out_resolution[0]) (h, w) = image.shape[:2] frame = cv2.resize( frame, (out_resolution[0], int(h * out_resolution[0] / float(w)))) ############################################################################### # FACE DETECTION ############################################################################### faces = face_detector.detect(frame) for (index, face) in enumerate(faces): (x, y, w, h) = face ############################################################################### # FACE AGE/GENDER/EMOTION ESTIMATION ############################################################################### face_image = frame[y:y + h, h:h + w] if model_ageestimator is not None: age = face_age_estimator.estimate(frame, face_image) if model_genderestimator is not None: gender = face_gender_estimator.estimate(frame, face_image) if model_emotionestimator is not None: emotion = face_emotion_estimator.estimate(frame, face_image) ############################################################################### # FACE RECOGNITION ############################################################################### face_id, confidence = face_encoder.identify(frame, (x, y, w, h)) ############################################################################### # EYE BLINKING DETECTION ############################################################################### total_eye_blinks, eye_counter = face_liveness.detect( frame, (x, y, w, h), total_eye_blinks, eye_counter) ############################################################################### # FACE POSE ESTIMATION ############################################################################### # Detect and draw face pose locations if model_poseestimator is not None: shape = face_pose_estimator.detect(frame, face) face_pose_estimator.add_overlay(frame, shape) # Display name, age, gender, emotion cv2.putText(frame, "Age: {}".format(age), (20, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText(frame, "Gender: {}".format(gender), (20, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText(frame, "Emotion: {}".format(emotion), (20, 100), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText(frame, "Name: {} [{:.2f}%]".format(face_id, confidence), (20, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) ############################################################################### # EYE BLINKING DETECTION ############################################################################### cv2.putText(frame, "Blinks: {}".format(total_eye_blinks), (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) # Update frame count fps_frames += 1 if (framecount != 0 and fps_frames >= framecount): break if (fps_frames % 30 == 29): fps = fps_frames / (time() - fps_start) fps_frames = 0 fps_start = time() cv2.putText(frame, "FPS {:.2f}".format(fps), (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA) # Save the frame to a video if saveVideo: out.write(frame) # Display the resulting frame cv2.imshow(WINDOW_NAME, frame) # Check for user actions keyPressed = cv2.waitKey(1) & 0xFF if keyPressed == 27: # ESC break elif keyPressed == 32: # Space saveVideo, out = save_video(saveVideo, out, frame.shape[:2], WINDOW_NAME + ".avi") elif keyPressed == 13: # Enter save_photo( frame, WINDOW_NAME + "_" + datetime.datetime.now().strftime("%Y%m%d_%H%M%S") + ".jpg") # Set the fps time_diff = time() - fps_start if time_diff: fps = fps_frames / time_diff if image is not None: cv2.waitKey(3000) if saveVideo == True: out.release() # Release the camera cam_release(cap) return fps
def login(): INPUT_DIR_DATASET = "datasets" INPUT_DIR_MODEL_DETECTION = "models/detection/" INPUT_DIR_MODEL_ENCODING = "models/encoding/" INPUT_DIR_MODEL_TRAINING = "models/training/" INPUT_DIR_MODEL_ESTIMATION = "models/estimation/" INPUT_DIR_MODEL_LIVENESS = "models/liveness/" # Set width and height RESOLUTION_QVGA = (320, 240) cap = cv2.VideoCapture(0) # cam_index = 0 cam_resolution = RESOLUTION_QVGA # detector = FaceDetectorModels.HAARCASCADE # detector=FaceDetectorModels.DLIBHOG # detector=FaceDetectorModels.DLIBCNN # detector=FaceDetectorModels.SSDRESNET # detector=FaceDetectorModels.MTCNN detector = FaceDetectorModels.FACENET # encoder = FaceEncoderModels.LBPH # encoder=FaceEncoderModels.OPENFACE # encoder=FaceEncoderModels.DLIBRESNET encoder = FaceEncoderModels.FACENET liveness = FaceLivenessModels.EYESBLINK_MOUTHOPEN # liveness=FaceLivenessModels.COLORSPACE_YCRCBLUV # Initialize the camera #camera = cam_init(cam_resolution[0], cam_resolution[1]) try: # Initialize face detection face_detector = FaceDetector(model=detector, path=INPUT_DIR_MODEL_DETECTION) # Initialize face recognizer face_encoder = FaceEncoder(model=encoder, path=INPUT_DIR_MODEL_ENCODING, path_training=INPUT_DIR_MODEL_TRAINING, training=False) # Initialize face liveness detection face_liveness = FaceLiveness(model=liveness, path=INPUT_DIR_MODEL_LIVENESS) face_liveness2 = FaceLiveness( model=FaceLivenessModels.COLORSPACE_YCRCBLUV, path=INPUT_DIR_MODEL_LIVENESS) except: print("Error, check if models and trained dataset models exists!") return face_id, confidence = (None, 0) eyes_close, eyes_ratio = (False, 0) total_eye_blinks, eye_counter, eye_continuous_close = ( 0, 0, 1) # eye_continuous_close should depend on frame rate mouth_open, mouth_ratio = (False, 0) total_mouth_opens, mouth_counter, mouth_continuous_open = ( 0, 0, 1) # eye_continuous_close should depend on frame rate time_start = time() time_elapsed = 0 frame_count = 0 identified_unique_faces = {} # dictionary runtime = 10 # monitor for 10 seconds only is_fake_count_print = 0 # print("Note: this will run for {} seconds only".format(runtime)) while (True): # Capture frame from webcam ret, frame = cap.read() if frame is None: print("Error, check if camera is connected!") break # Detect and identify faces in the frame # Indentify face based on trained dataset (note: should run facial_recognition_training.py) faces = face_detector.detect(frame) for (index, face) in enumerate(faces): # Check if eyes are close and if mouth is open eyes_close, eyes_ratio = face_liveness.is_eyes_close(frame, face) mouth_open, mouth_ratio = face_liveness.is_mouth_open(frame, face) print("eyes_close={}, eyes_ratio ={:.2f}".format( mouth_open, mouth_ratio)) print("mouth_open={}, mouth_ratio={:.2f}".format( mouth_open, mouth_ratio)) # print("confidence: " , confidence) # Detect if frame is a print attack or replay attack based on colorspace is_fake_print = face_liveness2.is_fake(frame, face) # is_fake_replay = face_liveness2.is_fake(frame, face, flag=1) # Identify face only if it is not fake and eyes are open and mouth is close if is_fake_print: is_fake_count_print += 1 face_id, confidence = ("Fake", None) elif not eyes_close and not mouth_open: face_id, confidence = face_encoder.identify(frame, face) if face_id not in identified_unique_faces: identified_unique_faces[face_id] = 1 else: identified_unique_faces[face_id] += 1 label_face(frame, face, face_id, confidence) # Set text and bounding box on face conf = confidence print("confidence :", confidence) print("faceid :", face_id) if conf >= 90: #return 'Recognized' return render_template('success.html') else: #return 'Not recognized' return render_template('dashboard.html') #yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + cv2.imencode('.jpg', frame)[1].tobytes() + b'\r\n\r\n') # Monitor eye blinking and mouth opening for liveness detection total_eye_blinks, eye_counter = monitor_eye_blinking( eyes_close, eyes_ratio, total_eye_blinks, eye_counter, eye_continuous_close) total_mouth_opens, mouth_counter = monitor_mouth_opening( mouth_open, mouth_ratio, total_mouth_opens, mouth_counter, mouth_continuous_open) # Update frame count frame_count += 1 # Release the camera cap.release() cv2.destroyAllWindows()