mediapipe-nightly 0.10.21.post20241223__cp311-cp311-manylinux_2_28_x86_64.whl

mediapipe/python/solutions/drawing_utils_test.py

@@ -0,0 +1,258 @@
+# Copyright 2020 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tests for mediapipe.python.solutions.drawing_utils."""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+import cv2
+import numpy as np
+
+from google.protobuf import text_format
+from mediapipe.framework.formats import detection_pb2
+from mediapipe.framework.formats import landmark_pb2
+from mediapipe.python.solutions import drawing_utils
+
+DEFAULT_BBOX_DRAWING_SPEC = drawing_utils.DrawingSpec()
+DEFAULT_CONNECTION_DRAWING_SPEC = drawing_utils.DrawingSpec()
+DEFAULT_CIRCLE_DRAWING_SPEC = drawing_utils.DrawingSpec(
+    color=drawing_utils.RED_COLOR)
+DEFAULT_AXIS_DRAWING_SPEC = drawing_utils.DrawingSpec()
+DEFAULT_CYCLE_BORDER_COLOR = (224, 224, 224)
+
+
+class DrawingUtilTest(parameterized.TestCase):
+
+  def test_invalid_input_image(self):
+    image = np.arange(18, dtype=np.uint8).reshape(3, 3, 2)
+    with self.assertRaisesRegex(
+        ValueError, 'Input image must contain three channel bgr data.'):
+      drawing_utils.draw_landmarks(image, landmark_pb2.NormalizedLandmarkList())
+    with self.assertRaisesRegex(
+        ValueError, 'Input image must contain three channel bgr data.'):
+      drawing_utils.draw_detection(image, detection_pb2.Detection())
+    with self.assertRaisesRegex(
+        ValueError, 'Input image must contain three channel bgr data.'):
+      rotation = np.eye(3, dtype=np.float32)
+      translation = np.array([0., 0., 1.])
+      drawing_utils.draw_axis(image, rotation, translation)
+
+  def test_invalid_connection(self):
+    landmark_list = text_format.Parse(
+        'landmark {x: 0.5 y: 0.5} landmark {x: 0.2 y: 0.2}',
+        landmark_pb2.NormalizedLandmarkList())
+    image = np.arange(27, dtype=np.uint8).reshape(3, 3, 3)
+    with self.assertRaisesRegex(ValueError, 'Landmark index is out of range.'):
+      drawing_utils.draw_landmarks(image, landmark_list, [(0, 2)])
+
+  def test_unqualified_detection(self):
+    detection = text_format.Parse('location_data {format: GLOBAL}',
+                                  detection_pb2.Detection())
+    image = np.arange(27, dtype=np.uint8).reshape(3, 3, 3)
+    with self.assertRaisesRegex(ValueError, 'LocationData must be relative'):
+      drawing_utils.draw_detection(image, detection)
+
+  def test_draw_keypoints_only(self):
+    detection = text_format.Parse(
+        'location_data {'
+        '  format: RELATIVE_BOUNDING_BOX'
+        '  relative_keypoints {x: 0 y: 1}'
+        '  relative_keypoints {x: 1 y: 0}}', detection_pb2.Detection())
+    image = np.zeros((100, 100, 3), np.uint8)
+    expected_result = np.copy(image)
+    cv2.circle(expected_result, (0, 99),
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius,
+               DEFAULT_CIRCLE_DRAWING_SPEC.color,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, (99, 0),
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius,
+               DEFAULT_CIRCLE_DRAWING_SPEC.color,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    drawing_utils.draw_detection(image, detection)
+    np.testing.assert_array_equal(image, expected_result)
+
+  def test_draw_bboxs_only(self):
+    detection = text_format.Parse(
+        'location_data {'
+        '  format: RELATIVE_BOUNDING_BOX'
+        '  relative_bounding_box {xmin: 0 ymin: 0 width: 1 height: 1}}',
+        detection_pb2.Detection())
+    image = np.zeros((100, 100, 3), np.uint8)
+    expected_result = np.copy(image)
+    cv2.rectangle(expected_result, (0, 0), (99, 99),
+                  DEFAULT_BBOX_DRAWING_SPEC.color,
+                  DEFAULT_BBOX_DRAWING_SPEC.thickness)
+    drawing_utils.draw_detection(image, detection)
+    np.testing.assert_array_equal(image, expected_result)
+
+  @parameterized.named_parameters(
+      ('landmark_list_has_only_one_element', 'landmark {x: 0.1 y: 0.1}'),
+      ('second_landmark_is_invisible',
+       'landmark {x: 0.1 y: 0.1} landmark {x: 0.5 y: 0.5 visibility: 0.0}'))
+  def test_draw_single_landmark_point(self, landmark_list_text):
+    landmark_list = text_format.Parse(landmark_list_text,
+                                      landmark_pb2.NormalizedLandmarkList())
+    image = np.zeros((100, 100, 3), np.uint8)
+    expected_result = np.copy(image)
+    cv2.circle(expected_result, (10, 10),
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius + 1,
+               DEFAULT_CYCLE_BORDER_COLOR,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, (10, 10),
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius,
+               DEFAULT_CIRCLE_DRAWING_SPEC.color,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    drawing_utils.draw_landmarks(image, landmark_list)
+    np.testing.assert_array_equal(image, expected_result)
+
+  @parameterized.named_parameters(
+      ('landmarks_have_x_and_y_only',
+       'landmark {x: 0.1 y: 0.5} landmark {x: 0.5 y: 0.1}'),
+      ('landmark_zero_visibility_and_presence',
+       'landmark {x: 0.1 y: 0.5 presence: 0.5}'
+       'landmark {x: 0.5 y: 0.1 visibility: 0.5}'))
+  def test_draw_landmarks_and_connections(self, landmark_list_text):
+    landmark_list = text_format.Parse(landmark_list_text,
+                                      landmark_pb2.NormalizedLandmarkList())
+    image = np.zeros((100, 100, 3), np.uint8)
+    expected_result = np.copy(image)
+    start_point = (10, 50)
+    end_point = (50, 10)
+    cv2.line(expected_result, start_point, end_point,
+             DEFAULT_CONNECTION_DRAWING_SPEC.color,
+             DEFAULT_CONNECTION_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, start_point,
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius + 1,
+               DEFAULT_CYCLE_BORDER_COLOR,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, end_point,
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius + 1,
+               DEFAULT_CYCLE_BORDER_COLOR,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, start_point,
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius,
+               DEFAULT_CIRCLE_DRAWING_SPEC.color,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, end_point,
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius,
+               DEFAULT_CIRCLE_DRAWING_SPEC.color,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    drawing_utils.draw_landmarks(
+        image=image, landmark_list=landmark_list, connections=[(0, 1)])
+    np.testing.assert_array_equal(image, expected_result)
+
+  def test_draw_axis(self):
+    image = np.zeros((100, 100, 3), np.uint8)
+    expected_result = np.copy(image)
+    origin = (50, 50)
+    x_axis = (75, 50)
+    y_axis = (50, 22)
+    z_axis = (50, 77)
+    cv2.arrowedLine(expected_result, origin, x_axis, drawing_utils.RED_COLOR,
+                    DEFAULT_AXIS_DRAWING_SPEC.thickness)
+    cv2.arrowedLine(expected_result, origin, y_axis, drawing_utils.GREEN_COLOR,
+                    DEFAULT_AXIS_DRAWING_SPEC.thickness)
+    cv2.arrowedLine(expected_result, origin, z_axis, drawing_utils.BLUE_COLOR,
+                    DEFAULT_AXIS_DRAWING_SPEC.thickness)
+    r = np.sqrt(2.) / 2.
+    rotation = np.array([[1., 0., 0.], [0., r, -r], [0., r, r]])
+    translation = np.array([0, 0, -0.2])
+    drawing_utils.draw_axis(image, rotation, translation)
+    np.testing.assert_array_equal(image, expected_result)
+
+  def test_draw_axis_zero_translation(self):
+    image = np.zeros((100, 100, 3), np.uint8)
+    expected_result = np.copy(image)
+    origin = (50, 50)
+    x_axis = (0, 50)
+    y_axis = (50, 100)
+    z_axis = (50, 50)
+    cv2.arrowedLine(expected_result, origin, x_axis, drawing_utils.RED_COLOR,
+                    DEFAULT_AXIS_DRAWING_SPEC.thickness)
+    cv2.arrowedLine(expected_result, origin, y_axis, drawing_utils.GREEN_COLOR,
+                    DEFAULT_AXIS_DRAWING_SPEC.thickness)
+    cv2.arrowedLine(expected_result, origin, z_axis, drawing_utils.BLUE_COLOR,
+                    DEFAULT_AXIS_DRAWING_SPEC.thickness)
+    rotation = np.eye(3, dtype=np.float32)
+    translation = np.zeros((3,), dtype=np.float32)
+    drawing_utils.draw_axis(image, rotation, translation)
+    np.testing.assert_array_equal(image, expected_result)
+
+  def test_min_and_max_coordinate_values(self):
+    landmark_list = text_format.Parse(
+        'landmark {x: 0.0 y: 1.0}'
+        'landmark {x: 1.0 y: 0.0}', landmark_pb2.NormalizedLandmarkList())
+    image = np.zeros((100, 100, 3), np.uint8)
+    expected_result = np.copy(image)
+    start_point = (0, 99)
+    end_point = (99, 0)
+    cv2.line(expected_result, start_point, end_point,
+             DEFAULT_CONNECTION_DRAWING_SPEC.color,
+             DEFAULT_CONNECTION_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, start_point,
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius + 1,
+               DEFAULT_CYCLE_BORDER_COLOR,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, end_point,
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius + 1,
+               DEFAULT_CYCLE_BORDER_COLOR,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, start_point,
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius,
+               DEFAULT_CIRCLE_DRAWING_SPEC.color,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    cv2.circle(expected_result, end_point,
+               DEFAULT_CIRCLE_DRAWING_SPEC.circle_radius,
+               DEFAULT_CIRCLE_DRAWING_SPEC.color,
+               DEFAULT_CIRCLE_DRAWING_SPEC.thickness)
+    drawing_utils.draw_landmarks(
+        image=image, landmark_list=landmark_list, connections=[(0, 1)])
+    np.testing.assert_array_equal(image, expected_result)
+
+  def test_drawing_spec(self):
+    landmark_list = text_format.Parse(
+        'landmark {x: 0.1 y: 0.1}'
+        'landmark {x: 0.8 y: 0.8}', landmark_pb2.NormalizedLandmarkList())
+    image = np.zeros((100, 100, 3), np.uint8)
+    landmark_drawing_spec = drawing_utils.DrawingSpec(
+        color=(0, 0, 255), thickness=5)
+    connection_drawing_spec = drawing_utils.DrawingSpec(
+        color=(255, 0, 0), thickness=3)
+    expected_result = np.copy(image)
+    start_point = (10, 10)
+    end_point = (80, 80)
+    cv2.line(expected_result, start_point, end_point,
+             connection_drawing_spec.color, connection_drawing_spec.thickness)
+    cv2.circle(expected_result, start_point,
+               landmark_drawing_spec.circle_radius + 1,
+               DEFAULT_CYCLE_BORDER_COLOR, landmark_drawing_spec.thickness)
+    cv2.circle(expected_result, end_point,
+               landmark_drawing_spec.circle_radius + 1,
+               DEFAULT_CYCLE_BORDER_COLOR, landmark_drawing_spec.thickness)
+    cv2.circle(expected_result, start_point,
+               landmark_drawing_spec.circle_radius, landmark_drawing_spec.color,
+               landmark_drawing_spec.thickness)
+    cv2.circle(expected_result, end_point, landmark_drawing_spec.circle_radius,
+               landmark_drawing_spec.color, landmark_drawing_spec.thickness)
+    drawing_utils.draw_landmarks(
+        image=image,
+        landmark_list=landmark_list,
+        connections=[(0, 1)],
+        landmark_drawing_spec=landmark_drawing_spec,
+        connection_drawing_spec=connection_drawing_spec)
+    np.testing.assert_array_equal(image, expected_result)
+
+
+if __name__ == '__main__':
+  absltest.main()

mediapipe/python/solutions/face_detection.py

@@ -0,0 +1,105 @@
+# Copyright 2021 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MediaPipe Face Detection."""
+
+import enum
+from typing import NamedTuple, Union
+
+import numpy as np
+from mediapipe.framework.formats import detection_pb2
+from mediapipe.framework.formats import location_data_pb2
+from mediapipe.modules.face_detection import face_detection_pb2
+from mediapipe.python.solution_base import SolutionBase
+
+_SHORT_RANGE_GRAPH_FILE_PATH = 'mediapipe/modules/face_detection/face_detection_short_range_cpu.binarypb'
+_FULL_RANGE_GRAPH_FILE_PATH = 'mediapipe/modules/face_detection/face_detection_full_range_cpu.binarypb'
+
+
+def get_key_point(
+    detection: detection_pb2.Detection, key_point_enum: 'FaceKeyPoint'
+) -> Union[None, location_data_pb2.LocationData.RelativeKeypoint]:
+  """A convenience method to return a face key point by the FaceKeyPoint type.
+
+  Args:
+    detection: A detection proto message that contains face key points.
+    key_point_enum: A FaceKeyPoint type.
+
+  Returns:
+    A RelativeKeypoint proto message.
+  """
+  if not detection or not detection.location_data:
+    return None
+  return detection.location_data.relative_keypoints[key_point_enum]
+
+
+class FaceKeyPoint(enum.IntEnum):
+  """The enum type of the six face detection key points."""
+  RIGHT_EYE = 0
+  LEFT_EYE = 1
+  NOSE_TIP = 2
+  MOUTH_CENTER = 3
+  RIGHT_EAR_TRAGION = 4
+  LEFT_EAR_TRAGION = 5
+
+
+class FaceDetection(SolutionBase):
+  """MediaPipe Face Detection.
+
+  MediaPipe Face Detection processes an RGB image and returns a list of the
+  detected face location data.
+
+  Please refer to
+  https://solutions.mediapipe.dev/face_detection#python-solution-api
+  for usage examples.
+  """
+
+  def __init__(self, min_detection_confidence=0.5, model_selection=0):
+    """Initializes a MediaPipe Face Detection object.
+
+    Args:
+      min_detection_confidence: Minimum confidence value ([0.0, 1.0]) for face
+        detection to be considered successful. See details in
+        https://solutions.mediapipe.dev/face_detection#min_detection_confidence.
+      model_selection: 0 or 1. 0 to select a short-range model that works
+        best for faces within 2 meters from the camera, and 1 for a full-range
+        model best for faces within 5 meters. See details in
+        https://solutions.mediapipe.dev/face_detection#model_selection.
+    """
+
+    binary_graph_path = _FULL_RANGE_GRAPH_FILE_PATH if model_selection == 1 else _SHORT_RANGE_GRAPH_FILE_PATH
+
+    super().__init__(
+        binary_graph_path=binary_graph_path,
+        graph_options=self.create_graph_options(
+            face_detection_pb2.FaceDetectionOptions(), {
+                'min_score_thresh': min_detection_confidence,
+            }),
+        outputs=['detections'])
+
+  def process(self, image: np.ndarray) -> NamedTuple:
+    """Processes an RGB image and returns a list of the detected face location data.
+
+    Args:
+      image: An RGB image represented as a numpy ndarray.
+
+    Raises:
+      RuntimeError: If the underlying graph throws any error.
+      ValueError: If the input image is not three channel RGB.
+
+    Returns:
+      A NamedTuple object with a "detections" field that contains a list of the
+      detected face location data.
+    """
+
+    return super().process(input_data={'image': image})

mediapipe/python/solutions/face_detection_test.py

@@ -0,0 +1,92 @@
+# Copyright 2021 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for mediapipe.python.solutions.face_detection."""
+
+import os
+import tempfile  # pylint: disable=unused-import
+from typing import NamedTuple
+
+from absl.testing import absltest
+from absl.testing import parameterized
+import cv2
+import numpy as np
+import numpy.testing as npt
+
+# resources dependency
+# undeclared dependency
+from mediapipe.python.solutions import drawing_utils as mp_drawing
+from mediapipe.python.solutions import face_detection as mp_faces
+
+TEST_IMAGE_PATH = 'mediapipe/python/solutions/testdata'
+SHORT_RANGE_EXPECTED_FACE_KEY_POINTS = [[363, 182], [460, 186], [420, 241],
+                                        [417, 284], [295, 199], [502, 198]]
+FULL_RANGE_EXPECTED_FACE_KEY_POINTS = [[363, 181], [455, 181], [413, 233],
+                                       [411, 278], [306, 204], [499, 207]]
+DIFF_THRESHOLD = 5  # pixels
+
+
+class FaceDetectionTest(parameterized.TestCase):
+
+  def _annotate(self, frame: np.ndarray, results: NamedTuple, idx: int):
+    for detection in results.detections:
+      mp_drawing.draw_detection(frame, detection)
+    path = os.path.join(tempfile.gettempdir(), self.id().split('.')[-1] +
+                                              '_frame_{}.png'.format(idx))
+    cv2.imwrite(path, frame)
+
+  def test_invalid_image_shape(self):
+    with mp_faces.FaceDetection() as faces:
+      with self.assertRaisesRegex(
+          ValueError, 'Input image must contain three channel rgb data.'):
+        faces.process(np.arange(36, dtype=np.uint8).reshape(3, 3, 4))
+
+  def test_blank_image(self):
+    image = np.zeros([100, 100, 3], dtype=np.uint8)
+    image.fill(255)
+    with mp_faces.FaceDetection(min_detection_confidence=0.5) as faces:
+      results = faces.process(image)
+      self.assertIsNone(results.detections)
+
+  @parameterized.named_parameters(('short_range_model', 0),
+                                  ('full_range_model', 1))
+  def test_face(self, model_selection):
+    image_path = os.path.join(os.path.dirname(__file__),
+                              'testdata/portrait.jpg')
+    image = cv2.imread(image_path)
+    rows, cols, _ = image.shape
+    with mp_faces.FaceDetection(
+        min_detection_confidence=0.5, model_selection=model_selection) as faces:
+      for idx in range(5):
+        results = faces.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        self._annotate(image.copy(), results, idx)
+        location_data = results.detections[0].location_data
+        x = [keypoint.x * cols for keypoint in location_data.relative_keypoints]
+        y = [keypoint.y * rows for keypoint in location_data.relative_keypoints]
+        face_keypoints = np.column_stack((x, y))
+        if model_selection == 0:
+          prediction_error = np.abs(
+              np.asarray(face_keypoints) -
+              np.asarray(SHORT_RANGE_EXPECTED_FACE_KEY_POINTS))
+        else:
+          prediction_error = np.abs(
+              np.asarray(face_keypoints) -
+              np.asarray(FULL_RANGE_EXPECTED_FACE_KEY_POINTS))
+
+        self.assertLen(results.detections, 1)
+        self.assertLen(location_data.relative_keypoints, 6)
+        npt.assert_array_less(prediction_error, DIFF_THRESHOLD)
+
+
+if __name__ == '__main__':
+  absltest.main()

mediapipe/python/solutions/face_mesh.py

@@ -0,0 +1,125 @@
+# Copyright 2020 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""MediaPipe Face Mesh."""
+
+from typing import NamedTuple
+
+import numpy as np
+
+# pylint: disable=unused-import
+from mediapipe.calculators.core import constant_side_packet_calculator_pb2
+from mediapipe.calculators.core import gate_calculator_pb2
+from mediapipe.calculators.core import split_vector_calculator_pb2
+from mediapipe.calculators.tensor import image_to_tensor_calculator_pb2
+from mediapipe.calculators.tensor import inference_calculator_pb2
+from mediapipe.calculators.tensor import tensors_to_classification_calculator_pb2
+from mediapipe.calculators.tensor import tensors_to_detections_calculator_pb2
+from mediapipe.calculators.tensor import tensors_to_landmarks_calculator_pb2
+from mediapipe.calculators.tflite import ssd_anchors_calculator_pb2
+from mediapipe.calculators.util import association_calculator_pb2
+from mediapipe.calculators.util import detections_to_rects_calculator_pb2
+from mediapipe.calculators.util import landmarks_refinement_calculator_pb2
+from mediapipe.calculators.util import logic_calculator_pb2
+from mediapipe.calculators.util import non_max_suppression_calculator_pb2
+from mediapipe.calculators.util import rect_transformation_calculator_pb2
+from mediapipe.calculators.util import thresholding_calculator_pb2
+# pylint: enable=unused-import
+from mediapipe.python.solution_base import SolutionBase
+# pylint: disable=unused-import
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_CONTOURS
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_FACE_OVAL
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_IRISES
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_LEFT_EYE
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_LEFT_EYEBROW
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_LEFT_IRIS
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_LIPS
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_NOSE
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_RIGHT_EYE
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_RIGHT_EYEBROW
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_RIGHT_IRIS
+from mediapipe.python.solutions.face_mesh_connections import FACEMESH_TESSELATION
+# pylint: enable=unused-import
+
+FACEMESH_NUM_LANDMARKS = 468
+FACEMESH_NUM_LANDMARKS_WITH_IRISES = 478
+_BINARYPB_FILE_PATH = 'mediapipe/modules/face_landmark/face_landmark_front_cpu.binarypb'
+
+
+class FaceMesh(SolutionBase):
+  """MediaPipe Face Mesh.
+
+  MediaPipe Face Mesh processes an RGB image and returns the face landmarks on
+  each detected face.
+
+  Please refer to https://solutions.mediapipe.dev/face_mesh#python-solution-api
+  for usage examples.
+  """
+
+  def __init__(self,
+               static_image_mode=False,
+               max_num_faces=1,
+               refine_landmarks=False,
+               min_detection_confidence=0.5,
+               min_tracking_confidence=0.5):
+    """Initializes a MediaPipe Face Mesh object.
+
+    Args:
+      static_image_mode: Whether to treat the input images as a batch of static
+        and possibly unrelated images, or a video stream. See details in
+        https://solutions.mediapipe.dev/face_mesh#static_image_mode.
+      max_num_faces: Maximum number of faces to detect. See details in
+        https://solutions.mediapipe.dev/face_mesh#max_num_faces.
+      refine_landmarks: Whether to further refine the landmark coordinates
+        around the eyes and lips, and output additional landmarks around the
+        irises. Default to False. See details in
+        https://solutions.mediapipe.dev/face_mesh#refine_landmarks.
+      min_detection_confidence: Minimum confidence value ([0.0, 1.0]) for face
+        detection to be considered successful. See details in
+        https://solutions.mediapipe.dev/face_mesh#min_detection_confidence.
+      min_tracking_confidence: Minimum confidence value ([0.0, 1.0]) for the
+        face landmarks to be considered tracked successfully. See details in
+        https://solutions.mediapipe.dev/face_mesh#min_tracking_confidence.
+    """
+    super().__init__(
+        binary_graph_path=_BINARYPB_FILE_PATH,
+        side_inputs={
+            'num_faces': max_num_faces,
+            'with_attention': refine_landmarks,
+            'use_prev_landmarks': not static_image_mode,
+        },
+        calculator_params={
+            'facedetectionshortrangecpu__facedetectionshortrange__facedetection__TensorsToDetectionsCalculator.min_score_thresh':
+                min_detection_confidence,
+            'facelandmarkcpu__ThresholdingCalculator.threshold':
+                min_tracking_confidence,
+        },
+        outputs=['multi_face_landmarks'])
+
+  def process(self, image: np.ndarray) -> NamedTuple:
+    """Processes an RGB image and returns the face landmarks on each detected face.
+
+    Args:
+      image: An RGB image represented as a numpy ndarray.
+
+    Raises:
+      RuntimeError: If the underlying graph throws any error.
+      ValueError: If the input image is not three channel RGB.
+
+    Returns:
+      A NamedTuple object with a "multi_face_landmarks" field that contains the
+      face landmarks on each detected face.
+    """
+
+    return super().process(input_data={'image': image})