Spaces:
Sleeping
Sleeping
| import cv2 | |
| import gradio as gr | |
| import mediapipe as mp | |
| import dlib | |
| import imutils | |
| import numpy as np | |
| mp_drawing = mp.solutions.drawing_utils | |
| mp_drawing_styles = mp.solutions.drawing_styles | |
| mp_face_mesh = mp.solutions.face_mesh | |
| mp_face_detection = mp.solutions.face_detection | |
| def apply_media_pipe_face_detection(image): | |
| with mp_face_detection.FaceDetection( | |
| model_selection=1, min_detection_confidence=0.5) as face_detection: | |
| results = face_detection.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) | |
| if not results.detections: | |
| return image | |
| annotated_image = image.copy() | |
| for detection in results.detections: | |
| mp_drawing.draw_detection(annotated_image, detection) | |
| return annotated_image | |
| def apply_media_pipe_facemesh(image): | |
| with mp_face_mesh.FaceMesh( | |
| static_image_mode=True, | |
| max_num_faces=1, | |
| refine_landmarks=True, | |
| min_detection_confidence=0.5) as face_mesh: | |
| results = face_mesh.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) | |
| if not results.multi_face_landmarks: | |
| return image | |
| annotated_image = image.copy() | |
| for face_landmarks in results.multi_face_landmarks: | |
| mp_drawing.draw_landmarks( | |
| image=annotated_image, | |
| landmark_list=face_landmarks, | |
| connections=mp_face_mesh.FACEMESH_TESSELATION, | |
| landmark_drawing_spec=None, | |
| connection_drawing_spec=mp_drawing_styles | |
| .get_default_face_mesh_tesselation_style()) | |
| mp_drawing.draw_landmarks( | |
| image=annotated_image, | |
| landmark_list=face_landmarks, | |
| connections=mp_face_mesh.FACEMESH_CONTOURS, | |
| landmark_drawing_spec=None, | |
| connection_drawing_spec=mp_drawing_styles | |
| .get_default_face_mesh_contours_style()) | |
| mp_drawing.draw_landmarks( | |
| image=annotated_image, | |
| landmark_list=face_landmarks, | |
| connections=mp_face_mesh.FACEMESH_IRISES, | |
| landmark_drawing_spec=None, | |
| connection_drawing_spec=mp_drawing_styles | |
| .get_default_face_mesh_iris_connections_style()) | |
| return annotated_image | |
| class FaceOrientation(object): | |
| def __init__(self): | |
| self.detect = dlib.get_frontal_face_detector() | |
| self.predict = dlib.shape_predictor("model/shape_predictor_68_face_landmarks.dat") | |
| def create_orientation(self, frame): | |
| draw_rect1 = True | |
| draw_rect2 = True | |
| draw_lines = True | |
| frame = imutils.resize(frame, width=800) | |
| gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) | |
| subjects = self.detect(gray, 0) | |
| for subject in subjects: | |
| landmarks = self.predict(gray, subject) | |
| size = frame.shape | |
| # 2D image points. If you change the image, you need to change vector | |
| image_points = np.array([ | |
| (landmarks.part(33).x, landmarks.part(33).y), # Nose tip | |
| (landmarks.part(8).x, landmarks.part(8).y), # Chin | |
| (landmarks.part(36).x, landmarks.part(36).y), # Left eye left corner | |
| (landmarks.part(45).x, landmarks.part(45).y), # Right eye right corne | |
| (landmarks.part(48).x, landmarks.part(48).y), # Left Mouth corner | |
| (landmarks.part(54).x, landmarks.part(54).y) # Right mouth corner | |
| ], dtype="double") | |
| # 3D model points. | |
| model_points = np.array([ | |
| (0.0, 0.0, 0.0), # Nose tip | |
| (0.0, -330.0, -65.0), # Chin | |
| (-225.0, 170.0, -135.0), # Left eye left corner | |
| (225.0, 170.0, -135.0), # Right eye right corne | |
| (-150.0, -150.0, -125.0), # Left Mouth corner | |
| (150.0, -150.0, -125.0) # Right mouth corner | |
| ]) | |
| # Camera internals | |
| focal_length = size[1] | |
| center = (size[1] / 2, size[0] / 2) | |
| camera_matrix = np.array( | |
| [[focal_length, 0, center[0]], | |
| [0, focal_length, center[1]], | |
| [0, 0, 1]], dtype="double" | |
| ) | |
| dist_coeffs = np.zeros((4, 1)) # Assuming no lens distortion | |
| (success, rotation_vector, translation_vector) = cv2.solvePnP(model_points, image_points, camera_matrix, | |
| dist_coeffs) | |
| (b1, jacobian) = cv2.projectPoints(np.array([(350.0, 270.0, 0.0)]), rotation_vector, translation_vector, | |
| camera_matrix, dist_coeffs) | |
| (b2, jacobian) = cv2.projectPoints(np.array([(-350.0, -270.0, 0.0)]), rotation_vector, | |
| translation_vector, camera_matrix, dist_coeffs) | |
| (b3, jacobian) = cv2.projectPoints(np.array([(-350.0, 270, 0.0)]), rotation_vector, translation_vector, | |
| camera_matrix, dist_coeffs) | |
| (b4, jacobian) = cv2.projectPoints(np.array([(350.0, -270.0, 0.0)]), rotation_vector, | |
| translation_vector, camera_matrix, dist_coeffs) | |
| (b11, jacobian) = cv2.projectPoints(np.array([(450.0, 350.0, 400.0)]), rotation_vector, | |
| translation_vector, camera_matrix, dist_coeffs) | |
| (b12, jacobian) = cv2.projectPoints(np.array([(-450.0, -350.0, 400.0)]), rotation_vector, | |
| translation_vector, camera_matrix, dist_coeffs) | |
| (b13, jacobian) = cv2.projectPoints(np.array([(-450.0, 350, 400.0)]), rotation_vector, | |
| translation_vector, camera_matrix, dist_coeffs) | |
| (b14, jacobian) = cv2.projectPoints(np.array([(450.0, -350.0, 400.0)]), rotation_vector, | |
| translation_vector, camera_matrix, dist_coeffs) | |
| b1 = (int(b1[0][0][0]), int(b1[0][0][1])) | |
| b2 = (int(b2[0][0][0]), int(b2[0][0][1])) | |
| b3 = (int(b3[0][0][0]), int(b3[0][0][1])) | |
| b4 = (int(b4[0][0][0]), int(b4[0][0][1])) | |
| b11 = (int(b11[0][0][0]), int(b11[0][0][1])) | |
| b12 = (int(b12[0][0][0]), int(b12[0][0][1])) | |
| b13 = (int(b13[0][0][0]), int(b13[0][0][1])) | |
| b14 = (int(b14[0][0][0]), int(b14[0][0][1])) | |
| if draw_rect1 == True: | |
| cv2.line(frame, b1, b3, (255, 255, 0), 10) | |
| cv2.line(frame, b3, b2, (255, 255, 0), 10) | |
| cv2.line(frame, b2, b4, (255, 255, 0), 10) | |
| cv2.line(frame, b4, b1, (255, 255, 0), 10) | |
| if draw_rect2 == True: | |
| cv2.line(frame, b11, b13, (255, 255, 0), 10) | |
| cv2.line(frame, b13, b12, (255, 255, 0), 10) | |
| cv2.line(frame, b12, b14, (255, 255, 0), 10) | |
| cv2.line(frame, b14, b11, (255, 255, 0), 10) | |
| if draw_lines == True: | |
| cv2.line(frame, b11, b1, (0, 255, 0), 10) | |
| cv2.line(frame, b13, b3, (0, 255, 0), 10) | |
| cv2.line(frame, b12, b2, (0, 255, 0), 10) | |
| cv2.line(frame, b14, b4, (0, 255, 0), 10) | |
| return frame | |
| face_orientation_obj = FaceOrientation() | |
| class FaceProcessing(object): | |
| def __init__(self, ui_obj): | |
| self.name = "Face Image Processing" | |
| self.description = "Call for Face Image and video Processing" | |
| self.ui_obj = ui_obj | |
| def take_webcam_photo(self, image): | |
| return image | |
| def take_webcam_video(self, images): | |
| return images | |
| def mp_webcam_photo(self, image): | |
| return image | |
| def mp_webcam_face_mesh(self, image): | |
| face_mesh_image = apply_media_pipe_facemesh(image) | |
| return face_mesh_image | |
| def mp_webcam_face_detection(self, image): | |
| face_detection_img = apply_media_pipe_face_detection(image) | |
| return face_detection_img | |
| def dlib_apply_face_orientation(self, image): | |
| image = face_orientation_obj.create_orientation(image) | |
| return image | |
| def webcam_stream_update(self, video_frame): | |
| video_out = face_orientation_obj.create_orientation(video_frame) | |
| return video_out | |
| def create_ui(self): | |
| with self.ui_obj: | |
| gr.Markdown(""" | |
| ### 👨💻Made By Bishal Kumar Rauniyar👨💻 | |
| ## Project: Face Processing based on DLIB Shape Predictor Model | |
| """) | |
| with gr.Tabs(): | |
| with gr.TabItem("Processing Webcam"): | |
| with gr.Row(): | |
| webcam_image_in = gr.Image(label="Webcam Image Input") | |
| webcam_video_in = gr.Video(label="Webcam Video Input") | |
| with gr.Row(): | |
| webcam_photo_action = gr.Button("Take the Photo") | |
| webcam_video_action = gr.Button("Take the Video") | |
| with gr.Row(): | |
| webcam_photo_out = gr.Image(label="Webcam Photo Output") | |
| webcam_video_out = gr.Video(label="Webcam Video") | |
| with gr.TabItem("Mediapipe Facemesh with Webcam"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| mp_image_in = gr.Image(label="Webcam Image Input") | |
| with gr.Column(): | |
| mp_photo_action = gr.Button("Take the Photo") | |
| mp_apply_fm_action = gr.Button("Apply Face Mesh the Photo") | |
| mp_apply_landmarks_action = gr.Button("Apply Face Landmarks the Photo") | |
| with gr.Row(): | |
| mp_photo_out = gr.Image(label="Webcam Photo Output") | |
| mp_fm_photo_out = gr.Image(label="Face Mesh Photo Output") | |
| mp_lm_photo_out = gr.Image(label="Face Landmarks Photo Output") | |
| with gr.TabItem("DLib Model Based Face Orientation"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| dlib_image_in = gr.Image(label="Webcam Image Input") | |
| with gr.Column(): | |
| dlib_photo_action = gr.Button("Take the Photo") | |
| dlib_apply_orientation_action = gr.Button("Apply Face Mesh the Photo") | |
| with gr.Row(): | |
| dlib_photo_out = gr.Image(label="Webcam Photo Output") | |
| dlib_orientation_photo_out = gr.Image(label="Face Mesh Photo Output") | |
| with gr.TabItem("Face Orientation on Live Webcam Stream"): | |
| with gr.Row(): | |
| webcam_stream_in = gr.Image(label="Webcam Stream Input", | |
| streaming=True) | |
| webcam_stream_out = gr.Image(label="Webcam Stream Output") | |
| webcam_stream_in.change( | |
| self.webcam_stream_update, | |
| inputs=webcam_stream_in, | |
| outputs=webcam_stream_out | |
| ) | |
| dlib_photo_action.click( | |
| self.mp_webcam_photo, | |
| [ | |
| dlib_image_in | |
| ], | |
| [ | |
| dlib_photo_out | |
| ] | |
| ) | |
| dlib_apply_orientation_action.click( | |
| self.dlib_apply_face_orientation, | |
| [ | |
| dlib_image_in | |
| ], | |
| [ | |
| dlib_orientation_photo_out | |
| ] | |
| ) | |
| mp_photo_action.click( | |
| self.mp_webcam_photo, | |
| [ | |
| mp_image_in | |
| ], | |
| [ | |
| mp_photo_out | |
| ] | |
| ) | |
| mp_apply_fm_action.click( | |
| self.mp_webcam_face_mesh, | |
| [ | |
| mp_image_in | |
| ], | |
| [ | |
| mp_fm_photo_out | |
| ] | |
| ) | |
| mp_apply_landmarks_action.click( | |
| self.mp_webcam_face_detection, | |
| [ | |
| mp_image_in | |
| ], | |
| [ | |
| mp_lm_photo_out | |
| ] | |
| ) | |
| webcam_photo_action.click( | |
| self.take_webcam_photo, | |
| [ | |
| webcam_image_in | |
| ], | |
| [ | |
| webcam_photo_out | |
| ] | |
| ) | |
| webcam_video_action.click( | |
| self.take_webcam_video, | |
| [ | |
| webcam_video_in | |
| ], | |
| [ | |
| webcam_video_out | |
| ] | |
| ) | |
| def launch_ui(self): | |
| self.ui_obj.launch() | |
| if __name__ == '__main__': | |
| my_app = gr.Blocks() | |
| face_ui = FaceProcessing(my_app) | |
| face_ui.create_ui() | |
| face_ui.launch_ui() |