@mediapipe/tasks-vision 0.1.0-alpha-7 → 0.1.0-alpha-9

package/README.md

@@ -2,6 +2,22 @@
 
 This package contains the vision tasks for MediaPipe.
 
+## Face Detection
+
+The MediaPipe Face Detector task lets you detect the presence and location of
+faces within images or videos.
+
+```
+const vision = await FilesetResolver.forVisionTasks(
+    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm"
+);
+const faceDetector = await FaceDetector.createFromModelPath(vision,
+    "https://storage.googleapis.com/mediapipe-tasks/object_detector/efficientdet_lite0_uint8.tflite"
+);
+const image = document.getElementById("image") as HTMLImageElement;
+const detections = faceDetector.detect(image);
+```
+
 ## Face Landmark Detection
 
 The MediaPipe Face Landmarker task lets you detect the landmarks of faces in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mediapipe/tasks-vision",
-  "version": "0.1.0-alpha-7",
+  "version": "0.1.0-alpha-9",
   "description": "MediaPipe Vision Tasks",
   "main": "vision_bundle.js",
   "author": "mediapipe@google.com",

package/vision.d.ts

@@ -29,6 +29,21 @@ declare interface BaseOptions_2 {
     delegate?: "CPU" | "GPU" | undefined;
 }
 
