rtmlib-ts 0.0.2

package/dist/solution/body.js

@@ -0,0 +1,52 @@
+/**
+ * Body solution - body pose estimation with 17 or 26 keypoints
+ */
+import { YOLOX } from '../models/yolox';
+import { RTMPose } from '../models/rtmpose';
+export class Body {
+    constructor(det = null, detInputSize = [640, 640], pose = null, poseInputSize = [288, 384], mode = 'balanced', toOpenpose = false, backend = 'onnxruntime', device = 'cpu') {
+        let finalDet = det;
+        let finalDetInputSize = detInputSize;
+        let finalPose = pose;
+        let finalPoseInputSize = poseInputSize;
+        if (det === null) {
+            finalDet = Body.MODE[mode].det;
+            finalDetInputSize = Body.MODE[mode].detInputSize;
+        }
+        if (pose === null) {
+            finalPose = Body.MODE[mode].pose;
+            finalPoseInputSize = Body.MODE[mode].poseInputSize;
+        }
+        this.detModel = new YOLOX(finalDet, finalDetInputSize, 0.45, 0.7, backend);
+        this.poseModel = new RTMPose(finalPose, finalPoseInputSize, toOpenpose, backend);
+    }
+    async init() {
+        await this.detModel.init();
+        await this.poseModel.init();
+    }
+    async call(image, imgWidth, imgHeight) {
+        const bboxes = await this.detModel.call(image, imgWidth, imgHeight);
+        const result = await this.poseModel.call(image, imgWidth, imgHeight, bboxes);
+        return result;
+    }
+}
+Body.MODE = {
+    performance: {
+        det: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/yolox_l_8xb8-300e_humanart-ce1d7a62.zip',
+        detInputSize: [640, 640],
+        pose: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/rtmpose-l_simcc-body7_pt-body7_420e-384x288-3f5a1437_20230504.zip',
+        poseInputSize: [288, 384],
+    },
+    lightweight: {
+        det: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/yolox_nano_8xb8-300e_humanart-40f6f0d0.zip',
+        detInputSize: [416, 416],
+        pose: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/rtmpose-t_simcc-body7_pt-body7_420e-256x192-026a1439_20230504.zip',
+        poseInputSize: [192, 256],
+    },
+    balanced: {
+        det: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/yolox_m_8xb8-300e_humanart-c2c7a14a.zip',
+        detInputSize: [640, 640],
+        pose: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/rtmpose-m_simcc-body7_pt-body7_420e-256x192-e48f03d0_20230504.zip',
+        poseInputSize: [192, 256],
+    },
+};

package/dist/solution/bodyWithFeet.d.ts

@@ -0,0 +1,16 @@
+/**
+ * BodyWithFeet solution - body pose estimation with 26 keypoints (including feet)
+ */
+import { ModeType } from '../types/index';
+export declare class BodyWithFeet {
+    private detModel;
+    private poseModel;
+    private static readonly MODE;
+    constructor(det?: string | null, detInputSize?: [number, number], pose?: string | null, poseInputSize?: [number, number], mode?: ModeType, toOpenpose?: boolean, backend?: 'onnxruntime', device?: string);
+    init(): Promise<void>;
+    call(image: Uint8Array, imgWidth: number, imgHeight: number): Promise<{
+        keypoints: number[][];
+        scores: number[];
+    }>;
+}
+//# sourceMappingURL=bodyWithFeet.d.ts.map

package/dist/solution/bodyWithFeet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bodyWithFeet.d.ts","sourceRoot":"","sources":["../../src/solution/bodyWithFeet.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,QAAQ,EAAe,MAAM,gBAAgB,CAAC;AAEvD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,SAAS,CAAU;IAE3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAmB1B;gBAGA,GAAG,GAAE,MAAM,GAAG,IAAW,EACzB,YAAY,GAAE,CAAC,MAAM,EAAE,MAAM,CAAc,EAC3C,IAAI,GAAE,MAAM,GAAG,IAAW,EAC1B,aAAa,GAAE,CAAC,MAAM,EAAE,MAAM,CAAc,EAC5C,IAAI,GAAE,QAAqB,EAC3B,UAAU,GAAE,OAAe,EAC3B,OAAO,GAAE,aAA6B,EACtC,MAAM,GAAE,MAAc;IAiClB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,IAAI,CACR,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAKxD"}

package/dist/solution/bodyWithFeet.js

