Spaces:
Runtime error
Runtime error
Download utils/general.py from manhdo/head_pose_estimation_tracking_app: direct link, hf CLI and curl.
- Browser
- Download file 9.05 kB
-
https://huggingface.co/spaces/manhdo/head_pose_estimation_tracking_app/resolve/main/utils/general.py
- Command line
-
hf download hf://spaces/manhdo/head_pose_estimation_tracking_app/utils/general.py
-
curl -L -o general.py https://huggingface.co/spaces/manhdo/head_pose_estimation_tracking_app/resolve/main/utils/general.py
9.05 kB
| import numpy as np | |
| import glob | |
| import cv2 | |
| import os | |
| import pickle | |
| def resize_img(img, size=(640, 640), pad_val=0, return_all_infos=False): | |
| """ | |
| Resize specific image according to original size ratio | |
| then padding for yielding given size | |
| Input: | |
| `img` (np.ndarray): original image | |
| `size` (tuple/list): size of new image (width, height) | |
| `pad_val` (int): padding value (default: 0) | |
| `return_all_infos` (bool): Return all informations for creating new sample | |
| Return: | |
| `New image` (np.ndarray) with given size | |
| If `return_all_infos` is True: | |
| `h_ratio`: h_new/h_old | |
| `w_ratio`: w_new/w_old | |
| `pad_top`: number of padding on top of image | |
| `pad_bot`: number of padding on bot of image | |
| `pad_left`: number of padding on left of image | |
| `pad_right`: number of padding on right of image | |
| """ | |
| # Check pad val | |
| if isinstance(pad_val, int): | |
| pad_val = (pad_val, pad_val, pad_val) | |
| old_size = img.shape[:2] # h, w | |
| hw_ratio = old_size[0] / old_size[1] | |
| if old_size[0] > old_size[1]: | |
| new_size = (size[0], int(size[1] / hw_ratio)) | |
| else: | |
| new_size = (int(size[0] * hw_ratio), size[1]) | |
| img = cv2.resize(img, (new_size[1], new_size[0])) # resize with hw-ratio | |
| # Get padding corner to yield given new size | |
| pad_top = (size[0] - new_size[0]) // 2 | |
| pad_bot = size[0] - (new_size[0] + pad_top) | |
| pad_left = (size[1] - new_size[1]) // 2 | |
| pad_right = size[1] - (new_size[1] + pad_left) | |
| h_ratio = new_size[0] / size[0] | |
| w_ratio = new_size[1] / size[1] | |
| # Resize to yield given new size | |
| img = cv2.copyMakeBorder(img, pad_top, pad_bot, pad_left, pad_right, cv2.BORDER_CONSTANT, value=pad_val) | |
| if return_all_infos: | |
| return img, h_ratio, w_ratio, pad_top, pad_bot, pad_left, pad_right, new_size | |
| return img | |
| def get_original_coordinate(detection, img_size, pad_infos): | |
| """ | |
| Detection result still has padding informations to image | |
| Need re-calculate to original coordinate info | |
| """ | |
| pad_top, pad_bot, pad_left, pad_right = pad_infos | |
| xmin = detection.location_data.relative_bounding_box.xmin | |
| ymin = detection.location_data.relative_bounding_box.ymin | |
| width = detection.location_data.relative_bounding_box.width | |
| height = detection.location_data.relative_bounding_box.height | |
| xmin_ori = (xmin * img_size[0]) / (img_size[0] - pad_top - pad_bot) | |
| ymin_ori = (ymin * img_size[1]) / (img_size[1] - pad_left - pad_right) | |
| width_ori = (width * img_size[0]) / (img_size[0] - pad_top - pad_bot) | |
| height_ori = (height * img_size[1]) / (img_size[1] - pad_left - pad_right) | |
| return xmin_ori, ymin_ori, width_ori, height_ori | |
| def get_main_sub_faces(face_detection_infos, min_face_ratio_over_max_face_to_be_main=0.7): | |
| """ | |
| Determine main or sub attribute for given faces according to | |
| area ratio according to image and area ratio according to face with max area | |
| Input: | |
| `face_detection_infos`: face detection info from face detector model | |
| `min_face_ratio_over_max_face_to_be_main`: area ratio according to max area face to be main | |
| Return: | |
| `face_is_main` (list[int]): list of is_main face, if face is main, return 1, otherwise | |
| `face_ratios` (list[float]): list of area ratios according to image | |
| """ | |
| face_ratios = [detection.location_data.relative_bounding_box.width*detection.location_data.relative_bounding_box.height for detection in face_detection_infos] | |
| face_ids = [id for id in range(len(face_detection_infos))] | |
| face_is_main = [0 for _ in range(len(face_detection_infos))] | |
| face_ratio_max = np.max(face_ratios) | |
| for id in face_ids: | |
| # if ratio according to max face ge given criteria | |
| if face_ratios[id] / face_ratio_max >= min_face_ratio_over_max_face_to_be_main: | |
| face_is_main[id] = 1 | |
| return face_is_main, face_ratios | |
| def get_final_result(main_sub_faces, face_ratios, | |
| face_detection_infos, face_direction_infos, face_position_infos, face_coordinate_infos, | |
| face_pose_infos, face_area_infos, chosen_rectangle_pos_list, | |
| return_all_informations=True): | |
| """ | |
| Get decision face for yielding final result | |
| Input: | |
| main_sub_faces (list[int]): list of is_main face, if face is main, return 1, otherwise | |
| face_ratios (list[float]): list of area ratios according to image | |
| `face_detection_infos`: face detection info from face detector model | |
| `face_direction_infos` (list[str]): direction for each face | |
| `face_position_infos` (list[str]): position for each face | |
| `face_coordinates_infos`(list(list[float])): coordinates for each face (x1y1x2y2) | |
| `face_pose_infos` (list(list[float])): pose info for each face (x,y,z) | |
| `face area_indos` (list[float]): area ratio of face according to image | |
| `chosen_rectangle_pos_list`(list(list[float])): chosen rectangle for each face | |
| Return: | |
| decision infomation of decision face | |
| """ | |
| face_ids = np.arange(len(main_sub_faces)) | |
| face_ids = [id for _, id in sorted(zip(face_ratios, face_ids), reverse=True)] | |
| final_id = face_ids[0] # Return the max ratio face if do not have any `FRONT` face | |
| for id in face_ids: | |
| # If face is sub, then the remaining faces also sub | |
| if main_sub_faces[id] == 0: | |
| break | |
| # If face is `FRONT`, do not need check the others | |
| if face_direction_infos[id] == 'FRONT': | |
| final_id = id | |
| break | |
| if return_all_informations: | |
| return face_detection_infos[final_id], face_direction_infos[final_id], face_position_infos[final_id], \ | |
| face_coordinate_infos[final_id], \ | |
| face_pose_infos[final_id], face_area_infos[final_id], chosen_rectangle_pos_list[final_id], \ | |
| final_id | |
| else: | |
| return final_id | |
| def get_cache_informations(save_dict, cache_path='cache.pkl'): | |
| """ | |
| if using cache is enabled, using local cache for storing predicted informations from samples | |
| avoid time consumption | |
| Input: | |
| save_dict (dict): current informations | |
| cache_path (str): path to previous informations | |
| Return: | |
| cache_dict (dict): merge informations from preivous cache to current one | |
| """ | |
| if os.path.exists(cache_path): | |
| with open(cache_path, 'rb') as f: | |
| cache_dict = pickle.load(f) | |
| if cache_dict.get('img_size', None) == save_dict['img_size'] and \ | |
| cache_dict.get('position_horizontal_thresholds', None) == save_dict['position_horizontal_thresholds'] and \ | |
| cache_dict.get('position_vertical_thresholds', None) == save_dict['position_vertical_thresholds']: | |
| return cache_dict | |
| return {} | |
| return {} | |
| def parse_head_pose_informations(head_pose_info, session_state): | |
| head_pose_info['POSITION']['TOP_LEFT'][:2] = [[0, 0], | |
| [session_state.position_horizontal_thresholds[0], session_state.position_vertical_thresholds[0]]] | |
| head_pose_info['POSITION']['TOP'][:2] = [[session_state.position_horizontal_thresholds[0], 0], | |
| [session_state.position_horizontal_thresholds[1], session_state.position_vertical_thresholds[0]]] | |
| head_pose_info['POSITION']['TOP_RIGHT'][:2] = [[session_state.position_horizontal_thresholds[1], 0], | |
| [1, session_state.position_vertical_thresholds[0]]] | |
| head_pose_info['POSITION']['RIGHT'][:2] = [[session_state.position_horizontal_thresholds[1], session_state.position_vertical_thresholds[0]], | |
| [1, session_state.position_vertical_thresholds[1]]] | |
| head_pose_info['POSITION']['BOTTOM_RIGHT'][:2] = [[session_state.position_horizontal_thresholds[1], session_state.position_vertical_thresholds[1]], | |
| [1, 1]] | |
| head_pose_info['POSITION']['BOTTOM'][:2] = [[session_state.position_horizontal_thresholds[0], session_state.position_vertical_thresholds[1]], | |
| [session_state.position_horizontal_thresholds[1], 1]] | |
| head_pose_info['POSITION']['BOTTOM_LEFT'][:2] = [[0, session_state.position_vertical_thresholds[1]], | |
| [session_state.position_horizontal_thresholds[0], 1]] | |
| head_pose_info['POSITION']['LEFT'][:2] = [[0, session_state.position_vertical_thresholds[0]], | |
| [session_state.position_horizontal_thresholds[0], session_state.position_vertical_thresholds[1]]] | |
| head_pose_info['POSITION']['MIDDLE'][:2] = [[session_state.position_horizontal_thresholds[0], session_state.position_vertical_thresholds[0]], | |
| [session_state.position_horizontal_thresholds[1], session_state.position_vertical_thresholds[1]]] |