@glyph-cat/ml-helpers/lib/types/index.d.ts

Helper functions to use in conjunction with machine learning outputs such as mediapipe.

import { Awaitable } from '@glyph-cat/foundation';
import { BuildType } from '@glyph-cat/foundation';
import { FaceLandmarker } from '@mediapipe/tasks-vision';
import { FaceLandmarkerOptions } from '@mediapipe/tasks-vision';
import { FaceLandmarkerResult } from '@mediapipe/tasks-vision';
import { FilesetResolver } from '@mediapipe/tasks-vision';
import { GestureRecognizer } from '@mediapipe/tasks-vision';
import { GestureRecognizerOptions } from '@mediapipe/tasks-vision';
import { GestureRecognizerResult } from '@mediapipe/tasks-vision';
import { HandLandmarker } from '@mediapipe/tasks-vision';
import { HandLandmarkerOptions } from '@mediapipe/tasks-vision';
import { HandLandmarkerResult } from '@mediapipe/tasks-vision';
import { NormalizedLandmark } from '@mediapipe/tasks-vision';
import { NormalizedLandmark as NormalizedLandmark_2 } from '@mediapipe/hands';
import { PartialRecord } from '@glyph-cat/foundation';
import { PoseLandmarker } from '@mediapipe/tasks-vision';
import { PoseLandmarkerOptions } from '@mediapipe/tasks-vision';
import { PoseLandmarkerResult } from '@mediapipe/tasks-vision';
import { PossiblyUndefined } from '@glyph-cat/foundation';
import { SimpleFiniteStateManager } from 'cotton-box';
import { SimpleStateManager } from 'cotton-box';
import { StringRecord } from '@glyph-cat/foundation';
import { Value2D } from '@glyph-cat/foundation';

/**
 * @public
 */
export declare abstract class BaseLandmarkAnalyzer<Landmarker extends VisionLandmarker, Result> extends BaseVisionAnalyzer<Landmarker, Result> {
    constructor(videoElement: HTMLVideoElement, initialResult: Result, getTaskRunner: () => Awaitable<Landmarker>, displayName: string, options: LandmarkAnalyzerOptions | undefined);
}

/**
 * @public
 */
export declare abstract class BaseVisionAnalyzer<TaskRunner extends StringRecord<any>, Result> {
    readonly videoElement: HTMLVideoElement;
    private readonly getTaskRunner;
    readonly detectionMethodName: DetectionMethod;
    protected static getVision(): Promise<WasmFileset>;
    protected taskRunner?: TaskRunner;
    protected lastRequestedAnimationFrame?: number;
    readonly result: SimpleStateManager<Result>;
    readonly state: SimpleFiniteStateManager<VisionAnalyzerState>;
    constructor(videoElement: HTMLVideoElement, initialResult: Result, getTaskRunner: () => Awaitable<TaskRunner>, detectionMethodName: DetectionMethod, classDisplayName: string, options: VisionAnalyzerOptions | undefined);
    initialize(): Promise<void>;
    start(): Promise<void>;
    stop(): Promise<void>;
    dispose(): Promise<void>;
    protected abstract getProcessedResult(rawResult: ReturnType<TaskRunner[typeof BaseVisionAnalyzer.detectionMethodName]>): PossiblyUndefined<Result>;
}

/**
 * @public
 */
export declare enum BodyPoseLandmark {
    NOSE = 0,
    LEFT_EYE_INNER = 1,
    LEFT_EYE = 2,
    LEFT_EYE_OUTER = 3,
    RIGHT_EYE_INNER = 4,
    RIGHT_EYE = 5,
    RIGHT_EYE_OUTER = 6,
    LEFT_EAR = 7,
    RIGHT_EAR = 8,
    MOUTH_LEFT = 9,
    MOUTH_RIGHT = 10,
    LEFT_SHOULDER = 11,
    RIGHT_SHOULDER = 12,
    LEFT_ELBOW = 13,
    RIGHT_ELBOW = 14,
    LEFT_WRIST = 15,
    RIGHT_WRIST = 16,
    LEFT_PINKY = 17,
    RIGHT_PINKY = 18,
    LEFT_INDEX = 19,
    RIGHT_INDEX = 20,
    LEFT_THUMB = 21,
    RIGHT_THUMB = 22,
    LEFT_HIP = 23,
    RIGHT_HIP = 24,
    LEFT_KNEE = 25,
    RIGHT_KNEE = 26,
    LEFT_ANKLE = 27,
    RIGHT_ANKLE = 28,
    LEFT_HEEL = 29,
    RIGHT_HEEL = 30,
    LEFT_FOOT_INDEX = 31,
    RIGHT_FOOT_INDEX = 32
}