@@ -0,0 +1,52 @@
+/**
+ * BodyWithFeet solution - body pose estimation with 26 keypoints (including feet)
+ */
+import { YOLOX } from '../models/yolox';
+import { RTMPose } from '../models/rtmpose';
+export class BodyWithFeet {
+    constructor(det = null, detInputSize = [640, 640], pose = null, poseInputSize = [288, 384], mode = 'balanced', toOpenpose = false, backend = 'onnxruntime', device = 'cpu') {
+        let finalDet = det;
+        let finalDetInputSize = detInputSize;
+        let finalPose = pose;
+        let finalPoseInputSize = poseInputSize;
+        if (det === null) {
+            finalDet = BodyWithFeet.MODE[mode].det;
+            finalDetInputSize = BodyWithFeet.MODE[mode].detInputSize;
+        }
+        if (pose === null) {
+            finalPose = BodyWithFeet.MODE[mode].pose;
+            finalPoseInputSize = BodyWithFeet.MODE[mode].poseInputSize;
+        }
+        this.detModel = new YOLOX(finalDet, finalDetInputSize, 0.45, 0.7, backend);
+        this.poseModel = new RTMPose(finalPose, finalPoseInputSize, toOpenpose, backend);
+    }
+    async init() {
+        await this.detModel.init();
+        await this.poseModel.init();
+    }
+    async call(image, imgWidth, imgHeight) {
+        const bboxes = await this.detModel.call(image, imgWidth, imgHeight);
+        const result = await this.poseModel.call(image, imgWidth, imgHeight, bboxes);
+        return result;
+    }
+}
+BodyWithFeet.MODE = {
+    performance: {
+        det: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/yolox_l_8xb8-300e_humanart-ce1d7a62.zip',
+        detInputSize: [640, 640],
+        pose: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/rtmpose-l_simcc-body7_pt-body7-halpe26_700e-384x288-734182ce_20230605.zip',
+        poseInputSize: [288, 384],
+    },
+    lightweight: {
+        det: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/yolox_nano_8xb8-300e_humanart-40f6f0d0.zip',
+        detInputSize: [416, 416],
+        pose: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/rtmpose-t_simcc-body7_pt-body7-halpe26_700e-256x192-6020f8a6_20230605.zip',
+        poseInputSize: [192, 256],
+    },
+    balanced: {
+        det: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/yolox_m_8xb8-300e_humanart-c2c7a14a.zip',
+        detInputSize: [640, 640],
+        pose: 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/rtmpose-m_simcc-body7_pt-body7-halpe26_700e-256x192-4d3e73dd_20230605.zip',
+        poseInputSize: [192, 256],
+    },
+};

package/dist/solution/customDetector.d.ts

