Source: FaceShapeAnalyzer.js

import Globals from "./Globals";
import { MountFileWithProgress } from "./Utility/MountFileWithProgress";

/* type Estimates = {
    Heart: number;
    Oblong: number;
    Oval: number;
    Round: number;
    Square: number;
}; */

let resource_loading = null;

export class FaceShapeAnalyzer {
    static async Create(modulesManager, onProgress) {
        const bsc = modulesManager.modules.visage.module;
        const bscAnalyzer = bsc.GetFaceShapeAnalysis();

        // file loads wrapped so they load lazily, but once-only
        if (!resource_loading) {
            // NOTE(Straza) byteLen added because if the server uses compression (gzip),
            // content-length will not be correct
            // there is no standard header for uncompressed size
            const resources = [
                {
                    name: "fs_c.bin",
                    path: Globals.pathToAssets + "Assets/Plugins/fs_c.bin",
                    byteLen: 1236,
                },
                {
                    name: "fs_m.js.json",
                    path: Globals.pathToAssets + "Assets/Plugins/fs_m.js.json",
                    byteLen: 80496,
                },
                {
                    name: "fs_m.js.bin",
                    path: Globals.pathToAssets + "Assets/Plugins/fs_m.js.bin",
                    byteLen: 3751840,
                },
            ];

            const curentprogresses = resources.reduce((acc, x) => {
                acc[x.name] = {
                    contentLength: x.byteLen,
                    receivedLength: 0,
                    progress: 0,
                    done: false,
                };
                return acc;
            }, {});

            const total = resources
                .map((k) => k.byteLen)
                .reduce((partialSum, a) => partialSum + a, 0);

            const start = () => {};
            const progress = (name) => (x) => {
                if (!onProgress) return;

                curentprogresses[name] = x;

                const keys = Object.keys(curentprogresses);
                const done = keys.every((k) => curentprogresses[k].done);

                let received = 0;

                if (done) {
                    received = total;
                } else {
                    received = keys
                        .map((k) => curentprogresses[k].receivedLength)
                        .reduce((partialSum, a) => partialSum + a, 0);
                }

                onProgress({
                    contentLength: total,
                    receivedLength: received,
                    progress: received / total,
                    done,
                });
            };

            const resource_promises = resources.map((r) =>
                MountFileWithProgress(
                    bsc.FS,
                    r.name,
                    r.path,
                    progress(r.name),
                    start,
                    r.byteLen,
                ),
            );

            resource_loading = Promise.all(resource_promises).catch(
                () => (resource_loading = null),
            );
        }
        await resource_loading;

        return new FaceShapeAnalyzer(bscAnalyzer, bsc);
    }

    constructor(bscAnalyzer, bsc) {
        this.bscAnalyzer = bscAnalyzer;
        this.bsc = bsc;
    }

    promise = null;

    /**
     *@callback FaceShapeCallback
     *@param {Object} FaceShapeAnalyzerResult - Analyzed face shape
     *@param {FaceShapeEstimates} FaceShapeAnalyzerResult.estimates - Object containing model estimates for each of the 5 possible faceshape classes (Heart, Oblong, Oval, Round, Square).
     *@param {number} FaceShapeAnalyzerResult.frameIndex -  Index of the frame that has been analyzed.
     *@param { "OFF"|"OK"|"RECOVERING"|"INIT" } FaceShapeAnalyzerResult.status - Indicates tracking status.
     */

    /**
     * Initiates the face shape analysis. When a frame has been analyzed a call to the {@link FaceShapeCallback}
     * function is issued, with the analysis results passed as the argument.
     * <br/>
     * @param {FaceShapeCallback} FaceShapeCallback - callback which will be called every time a new frame is analyzed
     */
    StartAnalysis(FaceShapeCallback) {
        const convert = (result) => {
            const status_mapping = new Map([
                [this.bsc.TrackStatus.off, "OFF"],
                [this.bsc.TrackStatus.init, "INIT"],
                [this.bsc.TrackStatus.recovering, "RECOVERING"],
                [this.bsc.TrackStatus.ok, "OK"],
            ]);

            let res = {
                frameIndex: result.frameIndex,
                estimates: result.estimates,
                status: status_mapping.get(result.status),
            };
            result.delete();

            return res;
        };

        const convertThenCall = (result) => {
            FaceShapeCallback(convert(result));
        };

        this.bscAnalyzer.SetCallback(convertThenCall);
        this.bscAnalyzer.StartAnalysis();
    }

    /**
     * Stops the face shape analysis and stops issuing calls to the callback given as a argument to the
     * {@link StartAnalysis} function.
     * <br/>
     */
    StopAnalysis() {
        this.bscAnalyzer.StopAnalysis();
    }

    /**
     * Resets the internal state of the face shape analyzer. This is useful when switching between frames of different people.
     */
    Reset() {
        this.bscAnalyzer.Reset();
    }
}