@mediapipe/tasks-vision 0.1.0-alpha-11 → 0.1.0-alpha-13

package/vision.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
+ * Copyright 2022 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.
@@ -30,7 +30,7 @@ declare interface BaseOptions_2 {
 }
 
 /**
- * Copyright 2023 The MediaPipe Authors. All Rights Reserved.
+ * Copyright 2023 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.
@@ -63,7 +63,7 @@ export declare interface BoundingBox {
 export declare type Callback<I, O> = (input: I) => O;
 
 /**
- * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
+ * Copyright 2022 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.
@@ -117,7 +117,7 @@ export declare interface Classifications {
 }
 
 /**
- * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
+ * Copyright 2022 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.
@@ -261,7 +261,7 @@ export declare class DrawingUtils {
 }
 
 /**
- * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
+ * Copyright 2022 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.
@@ -294,7 +294,7 @@ declare interface EmbedderOptions {
 }
 
 /**
- * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
+ * Copyright 2022 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.
@@ -533,7 +533,7 @@ export declare interface FaceLandmarkerResult {
 }
 
 /**
- * A class containing the Pairs of landmark indices to be rendered with
+ * A class containing the pairs of landmark indices to be rendered with
  * connections.
  */
 export declare class FaceLandmarksConnections {
@@ -593,16 +593,12 @@ export declare class FaceStylizer extends VisionTaskRunner {
      * synchronously once the callback returns. Only use this method when the
      * FaceStylizer is created with the image running mode.
      *
-     * The input image can be of any size. To ensure that the output image has
-     * reasonable quality, the stylized output image size is determined by the
-     * model output size.
-     *
      * @param image An image to process.
      * @param callback The callback that is invoked with the stylized image. The
      *    lifetime of the returned data is only guaranteed for the duration of the
      *    callback.
      */
-    stylize(image: ImageSource, callback: ImageCallback): void;
+    stylize(image: ImageSource, callback: FaceStylizerCallback): void;
     /**
      * Performs face stylization on the provided single image. The method returns
      * synchronously once the callback returns. Only use this method when the
@@ -617,11 +613,6 @@ export declare class FaceStylizer extends VisionTaskRunner {
      *  If both are specified, the crop around the region-of-interest is extracted
      *  first, then the specified rotation is applied to the crop.
      *
-     * The input image can be of any size. To ensure that the output image has
-     * reasonable quality, the stylized output image size is the smaller of the
-     * model output size and the size of the 'regionOfInterest' specified in
-     * 'imageProcessingOptions'.
-     *
      * @param image An image to process.
      * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
      *    to process the input image before running inference.
@@ -629,7 +620,7 @@ export declare class FaceStylizer extends VisionTaskRunner {
      *    lifetime of the returned data is only guaranteed for the duration of the
      *    callback.
      */
-    stylize(image: ImageSource, imageProcessingOptions: ImageProcessingOptions, callback: ImageCallback): void;
+    stylize(image: ImageSource, imageProcessingOptions: ImageProcessingOptions, callback: FaceStylizerCallback): void;
     /**
      * Performs face stylization on the provided video frame. Only use this method
      * when the FaceStylizer is created with the video running mode.
@@ -638,16 +629,13 @@ export declare class FaceStylizer extends VisionTaskRunner {
      * frame's timestamp (in milliseconds). The input timestamps must be
      * monotonically increasing.
      *
-     * To ensure that the output image has reasonable quality, the stylized
-     * output image size is determined by the model output size.
-     *
      * @param videoFrame A video frame to process.
      * @param timestamp The timestamp of the current frame, in ms.
      * @param callback The callback that is invoked with the stylized image. The
      *    lifetime of the returned data is only guaranteed for the duration of
      * the callback.
      */
-    stylizeForVideo(videoFrame: ImageSource, timestamp: number, callback: ImageCallback): void;
+    stylizeForVideo(videoFrame: ImageSource, timestamp: number, callback: FaceStylizerCallback): void;
     /**
      * Performs face stylization on the provided video frame. Only use this
      * method when the FaceStylizer is created with the video running mode.
@@ -665,10 +653,6 @@ export declare class FaceStylizer extends VisionTaskRunner {
      * frame's timestamp (in milliseconds). The input timestamps must be
      * monotonically increasing.
      *
-     * To ensure that the output image has reasonable quality, the stylized
-     * output image size is the smaller of the model output size and the size of
-     * the 'regionOfInterest' specified in 'imageProcessingOptions'.
-     *
      * @param videoFrame A video frame to process.
      * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
      *    to process the input image before running inference.
@@ -677,9 +661,19 @@ export declare class FaceStylizer extends VisionTaskRunner {
      *    lifetime of the returned data is only guaranteed for the duration of
      * the callback.
      */
-    stylizeForVideo(videoFrame: ImageSource, imageProcessingOptions: ImageProcessingOptions, timestamp: number, callback: ImageCallback): void;
+    stylizeForVideo(videoFrame: ImageSource, imageProcessingOptions: ImageProcessingOptions, timestamp: number, callback: FaceStylizerCallback): void;
 }
 
+/**
+ * A callback that receives an image from the face stylizer, or `null` if no
+ * face was detected. The lifetime of the underlying data is limited to the
+ * duration of the callback. If asynchronous processing is needed, all data
+ * needs to be copied before the callback returns.
+ *
+ * The `WebGLTexture` output type is reserved for future usage.
+ */
+export declare type FaceStylizerCallback = (image: ImageData | WebGLTexture | null, width: number, height: number) => void;
+
 /** Options to configure the MediaPipe Face Stylizer Task */
 export declare interface FaceStylizerOptions extends VisionTaskOptions {
 }
@@ -738,6 +732,11 @@ export declare class FilesetResolver {
 
 /** Performs hand gesture recognition on images. */
 export declare class GestureRecognizer extends VisionTaskRunner {
+    /**
+     * An array containing the pairs of hand landmark indices to be rendered with
+     * connections.
+     */
+    static HAND_CONNECTIONS: Connection[];
     /**
      * Initializes the Wasm runtime and creates a new gesture recognizer from the
      * provided options.
@@ -857,6 +856,11 @@ export declare interface GestureRecognizerResult {
 
 /** Performs hand landmarks detection on images. */
 export declare class HandLandmarker extends VisionTaskRunner {
+    /**
+     * An array containing the pairs of hand landmark indices to be rendered with
+     * connections.
+     */
+    static HAND_CONNECTIONS: Connection[];
     /**
      * Initializes the Wasm runtime and creates a new `HandLandmarker` from the
      * provided options.
@@ -949,22 +953,12 @@ export declare interface HandLandmarkerOptions extends VisionTaskOptions {
 export declare interface HandLandmarkerResult {
     /** Hand landmarks of detected hands. */
     landmarks: NormalizedLandmark[][];
-    /** Hand landmarks in world coordniates of detected hands. */
+    /** Hand landmarks in world coordinates of detected hands. */
     worldLandmarks: Landmark[][];
     /** Handedness of detected hands. */
     handednesses: Category[][];
 }
 
-/**
- * A callback that receives an `ImageData` object from a Vision task. The
- * lifetime of the underlying data is limited to the duration of the callback.
- * If asynchronous processing is needed, all data needs to be copied before the
- * callback returns.
- *
- * The `WebGLTexture` output type is reserved for future usage.
- */
-export declare type ImageCallback = (image: ImageData | WebGLTexture, width: number, height: number) => void;
-
 /** Performs classification on images. */
 export declare class ImageClassifier extends VisionTaskRunner {
     /**
@@ -1219,7 +1213,7 @@ export declare class ImageSegmenter extends VisionTaskRunner {
      *    lifetime of the returned data is only guaranteed for the duration of the
      *    callback.
      */
-    segment(image: ImageSource, callback: SegmentationMaskCallback): void;
+    segment(image: ImageSource, callback: ImageSegmenterCallback): void;
     /**
      * Performs image segmentation on the provided single image and invokes the
      * callback with the response. The method returns synchronously once the
@@ -1233,19 +1227,7 @@ export declare class ImageSegmenter extends VisionTaskRunner {
      *    lifetime of the returned data is only guaranteed for the duration of the
      *    callback.
      */
-    segment(image: ImageSource, imageProcessingOptions: ImageProcessingOptions, callback: SegmentationMaskCallback): void;
-    /**
-     * Get the category label list of the ImageSegmenter can recognize. For
-     * `CATEGORY_MASK` type, the index in the category mask corresponds to the
-     * category in the label list. For `CONFIDENCE_MASK` type, the output mask
-     * list at index corresponds to the category in the label list.
-     *
-     * If there is no labelmap provided in the model file, empty label array is
-     * returned.
-     *
-     * @return The labels used by the current model.
-     */
-    getLabels(): string[];
+    segment(image: ImageSource, imageProcessingOptions: ImageProcessingOptions, callback: ImageSegmenterCallback): void;
     /**
      * Performs image segmentation on the provided video frame and invokes the
      * callback with the response. The method returns synchronously once the
@@ -1258,7 +1240,7 @@ export declare class ImageSegmenter extends VisionTaskRunner {
      *    lifetime of the returned data is only guaranteed for the duration of the
      *    callback.
      */
-    segmentForVideo(videoFrame: ImageSource, timestamp: number, callback: SegmentationMaskCallback): void;
+    segmentForVideo(videoFrame: ImageSource, timestamp: number, callback: ImageSegmenterCallback): void;
     /**
      * Performs image segmentation on the provided video frame and invokes the
      * callback with the response. The method returns synchronously once the
@@ -1273,9 +1255,29 @@ export declare class ImageSegmenter extends VisionTaskRunner {
      *    lifetime of the returned data is only guaranteed for the duration of the
      *    callback.
      */
-    segmentForVideo(videoFrame: ImageSource, imageProcessingOptions: ImageProcessingOptions, timestamp: number, callback: SegmentationMaskCallback): void;
+    segmentForVideo(videoFrame: ImageSource, imageProcessingOptions: ImageProcessingOptions, timestamp: number, callback: ImageSegmenterCallback): void;
+    /**
+     * Get the category label list of the ImageSegmenter can recognize. For
+     * `CATEGORY_MASK` type, the index in the category mask corresponds to the
+     * category in the label list. For `CONFIDENCE_MASK` type, the output mask
+     * list at index corresponds to the category in the label list.
+     *
+     * If there is no labelmap provided in the model file, empty label array is
+     * returned.
+     *
+     * @return The labels used by the current model.
+     */
+    getLabels(): string[];
 }
 
+/**
+ * A callback that receives the computed masks from the image segmenter. The
+ * returned data is only valid for the duration of the callback. If
+ * asynchronous processing is needed, all data needs to be copied before the
+ * callback returns.
+ */
+export declare type ImageSegmenterCallback = (result: ImageSegmenterResult) => void;
+
 /** Options to configure the MediaPipe Image Segmenter Task */
 export declare interface ImageSegmenterOptions extends VisionTaskOptions {
     /**
@@ -1283,20 +1285,44 @@ export declare interface ImageSegmenterOptions extends VisionTaskOptions {
      * Metadata, if any. Defaults to English.
      */
     displayNamesLocale?: string | undefined;
+    /** Whether to output confidence masks. Defaults to true. */
+    outputConfidenceMasks?: boolean | undefined;
+    /** Whether to output the category masks. Defaults to false. */
+    outputCategoryMask?: boolean | undefined;
+}
+
+/**
+ * Copyright 2023 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 output result of ImageSegmenter. */
+export declare interface ImageSegmenterResult {
     /**
-     * The output type of segmentation results.
-     *
-     * The two supported modes are:
-     * - Category Mask:   Gives a single output mask where each pixel represents
-     *                    the class which the pixel in the original image was
-     *                    predicted to belong to.
-     * - Confidence Mask: Gives a list of output masks (one for each class). For
-     *                    each mask, the pixel represents the prediction
-     *                    confidence, usually in the [0.0, 0.1] range.
-     *
-     * Defaults to `CATEGORY_MASK`.
+     * Multiple masks as Float32Arrays or WebGLTextures where, for each mask, each
+     * pixel represents the prediction confidence, usually in the [0, 1] range.
+     */
+    confidenceMasks?: Float32Array[] | WebGLTexture[];
+    /**
+     * A category mask as a Uint8ClampedArray or WebGLTexture where each
+     * pixel represents the class which the pixel in the original image was
+     * predicted to belong to.
      */
-    outputType?: "CATEGORY_MASK" | "CONFIDENCE_MASK" | undefined;
+    categoryMask?: Uint8ClampedArray | WebGLTexture;
+    /** The width of the masks. */
+    width: number;
+    /** The height of the masks. */
+    height: number;
 }
 
 /**
@@ -1387,7 +1413,7 @@ export declare class InteractiveSegmenter extends VisionTaskRunner {
      *    lifetime of the returned data is only guaranteed for the duration of the
      *    callback.
      */
-    segment(image: ImageSource, roi: RegionOfInterest, callback: SegmentationMaskCallback): void;
+    segment(image: ImageSource, roi: RegionOfInterest, callback: InteractiveSegmenterCallback): void;
     /**
      * Performs interactive segmentation on the provided single image and invokes
      * the callback with the response. The `roi` parameter is used to represent a
@@ -1413,25 +1439,57 @@ export declare class InteractiveSegmenter extends VisionTaskRunner {
      *    lifetime of the returned data is only guaranteed for the duration of the
      *    callback.
      */
-    segment(image: ImageSource, roi: RegionOfInterest, imageProcessingOptions: ImageProcessingOptions, callback: SegmentationMaskCallback): void;
+    segment(image: ImageSource, roi: RegionOfInterest, imageProcessingOptions: ImageProcessingOptions, callback: InteractiveSegmenterCallback): void;
 }
 
+/**
+ * A callback that receives the computed masks from the interactive segmenter.
+ * The returned data is only valid for the duration of the callback. If
+ * asynchronous processing is needed, all data needs to be copied before the
+ * callback returns.
+ */
+export declare type InteractiveSegmenterCallback = (result: InteractiveSegmenterResult) => void;
+
 /** Options to configure the MediaPipe Interactive Segmenter Task */
 export declare interface InteractiveSegmenterOptions extends TaskRunnerOptions {
+    /** Whether to output confidence masks. Defaults to true. */
+    outputConfidenceMasks?: boolean | undefined;
+    /** Whether to output the category masks. Defaults to false. */
+    outputCategoryMask?: boolean | undefined;
+}
+
+/**
+ * Copyright 2023 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 output result of InteractiveSegmenter. */
+export declare interface InteractiveSegmenterResult {
     /**
-     * The output type of segmentation results.
-     *
-     * The two supported modes are:
-     * - Category Mask:   Gives a single output mask where each pixel represents
-     *                    the class which the pixel in the original image was
-     *                    predicted to belong to.
-     * - Confidence Mask: Gives a list of output masks (one for each class). For
-     *                    each mask, the pixel represents the prediction
-     *                    confidence, usually in the [0.0, 0.1] range.
-     *
-     * Defaults to `CATEGORY_MASK`.
+     * Multiple masks as Float32Arrays or WebGLTextures where, for each mask, each
+     * pixel represents the prediction confidence, usually in the [0, 1] range.
+     */
+    confidenceMasks?: Float32Array[] | WebGLTexture[];
+    /**
+     * A category mask as a Uint8ClampedArray or WebGLTexture where each
+     * pixel represents the class which the pixel in the original image was
+     * predicted to belong to.
      */
-    outputType?: "CATEGORY_MASK" | "CONFIDENCE_MASK" | undefined;
+    categoryMask?: Uint8ClampedArray | WebGLTexture;
+    /** The width of the masks. */
+    width: number;
+    /** The height of the masks. */
+    height: number;
 }
 
 /**
@@ -1456,7 +1514,7 @@ export declare interface LandmarkData {
 }
 
 /**
- * Copyright 2023 The MediaPipe Authors. All Rights Reserved.
+ * Copyright 2023 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.
@@ -1481,7 +1539,249 @@ declare interface Matrix {
 }
 
 /**
- * Copyright 2023 The MediaPipe Authors. All Rights Reserved.
+ * The wrapper class for MediaPipe Image objects.
+ *
+ * Images are stored as `ImageData`, `ImageBitmap` or `WebGLTexture` objects.
+ * You can convert the underlying type to any other type by passing the
+ * desired type to `getImage()`. As type conversions can be expensive, it is
+ * recommended to limit these conversions. You can verify what underlying
+ * types are already available by invoking `hasType()`.
+ *
+ * Images that are returned from a MediaPipe Tasks are owned by by the
+ * underlying C++ Task. If you need to extend the lifetime of these objects,
+ * you can invoke the `clone()` method. To free up the resources obtained
+ * during any clone or type conversion operation, it is important to invoke
+ * `close()` on the `MPImage` instance.
+ *
+ * Converting to and from ImageBitmap requires that the MediaPipe task is
+ * initialized with an `OffscreenCanvas`. As we require WebGL2 support, this
+ * places some limitations on Browser support as outlined here:
+ * https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas/getContext
+ *
+ * Some MediaPipe tasks return single channel masks. These masks are stored
+ * using an underlying `Uint8ClampedArray` an `Float32Array` (represented as
+ * single-channel arrays). To convert these type to other formats a conversion
+ * function is invoked to convert pixel values between single channel and four
+ * channel RGBA values. To customize this conversion, you can specify these
+ * conversion functions when you invoke `getImage()`. If you use the default
+ * conversion function a warning will be logged to the console.
+ */
+export declare class MPImage {
+    /** Returns the canvas element that the image is bound to. */
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas | undefined;
+    /** Returns the width of the image. */
+    readonly width: number;
+    /** Returns the height of the image. */
+    readonly height: number;
+    private constructor();
+    /**
+     * Returns whether this `MPImage` stores the image in the desired format.
+     * This method can be called to reduce expensive conversion before invoking
+     * `getType()`.
+     */
+    hasType(type: MPImageStorageType): boolean;
+    /**
+     * Returns the underlying image as a single channel `Uint8ClampedArray`. Note
+     * that this involves an expensive GPU to CPU transfer if the current image is
+     * only available as an `ImageBitmap` or `WebGLTexture`. If necessary, this
+     * function converts RGBA data pixel-by-pixel to a single channel value by
+     * invoking a conversion function (see class comment for detail).
+     *
+     * @param type The type of image to return.
+     * @param converter A set of conversion functions that will be invoked to
+     *     convert the underlying pixel data if necessary. You may omit this
+     *     function if the requested conversion does not change the pixel format.
+     * @return The current data as a Uint8ClampedArray.
+     */
+    getImage(type: MPImageStorageType.UINT8_CLAMPED_ARRAY, converter?: MPImageChannelConverter): Uint8ClampedArray;
+    /**
+     * Returns the underlying image as a single channel `Float32Array`. Note
+     * that this involves an expensive GPU to CPU transfer if the current image is
+     * only available as an `ImageBitmap` or `WebGLTexture`. If necessary, this
+     * function converts RGBA data pixel-by-pixel to a single channel value by
+     * invoking a conversion function (see class comment for detail).
+     *
+     * @param type The type of image to return.
+     * @param converter A set of conversion functions that will be invoked to
+     *     convert the underlying pixel data if necessary. You may omit this
+     *     function if the requested conversion does not change the pixel format.
+     * @return The current image as a Float32Array.
+     */
+    getImage(type: MPImageStorageType.FLOAT32_ARRAY, converter?: MPImageChannelConverter): Float32Array;
+    /**
+     * Returns the underlying image as an `ImageData` object. Note that this
+     * involves an expensive GPU to CPU transfer if the current image is only
+     * available as an `ImageBitmap` or `WebGLTexture`. If necessary, this
+     * function converts single channel pixel values to RGBA by invoking a
+     * conversion function (see class comment for detail).
+     *
+     * @return The current image as an ImageData object.
+     */
+    getImage(type: MPImageStorageType.IMAGE_DATA, converter?: MPImageChannelConverter): ImageData;
+    /**
+     * Returns the underlying image as an `ImageBitmap`. Note that
+     * conversions to `ImageBitmap` are expensive, especially if the data
+     * currently resides on CPU. If necessary, this function first converts single
+     * channel pixel values to RGBA by invoking a conversion function (see class
+     * comment for detail).
+     *
+     * Processing with `ImageBitmap`s requires that the MediaPipe Task was
+     * initialized with an `OffscreenCanvas` with WebGL2 support. See
+     * https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas/getContext
+     * for a list of supported platforms.
+     *
+     * @param type The type of image to return.
+     * @param converter A set of conversion functions that will be invoked to
+     *     convert the underlying pixel data if necessary. You may omit this
+     *     function if the requested conversion does not change the pixel format.
+     * @return The current image as an ImageBitmap object.
+     */
+    getImage(type: MPImageStorageType.IMAGE_BITMAP, converter?: MPImageChannelConverter): ImageBitmap;
+    /**
+     * Returns the underlying image as a `WebGLTexture` object. Note that this
+     * involves a CPU to GPU transfer if the current image is only available as
+     * an `ImageData` object. The returned texture is bound to the current
+     * canvas (see `.canvas`).
+     *
+     * @param type The type of image to return.
+     * @param converter A set of conversion functions that will be invoked to
+     *     convert the underlying pixel data if necessary. You may omit this
+     *     function if the requested conversion does not change the pixel format.
+     * @return The current image as a WebGLTexture.
+     */
+    getImage(type: MPImageStorageType.WEBGL_TEXTURE, converter?: MPImageChannelConverter): WebGLTexture;
+    /**
+     * Creates a copy of the resources stored in this `MPImage`. You can invoke
+     * this method to extend the lifetime of an image returned by a MediaPipe
+     * Task. Note that performance critical applications should aim to only use
+     * the `MPImage` within the MediaPipe Task callback so that copies can be
+     * avoided.
+     */
+    clone(): MPImage;
+    /**
+     * Frees up any resources owned by this `MPImage` instance.
+     *
+     * Note that this method does not free images that are owned by the C++
+     * Task, as these are freed automatically once you leave the MediaPipe
+     * callback. Additionally, some shared state is freed only once you invoke the
+     * Task's `close()` method.
+     */
+    close(): void;
+}
+
+/**
+ * An interface that can be used to provide custom conversion functions. These
+ * functions are invoked to convert pixel values between different channel
+ * counts and value ranges. Any conversion function that is not specified will
+ * result in a default conversion.
+ */
+export declare interface MPImageChannelConverter {
+    /**
+     * A conversion function to convert a number in the [0.0, 1.0] range to RGBA.
+     * The output is an array with four elemeents whose values range from 0 to 255
+     * inclusive.
+     *
+     * The default conversion function is `[v * 255, v * 255, v * 255, 255]`
+     * and will log a warning if invoked.
+     */
+    floatToRGBAConverter?: (value: number) => [
+    number,
+    number,
+    number,
+    number
+    ];
+    uint8ToRGBAConverter?: (value: number) => [
+    number,
+    number,
+    number,
+    number
+    ];
+    /**
+     * A conversion function to convert an RGBA value in the range of 0 to 255 to
+     * a single value in the [0.0, 1.0] range.
+     *
+     * The default conversion function is `(r / 3 + g / 3 + b / 3) / 255` and will
+     * log a warning if invoked.
+     */
+    rgbaToFloatConverter?: (r: number, g: number, b: number, a: number) => number;
+    /**
+     * A conversion function to convert an RGBA value in the range of 0 to 255 to
+     * a single value in the [0, 255] range.
+     *
+     * The default conversion function is `r / 3 + g / 3 + b / 3` and will log a
+     * warning if invoked.
+     */
+    rgbaToUint8Converter?: (r: number, g: number, b: number, a: number) => number;
+    /**
+     * A conversion function to convert a single value in the 0.0 to 1.0 range to
+     * [0, 255].
+     *
+     * The default conversion function is `r * 255` and will log a warning if
+     * invoked.
+     */
+    floatToUint8Converter?: (value: number) => number;
+    /**
+     * A conversion function to convert a single value in the 0 to 255 range to
+     * [0.0, 1.0] .
+     *
+     * The default conversion function is `r / 255` and will log a warning if
+     * invoked.
+     */
+    uint8ToFloatConverter?: (value: number) => number;
+}
+
+/** The supported image formats. For internal usage. */
+export declare type MPImageNativeContainer = Uint8ClampedArray | Float32Array | ImageData | ImageBitmap | WebGLTexture;
+
+/**
+ * A class that encapsulates the shaders used by an MPImage. Can be re-used
+ * across MPImages that use the same WebGL2Rendering context.
+ */
+export declare class MPImageShaderContext {
+    /** Runs the callback using the shader. */
+    run<T>(gl: WebGL2RenderingContext, flipVertically: boolean, callback: () => T): T;
+    /**
+     * Binds a framebuffer to the canvas. If the framebuffer does not yet exist,
+     * creates it first. Binds the provided texture to the framebuffer.
+     */
+    bindFramebuffer(gl: WebGL2RenderingContext, texture: WebGLTexture): void;
+    unbindFramebuffer(): void;
+    close(): void;
+}
+
+/**
+ * Copyright 2023 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 underlying type of the image. */
+export declare enum MPImageStorageType {
+    /** Represents the native `UInt8ClampedArray` type. */
+    UINT8_CLAMPED_ARRAY = 0,
+    /**
+     * Represents the native `Float32Array` type. Values range from [0.0, 1.0].
+     */
+    FLOAT32_ARRAY = 1,
+    /** Represents the native `ImageData` type. */
+    IMAGE_DATA = 2,
+    /** Represents the native `ImageBitmap` type. */
+    IMAGE_BITMAP = 3,
+    /** Represents the native `WebGLTexture` type. */
+    WEBGL_TEXTURE = 4
+}
+
+/**
+ * Copyright 2023 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.
@@ -1511,7 +1811,7 @@ declare interface NormalizedKeypoint {
 }
 
 /**
- * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
+ * Copyright 2022 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.
@@ -1609,6 +1909,155 @@ export declare class ObjectDetector extends VisionTaskRunner {
 export declare interface ObjectDetectorOptions extends VisionTaskOptions, ClassifierOptions {
 }
 
+/** Performs pose landmarks detection on images. */
+export declare class PoseLandmarker extends VisionTaskRunner {
+    /**
+     * An array containing the pairs of pose landmark indices to be rendered with
+     * connections.
+     */
+    static POSE_CONNECTIONS: Connection[];
+    /**
+     * Initializes the Wasm runtime and creates a new `PoseLandmarker` from the
+     * provided options.
+     * @param wasmFileset A configuration object that provides the location of the
+     *     Wasm binary and its loader.
+     * @param poseLandmarkerOptions The options for the PoseLandmarker.
+     *     Note that either a path to the model asset or a model buffer needs to
+     *     be provided (via `baseOptions`).
+     */
+    static createFromOptions(wasmFileset: WasmFileset, poseLandmarkerOptions: PoseLandmarkerOptions): Promise<PoseLandmarker>;
+    /**
+     * Initializes the Wasm runtime and creates a new `PoseLandmarker` based on
+     * the provided model asset buffer.
+     * @param wasmFileset A configuration object that provides the location of the
+     *     Wasm binary and its loader.
+     * @param modelAssetBuffer A binary representation of the model.
+     */
+    static createFromModelBuffer(wasmFileset: WasmFileset, modelAssetBuffer: Uint8Array): Promise<PoseLandmarker>;
+    /**
+     * Initializes the Wasm runtime and creates a new `PoseLandmarker` based on
+     * the path to the model asset.
+     * @param wasmFileset A configuration object that provides the location of the
+     *     Wasm binary and its loader.
+     * @param modelAssetPath The path to the model asset.
+     */
+    static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<PoseLandmarker>;
+    private constructor();
+    /**
+     * Sets new options for this `PoseLandmarker`.
+     *
+     * Calling `setOptions()` with a subset of options only affects those options.
+     * You can reset an option back to its default value by explicitly setting it
+     * to `undefined`.
+     *
+     * @param options The options for the pose landmarker.
+     */
+    setOptions(options: PoseLandmarkerOptions): Promise<void>;
+    /**
+     * Performs pose detection on the provided single image and waits
+     * synchronously for the response. Only use this method when the
+     * PoseLandmarker is created with running mode `image`.
+     *
+     * @param image An image to process.
+     * @param callback The callback that is invoked with the result. The
+     *    lifetime of the returned masks is only guaranteed for the duration of
+     *    the callback.
+     * @return The detected pose landmarks.
+     */
+    detect(image: ImageSource, callback: PoseLandmarkerCallback): void;
+    /**
+     * Performs pose detection on the provided single image and waits
+     * synchronously for the response. Only use this method when the
+     * PoseLandmarker is created with running mode `image`.
+     *
+     * @param image An image to process.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
+     * @param callback The callback that is invoked with the result. The
+     *    lifetime of the returned masks is only guaranteed for the duration of
+     *    the callback.
+     * @return The detected pose landmarks.
+     */
+    detect(image: ImageSource, imageProcessingOptions: ImageProcessingOptions, callback: PoseLandmarkerCallback): void;
+    /**
+     * Performs pose detection on the provided video frame and waits
+     * synchronously for the response. Only use this method when the
+     * PoseLandmarker is created with running mode `video`.
+     *
+     * @param videoFrame A video frame to process.
+     * @param timestamp The timestamp of the current frame, in ms.
+     * @param callback The callback that is invoked with the result. The
+     *    lifetime of the returned masks is only guaranteed for the duration of
+     *    the callback.
+     * @return The detected pose landmarks.
+     */
+    detectForVideo(videoFrame: ImageSource, timestamp: number, callback: PoseLandmarkerCallback): void;
+    /**
+     * Performs pose detection on the provided video frame and waits
+     * synchronously for the response. Only use this method when the
+     * PoseLandmarker is created with running mode `video`.
+     *
+     * @param videoFrame A video frame to process.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
+     * @param timestamp The timestamp of the current frame, in ms.
+     * @param callback The callback that is invoked with the result. The
+     *    lifetime of the returned masks is only guaranteed for the duration of
+     *    the callback.
+     * @return The detected pose landmarks.
+     */
+    detectForVideo(videoFrame: ImageSource, imageProcessingOptions: ImageProcessingOptions, timestamp: number, callback: PoseLandmarkerCallback): void;
+}
+
+/**
+ * A callback that receives the result from the pose detector. The returned
+ * masks are only valid for the duration of the callback. If asynchronous
+ * processing is needed, the masks need to be copied before the callback
+ * returns.
+ */
+export declare type PoseLandmarkerCallback = (result: PoseLandmarkerResult) => void;
+
+/** Options to configure the MediaPipe PoseLandmarker Task */
+export declare interface PoseLandmarkerOptions extends VisionTaskOptions {
+    /**
+     * The maximum number of poses can be detected by the PoseLandmarker.
+     * Defaults to 1.
+     */
+    numPoses?: number | undefined;
+    /**
+     * The minimum confidence score for the pose detection to be considered
+     * successful. Defaults to 0.5.
+     */
+    minPoseDetectionConfidence?: number | undefined;
+    /**
+     * The minimum confidence score of pose presence score in the pose landmark
+     * detection. Defaults to 0.5.
+     */
+    minPosePresenceConfidence?: number | undefined;
+    /**
+     * The minimum confidence score for the pose tracking to be considered
+     * successful. Defaults to 0.5.
+     */
+    minTrackingConfidence?: number | undefined;
+    /** Whether to output segmentation masks. Defaults to false. */
+    outputSegmentationMasks?: boolean | undefined;
+}
+
+/**
+ * Represents the pose landmarks deection results generated by `PoseLandmarker`.
+ * Each vector element represents a single pose detected in the image.
+ */
+export declare interface PoseLandmarkerResult {
+    /** Pose landmarks of detected poses. */
+    landmarks: NormalizedLandmark[];
+    /** Pose landmarks in world coordinates of detected poses. */
+    worldLandmarks: Landmark[];
+    /** Detected auxiliary landmarks, used for deriving ROI for next frame. */
+    auxilaryLandmarks: NormalizedLandmark[];
+    /** Segmentation mask for the detected pose. */
+    segmentationMasks?: Float32Array[] | WebGLTexture[];
+}
+
 /**
  * Defines a rectangle, used e.g. as part of detection results or as input
  * region-of-interest.
@@ -1646,16 +2095,6 @@ declare type RunningMode = "IMAGE" | "VIDEO";
  */
 export declare type SegmentationMask = Uint8ClampedArray | Float32Array | WebGLTexture;
 
-/**
- * A callback that receives the computed masks from the segmentation tasks. The
- * callback either receives a single element array with a category mask (as a
- * `[Uint8ClampedArray]`) or multiple confidence masks (as a `Float32Array[]`).
- * The returned data is only valid for the duration of the callback. If
- * asynchronous processing is needed, all data needs to be copied before the
- * callback returns.
- */
-export declare type SegmentationMaskCallback = (masks: SegmentationMask[], width: number, height: number) => void;
-
 /** Base class for all MediaPipe Tasks. */
 declare abstract class TaskRunner {
     protected constructor();
@@ -1695,7 +2134,7 @@ declare abstract class VisionTaskRunner extends TaskRunner {
 }
 
 /**
- * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
+ * Copyright 2022 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.