@@ -0,0 +1,137 @@
+/**
+ * CustomDetector - Maximum flexibility detector for any ONNX model
+ * Provides low-level API for custom model inference
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with auto-config
+ * const detector = new CustomDetector({
+ *   model: 'path/to/model.onnx',
+ * });
+ * await detector.init();
+ * const results = await detector.run(imageData, width, height);
+ *
+ * // Advanced usage with custom preprocessing
+ * const detector = new CustomDetector({
+ *   model: 'path/to/model.onnx',
+ *   inputName: 'input',
+ *   outputNames: ['output1', 'output2'],
+ *   preprocessing: (data) => customPreprocess(data),
+ *   postprocessing: (outputs) => customPostprocess(outputs),
+ * });
+ * ```
+ */
+import * as ort from 'onnxruntime-web';
+/**
+ * Configuration options for CustomDetector
+ */
+export interface CustomDetectorConfig {
+    /** Path to ONNX model (required) */
+    model: string;
+    /** Input tensor name (optional - auto-detected if not specified) */
+    inputName?: string;
+    /** Output tensor names (optional - auto-detected if not specified) */
+    outputNames?: string[];
+    /** Expected input shape [batch, channels, height, width] (optional) */
+    inputShape?: [number, number, number, number];
+    /** Custom preprocessing function */
+    preprocessing?: (data: ImageData, config: CustomDetectorConfig) => Float32Array | ort.Tensor;
+    /** Custom postprocessing function */
+    postprocessing?: (outputs: Record<string, ort.Tensor>, metadata: any) => any;
+    /** Execution backend (default: 'wasm') */
+    backend?: 'wasm' | 'webgpu';
+    /** Enable model caching (default: true) */
+    cache?: boolean;
+    /** Custom metadata for postprocessing */
+    metadata?: any;
+    /** Input normalization (default: { mean: [0, 0, 0], std: [1, 1, 1] }) */
+    normalization?: {
+        mean: number[];
+        std: number[];
+    };
+    /** Input size for automatic preprocessing (optional) */
+    inputSize?: [number, number];
+    /** Keep aspect ratio during preprocessing (default: true) */
+    keepAspectRatio?: boolean;
+    /** Background color for letterbox (default: black) */
+    backgroundColor?: string;
+}
+/**
+ * Detection result with metadata
+ */
+export interface DetectionResult<T = any> {
+    /** Raw model outputs */
+    outputs: Record<string, ort.Tensor>;
+    /** Processed results */
+    data: T;
+    /** Inference time in ms */
+    inferenceTime: number;
+    /** Input shape used */
+    inputShape: number[];
+}
+export declare class CustomDetector {
+    private config;
+    private session;
+    private initialized;
+    private canvas;
+    private ctx;
+    constructor(config: CustomDetectorConfig);
+    /**
+     * Initialize the model
+     */
+    init(): Promise<void>;
+    /**
+     * Run inference on canvas
+     */
+    runFromCanvas<T = any>(canvas: HTMLCanvasElement): Promise<DetectionResult<T>>;
+    /**
+     * Run inference on video
+     */
+    runFromVideo<T = any>(video: HTMLVideoElement, targetCanvas?: HTMLCanvasElement): Promise<DetectionResult<T>>;
+    /**
+     * Run inference on image
+     */
+    runFromImage<T = any>(image: HTMLImageElement, targetCanvas?: HTMLCanvasElement): Promise<DetectionResult<T>>;
+    /**
+     * Run inference on bitmap
+     */
+    runFromBitmap<T = any>(bitmap: ImageBitmap, targetCanvas?: HTMLCanvasElement): Promise<DetectionResult<T>>;
+    /**
+     * Run inference on file
+     */
+    runFromFile<T = any>(file: File, targetCanvas?: HTMLCanvasElement): Promise<DetectionResult<T>>;
+    /**
+     * Run inference on blob
+     */
+    runFromBlob<T = any>(blob: Blob, targetCanvas?: HTMLCanvasElement): Promise<DetectionResult<T>>;
+    /**
+     * Run inference with custom preprocessing
+     */
+    run<T = any>(imageData: ImageData, width: number, height: number, metadata?: any): Promise<DetectionResult<T>>;
+    /**
+     * Get model info
+     */
+    getModelInfo(): {
+        inputNames: string[];
+        outputNames: string[];
+        inputCount: number;
+        outputCount: number;
+    };
+    /**
+     * Get tensor by name from outputs
+     */
+    getOutputTensor<T extends ort.Tensor = ort.Tensor>(outputs: Record<string, ort.Tensor>, name?: string): T;
+    /**
+     * Simple preprocessing - just normalize to [0, 1] and convert to CHW
+     */
+    private simplePreprocess;
+    /**
+     * Preprocess with letterbox and normalization
+     */
+    private preprocess;
+    /**
+     * Dispose resources
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=customDetector.d.ts.map

package/dist/solution/customDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customDetector.d.ts","sourceRoot":"","sources":["../../src/solution/customDetector.ts"],"names":[],"mappings":"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"}

package/dist/solution/customDetector.js

@@ -0,0 +1,342 @@
+/**
+ * CustomDetector - Maximum flexibility detector for any ONNX model
+ * Provides low-level API for custom model inference
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with auto-config
+ * const detector = new CustomDetector({
+ *   model: 'path/to/model.onnx',
+ * });
+ * await detector.init();
+ * const results = await detector.run(imageData, width, height);
+ *
+ * // Advanced usage with custom preprocessing
+ * const detector = new CustomDetector({
+ *   model: 'path/to/model.onnx',
+ *   inputName: 'input',
+ *   outputNames: ['output1', 'output2'],
+ *   preprocessing: (data) => customPreprocess(data),
+ *   postprocessing: (outputs) => customPostprocess(outputs),
+ * });
+ * ```
+ */
+import * as ort from 'onnxruntime-web';
+import { getCachedModel, isModelCached } from '../core/modelCache';
+// Configure ONNX Runtime Web
+ort.env.wasm.wasmPaths = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.0/dist/';
+ort.env.wasm.simd = true;
+ort.env.wasm.proxy = false;
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+    backend: 'webgpu', // Default to WebGPU for better performance
+    cache: true,
+    keepAspectRatio: true,
+    backgroundColor: '#000000',
+    normalization: {
+        mean: [0, 0, 0],
+        std: [1, 1, 1],
+    },
+};
+export class CustomDetector {
+    constructor(config) {
+        this.session = null;
+        this.initialized = false;
+        this.canvas = null;
+        this.ctx = null;
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+            outputNames: config.outputNames || [],
+            inputShape: config.inputShape || [1, 3, 224, 224],
+            normalization: config.normalization || { mean: [0, 0, 0], std: [1, 1, 1] },
+        };
+    }
+    /**
+     * Initialize the model
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        try {
+            console.log(`[CustomDetector] Loading model from: ${this.config.model}`);
+            let modelBuffer;
+            if (this.config.cache) {
+                const cached = await isModelCached(this.config.model);
+                console.log(`[CustomDetector] Cache ${cached ? 'hit' : 'miss'}`);
+                modelBuffer = await getCachedModel(this.config.model);
+            }
+            else {
+                const response = await fetch(this.config.model);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch model: HTTP ${response.status}`);
+                }
+                modelBuffer = await response.arrayBuffer();
+            }
+            this.session = await ort.InferenceSession.create(modelBuffer, {
+                executionProviders: [this.config.backend],
+                graphOptimizationLevel: 'all',
+            });
+            // Auto-detect input/output names if not specified
+            if (!this.config.inputName && this.session.inputNames.length > 0) {
+                console.log(`[CustomDetector] Auto-detected input name: ${this.session.inputNames[0]}`);
+            }
+            if (this.config.outputNames.length === 0 && this.session.outputNames.length > 0) {
+                this.config.outputNames = [...this.session.outputNames];
+                console.log(`[CustomDetector] Auto-detected output names: ${this.config.outputNames}`);
+            }
+            console.log(`[CustomDetector] ✅ Initialized (${this.config.backend})`);
+            this.initialized = true;
+        }
+        catch (error) {
+            console.error('[CustomDetector] ❌ Initialization failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Run inference on canvas
+     */
+    async runFromCanvas(canvas) {
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Could not get 2D context from canvas');
+        }
+        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        return this.run(imageData, canvas.width, canvas.height);
+    }
+    /**
+     * Run inference on video
+     */
+    async runFromVideo(video, targetCanvas) {
+        if (video.readyState < 2) {
+            throw new Error('Video not ready');
+        }
+        const canvas = targetCanvas || document.createElement('canvas');
+        canvas.width = video.videoWidth;
+        canvas.height = video.videoHeight;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Could not get 2D context from canvas');
+        }
+        ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        return this.run(imageData, canvas.width, canvas.height);
+    }
+    /**
+     * Run inference on image
+     */
+    async runFromImage(image, targetCanvas) {
+        if (!image.complete || !image.naturalWidth) {
+            throw new Error('Image not loaded');
+        }
+        const canvas = targetCanvas || document.createElement('canvas');
+        canvas.width = image.naturalWidth;
+        canvas.height = image.naturalHeight;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Could not get 2D context from canvas');
+        }
+        ctx.drawImage(image, 0, 0);
+        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        return this.run(imageData, canvas.width, canvas.height);
+    }
+    /**
+     * Run inference on bitmap
+     */
+    async runFromBitmap(bitmap, targetCanvas) {
+        const canvas = targetCanvas || document.createElement('canvas');
+        canvas.width = bitmap.width;
+        canvas.height = bitmap.height;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Could not get 2D context from canvas');
+        }
+        ctx.drawImage(bitmap, 0, 0);
+        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        return this.run(imageData, canvas.width, canvas.height);
+    }
+    /**
+     * Run inference on file
+     */
+    async runFromFile(file, targetCanvas) {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = async () => {
+                try {
+                    const result = await this.runFromImage(img, targetCanvas);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            img.onerror = () => reject(new Error('Failed to load image'));
+            img.src = URL.createObjectURL(file);
+        });
+    }
+    /**
+     * Run inference on blob
+     */
+    async runFromBlob(blob, targetCanvas) {
+        const bitmap = await createImageBitmap(blob);
+        const result = await this.runFromBitmap(bitmap, targetCanvas);
+        bitmap.close();
+        return result;
+    }
+    /**
+     * Run inference with custom preprocessing
+     */
+    async run(imageData, width, height, metadata) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        const startTime = performance.now();
+        // Preprocess
+        let inputTensor;
+        if (this.config.preprocessing) {
+            // Custom preprocessing
+            const result = this.config.preprocessing(imageData, this.config);
+            if (result instanceof Float32Array) {
+                const [h, w] = this.config.inputSize || [height, width];
+                inputTensor = new ort.Tensor('float32', result, [1, 3, h, w]);
+            }
+            else {
+                inputTensor = result;
+            }
+        }
+        else if (this.config.inputSize) {
+            // Automatic preprocessing with letterbox
+            inputTensor = this.preprocess(imageData, width, height, this.config.inputSize);
+        }
+        else {
+            // Simple preprocessing - just normalize
+            inputTensor = this.simplePreprocess(imageData);
+        }
+        // Get input name
+        const inputName = this.config.inputName || this.session.inputNames[0];
+        // Run inference
+        const feeds = {};
+        feeds[inputName] = inputTensor;
+        const results = await this.session.run(feeds);
+        // Postprocess
+        let data;
+        if (this.config.postprocessing) {
+            data = this.config.postprocessing(results, metadata || this.config.metadata);
+        }
+        else {
+            // Return raw outputs
+            data = results;
+        }
+        const inferenceTime = performance.now() - startTime;
+        return {
+            outputs: results,
+            data,
+            inferenceTime,
+            inputShape: [...inputTensor.dims],
+        };
+    }
+    /**
+     * Get model info
+     */
+    getModelInfo() {
+        if (!this.session) {
+            throw new Error('Model not initialized. Call init() first.');
+        }
+        return {
+            inputNames: [...this.session.inputNames],
+            outputNames: [...this.session.outputNames],
+            inputCount: this.session.inputNames.length,
+            outputCount: this.session.outputNames.length,
+        };
+    }
+    /**
+     * Get tensor by name from outputs
+     */
+    getOutputTensor(outputs, name) {
+        const tensorName = name || this.config.outputNames[0] || this.session.outputNames[0];
+        return outputs[tensorName];
+    }
+    /**
+     * Simple preprocessing - just normalize to [0, 1] and convert to CHW
+     */
+    simplePreprocess(imageData) {
+        const { width, height, data } = imageData;
+        const tensor = new Float32Array(3 * width * height);
+        for (let i = 0; i < data.length; i += 4) {
+            const pixelIdx = i / 4;
+            tensor[pixelIdx] = data[i] / 255;
+            tensor[pixelIdx + width * height] = data[i + 1] / 255;
+            tensor[pixelIdx + 2 * width * height] = data[i + 2] / 255;
+        }
+        return new ort.Tensor('float32', tensor, [1, 3, height, width]);
+    }
+    /**
+     * Preprocess with letterbox and normalization
+     */
+    preprocess(imageData, imgWidth, imgHeight, inputSize) {
+        const [inputW, inputH] = inputSize;
+        if (!this.canvas || !this.ctx) {
+            this.canvas = document.createElement('canvas');
+            this.canvas.width = inputW;
+            this.canvas.height = inputH;
+            this.ctx = this.canvas.getContext('2d', { willReadFrequently: true, alpha: false });
+        }
+        const ctx = this.ctx;
+        ctx.fillStyle = this.config.backgroundColor;
+        ctx.fillRect(0, 0, inputW, inputH);
+        // Calculate letterbox
+        const aspectRatio = imgWidth / imgHeight;
+        const targetAspectRatio = inputW / inputH;
+        let drawWidth, drawHeight, offsetX, offsetY;
+        if (this.config.keepAspectRatio) {
+            if (aspectRatio > targetAspectRatio) {
+                drawWidth = inputW;
+                drawHeight = Math.floor(inputW / aspectRatio);
+                offsetX = 0;
+                offsetY = Math.floor((inputH - drawHeight) / 2);
+            }
+            else {
+                drawHeight = inputH;
+                drawWidth = Math.floor(inputH * aspectRatio);
+                offsetX = Math.floor((inputW - drawWidth) / 2);
+                offsetY = 0;
+            }
+        }
+        else {
+            drawWidth = inputW;
+            drawHeight = inputH;
+            offsetX = 0;
+            offsetY = 0;
+        }
+        // Create source canvas
+        const srcCanvas = document.createElement('canvas');
+        const srcCtx = srcCanvas.getContext('2d');
+        srcCanvas.width = imgWidth;
+        srcCanvas.height = imgHeight;
+        srcCtx.putImageData(imageData, 0, 0);
+        // Draw with letterbox
+        ctx.drawImage(srcCanvas, 0, 0, imgWidth, imgHeight, offsetX, offsetY, drawWidth, drawHeight);
+        const paddedData = ctx.getImageData(0, 0, inputW, inputH);
+        const tensor = new Float32Array(inputW * inputH * 3);
+        const { mean, std } = this.config.normalization;
+        for (let i = 0; i < paddedData.data.length; i += 4) {
+            const pixelIdx = i / 4;
+            tensor[pixelIdx] = (paddedData.data[i] - mean[0]) / std[0];
+            tensor[pixelIdx + inputW * inputH] = (paddedData.data[i + 1] - mean[1]) / std[1];
+            tensor[pixelIdx + 2 * inputW * inputH] = (paddedData.data[i + 2] - mean[2]) / std[2];
+        }
+        return new ort.Tensor('float32', tensor, [1, 3, inputH, inputW]);
+    }
+    /**
+     * Dispose resources
+     */
+    dispose() {
+        if (this.session) {
+            this.session.release();
+            this.session = null;
+        }
+        this.initialized = false;
+    }
+}