+/**
+ * Copyright 2023 The MediaPipe Authors. All Rights Reserved.
+ *
+ * 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.
+ */
 /** An integer bounding box, axis aligned. */
 export declare interface BoundingBox {
     /** The X coordinate of the top-left corner, in pixels. */
@@ -138,13 +153,50 @@ declare interface ClassifierOptions {
     categoryDenylist?: string[] | undefined;
 }
 
-/** Represents one object detected by the `ObjectDetector`. */
+/**
+ * CopyRIGHT 2023 The MediaPipe Authors. All RIGHTs Reserved.
+ *
+ * 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.
+ */
+/** A face landmark connection. */
+export declare interface Connection {
+    start: number;
+    end: number;
+}
+
+/** Represents one detection by a detection task. */
 export declare interface Detection {
     /** A list of `Category` objects. */
     categories: Category[];
     /** The bounding box of the detected objects. */
     boundingBox?: BoundingBox;
+    /**
+     * Optional list of keypoints associated with the detection. Keypoints
+     * represent interesting points related to the detection. For example, the
+     * keypoints represent the eye, ear and mouth from face detection model. Or
+     * in the template matching detection, e.g. KNIFT, they can represent the
+     * feature points for template matching.
+     */
+    keypoints?: NormalizedKeypoint[];
+}
+
+/** Detection results of a model. */
+declare interface DetectionResult {
+    /** A list of Detections. */
+    detections: Detection[];
 }
+export { DetectionResult as FaceDetectorResult }
+export { DetectionResult as ObjectDetectorResult }
 
 /**
  * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
@@ -224,6 +276,84 @@ export declare interface Embedding {
     headName: string;
 }
 
+/** Performs face detection on images. */
+export declare class FaceDetector extends VisionTaskRunner {
+    /**
+     * Initializes the Wasm runtime and creates a new face detector from the
+     * provided options.
+     * @param wasmFileset A configuration object that provides the location of the
+     *     Wasm binary and its loader.
+     * @param faceDetectorOptions The options for the FaceDetector. Note that
+     *     either a path to the model asset or a model buffer needs to be
+     *     provided (via `baseOptions`).
+     */
+    static createFromOptions(wasmFileset: WasmFileset, faceDetectorOptions: FaceDetectorOptions): Promise<FaceDetector>;
+    /**
+     * Initializes the Wasm runtime and creates a new face detector 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<FaceDetector>;
+    /**
+     * Initializes the Wasm runtime and creates a new face detector 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<FaceDetector>;
+    private constructor();
+    /**
+     * Sets new options for the FaceDetector.
+     *
+     * 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 FaceDetector.
+     */
+    setOptions(options: FaceDetectorOptions): Promise<void>;
+    /**
+     * Performs face detection on the provided single image and waits
+     * synchronously for the response. Only use this method when the
+     * FaceDetector 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.
+     * @return A result containing the list of detected faces.
+     */
+    detect(image: ImageSource, imageProcessingOptions?: ImageProcessingOptions): DetectionResult;
+    /**
+     * Performs face detection on the provided video frame and waits
+     * synchronously for the response. Only use this method when the
+     * FaceDetector is created with running mode `video`.
+     *
+     * @param videoFrame A video frame to process.
+     * @param timestamp The timestamp of the current frame, in ms.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
+     * @return A result containing the list of detected faces.
+     */
+    detectForVideo(videoFrame: ImageSource, timestamp: number, imageProcessingOptions?: ImageProcessingOptions): DetectionResult;
+}
+
+/** Options to configure the MediaPipe Face Detector Task */
+export declare interface FaceDetectorOptions extends VisionTaskOptions {
+    /**
+     * The minimum confidence score for the face detection to be considered
+     * successful. Defaults to 0.5.
+     */
+    minDetectionConfidence?: number | undefined;
+    /**
+     * The minimum non-maximum-suppression threshold for face detection to be
+     * considered overlapped. Defaults to 0.3.
+     */
+    minSuppressionThreshold?: number | undefined;
+}
+
 /**
  * Performs face landmarks detection on images.
  *
@@ -340,6 +470,53 @@ export declare interface FaceLandmarkerResult {
     facialTransformationMatrixes?: Matrix[];
 }
 
+/**
+ * A class containing the Pairs of landmark indices to be rendered with
+ * connections.
+ */
+export declare class FaceLandmarksConnections {
+    static FACE_LANDMARKS_LIPS: {
+        start: number;
+        end: number;
+    }[];
+    static FACE_LANDMARKS_LEFT_EYE: {
+        start: number;
+        end: number;
+    }[];
+    static FACE_LANDMARKS_LEFT_EYEBROW: {
+        start: number;
+        end: number;
+    }[];
+    static FACE_LANDMARKS_LEFT_IRIS: {
+        start: number;
+        end: number;
+    }[];
+    static FACE_LANDMARKS_RIGHT_EYE: {
+        start: number;
+        end: number;
+    }[];
+    static FACE_LANDMARKS_RIGHT_EYEBROW: {
+        start: number;
+        end: number;
+    }[];
+    static FACE_LANDMARKS_RIGHT_IRIS: {
+        start: number;
+        end: number;
+    }[];
+    static FACE_LANDMARKS_FACE_OVAL: {
+        start: number;
+        end: number;
+    }[];
+    static FACE_LANDMARKS_CONTOURS: {
+        start: number;
+        end: number;
+    }[];
+    static FACE_LANDMARKS_TESSELATION: {
+        start: number;
+        end: number;
+    }[];
+}
+
 /** Performs face stylization on images. */
 export declare class FaceStylizer extends VisionTaskRunner {
     /**
@@ -1254,7 +1431,7 @@ export declare interface Landmark {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/** A two-dimenionsal matrix. */
+/** A two-dimensional matrix. */
 declare interface Matrix {
     /** The number of rows. */
     rows: number;
@@ -1372,9 +1549,9 @@ export declare class ObjectDetector extends VisionTaskRunner {
      * @param image An image to process.
      * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
      *    to process the input image before running inference.
-     * @return The list of detected objects
+     * @return A result containing a list of detected objects.
      */
-    detect(image: ImageSource, imageProcessingOptions?: ImageProcessingOptions): Detection[];
+    detect(image: ImageSource, imageProcessingOptions?: ImageProcessingOptions): DetectionResult;
     /**
      * Performs object detection on the provided video frame and waits
      * synchronously for the response. Only use this method when the
@@ -1384,9 +1561,9 @@ export declare class ObjectDetector extends VisionTaskRunner {
      * @param timestamp The timestamp of the current frame, in ms.
      * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
      *    to process the input image before running inference.
-     * @return The list of detected objects
+     * @return A result containing a list of detected objects.
      */
-    detectForVideo(videoFrame: ImageSource, timestamp: number, imageProcessingOptions?: ImageProcessingOptions): Detection[];
+    detectForVideo(videoFrame: ImageSource, timestamp: number, imageProcessingOptions?: ImageProcessingOptions): DetectionResult;
 }
 
 /** Options to configure the MediaPipe Object Detector Task */
@@ -1424,7 +1601,7 @@ declare type RunningMode = "IMAGE" | "VIDEO";
 /**
  * The segmentation tasks return the segmentation either as a WebGLTexture (when
  * the output is on GPU) or as a typed JavaScript arrays for CPU-based
- * category or confidence masks. `Uint8ClampedArray`s are used to represend
+ * category or confidence masks. `Uint8ClampedArray`s are used to represent
  * CPU-based category masks and `Float32Array`s are used for CPU-based
  * confidence masks.
  */
@@ -1457,7 +1634,7 @@ declare interface TaskRunnerOptions {
 declare interface VisionTaskOptions extends TaskRunnerOptions {
     /**
      * The canvas element to bind textures to. This has to be set for GPU
-     * processing. The task will initialize a WebGL context and throw an eror if
+     * processing. The task will initialize a WebGL context and throw an error if
      * this fails (e.g. if you have already initialized a different type of
      * context).
      */