/**
 * Git commit hash of which the package was built.
 * @public
 */
export declare const BUILD_HASH: string;

/**
 * The package build type.
 * @public
 */
export declare const BUILD_TYPE: BuildType;

/**
 * @public
 */
export declare class ComplexHandGesture {
    static getFingerCurlAngles(hand: Array<NormalizedLandmark_2>, finger: Finger): Array<number>;
    static determineFingerCurl(hand: Array<NormalizedLandmark_2>, finger: Finger): FingerCurl;
    constructor(fingerCurlStates: PartialRecord<Finger, FingerCurlExpression>);
    isMatchedBy(hand: Array<NormalizedLandmark_2>): boolean;
}

/**
 * @public
 */
export declare enum DetectionMethod {
    detectForVideo = "detectForVideo",
    recognizeForVideo = "recognizeForVideo"
}

/**
 * @public
 */
export declare interface DrawConnectorOptions {
    /**
     * @defaultValue `'#ffffff'`
     */
    color?: string;
    /**
     * @defaultValue `1`
     */
    lineWidth?: number;
}

/**
 * @public
 */
export declare function drawConnectors(ctx: CanvasRenderingContext2D, landmarks: Array<Value2D>, connections: Array<[start: number, end: number]>, style?: DrawConnectorOptions): void;

/**
 * @public
 */
export declare interface DrawLandmarkOptions {
    /**
     * @defaultValue `'#ffffff'`
     */
    color?: string;
    /**
     * @defaultValue `3`
     */
    radius?: number;
}

/**
 * @public
 */
export declare function drawLandmarks(ctx: CanvasRenderingContext2D, landmarks: Array<Value2D>, style?: DrawLandmarkOptions): void;

/**
 * @public
 */
export declare class FilesetResolverPath {
    static get(): string;
    /**
     * This can a the path to the wasm hosted on your server.
     * Alternative: https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm
     */
    static set(path: string): void;
}

/**
 * @public
 */
export declare enum Finger {
    THUMB = "T",
    INDEX = "I",
    MIDDLE = "M",
    RING = "R",
    PINKY = "P"
}

/**
 * @public
 */
export declare enum FingerCurl {
    STRAIGHT = 1,
    HALF = 2,
    FULL = 3
}

/**
 * @public
 */
export declare type FingerCurlExpression = {
    is: FingerCurl;
    isOneOf?: never;
    isNot?: never;
    isNotOneOf?: never;
} | {
    is?: never;
    isOneOf: Array<FingerCurl>;
    isNot?: never;
    isNotOneOf?: never;
} | {
    is?: never;
    isOneOf?: never;
    isNot: FingerCurl;
    isNotOneOf?: never;
} | {
    is?: never;
    isOneOf?: never;
    isNot?: never;
    isNotOneOf: Array<FingerCurl>;
};

/**
 * - A replacement for `import { HAND_CONNECTIONS } from '@mediapipe/hands'`
 * - "TypeError: connections is not iterable" is thrown when trying to use it.
 * - No idea why the f••• it is `undefined`.
 * @public
 */
export declare const HAND_CONNECTIONS: Array<[start: number, end: number]>;

/**
 * @public
 */
export declare enum HandGesture {
    NONE = "None",
    CLOSED_FIST = "Closed_Fist",
    OPEN_PALM = "Open_Palm",
    POINTING_UP = "Pointing_Up",
    THUMB_DOWN = "Thumb_Down",
    THUMB_UP = "Thumb_Up",
    VICTORY = "Victory",
    I_LOVE_YOU = "ILoveYou"
}

/**
 * @public
 */
export declare interface LandmarkAnalyzerOptions extends VisionAnalyzerOptions {
    flipHorizontally?: boolean;
}

/**
 * @public
 */
