| import math |
| import numpy as np |
| import cv2 |
| from .pupil import Pupil |
|
|
|
|
| class Eye(object): |
| """ |
| This class creates a new frame to isolate the eye and |
| initiates the pupil detection. |
| """ |
|
|
| LEFT_EYE_POINTS = [36, 37, 38, 39, 40, 41] |
| RIGHT_EYE_POINTS = [42, 43, 44, 45, 46, 47] |
|
|
| def __init__(self, original_frame, landmarks, side, calibration): |
| self.frame = None |
| self.origin = None |
| self.center = None |
| self.pupil = None |
| self.landmark_points = None |
|
|
| self._analyze(original_frame, landmarks, side, calibration) |
|
|
| @staticmethod |
| def _middle_point(p1, p2): |
| """Returns the middle point (x,y) between two points |
| |
| Arguments: |
| p1 (dlib.point): First point |
| p2 (dlib.point): Second point |
| """ |
| x = int((p1.x + p2.x) / 2) |
| y = int((p1.y + p2.y) / 2) |
| return (x, y) |
|
|
| def _isolate(self, frame, landmarks, points): |
| """Isolate an eye, to have a frame without other part of the face. |
| |
| Arguments: |
| frame (numpy.ndarray): Frame containing the face |
| landmarks (dlib.full_object_detection): Facial landmarks for the face region |
| points (list): Points of an eye (from the 68 Multi-PIE landmarks) |
| """ |
| region = np.array([(landmarks.part(point).x, landmarks.part(point).y) for point in points]) |
| region = region.astype(np.int32) |
| self.landmark_points = region |
|
|
| |
| height, width = frame.shape[:2] |
| black_frame = np.zeros((height, width), np.uint8) |
| mask = np.full((height, width), 255, np.uint8) |
| cv2.fillPoly(mask, [region], (0, 0, 0)) |
| eye = cv2.bitwise_not(black_frame, frame.copy(), mask=mask) |
|
|
| |
| margin = 5 |
| min_x = np.min(region[:, 0]) - margin |
| max_x = np.max(region[:, 0]) + margin |
| min_y = np.min(region[:, 1]) - margin |
| max_y = np.max(region[:, 1]) + margin |
|
|
| self.frame = eye[min_y:max_y, min_x:max_x] |
| self.origin = (min_x, min_y) |
|
|
| height, width = self.frame.shape[:2] |
| self.center = (width / 2, height / 2) |
|
|
| def _blinking_ratio(self, landmarks, points): |
| """Calculates a ratio that can indicate whether an eye is closed or not. |
| It's the division of the width of the eye, by its height. |
| |
| Arguments: |
| landmarks (dlib.full_object_detection): Facial landmarks for the face region |
| points (list): Points of an eye (from the 68 Multi-PIE landmarks) |
| |
| Returns: |
| The computed ratio |
| """ |
| left = (landmarks.part(points[0]).x, landmarks.part(points[0]).y) |
| right = (landmarks.part(points[3]).x, landmarks.part(points[3]).y) |
| top = self._middle_point(landmarks.part(points[1]), landmarks.part(points[2])) |
| bottom = self._middle_point(landmarks.part(points[5]), landmarks.part(points[4])) |
|
|
| eye_width = math.hypot((left[0] - right[0]), (left[1] - right[1])) |
| eye_height = math.hypot((top[0] - bottom[0]), (top[1] - bottom[1])) |
|
|
| try: |
| ratio = eye_width / eye_height |
| except ZeroDivisionError: |
| ratio = None |
|
|
| return ratio |
|
|
| def _analyze(self, original_frame, landmarks, side, calibration): |
| """Detects and isolates the eye in a new frame, sends data to the calibration |
| and initializes Pupil object. |
| |
| Arguments: |
| original_frame (numpy.ndarray): Frame passed by the user |
| landmarks (dlib.full_object_detection): Facial landmarks for the face region |
| side: Indicates whether it's the left eye (0) or the right eye (1) |
| calibration (calibration.Calibration): Manages the binarization threshold value |
| """ |
| if side == 0: |
| points = self.LEFT_EYE_POINTS |
| elif side == 1: |
| points = self.RIGHT_EYE_POINTS |
| else: |
| return |
|
|
| self.blinking = self._blinking_ratio(landmarks, points) |
| self._isolate(original_frame, landmarks, points) |
|
|
| if not calibration.is_complete(): |
| calibration.evaluate(self.frame, side) |
|
|
| threshold = calibration.threshold(side) |
| self.pupil = Pupil(self.frame, threshold) |
|
|
