| import traceback |
|
|
| import cv2 |
| import numpy as np |
| from modules import images |
| from PIL import Image |
|
|
|
|
| from scripts.reactor_entities.rect import Point, Rect |
|
|
|
|
| class FaceArea: |
| def __init__(self, entire_image: np.ndarray, face_area: Rect, face_margin: float, face_size: int, upscaler: str): |
| self.face_area = face_area |
| self.center = face_area.center |
| left, top, right, bottom = face_area.to_square() |
|
|
| self.left, self.top, self.right, self.bottom = self.__ensure_margin( |
| left, top, right, bottom, entire_image, face_margin |
| ) |
|
|
| self.width = self.right - self.left |
| self.height = self.bottom - self.top |
|
|
| self.image = self.__crop_face_image(entire_image, face_size, upscaler) |
| self.face_size = face_size |
| self.scale_factor = face_size / self.width |
| self.face_area_on_image = self.__get_face_area_on_image() |
| self.landmarks_on_image = self.__get_landmarks_on_image() |
|
|
| def __get_face_area_on_image(self): |
| left = int((self.face_area.left - self.left) * self.scale_factor) |
| top = int((self.face_area.top - self.top) * self.scale_factor) |
| right = int((self.face_area.right - self.left) * self.scale_factor) |
| bottom = int((self.face_area.bottom - self.top) * self.scale_factor) |
| return self.__clip_values(left, top, right, bottom) |
|
|
| def __get_landmarks_on_image(self): |
| landmarks = [] |
| if self.face_area.landmarks is not None: |
| for landmark in self.face_area.landmarks: |
| landmarks.append( |
| Point( |
| int((landmark.x - self.left) * self.scale_factor), |
| int((landmark.y - self.top) * self.scale_factor), |
| ) |
| ) |
| return landmarks |
|
|
| def __crop_face_image(self, entire_image: np.ndarray, face_size: int, upscaler: str): |
| cropped = entire_image[self.top : self.bottom, self.left : self.right, :] |
| if upscaler: |
| return images.resize_image(0, Image.fromarray(cropped), face_size, face_size, upscaler) |
| else: |
| return Image.fromarray(cv2.resize(cropped, dsize=(face_size, face_size))) |
|
|
| def __ensure_margin(self, left: int, top: int, right: int, bottom: int, entire_image: np.ndarray, margin: float): |
| entire_height, entire_width = entire_image.shape[:2] |
|
|
| side_length = right - left |
| margin = min(min(entire_height, entire_width) / side_length, margin) |
| diff = int((side_length * margin - side_length) / 2) |
|
|
| top = top - diff |
| bottom = bottom + diff |
| left = left - diff |
| right = right + diff |
|
|
| if top < 0: |
| bottom = bottom - top |
| top = 0 |
| if left < 0: |
| right = right - left |
| left = 0 |
|
|
| if bottom > entire_height: |
| top = top - (bottom - entire_height) |
| bottom = entire_height |
| if right > entire_width: |
| left = left - (right - entire_width) |
| right = entire_width |
|
|
| return left, top, right, bottom |
|
|
| def get_angle(self) -> float: |
| landmarks = getattr(self.face_area, "landmarks", None) |
| if landmarks is None: |
| return 0 |
|
|
| eye1 = getattr(landmarks, "eye1", None) |
| eye2 = getattr(landmarks, "eye2", None) |
| if eye2 is None or eye1 is None: |
| return 0 |
|
|
| try: |
| dx = eye2.x - eye1.x |
| dy = eye2.y - eye1.y |
| if dx == 0: |
| dx = 1 |
| angle = np.arctan(dy / dx) * 180 / np.pi |
|
|
| if dx < 0: |
| angle = (angle + 180) % 360 |
| return angle |
| except Exception: |
| print(traceback.format_exc()) |
| return 0 |
|
|
| def rotate_face_area_on_image(self, angle: float): |
| center = [ |
| (self.face_area_on_image[0] + self.face_area_on_image[2]) / 2, |
| (self.face_area_on_image[1] + self.face_area_on_image[3]) / 2, |
| ] |
|
|
| points = [ |
| [self.face_area_on_image[0], self.face_area_on_image[1]], |
| [self.face_area_on_image[2], self.face_area_on_image[3]], |
| ] |
|
|
| angle = np.radians(angle) |
| rot_matrix = np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]]) |
|
|
| points = np.array(points) - center |
| points = np.dot(points, rot_matrix.T) |
| points += center |
| left, top, right, bottom = (int(points[0][0]), int(points[0][1]), int(points[1][0]), int(points[1][1])) |
|
|
| left, right = (right, left) if left > right else (left, right) |
| top, bottom = (bottom, top) if top > bottom else (top, bottom) |
|
|
| width, height = right - left, bottom - top |
| if width < height: |
| left, right = left - (height - width) // 2, right + (height - width) // 2 |
| elif height < width: |
| top, bottom = top - (width - height) // 2, bottom + (width - height) // 2 |
| return self.__clip_values(left, top, right, bottom) |
|
|
| def __clip_values(self, *args): |
| result = [] |
| for val in args: |
| if val < 0: |
| result.append(0) |
| elif val > self.face_size: |
| result.append(self.face_size) |
| else: |
| result.append(val) |
| return tuple(result) |
|
|
