upload

README.md

@@ -1,8 +1,8 @@
 ---
-title: Google MediaPipe
-emoji: 🐠
-colorFrom: gray
-colorTo: gray
+title: Test Mediapipe
+emoji: 👁
+colorFrom: yellow
+colorTo: indigo
 sdk: gradio
 sdk_version: 3.1.4
 app_file: app.py

app.py

@@ -0,0 +1,59 @@
+import gradio as gr
+from facemesh import mp_face_mesh_fn
+from facedetect import mp_face_detect_fn
+from handposedetect import mp_hand_pose_detect_fn
+from posestimate import mp_pose_estimation_fn
+from holistic import mp_holistic_fn
+
+
+def run_mediapipe(image, soln_type):
+    if soln_type == 'facemesh':
+        annotated_image = mp_face_mesh_fn(image)
+    elif soln_type == 'facedetect':
+        annotated_image = mp_face_detect_fn(image)
+    elif soln_type == 'handpose':
+        annotated_image = mp_hand_pose_detect_fn(image)
+    elif soln_type == 'pose estimate':
+        annotated_image = mp_pose_estimation_fn(image)
+    elif soln_type == 'holistic':
+        annotated_image = mp_holistic_fn(image)
+    return annotated_image
+
+
+def main():
+    solutions = [
+        'facedetect', 
+        'facemesh', 
+        'handpose', 
+        'pose estimate',
+        'holistic'
+    ]
+
+    sample_images = [
+        ["examples/0.jpg", solutions[0]],
+        ["examples/1.jpg", solutions[1]],
+        ["examples/2.png", solutions[2]],
+        ["examples/3.jpg", solutions[3]],
+        ["examples/4.jpg", solutions[4]],
+    ]
+
+    iface = gr.Interface(
+        fn=run_mediapipe,
+        inputs=[
+            gr.inputs.Image(label="Input Image"),
+            gr.inputs.Radio(
+                solutions,
+                type='value',
+                default=solutions[0],
+                label='Solutions'
+            ),
+        ],
+
+        outputs=gr.outputs.Image(label="MediaPipe"),
+        examples=sample_images
+    )
+
+    iface.launch()
+
+if __name__ == '__main__':
+    main()

facedetect.py

@@ -0,0 +1,23 @@
+import mediapipe as mp
+from utils import read_n_resize
+
+def mp_face_detect_fn(image):
+    mp_face_detection = mp.solutions.face_detection
+    mp_drawing = mp.solutions.drawing_utils 
+
+    with mp_face_detection.FaceDetection(
+        min_detection_confidence=0.5, model_selection=0
+        ) as face_detection:
+    
+        resized_image_array = read_n_resize(image, read=False)
+        
+        # Convert the BGR image to RGB and process it with MediaPipe Face Detection.
+        results = face_detection.process(resized_image_array)
+        
+   
+        annotated_image = resized_image_array.copy()
+        for detection in results.detections:
+            mp_drawing.draw_detection(annotated_image, detection)
+        resized_annotated_image = read_n_resize(annotated_image, read=False)
+        return resized_annotated_image
+

facemesh.py

@@ -0,0 +1,46 @@
+
+import mediapipe as mp
+from utils import read_n_resize
+
+def mp_face_mesh_fn(image):
+    mp_drawing = mp.solutions.drawing_utils
+    mp_drawing_styles = mp.solutions.drawing_styles
+    mp_face_mesh = mp.solutions.face_mesh
+
+    with mp_face_mesh.FaceMesh(
+        static_image_mode=True,
+        max_num_faces=1,
+        refine_landmarks=True,
+        min_detection_confidence=0.5
+    ) as face_mesh:
+        resized_image = read_n_resize(image, read=False)
+        results = face_mesh.process(resized_image)
+
+        annotated_image = resized_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
+

handposedetect.py