package/dist/solution/hand.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hand solution - hand pose estimation with 21 keypoints
+ */
+export declare class Hand {
+    private detModel;
+    private poseModel;
+    constructor(det?: string, detInputSize?: [number, number], pose?: string, poseInputSize?: [number, number], toOpenpose?: boolean, backend?: 'onnxruntime', device?: string);
+    init(): Promise<void>;
+    call(image: Uint8Array, imgWidth: number, imgHeight: number): Promise<{
+        keypoints: number[][];
+        scores: number[];
+    }>;
+}
+//# sourceMappingURL=hand.d.ts.map

package/dist/solution/hand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hand.d.ts","sourceRoot":"","sources":["../../src/solution/hand.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,qBAAa,IAAI;IACf,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,SAAS,CAAU;gBAGzB,GAAG,GAAE,MAAwH,EAC7H,YAAY,GAAE,CAAC,MAAM,EAAE,MAAM,CAAc,EAC3C,IAAI,GAAE,MAAmJ,EACzJ,aAAa,GAAE,CAAC,MAAM,EAAE,MAAM,CAAc,EAC5C,UAAU,GAAE,OAAe,EAC3B,OAAO,GAAE,aAA6B,EACtC,MAAM,GAAE,MAAc;IAkBlB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,IAAI,CACR,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAKxD"}

