mediapipe-nightly 0.10.21.post20241223__cp39-cp39-manylinux_2_28_x86_64.whl

mediapipe/python/image_frame_test.py

@@ -0,0 +1,194 @@
+# 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._framework_bindings.image_frame."""
+
+import gc
+import random
+import sys
+
+from absl.testing import absltest
+import cv2
+import numpy as np
+import PIL.Image
+
+from mediapipe.python._framework_bindings import image_frame
+
+ImageFormat = image_frame.ImageFormat
+ImageFrame = image_frame.ImageFrame
+
+
+# TODO: Add unit tests specifically for memory management.
+class ImageFrameTest(absltest.TestCase):
+
+  def test_create_image_frame_from_gray_cv_mat(self):
+    w, h = random.randrange(3, 100), random.randrange(3, 100)
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, 3), dtype=np.uint8),
+        cv2.COLOR_RGB2GRAY)
+    mat[2, 2] = 42
+    gray8_image_frame = ImageFrame(image_format=ImageFormat.GRAY8, data=mat)
+    self.assertTrue(np.array_equal(mat, gray8_image_frame.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'index dimension mismatch'):
+      print(gray8_image_frame[w, h, 1])
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(gray8_image_frame[w, h])
+    self.assertEqual(42, gray8_image_frame[2, 2])
+
+  def test_create_image_frame_from_rgb_cv_mat(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 3
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        cv2.COLOR_RGB2BGR)
+    mat[2, 2, 1] = 42
+    rgb_image_frame = ImageFrame(image_format=ImageFormat.SRGB, data=mat)
+    self.assertTrue(np.array_equal(mat, rgb_image_frame.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(rgb_image_frame[w, h, channels])
+    self.assertEqual(42, rgb_image_frame[2, 2, 1])
+
+  def test_create_image_frame_from_rgb48_cv_mat(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 3
+    mat = cv2.cvtColor(
+        np.random.randint(2**16 - 1, size=(h, w, channels), dtype=np.uint16),
+        cv2.COLOR_RGB2BGR)
+    mat[2, 2, 1] = 42
+    rgb48_image_frame = ImageFrame(image_format=ImageFormat.SRGB48, data=mat)
+    self.assertTrue(np.array_equal(mat, rgb48_image_frame.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(rgb48_image_frame[w, h, channels])
+    self.assertEqual(42, rgb48_image_frame[2, 2, 1])
+
+  def test_create_image_frame_from_gray_pil_image(self):
+    w, h = random.randrange(3, 100), random.randrange(3, 100)
+    img = PIL.Image.fromarray(
+        np.random.randint(2**8 - 1, size=(h, w), dtype=np.uint8), 'L')
+    gray8_image_frame = ImageFrame(
+        image_format=ImageFormat.GRAY8, data=np.asarray(img))
+    self.assertTrue(
+        np.array_equal(np.asarray(img), gray8_image_frame.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'index dimension mismatch'):
+      print(gray8_image_frame[w, h, 1])
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(gray8_image_frame[w, h])
+
+  def test_create_image_frame_from_rgb_pil_image(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 3
+    img = PIL.Image.fromarray(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        'RGB')
+    rgb_image_frame = ImageFrame(
+        image_format=ImageFormat.SRGB, data=np.asarray(img))
+    self.assertTrue(
+        np.array_equal(np.asarray(img), rgb_image_frame.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(rgb_image_frame[w, h, channels])
+
+  def test_create_image_frame_from_rgba64_pil_image(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 4
+    img = PIL.Image.fromarray(
+        np.random.randint(2**16 - 1, size=(h, w, channels), dtype=np.uint16),
+        'RGBA')
+    rgba_image_frame = ImageFrame(
+        image_format=ImageFormat.SRGBA64,
+        data=np.asarray(img).astype(np.uint16))
+    self.assertTrue(
+        np.array_equal(np.asarray(img), rgba_image_frame.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(rgba_image_frame[1000, 1000, 1000])
+
+  def test_image_frame_numby_view(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 3
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        cv2.COLOR_RGB2BGR)
+    rgb_image_frame = ImageFrame(image_format=ImageFormat.SRGB, data=mat)
+    output_ndarray = rgb_image_frame.numpy_view()
+    self.assertTrue(np.array_equal(mat, rgb_image_frame.numpy_view()))
+    # The output of numpy_view() is a reference to the internal data and it's
+    # unwritable after creation.
+    with self.assertRaisesRegex(ValueError,
+                                'assignment destination is read-only'):
+      output_ndarray[0, 0, 0] = 0
+    copied_ndarray = np.copy(output_ndarray)
+    copied_ndarray[0, 0, 0] = 0
+
+  def test_cropped_gray8_image(self):
+    w, h = random.randrange(20, 100), random.randrange(20, 100)
+    channels, offset = 3, 10
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        cv2.COLOR_RGB2GRAY)
+    gray8_image_frame = ImageFrame(
+        image_format=ImageFormat.GRAY8,
+        data=np.ascontiguousarray(mat[offset:-offset, offset:-offset]))
+    self.assertTrue(
+        np.array_equal(mat[offset:-offset, offset:-offset],
+                       gray8_image_frame.numpy_view()))
+
+  def test_cropped_rgb_image(self):
+    w, h = random.randrange(20, 100), random.randrange(20, 100)
+    channels, offset = 3, 10
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        cv2.COLOR_RGB2BGR)
+    rgb_image_frame = ImageFrame(
+        image_format=ImageFormat.SRGB,
+        data=np.ascontiguousarray(mat[offset:-offset, offset:-offset, :]))
+    self.assertTrue(
+        np.array_equal(mat[offset:-offset, offset:-offset, :],
+                       rgb_image_frame.numpy_view()))
+
+  # For image frames that store contiguous data, the output of numpy_view()
+  # points to the pixel data of the original image frame object. The life cycle
+  # of the data array should tie to the image frame object.
+  def test_image_frame_numpy_view_with_contiguous_data(self):
+    w, h = 640, 480
+    mat = np.random.randint(2**8 - 1, size=(h, w, 3), dtype=np.uint8)
+    rgb_image_frame = ImageFrame(image_format=ImageFormat.SRGB, data=mat)
+    self.assertTrue(rgb_image_frame.is_contiguous())
+    initial_ref_count = sys.getrefcount(rgb_image_frame)
+    self.assertTrue(np.array_equal(mat, rgb_image_frame.numpy_view()))
+    # Get 2 data array objects and verify that the image frame's ref count is
+    # increased by 2.
+    np_view = rgb_image_frame.numpy_view()
+    self.assertEqual(sys.getrefcount(rgb_image_frame), initial_ref_count + 1)
+    np_view2 = rgb_image_frame.numpy_view()
+    self.assertEqual(sys.getrefcount(rgb_image_frame), initial_ref_count + 2)
+    del np_view
+    del np_view2
+    gc.collect()
+    # After the two data array objects getting destroyed, the current ref count
+    # should euqal to the initial ref count.
+    self.assertEqual(sys.getrefcount(rgb_image_frame), initial_ref_count)
+
+  # For image frames that store non contiguous data, the output of numpy_view()
+  # stores a copy of the pixel data of the image frame object. The life cycle of
+  # the data array doesn't tie to the image frame object.
+  def test_image_frame_numpy_view_with_non_contiguous_data(self):
+    w, h = 641, 481
+    mat = np.random.randint(2**8 - 1, size=(h, w, 3), dtype=np.uint8)
+    rgb_image_frame = ImageFrame(image_format=ImageFormat.SRGB, data=mat)
+    self.assertFalse(rgb_image_frame.is_contiguous())
+    initial_ref_count = sys.getrefcount(rgb_image_frame)
+    self.assertTrue(np.array_equal(mat, rgb_image_frame.numpy_view()))
+    np_view = rgb_image_frame.numpy_view()
+    self.assertEqual(sys.getrefcount(rgb_image_frame), initial_ref_count)
+    del np_view
+    gc.collect()
+    self.assertEqual(sys.getrefcount(rgb_image_frame), initial_ref_count)
+
+
+if __name__ == '__main__':
+  absltest.main()

mediapipe/python/image_test.py

@@ -0,0 +1,218 @@
+# 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._framework_bindings.image."""
+
+import gc
+import os
+import random
+import sys
+
+from absl.testing import absltest
+import cv2
+import numpy as np
+import PIL.Image
+
+# resources dependency
+from mediapipe.python._framework_bindings import image
+from mediapipe.python._framework_bindings import image_frame
+
+TEST_IMAGE_PATH = 'mediapipe/python/solutions/testdata'
+
+Image = image.Image
+ImageFormat = image_frame.ImageFormat
+
+
+# TODO: Add unit tests specifically for memory management.
+class ImageTest(absltest.TestCase):
+
+  def test_create_image_from_gray_cv_mat(self):
+    w, h = random.randrange(3, 100), random.randrange(3, 100)
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, 3), dtype=np.uint8),
+        cv2.COLOR_RGB2GRAY)
+    mat[2, 2] = 42
+    gray8_image = Image(image_format=ImageFormat.GRAY8, data=mat)
+    self.assertTrue(np.array_equal(mat, gray8_image.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'index dimension mismatch'):
+      print(gray8_image[w, h, 1])
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(gray8_image[w, h])
+    self.assertEqual(42, gray8_image[2, 2])
+
+  def test_create_image_from_rgb_cv_mat(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 3
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        cv2.COLOR_RGB2BGR)
+    mat[2, 2, 1] = 42
+    rgb_image = Image(image_format=ImageFormat.SRGB, data=mat)
+    self.assertTrue(np.array_equal(mat, rgb_image.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(rgb_image[w, h, channels])
+    self.assertEqual(42, rgb_image[2, 2, 1])
+
+  def test_create_image_from_rgb48_cv_mat(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 3
+    mat = cv2.cvtColor(
+        np.random.randint(2**16 - 1, size=(h, w, channels), dtype=np.uint16),
+        cv2.COLOR_RGB2BGR)
+    mat[2, 2, 1] = 42
+    rgb48_image = Image(image_format=ImageFormat.SRGB48, data=mat)
+    self.assertTrue(np.array_equal(mat, rgb48_image.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(rgb48_image[w, h, channels])
+    self.assertEqual(42, rgb48_image[2, 2, 1])
+
+  def test_create_image_from_gray_pil_image(self):
+    w, h = random.randrange(3, 100), random.randrange(3, 100)
+    img = PIL.Image.fromarray(
+        np.random.randint(2**8 - 1, size=(h, w), dtype=np.uint8), 'L')
+    gray8_image = Image(image_format=ImageFormat.GRAY8, data=np.asarray(img))
+    self.assertTrue(np.array_equal(np.asarray(img), gray8_image.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'index dimension mismatch'):
+      print(gray8_image[w, h, 1])
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(gray8_image[w, h])
+
+  def test_create_image_from_rgb_pil_image(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 3
+    img = PIL.Image.fromarray(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        'RGB')
+    rgb_image = Image(image_format=ImageFormat.SRGB, data=np.asarray(img))
+    self.assertTrue(np.array_equal(np.asarray(img), rgb_image.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(rgb_image[w, h, channels])
+
+  def test_create_image_from_rgba64_pil_image(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 4
+    img = PIL.Image.fromarray(
+        np.random.randint(2**16 - 1, size=(h, w, channels), dtype=np.uint16),
+        'RGBA')
+    rgba_image = Image(
+        image_format=ImageFormat.SRGBA64,
+        data=np.asarray(img).astype(np.uint16))
+    self.assertTrue(np.array_equal(np.asarray(img), rgba_image.numpy_view()))
+    with self.assertRaisesRegex(IndexError, 'out of bounds'):
+      print(rgba_image[1000, 1000, 1000])
+
+  def test_image_numby_view(self):
+    w, h, channels = random.randrange(3, 100), random.randrange(3, 100), 3
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        cv2.COLOR_RGB2BGR)
+    rgb_image = Image(image_format=ImageFormat.SRGB, data=mat)
+    output_ndarray = rgb_image.numpy_view()
+    self.assertTrue(np.array_equal(mat, rgb_image.numpy_view()))
+    # The output of numpy_view() is a reference to the internal data and it's
+    # unwritable after creation.
+    with self.assertRaisesRegex(ValueError,
+                                'assignment destination is read-only'):
+      output_ndarray[0, 0, 0] = 0
+    copied_ndarray = np.copy(output_ndarray)
+    copied_ndarray[0, 0, 0] = 0
+
+  def test_cropped_gray8_image(self):
+    w, h = random.randrange(20, 100), random.randrange(20, 100)
+    channels, offset = 3, 10
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        cv2.COLOR_RGB2GRAY)
+    gray8_image = Image(
+        image_format=ImageFormat.GRAY8,
+        data=np.ascontiguousarray(mat[offset:-offset, offset:-offset]))
+    self.assertTrue(
+        np.array_equal(mat[offset:-offset, offset:-offset],
+                       gray8_image.numpy_view()))
+
+  def test_cropped_rgb_image(self):
+    w, h = random.randrange(20, 100), random.randrange(20, 100)
+    channels, offset = 3, 10
+    mat = cv2.cvtColor(
+        np.random.randint(2**8 - 1, size=(h, w, channels), dtype=np.uint8),
+        cv2.COLOR_RGB2BGR)
+    rgb_image = Image(
+        image_format=ImageFormat.SRGB,
+        data=np.ascontiguousarray(mat[offset:-offset, offset:-offset, :]))
+    self.assertTrue(
+        np.array_equal(mat[offset:-offset, offset:-offset, :],
+                       rgb_image.numpy_view()))
+
+  # For image frames that store contiguous data, the output of numpy_view()
+  # points to the pixel data of the original image frame object. The life cycle
+  # of the data array should tie to the image frame object.
+  def test_image_numpy_view_with_contiguous_data(self):
+    w, h = 640, 480
+    mat = np.random.randint(2**8 - 1, size=(h, w, 3), dtype=np.uint8)
+    rgb_image = Image(image_format=ImageFormat.SRGB, data=mat)
+    self.assertTrue(rgb_image.is_contiguous())
+    initial_ref_count = sys.getrefcount(rgb_image)
+    self.assertTrue(np.array_equal(mat, rgb_image.numpy_view()))
+    # Get 2 data array objects and verify that the image frame's ref count is
+    # increased by 2.
+    np_view = rgb_image.numpy_view()
+    self.assertEqual(sys.getrefcount(rgb_image), initial_ref_count + 1)
+    np_view2 = rgb_image.numpy_view()
+    self.assertEqual(sys.getrefcount(rgb_image), initial_ref_count + 2)
+    del np_view
+    del np_view2
+    gc.collect()
+    # After the two data array objects getting destroyed, the current ref count
+    # should euqal to the initial ref count.
+    self.assertEqual(sys.getrefcount(rgb_image), initial_ref_count)
+
+  # For image frames that store non contiguous data, the output of numpy_view()
+  # stores a copy of the pixel data of the image frame object. The life cycle of
+  # the data array doesn't tie to the image frame object.
+  def test_image_numpy_view_with_non_contiguous_data(self):
+    w, h = 641, 481
+    mat = np.random.randint(2**8 - 1, size=(h, w, 3), dtype=np.uint8)
+    rgb_image = Image(image_format=ImageFormat.SRGB, data=mat)
+    self.assertFalse(rgb_image.is_contiguous())
+    initial_ref_count = sys.getrefcount(rgb_image)
+    self.assertTrue(np.array_equal(mat, rgb_image.numpy_view()))
+    np_view = rgb_image.numpy_view()
+    self.assertEqual(sys.getrefcount(rgb_image), initial_ref_count)
+    del np_view
+    gc.collect()
+    self.assertEqual(sys.getrefcount(rgb_image), initial_ref_count)
+
+  def test_image_create_from_cvmat(self):
+    image_path = os.path.join(os.path.dirname(__file__),
+                              'solutions/testdata/hands.jpg')
+    mat = cv2.imread(image_path).astype(np.uint8)
+    mat = cv2.cvtColor(mat, cv2.COLOR_BGR2RGB)
+    rgb_image = Image(image_format=ImageFormat.SRGB, data=mat)
+    self.assertEqual(rgb_image.width, 720)
+    self.assertEqual(rgb_image.height, 382)
+    self.assertEqual(rgb_image.channels, 3)
+    self.assertEqual(rgb_image.image_format, ImageFormat.SRGB)
+    self.assertTrue(np.array_equal(mat, rgb_image.numpy_view()))
+
+  def test_image_create_from_file(self):
+    image_path = os.path.join(os.path.dirname(__file__),
+                              'solutions/testdata/hands.jpg')
+    loaded_image = Image.create_from_file(image_path)
+    self.assertEqual(loaded_image.width, 720)
+    self.assertEqual(loaded_image.height, 382)
+    # On Mac w/ GPU support, images use 4 channels (SRGBA). Otherwise, all
+    # images use 3 channels (SRGB).
+    self.assertIn(loaded_image.channels, [3, 4])
+    self.assertIn(
+        loaded_image.image_format, [ImageFormat.SRGB, ImageFormat.SRGBA]
+    )
+
+if __name__ == '__main__':
+  absltest.main()

mediapipe/python/packet_creator.py

@@ -0,0 +1,275 @@
+# 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.
+
+"""The public facing packet creator APIs."""
+
+from typing import List, Union
+import warnings
+
+import numpy as np
+
+from google.protobuf import message
+from mediapipe.python._framework_bindings import _packet_creator
+from mediapipe.python._framework_bindings import image
+from mediapipe.python._framework_bindings import image_frame
+from mediapipe.python._framework_bindings import packet
+
+
+create_string = _packet_creator.create_string
+create_bool = _packet_creator.create_bool
+create_int = _packet_creator.create_int
+create_int8 = _packet_creator.create_int8
+create_int16 = _packet_creator.create_int16
+create_int32 = _packet_creator.create_int32
+create_int64 = _packet_creator.create_int64
+create_uint8 = _packet_creator.create_uint8
+create_uint16 = _packet_creator.create_uint16
+create_uint32 = _packet_creator.create_uint32
+create_uint64 = _packet_creator.create_uint64
+create_float = _packet_creator.create_float
+create_double = _packet_creator.create_double
+create_int_array = _packet_creator.create_int_array
+create_float_array = _packet_creator.create_float_array
+create_int_vector = _packet_creator.create_int_vector
+create_bool_vector = _packet_creator.create_bool_vector
+create_float_vector = _packet_creator.create_float_vector
+create_string_vector = _packet_creator.create_string_vector
+create_image_vector = _packet_creator.create_image_vector
+create_packet_vector = _packet_creator.create_packet_vector
+create_string_to_packet_map = _packet_creator.create_string_to_packet_map
+create_matrix = _packet_creator.create_matrix
+
+
+def create_image_frame(data: Union[image_frame.ImageFrame, np.ndarray],  # pytype: disable=annotation-type-mismatch
+                       *,
+                       image_format: image_frame.ImageFormat = None,
+                       copy: bool = None) -> packet.Packet:
+  """Create a MediaPipe ImageFrame packet.
+
+  A MediaPipe ImageFrame packet can be created from an existing MediaPipe
+  ImageFrame object and the data will be realigned and copied into a new
+  ImageFrame object inside of the packet.
+
+  A MediaPipe ImageFrame packet can also be created from the raw pixel data
+  represented as a numpy array with one of the uint8, uint16, and float data
+  types. There are three data ownership modes depending on how the 'copy' arg
+  is set.
+
+  i) Default mode
+  If copy is not set, mutable data is always copied while the immutable data
+  is by reference.
+
+  ii) Copy mode (safe)
+  If copy is set to True, the data will be realigned and copied into an
+  ImageFrame object inside of the packet regardless the immutablity of the
+  original data.
+
+  iii) Reference mode (dangerous)
+  If copy is set to False, the data will be forced to be shared. If the data is
+  mutable (data.flags.writeable is True), a warning will be raised.
+
+  Args:
+    data: A MediaPipe ImageFrame object or the raw pixel data that is
+      represnted as a numpy ndarray.
+    image_format: One of the image_frame.ImageFormat enum types.
+    copy: Indicate if the packet should copy the data from the numpy nparray.
+
+  Returns:
+    A MediaPipe ImageFrame Packet.
+
+  Raises:
+    ValueError:
+      i) When "data" is a numpy ndarray, "image_format" is not provided or
+        the "data" array is not c_contiguous in the reference mode.
+      ii) When "data" is an ImageFrame object, the "image_format" arg doesn't
+        match the image format of the "data" ImageFrame object or "copy" is
+        explicitly set to False.
+    TypeError: If "image format" doesn't match "data" array's data type.
+
+  Examples:
+    np_array = np.random.randint(255, size=(321, 123, 3), dtype=np.uint8)
+    # Copy mode by default if the data array is writable.
+    image_frame_packet = mp.packet_creator.create_image_frame(
+        image_format=mp.ImageFormat.SRGB, data=np_array)
+
+    # Make the array unwriteable to trigger the reference mode.
+    np_array.flags.writeable = False
+    image_frame_packet = mp.packet_creator.create_image_frame(
+        image_format=mp.ImageFormat.SRGB, data=np_array)
+
+    image_frame = mp.ImageFrame(image_format=mp.ImageFormat.SRGB, data=np_array)
+    image_frame_packet = mp.packet_creator.create_image_frame(image_frame)
+
+  """
+  if isinstance(data, image_frame.ImageFrame):
+    if image_format is not None and data.image_format != image_format:
+      raise ValueError(
+          'The provided image_format doesn\'t match the one from the data arg.')
+    if copy is not None and not copy:
+      # Taking a reference will make the created packet be mutable since the
+      # ImageFrame object can still be manipulated in Python, which voids packet
+      # immutability.
+      raise ValueError(
+          'Creating ImageFrame packet by taking a reference of another ImageFrame object is not supported yet.'
+      )
+    # pylint:disable=protected-access
+    return _packet_creator._create_image_frame_from_image_frame(data)
+    # pylint:enable=protected-access
+  else:
+    if image_format is None:
+      raise ValueError('Please provide \'image_format\' with \'data\'.')
+    # If copy arg is not set, copying the data if it's immutable. Otherwise,
+    # take a reference of the immutable data to avoid data copy.
+    if copy is None:
+      copy = True if data.flags.writeable else False
+    if not copy:
+      # TODO: Investigate why the first 2 bytes of the data has data
+      # corruption when "data" is not c_contiguous.
+      if not data.flags.c_contiguous:
+        raise ValueError(
+            'Reference mode is unavailable if \'data\' is not c_contiguous.')
+      if data.flags.writeable:
+        warnings.warn(
+            '\'data\' is still writeable. Taking a reference of the data to create ImageFrame packet is dangerous.',
+            RuntimeWarning, 2)
+    # pylint:disable=protected-access
+    return _packet_creator._create_image_frame_from_pixel_data(
+        image_format, data, copy)
+    # pylint:enable=protected-access
+
+
+def create_image(data: Union[image.Image, np.ndarray],  # pytype: disable=annotation-type-mismatch
+                 *,
+                 image_format: image_frame.ImageFormat = None,
+                 copy: bool = None) -> packet.Packet:
+  """Create a MediaPipe Image packet.
+
+  A MediaPipe Image packet can be created from an existing MediaPipe
+  Image object and the data will be realigned and copied into a new
+  Image object inside of the packet.
+
+  A MediaPipe Image packet can also be created from the raw pixel data
+  represented as a numpy array with one of the uint8, uint16, and float data
+  types. There are three data ownership modes depending on how the 'copy' arg
+  is set.
+
+  i) Default mode
+  If copy is not set, mutable data is always copied while the immutable data
+  is by reference.
+
+  ii) Copy mode (safe)
+  If copy is set to True, the data will be realigned and copied into an
+  Image object inside of the packet regardless the immutablity of the
+  original data.
+
+  iii) Reference mode (dangerous)
+  If copy is set to False, the data will be forced to be shared. If the data is
+  mutable (data.flags.writeable is True), a warning will be raised.
+
+  Args:
+    data: A MediaPipe Image object or the raw pixel data that is represnted as a
+      numpy ndarray.
+    image_format: One of the mp.ImageFormat enum types.
+    copy: Indicate if the packet should copy the data from the numpy nparray.
+
+  Returns:
+    A MediaPipe Image Packet.
+
+  Raises:
+    ValueError:
+      i) When "data" is a numpy ndarray, "image_format" is not provided or
+        the "data" array is not c_contiguous in the reference mode.
+      ii) When "data" is an Image object, the "image_format" arg doesn't
+        match the image format of the "data" Image object or "copy" is
+        explicitly set to False.
+    TypeError: If "image format" doesn't match "data" array's data type.
+
+  Examples:
+    np_array = np.random.randint(255, size=(321, 123, 3), dtype=np.uint8)
+    # Copy mode by default if the data array is writable.
+    image_packet = mp.packet_creator.create_image(
+        image_format=mp.ImageFormat.SRGB, data=np_array)
+
+    # Make the array unwriteable to trigger the reference mode.
+    np_array.flags.writeable = False
+    image_packet = mp.packet_creator.create_image(
+        image_format=mp.ImageFormat.SRGB, data=np_array)
+
+    image = mp.Image(image_format=mp.ImageFormat.SRGB, data=np_array)
+    image_packet = mp.packet_creator.create_image(image)
+
+  """
+  if isinstance(data, image.Image):
+    if image_format is not None and data.image_format != image_format:
+      raise ValueError(
+          'The provided image_format doesn\'t match the one from the data arg.')
+    if copy is not None and not copy:
+      # Taking a reference will make the created packet be mutable since the
+      # Image object can still be manipulated in Python, which voids packet
+      # immutability.
+      raise ValueError(
+          'Creating Image packet by taking a reference of another Image object is not supported yet.'
+      )
+    # pylint:disable=protected-access
+    return _packet_creator._create_image_from_image(data)
+    # pylint:enable=protected-access
+  else:
+    if image_format is None:
+      raise ValueError('Please provide \'image_format\' with \'data\'.')
+    # If copy arg is not set, copying the data if it's immutable. Otherwise,
+    # take a reference of the immutable data to avoid data copy.
+    if copy is None:
+      copy = True if data.flags.writeable else False
+    if not copy:
+      # TODO: Investigate why the first 2 bytes of the data has data
+      # corruption when "data" is not c_contiguous.
+      if not data.flags.c_contiguous:
+        raise ValueError(
+            'Reference mode is unavailable if \'data\' is not c_contiguous.')
+      if data.flags.writeable:
+        warnings.warn(
+            '\'data\' is still writeable. Taking a reference of the data to create Image packet is dangerous.',
+            RuntimeWarning, 2)
+    # pylint:disable=protected-access
+    return _packet_creator._create_image_from_pixel_data(
+        image_format, data, copy)
+    # pylint:enable=protected-access
+
+
+def create_proto(proto_message: message.Message) -> packet.Packet:
+  """Create a MediaPipe protobuf message packet.
+
+  Args:
+    proto_message: A Python protobuf message.
+
+  Returns:
+    A MediaPipe protobuf message Packet.
+
+  Raises:
+    RuntimeError: If the protobuf message type is not registered in MediaPipe.
+
+  Examples:
+    detection = detection_pb2.Detection()
+    text_format.Parse('score: 0.5', detection)
+    packet = mp.packet_creator.create_proto(detection)
+    output_detection = mp.packet_getter.get_proto(packet)
+  """
+  # pylint:disable=protected-access
+  return _packet_creator._create_proto(proto_message.DESCRIPTOR.full_name,
+                                       proto_message.SerializeToString())
+  # pylint:enable=protected-access
+
+
+def create_proto_vector(message_list: List[message.Message]) -> packet.Packet:
+  raise NotImplementedError('create_proto_vector is not implemented.')