@@ -0,0 +1,31 @@
+import mediapipe as mp
+
+import cv2
+from utils import read_n_resize
+
+def mp_hand_pose_detect_fn(image):
+    mp_drawing = mp.solutions.drawing_utils
+    mp_drawing_styles = mp.solutions.drawing_styles
+    mp_hands = mp.solutions.hands
+
+    with mp_hands.Hands(
+        static_image_mode=True,
+        max_num_hands=5,
+        min_detection_confidence=0.5
+        ) as hands:
+        image = cv2.flip(read_n_resize(image, read=False), 1)
+        results = hands.process(image)
+
+        image_height, image_width, _ = image.shape
+        annotated_image = image.copy()
+
+        for hand_landmarks in results.multi_hand_landmarks:
+            mp_drawing.draw_landmarks(
+                annotated_image,
+                hand_landmarks,
+                mp_hands.HAND_CONNECTIONS,
+                mp_drawing_styles.get_default_hand_landmarks_style(),
+                mp_drawing_styles.get_default_hand_connections_style())
+
+        return cv2.flip(annotated_image, 1)
+

holistic.py

@@ -0,0 +1,34 @@
+import mediapipe as mp
+from utils import read_n_resize
+
+def mp_holistic_fn(image):
+    mp_drawing = mp.solutions.drawing_utils
+    mp_drawing_styles = mp.solutions.drawing_styles
+    mp_holistic = mp.solutions.holistic
+
+    with mp_holistic.Holistic(
+        static_image_mode=True,
+        model_complexity=2,
+        enable_segmentation=True,
+        refine_face_landmarks=True
+        ) as holistic:
+        image = read_n_resize(image, read=False)
+        results = holistic.process(image)
+        annotated_image = image.copy()
+
+        mp_drawing.draw_landmarks(
+            annotated_image,
+            results.face_landmarks,
+            mp_holistic.FACEMESH_TESSELATION,
+            landmark_drawing_spec=None,
+            connection_drawing_spec=mp_drawing_styles
+            .get_default_face_mesh_tesselation_style())
+        mp_drawing.draw_landmarks(
+            annotated_image,
+            results.pose_landmarks,
+            mp_holistic.POSE_CONNECTIONS,
+            landmark_drawing_spec=mp_drawing_styles.
+            get_default_pose_landmarks_style())
+
+        return annotated_image
+            

posestimate.py

@@ -0,0 +1,26 @@
+import mediapipe as mp
+from utils import read_n_resize
+
+def mp_pose_estimation_fn(image):
+    mp_drawing = mp.solutions.drawing_utils
+    mp_drawing_styles = mp.solutions.drawing_styles
+    mp_pose = mp.solutions.pose
+    
+    with mp_pose.Pose(
+        static_image_mode=True,
+        model_complexity=2,
+        enable_segmentation=True,
+        min_detection_confidence=0.5
+    ) as pose:
+
+        image = read_n_resize(image, read=False)
+        results = pose.process(image)
+        annotated_image = image.copy()
+        # Draw pose landmarks on the image.
+        mp_drawing.draw_landmarks(
+            annotated_image,
+            results.pose_landmarks,
+            mp_pose.POSE_CONNECTIONS,
+            landmark_drawing_spec=mp_drawing_styles.get_default_pose_landmarks_style()
+        )
+        return annotated_image

requirements.txt

@@ -0,0 +1,2 @@
+mediapipe
+opencv-python

utils.py

@@ -0,0 +1,22 @@
+
+import cv2, math 
+
+DESIRED_HEIGHT = 480
+DESIRED_WIDTH = 480
+
+def read_n_resize(image_file, read=True):
+    image = cv2.imread(image_file) if read else image_file
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) if read else image
+    
+    h, w = image.shape[:2]
+    
+    if h < w:
+        img = cv2.resize(
+            image, (DESIRED_WIDTH, math.floor(h/(w/DESIRED_WIDTH)))
+        )
+    else:
+        img = cv2.resize(
+            image, (math.floor(w/(h/DESIRED_HEIGHT)), DESIRED_HEIGHT)
+        )
+    
+    return img