export declare class OnePersonBodyPoseAnalyzer extends BaseLandmarkAnalyzer<PoseLandmarker, OnePersonBodyPoseAnalyzerResult> {
    private readonly options?;
    private static readonly M$cache;
    constructor(videoElement: HTMLVideoElement, poseLandmarkerOptions: Omit<PoseLandmarkerOptions, 'numPoses'>, options?: LandmarkAnalyzerOptions | undefined);
    protected getProcessedResult(rawResult: PoseLandmarkerResult): PossiblyUndefined<OnePersonBodyPoseAnalyzerResult>;
}

/**
 * @public
 */
export declare type OnePersonBodyPoseAnalyzerResult = Array<NormalizedLandmark>;

/**
 * @public
 */
export declare class OnePersonFaceMeshAnalyzer extends BaseLandmarkAnalyzer<FaceLandmarker, OnePersonFaceMeshAnalyzerResult> {
    private readonly options;
    private static readonly M$cache;
    constructor(videoElement: HTMLVideoElement, faceLandmarkerOptions: Omit<FaceLandmarkerOptions, 'numFaces'>, options: LandmarkAnalyzerOptions);
    protected getProcessedResult(rawResult: FaceLandmarkerResult): PossiblyUndefined<OnePersonFaceMeshAnalyzerResult>;
}

/**
 * @public
 */
export declare type OnePersonFaceMeshAnalyzerResult = Array<NormalizedLandmark>;

/**
 * @public
 */
export declare class OnePersonHandGestureAnalyzer extends BaseVisionAnalyzer<GestureRecognizer, OnePersonHandGestureAnalyzerResult> {
    private readonly bodyPoseAnalyzer;
    private static readonly M$cache;
    constructor(bodyPoseAnalyzer: OnePersonBodyPoseAnalyzer, gestureRecognizerOptions: Omit<GestureRecognizerOptions, 'numHands'>, options?: LandmarkAnalyzerOptions);
    protected getProcessedResult(rawResult: GestureRecognizerResult): PossiblyUndefined<OnePersonHandGestureAnalyzerResult>;
}

/**
 * @public
 */
export declare type OnePersonHandGestureAnalyzerHandResult = [
gesture: HandGesture,
landmarks: Array<NormalizedLandmark>
];

/**
 * @public
 */
export declare interface OnePersonHandGestureAnalyzerResult {
    L?: OnePersonHandGestureAnalyzerHandResult;
    R?: OnePersonHandGestureAnalyzerHandResult;
}

/**
 * @public
 */
export declare class OnePersonHandPoseAnalyzer extends BaseLandmarkAnalyzer<HandLandmarker, OnePersonHandPoseAnalyzerResult> {
    private readonly bodyPoseAnalyzer;
    private readonly options?;
    private static readonly M$cache;
    constructor(bodyPoseAnalyzer: OnePersonBodyPoseAnalyzer, handLandmarkerOptions: Omit<HandLandmarkerOptions, 'numHands'>, options?: LandmarkAnalyzerOptions | undefined);
    protected getProcessedResult(rawResult: HandLandmarkerResult): PossiblyUndefined<OnePersonHandPoseAnalyzerResult>;
}

/**
 * @public
 */
export declare type OnePersonHandPoseAnalyzerHandResult = Array<NormalizedLandmark>;

/**
 * @public
 */
export declare interface OnePersonHandPoseAnalyzerResult {
    L?: OnePersonHandPoseAnalyzerHandResult;
    R?: OnePersonHandPoseAnalyzerHandResult;
}

/**
 * The package version.
 * @public
 */
export declare const VERSION: string | undefined;

/**
 * @public
 */
export declare interface VisionAnalyzerOptions {
    /**
     * @defaultValue `false`
     */
    initializeImmediately?: boolean;
}

/**
 * @public
 */
export declare enum VisionAnalyzerState {
    CREATED = 0,
    INITIALIZING = 1,
    STANDBY = 2,
    ACTIVE = 3,
    DISPOSED = 4
}

/**
 * @public
 */
export declare type VisionLandmarker = FaceLandmarker | HandLandmarker | PoseLandmarker;

/**
 * "Module '"@mediapipe/tasks-vision"' declares 'WasmFileset' locally, but it is not exported."
 * BRUH... zzz
 * @public
 */
export declare type WasmFileset = Awaited<ReturnType<typeof FilesetResolver.forVisionTasks>>;

export { }