From 3d7007f13d81b30f29fef53345beb9ae461a14ac Mon Sep 17 00:00:00 2001
From: Vladimir Mandic <mandic00@live.com>
Date: Sun, 7 Mar 2021 07:26:23 -0500
Subject: [PATCH] added documentation

---
 .markdownlint.json                  |   6 +
 README.md                           |  63 ++-
 TUTORIAL.md                         | 744 ++++++++++++++++++++++++++++
 dist/face-api.esm.json              |   2 +-
 dist/face-api.json                  |   2 +-
 example/facemesh.png                | Bin 0 -> 32644 bytes
 example/node-multiprocess-worker.js |   1 +
 example/node-multiprocess.js        |   1 +
 example/node-singleprocess.js       |   1 +
 example/webcam.js                   |   4 +-
 package-lock.json                   |  36 +-
 package.json                        |  10 +-
 12 files changed, 837 insertions(+), 33 deletions(-)
 create mode 100644 .markdownlint.json
 create mode 100644 TUTORIAL.md
 create mode 100755 example/facemesh.png

diff --git a/.markdownlint.json b/.markdownlint.json
new file mode 100644
index 0000000..fac5739
--- /dev/null
+++ b/.markdownlint.json
@@ -0,0 +1,6 @@
+{
+  "MD012": false,
+  "MD013": false,
+  "MD033": false,
+  "MD036": false
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 48c69ba..3df04b3 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 This is updated **face-api.js** with latest available TensorFlow/JS as the original face-api.js is not compatible with **tfjs 2.0+**.  
 
-Forked from [face-api.js](https://github.com/justadudewhohacks/face-api.js) version **0.22.2** released on March 22nd, 2020  
+Forked from [face-api.js](https://github.com/justadudewhohacks/face-api.js) version **0.22.2** which was released on March 22nd, 2020  
 
 Currently based on **`TensorFlow/JS` 3.2.0**  
 
@@ -62,7 +62,7 @@ Example can be accessed directly using Git pages using URL: <https://vladmandic.
 
 *Note: Photos shown below are taken by me*
 
-![alt text](example/screenshot.png)
+![screenshot](example/screenshot.png)
 
 <br>
 
@@ -130,6 +130,7 @@ Face-API ships with several pre-build versions of the library:
    *without* TFJS pre-bundled and using JS engine for platforms where tensorflow binary library version is not available
 
 Defaults are:
+
 ```json
 {
   "main": "dist/face-api.node-js",
@@ -150,7 +151,7 @@ All versions include `sourcemap` and `asset manifest`
 <hr>
 <br>
 
-There are several ways to use Face-API: 
+There are several ways to use Face-API:
 
 ### 1. IIFE script
 
@@ -161,7 +162,7 @@ Simply download `dist/face-api.js`, include it in your `HTML` file & it's ready
 
 ```html
 <script src="dist/face-api.js"><script>
-``` 
+```
 
 IIFE script bundles TFJS and auto-registers global namespace `faceapi` within Window object which can be accessed directly from a `<script>` tag or from your JS file.  
 
@@ -178,6 +179,7 @@ To use ESM import directly in a Browser, you must import your script (e.g. `inde
 ```html
   <script src="./index.js" type="module">
 ```
+
 and then in your `index.js`
 
 ```js
@@ -187,6 +189,7 @@ and then in your `index.js`
 #### 2.2. With Bundler
 
 Same as above, but expectation is that you've installed `@vladmandic/faceapi` package:
+
 ```shell
   npm install @vladmandic/face-api 
 ```
@@ -197,11 +200,15 @@ in which case, you do not need to import a script as module - that depends on yo
 ```js
   import * as faceapi from '@vladmandic/face-api';
 ```
+
 or if your bundler doesn't recognize `recommended` type, force usage with:
+
 ```js
   import * as faceapi from '@vladmandic/face-api/dist/face-api.esm.js';
 ```
+
 or to use non-bundled version
+
 ```js
   import * as tf from `@tensorflow/tfjs`;
   import * as faceapi from '@vladmandic/face-api/dist/face-api.esm-nobundle.js';
@@ -218,17 +225,21 @@ or to use non-bundled version
 *Node: Face-API for NodeJS does not bundle TFJS due to binary dependencies that are installed during TFJS installation*
 
 Install with:
+
 ```shell
   npm install @tensorflow/tfjs-node
   npm install @vladmandic/face-api 
 ```
+
 And then use with:
+
 ```js
   const tf = require('@tensorflow/tfjs-node')
   const faceapi = require('@vladmandic/face-api');
 ```
 
 If you want to force CommonJS module instead of relying on `recommended` field:
+
 ```js
   const faceapi = require('@vladmandic/face-api/dist/face-api.node.js');
 ```
@@ -240,7 +251,9 @@ Then install appropriate version of `Face-API`:
   npm install @tensorflow/tfjs-node
   npm install @vladmandic/face-api 
 ```
+
 And then use with:
+
 ```js
   const tf = require('@tensorflow/tfjs-node-gpu')
   const faceapi = require('@vladmandic/face-api/dist/face-api.node-gpu.js'); // this loads face-api version with correct bindings for tfjs-node-gpu
@@ -252,10 +265,30 @@ If you want to use `Face-API` in a NodeJS on platforms where NodeJS binary libra
   npm install @tensorflow/tfjs
   npm install @vladmandic/face-api 
 ```
+
 And then use with:
+
 ```js
   const tf = require('@tensorflow/tfjs')
-  const faceapi = require('@vladmandic/face-api/dist/face-api.node-pcu.js');
+  const faceapi = require('@vladmandic/face-api/dist/face-api.node-cpu.js');
+```
+
+If you want to use graphical functions inside NodeJS, you must provide appropriate graphical library as NodeJS does not include implementation for DOM elements such as HTMLImageElement or HTMLCanvasElement:
+
+Install `Canvas` for NodeJS:
+
+```shell
+npm install canvas
+```
+
+Patch NodeJS environment to use newly installed `Canvas` library:
+
+```js
+const canvas = require('canvas');
+const faceapi = require('@vladmandic/face-api');
+
+const { Canvas, Image, ImageData } = canvas
+faceapi.env.monkeyPatch({ Canvas, Image, ImageData })
 ```
 
 <br>
@@ -273,11 +306,13 @@ Pretrained models and their weights are includes in `./model`.
 ## Test & Dev Web Server
 
 Built-in test&dev web server can be started using
+
 ```shell
 npm run dev
 ```
 
 By default it starts HTTP server on port 8000 and HTTPS server on port 8001 and can be accessed as:  
+
 - <https://localhost:8001/example/index.html>
 - <https://localhost:8001/example/webcam.html>
 
@@ -302,18 +337,21 @@ By default it starts HTTP server on port 8000 and HTTPS server on port 8001 and
 ## Build
 
 If you want to do a full rebuild, either download npm module
+
 ```shell
 npm install @vladmandic/face-api
 cd node_modules/@vladmandic/face-api
 ```
 
 or clone a git project
+
 ```shell
 git clone https://github.com/vladmandic/face-api
 cd face-api
 ```
 
 Then install all dependencies and run rebuild:
+
 ```shell
 npm install
 npm run build
@@ -348,8 +386,19 @@ npm run build
 <hr>
 <br>
 
-## Credits & Documentation
+## Face Mesh
 
-- Original project and usage documentation: [Face-API](https://github.com/justadudewhohacks/face-api.js)  
+`FaceAPI` returns 68-point face mesh as detailed in the image below:
+
+![facemesh](example/facemesh.png)
+
+## Documentation
+
+- [**Tutorial**](TUTORIAL.md)
+- [**API Documentation**](https://justadudewhohacks.github.io/face-api.js/docs/globals.html)
+
+## Credits
+
+- Original project: [Face-API](https://github.com/justadudewhohacks/face-api.js)  
 - Original model weighs: [Face-API](https://github.com/justadudewhohacks/face-api.js-models)
 - ML API Documentation: [Tensorflow/JS](https://js.tensorflow.org/api/latest/)
diff --git a/TUTORIAL.md b/TUTORIAL.md
new file mode 100644
index 0000000..217cc20
--- /dev/null
+++ b/TUTORIAL.md
@@ -0,0 +1,744 @@
+# FaceAPI Usage
+
+## Features
+
+* Face Recognition
+* Face Landmark Detection
+* Face Expression Recognition
+* Age Estimation & Gender Recognition
+
+<br>
+
+## Table of Contents
+
+* **[Usage](#getting-started)**
+  * **[Loading the Models](#getting-started-loading-models)**
+  * **[High Level API](#high-level-api)**
+  * **[Displaying Detection Results](#getting-started-displaying-detection-results)**
+  * **[Face Detection Options](#getting-started-face-detection-options)**
+  * **[Utility Classes](#getting-started-utility-classes)**
+  * **[Other Useful Utility](#other-useful-utility)**
+* **[Available Models](#models)**
+  * **[Face Detection](#models-face-detection)**
+  * **[Face Landmark Detection](#models-face-landmark-detection)**
+  * **[Face Recognition](#models-face-recognition)**
+  * **[Face Expression Recognition](#models-face-expression-recognition)**
+  * **[Age Estimation and Gender Recognition](#models-age-and-gender-recognition)**
+* **[API Documentation](https://justadudewhohacks.github.io/face-api.js/docs/globals.html)**
+
+<br><hr><br>
+
+<a name="getting-started"></a>
+
+## Getting Started
+
+<a name="getting-started-loading-models"></a>
+
+### Loading the Models
+
+All global neural network instances are exported via faceapi.nets:
+
+``` javascript
+console.log(faceapi.nets)
+// ageGenderNet
+// faceExpressionNet
+// faceLandmark68Net
+// faceLandmark68TinyNet
+// faceRecognitionNet
+// ssdMobilenetv1
+// tinyFaceDetector
+// tinyYolov2
+```
+
+To load a model, you have to provide the corresponding manifest.json file as well as the model weight files (shards) as assets. Simply copy them to your public or assets folder. The manifest.json and shard files of a model have to be located in the same directory / accessible under the same route.
+
+Assuming the models reside in **public/models**:
+
+``` javascript
+await faceapi.nets.ssdMobilenetv1.loadFromUri('/models')
+// accordingly for the other models:
+// await faceapi.nets.faceLandmark68Net.loadFromUri('/models')
+// await faceapi.nets.faceRecognitionNet.loadFromUri('/models')
+// ...
+```
+
+In a nodejs environment you can furthermore load the models directly from disk:
+
+``` javascript
+await faceapi.nets.ssdMobilenetv1.loadFromDisk('./models')
+```
+
+You can also load the model from a tf.NamedTensorMap:
+
+``` javascript
+await faceapi.nets.ssdMobilenetv1.loadFromWeightMap(weightMap)
+```
+
+Alternatively, you can also create own instances of the neural nets:
+
+``` javascript
+const net = new faceapi.SsdMobilenetv1()
+await net.loadFromUri('/models')
+```
+
+You can also load the weights as a Float32Array (in case you want to use the uncompressed models):
+
+``` javascript
+// using fetch
+net.load(await faceapi.fetchNetWeights('/models/face_detection_model.weights'))
+
+// using axios
+const res = await axios.get('/models/face_detection_model.weights', { responseType: 'arraybuffer' })
+const weights = new Float32Array(res.data)
+net.load(weights)
+```
+
+<a name="getting-high-level-api"></a>
+
+### High Level API
+
+In the following **input** can be an HTML img, video or canvas element or the id of that element.
+
+``` html
+<img id="myImg" src="images/example.png" />
+<video id="myVideo" src="media/example.mp4" />
+<canvas id="myCanvas" />
+```
+
+``` javascript
+const input = document.getElementById('myImg')
+// const input = document.getElementById('myVideo')
+// const input = document.getElementById('myCanvas')
+// or simply:
+// const input = 'myImg'
+```
+
+### Detecting Faces
+
+Detect all faces in an image. Returns **Array<[FaceDetection](#interface-face-detection)>**:
+
+``` javascript
+const detections = await faceapi.detectAllFaces(input)
+```
+
+Detect the face with the highest confidence score in an image. Returns **[FaceDetection](#interface-face-detection) | undefined**:
+
+``` javascript
+const detection = await faceapi.detectSingleFace(input)
+```
+
+By default **detectAllFaces** and **detectSingleFace** utilize the SSD Mobilenet V1 Face Detector. You can specify the face detector by passing the corresponding options object:
+
+``` javascript
+const detections1 = await faceapi.detectAllFaces(input, new faceapi.SsdMobilenetv1Options())
+const detections2 = await faceapi.detectAllFaces(input, new faceapi.TinyFaceDetectorOptions())
+```
+
+You can tune the options of each face detector as shown [here](#getting-started-face-detection-options).
+
+#### Detecting 68 Face Landmark Points
+
+**After face detection, we can furthermore predict the facial landmarks for each detected face as follows:**
+
+Detect all faces in an image + computes 68 Point Face Landmarks for each detected face. Returns **Array<[WithFaceLandmarks<WithFaceDetection<{}>>](#getting-started-utility-classes)>**:
+
+``` javascript
+const detectionsWithLandmarks = await faceapi.detectAllFaces(input).withFaceLandmarks()
+```
+
+Detect the face with the highest confidence score in an image + computes 68 Point Face Landmarks for that face. Returns **[WithFaceLandmarks<WithFaceDetection<{}>>](#getting-started-utility-classes) | undefined**:
+
+``` javascript
+const detectionWithLandmarks = await faceapi.detectSingleFace(input).withFaceLandmarks()
+```
+
+You can also specify to use the tiny model instead of the default model:
+
+``` javascript
+const useTinyModel = true
+const detectionsWithLandmarks = await faceapi.detectAllFaces(input).withFaceLandmarks(useTinyModel)
+```
+
+#### Computing Face Descriptors
+
+**After face detection and facial landmark prediction the face descriptors for each face can be computed as follows:**
+
+Detect all faces in an image + compute 68 Point Face Landmarks for each detected face. Returns **Array<[WithFaceDescriptor<WithFaceLandmarks<WithFaceDetection<{}>>>](#getting-started-utility-classes)>**:
+
+``` javascript
+const results = await faceapi.detectAllFaces(input).withFaceLandmarks().withFaceDescriptors()
+```
+
+Detect the face with the highest confidence score in an image + compute 68 Point Face Landmarks and face descriptor for that face. Returns **[WithFaceDescriptor<WithFaceLandmarks<WithFaceDetection<{}>>>](#getting-started-utility-classes) | undefined**:
+
+``` javascript
+const result = await faceapi.detectSingleFace(input).withFaceLandmarks().withFaceDescriptor()
+```
+
+#### Recognizing Face Expressions
+
+**Face expression recognition can be performed for detected faces as follows:**
+
+Detect all faces in an image + recognize face expressions of each face. Returns **Array<[WithFaceExpressions<WithFaceLandmarks<WithFaceDetection<{}>>>](#getting-started-utility-classes)>**:
+
+``` javascript
+const detectionsWithExpressions = await faceapi.detectAllFaces(input).withFaceLandmarks().withFaceExpressions()
+```
+
+Detect the face with the highest confidence score in an image + recognize the face expressions for that face. Returns **[WithFaceExpressions<WithFaceLandmarks<WithFaceDetection<{}>>>](#getting-started-utility-classes) | undefined**:
+
+``` javascript
+const detectionWithExpressions = await faceapi.detectSingleFace(input).withFaceLandmarks().withFaceExpressions()
+```
+
+**You can also skip .withFaceLandmarks(), which will skip the face alignment step (less stable accuracy):**
+
+Detect all faces without face alignment + recognize face expressions of each face. Returns **Array<[WithFaceExpressions<WithFaceDetection<{}>>](#getting-started-utility-classes)>**:
+
+``` javascript
+const detectionsWithExpressions = await faceapi.detectAllFaces(input).withFaceExpressions()
+```
+
+Detect the face with the highest confidence score without face alignment + recognize the face expression for that face. Returns **[WithFaceExpressions<WithFaceDetection<{}>>](#getting-started-utility-classes) | undefined**:
+
+``` javascript
+const detectionWithExpressions = await faceapi.detectSingleFace(input).withFaceExpressions()
+```
+
+#### Age Estimation and Gender Recognition
+
+**Age estimation and gender recognition from detected faces can be done as follows:**
+
+Detect all faces in an image + estimate age and recognize gender of each face. Returns **Array<[WithAge<WithGender<WithFaceLandmarks<WithFaceDetection<{}>>>>](#getting-started-utility-classes)>**:
+
+``` javascript
+const detectionsWithAgeAndGender = await faceapi.detectAllFaces(input).withFaceLandmarks().withAgeAndGender()
+```
+
+Detect the face with the highest confidence score in an image  + estimate age and recognize gender for that face. Returns **[WithAge<WithGender<WithFaceLandmarks<WithFaceDetection<{}>>>>](#getting-started-utility-classes) | undefined**:
+
+``` javascript
+const detectionWithAgeAndGender = await faceapi.detectSingleFace(input).withFaceLandmarks().withAgeAndGender()
+```
+
+**You can also skip .withFaceLandmarks(), which will skip the face alignment step (less stable accuracy):**
+
+Detect all faces without face alignment + estimate age and recognize gender of each face. Returns **Array<[WithAge<WithGender<WithFaceDetection<{}>>>](#getting-started-utility-classes)>**:
+
+``` javascript
+const detectionsWithAgeAndGender = await faceapi.detectAllFaces(input).withAgeAndGender()
+```
+
+Detect the face with the highest confidence score without face alignment + estimate age and recognize gender for that face. Returns **[WithAge<WithGender<WithFaceDetection<{}>>>](#getting-started-utility-classes) | undefined**:
+
+``` javascript
+const detectionWithAgeAndGender = await faceapi.detectSingleFace(input).withAgeAndGender()
+```
+
+#### Composition of Tasks
+
+**Tasks can be composed as follows:**
+
+``` javascript
+// all faces
+await faceapi.detectAllFaces(input)
+await faceapi.detectAllFaces(input).withFaceExpressions()
+await faceapi.detectAllFaces(input).withFaceLandmarks()
+await faceapi.detectAllFaces(input).withFaceLandmarks().withFaceExpressions()
+await faceapi.detectAllFaces(input).withFaceLandmarks().withFaceExpressions().withFaceDescriptors()
+await faceapi.detectAllFaces(input).withFaceLandmarks().withAgeAndGender().withFaceDescriptors()
+await faceapi.detectAllFaces(input).withFaceLandmarks().withFaceExpressions().withAgeAndGender().withFaceDescriptors()
+
+// single face
+await faceapi.detectSingleFace(input)
+await faceapi.detectSingleFace(input).withFaceExpressions()
+await faceapi.detectSingleFace(input).withFaceLandmarks()
+await faceapi.detectSingleFace(input).withFaceLandmarks().withFaceExpressions()
+await faceapi.detectSingleFace(input).withFaceLandmarks().withFaceExpressions().withFaceDescriptor()
+await faceapi.detectSingleFace(input).withFaceLandmarks().withAgeAndGender().withFaceDescriptor()
+await faceapi.detectSingleFace(input).withFaceLandmarks().withFaceExpressions().withAgeAndGender().withFaceDescriptor()
+```
+
+#### Face Recognition by Matching Descriptors
+
+To perform face recognition, one can use faceapi.FaceMatcher to compare reference face descriptors to query face descriptors.
+
+First, we initialize the FaceMatcher with the reference data, for example we can simply detect faces in a **referenceImage** and match the descriptors of the detected faces to faces of subsequent images:
+
+``` javascript
+const results = await faceapi
+  .detectAllFaces(referenceImage)
+  .withFaceLandmarks()
+  .withFaceDescriptors()
+
+if (!results.length) {
+  return
+}
+
+// create FaceMatcher with automatically assigned labels
+// from the detection results for the reference image
+const faceMatcher = new faceapi.FaceMatcher(results)
+```
+
+Now we can recognize a persons face shown in **queryImage1**:
+
+``` javascript
+const singleResult = await faceapi
+  .detectSingleFace(queryImage1)
+  .withFaceLandmarks()
+  .withFaceDescriptor()
+
+if (singleResult) {
+  const bestMatch = faceMatcher.findBestMatch(singleResult.descriptor)
+  console.log(bestMatch.toString())
+}
+```
+
+Or we can recognize all faces shown in **queryImage2**:
+
+``` javascript
+const results = await faceapi
+  .detectAllFaces(queryImage2)
+  .withFaceLandmarks()
+  .withFaceDescriptors()
+
+results.forEach(fd => {
+  const bestMatch = faceMatcher.findBestMatch(fd.descriptor)
+  console.log(bestMatch.toString())
+})
+```
+
+You can also create labeled reference descriptors as follows:
+
+``` javascript
+const labeledDescriptors = [
+  new faceapi.LabeledFaceDescriptors(
+    'obama',
+    [descriptorObama1, descriptorObama2]
+  ),
+  new faceapi.LabeledFaceDescriptors(
+    'trump',
+    [descriptorTrump]
+  )
+]
+
+const faceMatcher = new faceapi.FaceMatcher(labeledDescriptors)
+```
+
+<a name="getting-started-displaying-detection-results"></a>
+
+### Displaying Detection Results
+
+Preparing the overlay canvas:
+
+``` javascript
+const displaySize = { width: input.width, height: input.height }
+// resize the overlay canvas to the input dimensions
+const canvas = document.getElementById('overlay')
+faceapi.matchDimensions(canvas, displaySize)
+```
+
+face-api.js predefines some highlevel drawing functions, which you can utilize:
+
+``` javascript
+/* Display detected face bounding boxes */
+const detections = await faceapi.detectAllFaces(input)
+// resize the detected boxes in case your displayed image has a different size than the original
+const resizedDetections = faceapi.resizeResults(detections, displaySize)
+// draw detections into the canvas
+faceapi.draw.drawDetections(canvas, resizedDetections)
+
+/* Display face landmarks */
+const detectionsWithLandmarks = await faceapi
+  .detectAllFaces(input)
+  .withFaceLandmarks()
+// resize the detected boxes and landmarks in case your displayed image has a different size than the original
+const resizedResults = faceapi.resizeResults(detectionsWithLandmarks, displaySize)
+// draw detections into the canvas
+faceapi.draw.drawDetections(canvas, resizedResults)
+// draw the landmarks into the canvas
+faceapi.draw.drawFaceLandmarks(canvas, resizedResults)
+
+
+/* Display face expression results */
+const detectionsWithExpressions = await faceapi
+  .detectAllFaces(input)
+  .withFaceLandmarks()
+  .withFaceExpressions()
+// resize the detected boxes and landmarks in case your displayed image has a different size than the original
+const resizedResults = faceapi.resizeResults(detectionsWithExpressions, displaySize)
+// draw detections into the canvas
+faceapi.draw.drawDetections(canvas, resizedResults)
+// draw a textbox displaying the face expressions with minimum probability into the canvas
+const minProbability = 0.05
+faceapi.draw.drawFaceExpressions(canvas, resizedResults, minProbability)
+```
+
+You can also draw boxes with custom text ([DrawBox](https://github.com/justadudewhohacks/tfjs-image-recognition-base/blob/master/src/draw/DrawBox.ts)):
+
+``` javascript
+const box = { x: 50, y: 50, width: 100, height: 100 }
+// see DrawBoxOptions below
+const drawOptions = {
+  label: 'Hello I am a box!',
+  lineWidth: 2
+}
+const drawBox = new faceapi.draw.DrawBox(box, drawOptions)
+drawBox.draw(document.getElementById('myCanvas'))
+```
+
+DrawBox drawing options:
+
+``` javascript
+export interface IDrawBoxOptions {
+  boxColor?: string
+  lineWidth?: number
+  drawLabelOptions?: IDrawTextFieldOptions
+  label?: string
+}
+```
+
+Finally you can draw custom text fields ([DrawTextField](https://github.com/justadudewhohacks/tfjs-image-recognition-base/blob/master/src/draw/DrawTextField.ts)):
+
+``` javascript
+const text = [
+  'This is a textline!',
+  'This is another textline!'
+]
+const anchor = { x: 200, y: 200 }
+// see DrawTextField below
+const drawOptions = {
+  anchorPosition: 'TOP_LEFT',
+  backgroundColor: 'rgba(0, 0, 0, 0.5)'
+}
+const drawBox = new faceapi.draw.DrawTextField(text, anchor, drawOptions)
+drawBox.draw(document.getElementById('myCanvas'))
+```
+
+DrawTextField drawing options:
+
+``` javascript
+export interface IDrawTextFieldOptions {
+  anchorPosition?: AnchorPosition
+  backgroundColor?: string
+  fontColor?: string
+  fontSize?: number
+  fontStyle?: string
+  padding?: number
+}
+
+export enum AnchorPosition {
+  TOP_LEFT = 'TOP_LEFT',
+  TOP_RIGHT = 'TOP_RIGHT',
+  BOTTOM_LEFT = 'BOTTOM_LEFT',
+  BOTTOM_RIGHT = 'BOTTOM_RIGHT'
+}
+```
+
+<a name="getting-started-face-detection-options"></a>
+
+### Face Detection Options
+
+#### SsdMobilenetv1Options
+
+``` javascript
+export interface ISsdMobilenetv1Options {
+  // minimum confidence threshold
+  // default: 0.5
+  minConfidence?: number
+
+  // maximum number of faces to return
+  // default: 100
+  maxResults?: number
+}
+
+// example
+const options = new faceapi.SsdMobilenetv1Options({ minConfidence: 0.8 })
+```
+
+#### TinyFaceDetectorOptions
+
+``` javascript
+export interface ITinyFaceDetectorOptions {
+  // size at which image is processed, the smaller the faster,
+  // but less precise in detecting smaller faces, must be divisible
+  // by 32, common sizes are 128, 160, 224, 320, 416, 512, 608,
+  // for face tracking via webcam I would recommend using smaller sizes,
+  // e.g. 128, 160, for detecting smaller faces use larger sizes, e.g. 512, 608
+  // default: 416
+  inputSize?: number
+
+  // minimum confidence threshold
+  // default: 0.5
+  scoreThreshold?: number
+}
+
+// example
+const options = new faceapi.TinyFaceDetectorOptions({ inputSize: 320 })
+```
+
+<a name="getting-started-utility-classes"></a>
+
+### Utility Classes
+
+#### IBox
+
+``` javascript
+export interface IBox {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+```
+
+#### IFaceDetection
+
+``` javascript
+export interface IFaceDetection {
+  score: number
+  box: Box
+}
+```
+
+#### IFaceLandmarks
+
+``` javascript
+export interface IFaceLandmarks {
+  positions: Point[]
+  shift: Point
+}
+```
+
+#### WithFaceDetection
+
+``` javascript
+export type WithFaceDetection<TSource> = TSource & {
+  detection: FaceDetection
+}
+```
+
+#### WithFaceLandmarks
+
+``` javascript
+export type WithFaceLandmarks<TSource> = TSource & {
+  unshiftedLandmarks: FaceLandmarks
+  landmarks: FaceLandmarks
+  alignedRect: FaceDetection
+}
+```
+
+#### WithFaceDescriptor
+
+``` javascript
+export type WithFaceDescriptor<TSource> = TSource & {
+  descriptor: Float32Array
+}
+```
+
+#### WithFaceExpressions
+
+``` javascript
+export type WithFaceExpressions<TSource> = TSource & {
+  expressions: FaceExpressions
+}
+```
+
+#### WithAge
+
+``` javascript
+export type WithAge<TSource> = TSource & {
+  age: number
+}
+```
+
+#### WithGender
+
+``` javascript
+export type WithGender<TSource> = TSource & {
+  gender: Gender
+  genderProbability: number
+}
+
+export enum Gender {
+  FEMALE = 'female',
+  MALE = 'male'
+}
+```
+
+<a name="getting-started-other-useful-utility"></a>
+
+### Other Useful Utility
+
+#### Using the Low Level API
+
+Instead of using the high level API, you can directly use the forward methods of each neural network:
+
+``` javascript
+const detections1 = await faceapi.ssdMobilenetv1(input, options)
+const detections2 = await faceapi.tinyFaceDetector(input, options)
+const landmarks1 = await faceapi.detectFaceLandmarks(faceImage)
+const landmarks2 = await faceapi.detectFaceLandmarksTiny(faceImage)
+const descriptor = await faceapi.computeFaceDescriptor(alignedFaceImage)
+```
+
+#### Extracting a Canvas for an Image Region
+
+``` javascript
+const regionsToExtract = [
+  new faceapi.Rect(0, 0, 100, 100)
+]
+// actually extractFaces is meant to extract face regions from bounding boxes
+// but you can also use it to extract any other region
+const canvases = await faceapi.extractFaces(input, regionsToExtract)
+```
+
+#### Euclidean Distance
+
+``` javascript
+// ment to be used for computing the euclidean distance between two face descriptors
+const dist = faceapi.euclideanDistance([0, 0], [0, 10])
+console.log(dist) // 10
+```
+
+#### Retrieve the Face Landmark Points and Contours
+
+``` javascript
+const landmarkPositions = landmarks.positions
+
+// or get the positions of individual contours,
+// only available for 68 point face ladnamrks (FaceLandmarks68)
+const jawOutline = landmarks.getJawOutline()
+const nose = landmarks.getNose()
+const mouth = landmarks.getMouth()
+const leftEye = landmarks.getLeftEye()
+const rightEye = landmarks.getRightEye()
+const leftEyeBbrow = landmarks.getLeftEyeBrow()
+const rightEyeBrow = landmarks.getRightEyeBrow()
+```
+
+#### Fetch and Display Images from an URL
+
+``` html
+<img id="myImg" src="">
+```
+
+``` javascript
+const image = await faceapi.fetchImage('/images/example.png')
+
+console.log(image instanceof HTMLImageElement) // true
+
+// displaying the fetched image content
+const myImg = document.getElementById('myImg')
+myImg.src = image.src
+```
+
+#### Fetching JSON
+
+``` javascript
+const json = await faceapi.fetchJson('/files/example.json')
+```
+
+#### Creating an Image Picker
+
+``` html
+<img id="myImg" src="">
+<input id="myFileUpload" type="file" onchange="uploadImage()" accept=".jpg, .jpeg, .png">
+```
+
+``` javascript
+async function uploadImage() {
+  const imgFile = document.getElementById('myFileUpload').files[0]
+  // create an HTMLImageElement from a Blob
+  const img = await faceapi.bufferToImage(imgFile)
+  document.getElementById('myImg').src = img.src
+}
+```
+
+#### Creating a Canvas Element from an Image or Video Element
+
+``` html
+<img id="myImg" src="images/example.png" />
+<video id="myVideo" src="media/example.mp4" />
+```
+
+``` javascript
+const canvas1 = faceapi.createCanvasFromMedia(document.getElementById('myImg'))
+const canvas2 = faceapi.createCanvasFromMedia(document.getElementById('myVideo'))
+```
+
+<a name="models"></a>
+
+<br><hr><br>
+
+## Available Models
+
+<a name="models-face-detection"></a>
+
+### Face Detection Models
+
+#### SSD Mobilenet V1
+
+For face detection, this project implements a SSD (Single Shot Multibox Detector) based on MobileNetV1. The neural net will compute the locations of each face in an image and will return the bounding boxes together with it's probability for each face. This face detector is aiming towards obtaining high accuracy in detecting face bounding boxes instead of low inference time. The size of the quantized model is about 5.4 MB (**ssd_mobilenetv1_model**).
+
+The face detection model has been trained on the [WIDERFACE dataset](http://mmlab.ie.cuhk.edu.hk/projects/WIDERFace/) and the weights are provided by [yeephycho](https://github.com/yeephycho) in [this](https://github.com/yeephycho/tensorflow-face-detection) repo.
+
+#### Tiny Face Detector
+
+The Tiny Face Detector is a very performant, realtime face detector, which is much faster, smaller and less resource consuming compared to the SSD Mobilenet V1 face detector, in return it performs slightly less well on detecting small faces. This model is extremely mobile and web friendly, thus it should be your GO-TO face detector on mobile devices and resource limited clients. The size of the quantized model is only 190 KB (**tiny_face_detector_model**).
+
+The face detector has been trained on a custom dataset of ~14K images labeled with bounding boxes. Furthermore the model has been trained to predict bounding boxes, which entirely cover facial feature points, thus it in general produces better results in combination with subsequent face landmark detection than SSD Mobilenet V1.
+
+This model is basically an even tinier version of Tiny Yolo V2, replacing the regular convolutions of Yolo with depthwise separable convolutions. Yolo is fully convolutional, thus can easily adapt to different input image sizes to trade off accuracy for performance (inference time).
+
+<a name="models-face-landmark-detection"></a>
+
+### 68 Point Face Landmark Detection Models
+
+This package implements a very lightweight and fast, yet accurate 68 point face landmark detector. The default model has a size of only 350kb (**face_landmark_68_model**) and the tiny model is only 80kb (**face_landmark_68_tiny_model**). Both models employ the ideas of depthwise separable convolutions as well as densely connected blocks. The models have been trained on a dataset of ~35k face images labeled with 68 face landmark points.
+
+<a name="models-face-recognition"></a>
+
+### Face Recognition Model
+
+For face recognition, a ResNet-34 like architecture is implemented to compute a face descriptor (a feature vector with 128 values) from any given face image, which is used to describe the characteristics of a persons face. The model is **not** limited to the set of faces used for training, meaning you can use it for face recognition of any person, for example yourself. You can determine the similarity of two arbitrary faces by comparing their face descriptors, for example by computing the euclidean distance or using any other classifier of your choice.
+
+The neural net is equivalent to the **FaceRecognizerNet** used in [face-recognition.js](https://github.com/justadudewhohacks/face-recognition.js) and the net used in the [dlib](https://github.com/davisking/dlib/blob/master/examples/dnn_face_recognition_ex.cpp) face recognition example. The weights have been trained by [davisking](https://github.com/davisking) and the model achieves a prediction accuracy of 99.38% on the LFW (Labeled Faces in the Wild) benchmark for face recognition.
+
+The size of the quantized model is roughly 6.2 MB (**face_recognition_model**).
+
+<a name="models-face-expression-recognition"></a>
+
+### Face Expression Recognition Model
+
+The face expression recognition model is lightweight, fast and provides reasonable accuracy. The model has a size of roughly 310kb and it employs depthwise separable convolutions and densely connected blocks. It has been trained on a variety of images from publicly available datasets as well as images scraped from the web. Note, that wearing glasses might decrease the accuracy of the prediction results.
+
+<a name="models-age-and-gender-recognition"></a>
+
+### Age and Gender Recognition Model
+
+The age and gender recognition model is a multitask network, which employs a feature extraction layer, an age regression layer and a gender classifier. The model has a size of roughly 420kb and the feature extractor employs a tinier but very similar architecture to Xception.
+
+This model has been trained and tested on the following databases with an 80/20 train/test split each: UTK, FGNET, Chalearn, Wiki, IMDB*, CACD*, MegaAge, MegaAge-Asian. The `*` indicates, that these databases have been algorithmically cleaned up, since the initial databases are very noisy.
+
+#### Total Test Results
+
+Total MAE (Mean Age Error): **4.54**
+
+Total Gender Accuracy: **95%**
+
+#### Test results for each database
+
+The `-` indicates, that there are no gender labels available for these databases.
+
+Database        | UTK    | FGNET | Chalearn | Wiki | IMDB* | CACD* | MegaAge | MegaAge-Asian |
+----------------|-------:|------:|---------:|-----:|------:|------:|--------:|--------------:|
+MAE             | 5.25   | 4.23  | 6.24     | 6.54 | 3.63  | 3.20  | 6.23    | 4.21          |
+Gender Accuracy | 0.93   | -     | 0.94     | 0.95 | -     | 0.97  | -       | -             |
+
+#### Test results for different age category groups
+
+Age Range       | 0 - 3  | 4 - 8 | 9 - 18 | 19 - 28 | 29 - 40 | 41 - 60 | 60 - 80 | 80+     |
+----------------|-------:|------:|-------:|--------:|--------:|--------:|--------:|--------:|
+MAE             | 1.52   | 3.06  | 4.82   | 4.99    | 5.43    | 4.94    | 6.17    | 9.91    |
+Gender Accuracy | 0.69   | 0.80  | 0.88   | 0.96    | 0.97    | 0.97    | 0.96    | 0.9     |
diff --git a/dist/face-api.esm.json b/dist/face-api.esm.json
index 454b68b..df57f2a 100644
--- a/dist/face-api.esm.json
+++ b/dist/face-api.esm.json
@@ -1292,7 +1292,7 @@
       ]
     },
     "package.json": {
-      "bytes": 1878,
+      "bytes": 1914,
       "imports": []
     },
     "src/xception/extractParams.ts": {
diff --git a/dist/face-api.json b/dist/face-api.json
index 0fc2d01..ecfb0ff 100644
--- a/dist/face-api.json
+++ b/dist/face-api.json
@@ -1292,7 +1292,7 @@
       ]
     },
     "package.json": {
-      "bytes": 1878,
+      "bytes": 1914,
       "imports": []
     },
     "src/xception/extractParams.ts": {
diff --git a/example/facemesh.png b/example/facemesh.png
new file mode 100755
index 0000000000000000000000000000000000000000..15766d2253cc65f267a01f0c446520a2bd69fc6b
GIT binary patch
literal 32644
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

literal 0
HcmV?d00001

diff --git a/example/node-multiprocess-worker.js b/example/node-multiprocess-worker.js
index 80e8733..d56d632 100644
--- a/example/node-multiprocess-worker.js
+++ b/example/node-multiprocess-worker.js
@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+// eslint-disable-next-line import/no-extraneous-dependencies, node/no-unpublished-require
 const log = require('@vladmandic/pilogger');
 
 // workers actual import tfjs and faceapi modules
diff --git a/example/node-multiprocess.js b/example/node-multiprocess.js
index 3dc5526..fc7ad70 100644
--- a/example/node-multiprocess.js
+++ b/example/node-multiprocess.js
@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+// eslint-disable-next-line import/no-extraneous-dependencies, node/no-unpublished-require
 const log = require('@vladmandic/pilogger'); // this is my simple logger with few extra features
 const child_process = require('child_process');
 // note that main process import faceapi or tfjs at all
diff --git a/example/node-singleprocess.js b/example/node-singleprocess.js
index a348684..3a3fd9f 100644
--- a/example/node-singleprocess.js
+++ b/example/node-singleprocess.js
@@ -3,6 +3,7 @@
 const fs = require('fs');
 const process = require('process');
 const path = require('path');
+// eslint-disable-next-line import/no-extraneous-dependencies, node/no-unpublished-require
 const log = require('@vladmandic/pilogger');
 // eslint-disable-next-line import/no-extraneous-dependencies, node/no-unpublished-require
 const tf = require('@tensorflow/tfjs-node');
diff --git a/example/webcam.js b/example/webcam.js
index d55c4b3..0b579ff 100644
--- a/example/webcam.js
+++ b/example/webcam.js
@@ -183,8 +183,8 @@ async function main() {
   log(`Version: FaceAPI ${str(faceapi?.version.faceapi || '(not loaded)')} TensorFlow/JS ${str(faceapi?.tf?.version_core || '(not loaded)')} Backend: ${str(faceapi?.tf?.getBackend() || '(not loaded)')}`);
   log(`Flags: ${JSON.stringify(faceapi?.tf?.ENV.flags || { tf: 'not loaded' })}`);
 
-  setupFaceAPI();
-  setupCamera();
+  await setupFaceAPI();
+  await setupCamera();
 }
 
 // start processing as soon as page is loaded
diff --git a/package-lock.json b/package-lock.json
index 15987fe..4be36d8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -315,9 +315,9 @@
       "dev": true
     },
     "@types/node": {
-      "version": "14.14.31",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.14.31.tgz",
-      "integrity": "sha512-vFHy/ezP5qI0rFgJ7aQnjDXwAMrG0KqqIH7tQG5PPv3BWBayOPIQNBjVc/P6hhdZfMx51REc6tfDNXHUio893g==",
+      "version": "14.14.32",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.14.32.tgz",
+      "integrity": "sha512-/Ctrftx/zp4m8JOujM5ZhwzlWLx22nbQJiVqz8/zE15gOeEW+uly3FSX4fGFpcfEvFzXcMCJwq9lGVWgyARXhg==",
       "dev": true
     },
     "@types/node-fetch": {
@@ -963,9 +963,9 @@
       }
     },
     "esbuild": {
-      "version": "0.8.55",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.8.55.tgz",
-      "integrity": "sha512-mM/s7hjYe5mQR+zAWOM5JVrCtYCke182E9l1Bbs6rG5EDP3b1gZF9sHZka53PD/iNt6OccymVZRWkTtBfcKW4w==",
+      "version": "0.8.56",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.8.56.tgz",
+      "integrity": "sha512-PTMdAWK3JI2MNW811znGssGP5GR44tQPr++VQ1rPP0n8Z1cTKbCPD3S/kXPLr3ZZDIwAaVm08fuFym6Rp8l/0A==",
       "dev": true
     },
     "escalade": {
@@ -1542,9 +1542,9 @@
       }
     },
     "glob-parent": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
-      "integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
       "dev": true,
       "requires": {
         "is-glob": "^4.0.1"
@@ -1574,9 +1574,9 @@
       }
     },
     "google-protobuf": {
-      "version": "3.15.4",
-      "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.15.4.tgz",
-      "integrity": "sha512-szktYSHUV9D+ZY1FbS+zvJLdkT+OsZ0HIr4PPP3Tgi9kYpJAPcvY9H2uEsRvJkeHzMAzOS+F1sueFIMrDbcjLw==",
+      "version": "3.15.5",
+      "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.15.5.tgz",
+      "integrity": "sha512-6bLpAI4nMIQODlegR7OevgkCoyOj5frLVDArUpeuBWad7XWUNWMGP0v5lz1/aeUI6Yf3cG9XA6acZkPxom4SEw==",
       "dev": true
     },
     "graceful-fs": {
@@ -2774,9 +2774,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "4.3.0-dev.20210304",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.0-dev.20210304.tgz",
-      "integrity": "sha512-WKBkHocfKiF1PaQRLirbrZYznReRj8JydT5etrhNOSGj0OCEq/3MXzeted9pP8czVfQ+yhzamrDnHlHqYIBTbg==",
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.2.3.tgz",
+      "integrity": "sha512-qOcYwxaByStAWrBf4x0fibwZvMRG+r4cQoTjbPtUlrWjBHbmCAww1i448U0GJ+3cNNEtebDteo/cHOR3xJ4wEw==",
       "dev": true
     },
     "unbox-primitive": {
@@ -2807,9 +2807,9 @@
       "dev": true
     },
     "v8-compile-cache": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.2.0.tgz",
-      "integrity": "sha512-gTpR5XQNKFwOd4clxfnhaqvfqMpqEwr4tOtCyz4MtYZX2JYhfr1JvBFKdS+7K/9rfpZR3VLX+YWBbKoxCgS43Q==",
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz",
+      "integrity": "sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==",
       "dev": true
     },
     "validate-npm-package-license": {
diff --git a/package.json b/package.json
index d351aa1..664b464 100644
--- a/package.json
+++ b/package.json
@@ -22,7 +22,9 @@
     "face",
     "face-api",
     "face-detection",
-    "age-gender"
+    "age-gender",
+    "emotion-detection",
+    "face-recognition"
   ],
   "repository": {
     "type": "git",
@@ -44,12 +46,12 @@
     "@tensorflow/tfjs-backend-wasm": "^3.2.0",
     "@tensorflow/tfjs-node": "^3.2.0",
     "@tensorflow/tfjs-node-gpu": "^3.2.0",
-    "@types/node": "^14.14.31",
+    "@types/node": "^14.14.32",
     "@typescript-eslint/eslint-plugin": "^4.16.1",
     "@typescript-eslint/parser": "^4.16.1",
     "@vladmandic/pilogger": "^0.2.14",
     "chokidar": "^3.5.1",
-    "esbuild": "^0.8.55",
+    "esbuild": "^0.8.56",
     "eslint": "^7.21.0",
     "eslint-config-airbnb-base": "^14.2.1",
     "eslint-plugin-import": "^2.22.1",
@@ -58,6 +60,6 @@
     "eslint-plugin-promise": "^4.3.1",
     "rimraf": "^3.0.2",
     "tslib": "^2.1.0",
-    "typescript": "^4.3.0-dev.20210304"
+    "typescript": "^4.2.3"
   }
 }