| import os
|
| import cv2
|
| import numpy as np
|
| from codes.base.core import (
|
| detections_to_rect,
|
| landmarks_to_detections,
|
| slice_from_roi,
|
| tflite_inference,
|
| transform_rect,
|
| )
|
|
|
|
|
| PATH2ROOT_ABS = os.path.dirname(__file__) + "/../../"
|
|
|
|
|
| def from_landmarks_to_depth(
|
| frame_rgb, eye_landmarks, image_size, is_right_eye=False, focal_length=None
|
| ):
|
| """
|
| Predicting the iris position using eyes landmarks
|
|
|
| Parameters:
|
| frame_rgb: the frame (RGB)
|
| eye_landmarks: the landmarks of the eyes
|
| image_size: the image size
|
| is_right_eye: whether or not it's the right eye
|
| focal_length: the focal length of the camera
|
|
|
| Returns:
|
| success: whether or not the iris is detected
|
| depth: distance to the camera
|
| iris_size: the size of the iris
|
| iris_landmarks: iris landmarks
|
| eye_contours: eye contours
|
| iris_landmarks_respect: iris landmarks respect to the eyes
|
| """
|
| if focal_length is None:
|
| focal_length = frame_rgb.shape[1]
|
|
|
| detections = landmarks_to_detections(eye_landmarks)
|
| rect = detections_to_rect(detections, image_size, rotation_vector_start_end=(0, 1))
|
| roi = transform_rect(rect, image_size, scale_x=2.3, scale_y=2.3)
|
|
|
| slice_y = slice_from_roi(roi, image_size, False)
|
| slice_x = slice_from_roi(roi, image_size, True)
|
| eye_image = frame_rgb[slice(*slice_y), slice(*slice_x), :]
|
| position_in_frame = np.array((slice_x[0], slice_y[0], 0))
|
|
|
| if eye_image.any():
|
| success = True
|
| eye_contours, iris_landmarks, eye_frame_low = detect_iris(
|
| eye_image.copy(), is_right_eye=is_right_eye
|
| )
|
|
|
| iris_landmarks_respect = iris_landmarks.copy()
|
|
|
| eye_contours[:, 0] = eye_contours[:, 0] * eye_image.shape[0]
|
| eye_contours[:, 1] = eye_contours[:, 1] * eye_image.shape[1]
|
| eye_contours = eye_contours + position_in_frame
|
|
|
| eye_contours[:, 0] = eye_contours[:, 0] / frame_rgb.shape[1]
|
| eye_contours[:, 1] = eye_contours[:, 1] / frame_rgb.shape[0]
|
|
|
| iris_landmarks[:, 0] = iris_landmarks[:, 0] * eye_image.shape[0]
|
| iris_landmarks[:, 1] = iris_landmarks[:, 1] * eye_image.shape[1]
|
| iris_landmarks = iris_landmarks + position_in_frame
|
|
|
| iris_landmarks[:, 0] = iris_landmarks[:, 0] / frame_rgb.shape[1]
|
| iris_landmarks[:, 1] = iris_landmarks[:, 1] / frame_rgb.shape[0]
|
|
|
| depth, iris_size = calculate_iris_depth(iris_landmarks, image_size, focal_length)
|
|
|
| else:
|
| success = False
|
| depth = None
|
| iris_size = None
|
| iris_landmarks = None
|
| eye_contours = None
|
| iris_landmarks_respect = None
|
|
|
| return success, depth, iris_size, iris_landmarks, eye_contours, iris_landmarks_respect
|
|
|
|
|
| def detect_iris(eye_frame, is_right_eye=False):
|
| side_low = 64
|
| eye_frame_low = cv2.resize(
|
| eye_frame, (side_low, side_low), interpolation=cv2.INTER_AREA
|
| )
|
|
|
| model_path = PATH2ROOT_ABS + "models/iris/iris_landmark.tflite"
|
|
|
| if is_right_eye:
|
| eye_frame_low = np.fliplr(eye_frame_low)
|
|
|
| outputs = tflite_inference(eye_frame_low / 127.5 - 1.0, model_path)
|
| eye_contours_low = np.reshape(outputs[0], (71, 3))
|
| iris_landmarks_low = np.reshape(outputs[1], (5, 3))
|
|
|
| eye_contours = eye_contours_low / side_low
|
| iris_landmarks = iris_landmarks_low / side_low
|
|
|
| if is_right_eye:
|
| eye_contours[:, 0] = 1 - eye_contours[:, 0]
|
| iris_landmarks[:, 0] = 1 - iris_landmarks[:, 0]
|
|
|
| return eye_contours, iris_landmarks, eye_frame_low
|
|
|
|
|
| def calculate_iris_depth(iris_landmarks, image_size, focal_length_pixel):
|
| """
|
| iris_landmarks should be normalized to the complete image frame
|
| depth in mm
|
| """
|
| iris_size = calculate_iris_diameter(iris_landmarks, image_size)
|
| depth = calculate_depth(
|
| iris_landmarks[0, :], focal_length_pixel, iris_size, image_size
|
| )
|
|
|
| return depth, iris_size
|
|
|
|
|
| def get_depth(x0, y0, x1, y1):
|
| return np.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2)
|
|
|
|
|
| def get_landmark_depth(ld0, ld1, image_size):
|
| return get_depth(
|
| ld0[0] * image_size[0],
|
| ld0[1] * image_size[1],
|
| ld1[0] * image_size[0],
|
| ld1[1] * image_size[1],
|
| )
|
|
|
|
|
| def calculate_iris_diameter(iris_landmarks, image_size):
|
| dist_vert = get_landmark_depth(
|
| iris_landmarks[1, :], iris_landmarks[3, :], image_size
|
| )
|
| dist_hori = get_landmark_depth(
|
| iris_landmarks[2, :], iris_landmarks[4, :], image_size
|
| )
|
|
|
| return (dist_hori + dist_vert) / 2.0
|
|
|
|
|
| def calculate_depth(center_landmark, focal_length_pixel, iris_size, image_size):
|
|
|
| human_iris_size_in_mm = 11.8
|
| origin = np.array(image_size) / 2.0
|
| center_landmark_pixel = center_landmark[:2] * np.array(image_size)
|
| y = get_depth(
|
| origin[0], origin[1], center_landmark_pixel[0], center_landmark_pixel[1]
|
| )
|
| x = np.sqrt(focal_length_pixel ** 2 + y ** 2)
|
| depth = human_iris_size_in_mm * x / iris_size
|
|
|
| return depth
|
|
|