package/dist/solution/hand.js

@@ -0,0 +1,20 @@
+/**
+ * Hand solution - hand pose estimation with 21 keypoints
+ */
+import { YOLOX } from '../models/yolox';
+import { RTMPose } from '../models/rtmpose';
+export class Hand {
+    constructor(det = 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/rtmdet_nano_8xb32-300e_hand-267f9c8f.zip', detInputSize = [320, 320], pose = 'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/rtmpose-m_simcc-hand5_pt-aic-coco_210e-256x256-74fb594_20230320.zip', poseInputSize = [256, 256], toOpenpose = false, backend = 'onnxruntime', device = 'cpu') {
+        this.detModel = new YOLOX(det, detInputSize, 0.45, 0.5, backend);
+        this.poseModel = new RTMPose(pose, poseInputSize, toOpenpose, backend);
+    }
+    async init() {
+        await this.detModel.init();
+        await this.poseModel.init();
+    }
+    async call(image, imgWidth, imgHeight) {
+        const bboxes = await this.detModel.call(image, imgWidth, imgHeight);
+        const result = await this.poseModel.call(image, imgWidth, imgHeight, bboxes);
+        return result;
+    }
+}

package/dist/solution/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Solution exports
+ */
+export { Wholebody } from './wholebody';
+export { Wholebody3D, type Wholebody3DResult } from './wholebody3d';
+export { Body } from './body';
+export { Hand } from './hand';
+export { BodyWithFeet } from './bodyWithFeet';
+export { PoseTracker } from './poseTracker';
+//# sourceMappingURL=index.d.ts.map

package/dist/solution/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/solution/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/solution/index.js

@@ -0,0 +1,9 @@
+/**
+ * Solution exports
+ */
+export { Wholebody } from './wholebody';
+export { Wholebody3D } from './wholebody3d';
+export { Body } from './body';
+export { Hand } from './hand';
+export { BodyWithFeet } from './bodyWithFeet';
+export { PoseTracker } from './poseTracker';