rtmlib-ts 0.0.2

package/dist/solution/animalDetector.js

@@ -0,0 +1,663 @@
+/**
+ * AnimalDetector - Animal detection and pose estimation API
+ * Supports 30 animal classes with ViTPose++ pose model
+ *
+ * @example
+ * ```typescript
+ * // Initialize with default models
+ * const detector = new AnimalDetector();
+ * await detector.init();
+ *
+ * // Detect animals
+ * const animals = await detector.detectFromCanvas(canvas);
+ * console.log(`Found ${animals.length} animals`);
+ *
+ * // With custom models
+ * const detector2 = new AnimalDetector({
+ *   detModel: 'path/to/yolox_animal.onnx',
+ *   poseModel: 'path/to/vitpose_animal.onnx',
+ * });
+ * ```
+ */
+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;
+/**
+ * 30 Animal class names supported by AnimalDetector
+ */
+export const ANIMAL_CLASSES = [
+    'gorilla',
+    'spider-monkey',
+    'howling-monkey',
+    'zebra',
+    'elephant',
+    'hippo',
+    'raccon',
+    'rhino',
+    'giraffe',
+    'tiger',
+    'deer',
+    'lion',
+    'panda',
+    'cheetah',
+    'black-bear',
+    'polar-bear',
+    'antelope',
+    'fox',
+    'buffalo',
+    'cow',
+    'wolf',
+    'dog',
+    'sheep',
+    'cat',
+    'horse',
+    'rabbit',
+    'pig',
+    'chimpanzee',
+    'monkey',
+    'orangutan',
+];
+/**
+ * Available ViTPose++ models for animal pose estimation
+ * All models are trained on 6 datasets and support 30 animal classes
+ */
+export const VITPOSE_MODELS = {
+    /** ViTPose++-s: Fastest, 74.2 AP on AP10K */
+    'vitpose-s': {
+        name: 'ViTPose++-s',
+        url: 'https://huggingface.co/JunkyByte/easy_ViTPose/resolve/main/onnx/apt36k/vitpose-s-apt36k.onnx',
+        inputSize: [256, 192],
+        ap: 74.2,
+        description: 'Fastest inference, suitable for real-time applications',
+    },
+    /** ViTPose++-b: Balanced, 75.9 AP on AP10K */
+    'vitpose-b': {
+        name: 'ViTPose++-b',
+        url: 'https://huggingface.co/JunkyByte/easy_ViTPose/resolve/main/onnx/apt36k/vitpose-b-apt36k.onnx',
+        inputSize: [256, 192],
+        ap: 75.9,
+        description: 'Balanced speed and accuracy',
+    },
+    /** ViTPose++-l: Most accurate, 80.8 AP on AP10K */
+    'vitpose-l': {
+        name: 'ViTPose++-l',
+        url: 'https://huggingface.co/JunkyByte/easy_ViTPose/resolve/main/onnx/apt36k/vitpose-h-apt36k.onnx',
+        inputSize: [256, 192],
+        ap: 80.8,
+        description: 'Highest accuracy, slower inference',
+    },
+};
+/**
+ * COCO17 keypoint names (used for animal pose)
+ */
+const KEYPOINT_NAMES = [
+    'nose',
+    'left_eye',
+    'right_eye',
+    'left_ear',
+    'right_ear',
+    'left_shoulder',
+    'right_shoulder',
+    'left_elbow',
+    'right_elbow',
+    'left_wrist',
+    'right_wrist',
+    'left_hip',
+    'right_hip',
+    'left_knee',
+    'right_knee',
+    'left_ankle',
+    'right_ankle',
+];
+/**
+ * Default configuration - uses ViTPose++-b model
+ */
+const DEFAULT_CONFIG = {
+    detModel: 'https://huggingface.co/demon2233/rtmlib-ts/resolve/main/yolo/yolov12n.onnx',
+    poseModel: undefined, // Will be set from poseModelType
+    poseModelType: 'vitpose-b',
+    detInputSize: [640, 640],
+    poseInputSize: [256, 192],
+    detConfidence: 0.5,
+    nmsThreshold: 0.45,
+    poseConfidence: 0.3,
+    backend: 'webgpu', // Default to WebGPU for better performance
+    cache: true,
+    classes: null,
+};
+export class AnimalDetector {
+    constructor(config = {}) {
+        this.detSession = null;
+        this.poseSession = null;
+        this.initialized = false;
+        this.classFilter = null;
+        // Pre-allocated buffers
+        this.canvas = null;
+        this.ctx = null;
+        this.poseCanvas = null;
+        this.poseCtx = null;
+        this.poseTensorBuffer = null;
+        this.detInputSize = [640, 640];
+        this.poseInputSize = [256, 192];
+        // Resolve pose model URL from poseModelType if poseModel not explicitly provided
+        let finalConfig = { ...DEFAULT_CONFIG, ...config };
+        if (!config.poseModel && config.poseModelType) {
+            const vitposeModel = VITPOSE_MODELS[config.poseModelType];
+            finalConfig.poseModel = vitposeModel.url;
+            finalConfig.poseInputSize = vitposeModel.inputSize;
+        }
+        else if (!config.poseModel && !config.poseModelType) {
+            // Use default vitpose-b
+            finalConfig.poseModel = VITPOSE_MODELS['vitpose-b'].url;
+            finalConfig.poseInputSize = VITPOSE_MODELS['vitpose-b'].inputSize;
+        }
+        this.config = finalConfig;
+        this.updateClassFilter();
+    }
+    /**
+     * Update class filter based on config
+     */
+    updateClassFilter() {
+        if (!this.config.classes) {
+            this.classFilter = null;
+            return;
+        }
+        this.classFilter = new Set();
+        this.config.classes.forEach((className) => {
+            const classId = ANIMAL_CLASSES.indexOf(className.toLowerCase());
+            if (classId !== -1) {
+                this.classFilter.add(classId);
+            }
+            else {
+                console.warn(`[AnimalDetector] Unknown class: ${className}`);
+            }
+        });
+    }
+    /**
+     * Set which animal classes to detect
+     */
+    setClasses(classes) {
+        this.config.classes = classes;
+        this.updateClassFilter();
+    }
+    /**
+     * Get list of available animal classes
+     */
+    getAvailableClasses() {
+        return [...ANIMAL_CLASSES];
+    }
+    /**
+     * Get information about the current ViTPose++ model
+     */
+    getPoseModelInfo() {
+        const modelType = this.config.poseModelType;
+        if (modelType && VITPOSE_MODELS[modelType]) {
+            return VITPOSE_MODELS[modelType];
+        }
+        return null;
+    }
+    /**
+     * Initialize both detection and pose models
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        try {
+            // Load detection model
+            console.log(`[AnimalDetector] Loading detection model from: ${this.config.detModel}`);
+            let detBuffer;
+            if (this.config.cache) {
+                const detCached = await isModelCached(this.config.detModel);
+                console.log(`[AnimalDetector] Det model cache ${detCached ? 'hit' : 'miss'}`);
+                detBuffer = await getCachedModel(this.config.detModel);
+            }
+            else {
+                const detResponse = await fetch(this.config.detModel);
+                if (!detResponse.ok) {
+                    throw new Error(`Failed to fetch det model: HTTP ${detResponse.status}`);
+                }
+                detBuffer = await detResponse.arrayBuffer();
+            }
+            this.detSession = await ort.InferenceSession.create(detBuffer, {
+                executionProviders: [this.config.backend],
+                graphOptimizationLevel: 'all',
+            });
+            console.log(`[AnimalDetector] Detection model loaded, size: ${(detBuffer.byteLength / 1024 / 1024).toFixed(2)} MB`);
+            // Load pose model
+            console.log(`[AnimalDetector] Loading pose model from: ${this.config.poseModel}`);
+            let poseBuffer;
+            if (this.config.cache) {
+                const poseCached = await isModelCached(this.config.poseModel);
+                console.log(`[AnimalDetector] Pose model cache ${poseCached ? 'hit' : 'miss'}`);
+                poseBuffer = await getCachedModel(this.config.poseModel);
+            }
+            else {
+                const poseResponse = await fetch(this.config.poseModel);
+                if (!poseResponse.ok) {
+                    throw new Error(`Failed to fetch pose model: HTTP ${poseResponse.status}`);
+                }
+                poseBuffer = await poseResponse.arrayBuffer();
+            }
+            this.poseSession = await ort.InferenceSession.create(poseBuffer, {
+                executionProviders: [this.config.backend],
+                graphOptimizationLevel: 'all',
+            });
+            console.log(`[AnimalDetector] Pose model loaded, size: ${(poseBuffer.byteLength / 1024 / 1024).toFixed(2)} MB`);
+            // Pre-allocate resources
+            const [detW, detH] = this.config.detInputSize;
+            this.detInputSize = [detW, detH];
+            const [poseW, poseH] = this.config.poseInputSize;
+            this.poseInputSize = [poseW, poseH];
+            // Main canvas for detection
+            this.canvas = document.createElement('canvas');
+            this.canvas.width = detW;
+            this.canvas.height = detH;
+            this.ctx = this.canvas.getContext('2d', {
+                willReadFrequently: true,
+                alpha: false
+            });
+            // Pose crop canvas
+            this.poseCanvas = document.createElement('canvas');
+            this.poseCanvas.width = poseW;
+            this.poseCanvas.height = poseH;
+            this.poseCtx = this.poseCanvas.getContext('2d', {
+                willReadFrequently: true,
+                alpha: false
+            });
+            // Pre-allocate pose tensor buffer
+            this.poseTensorBuffer = new Float32Array(3 * poseW * poseH);
+            this.initialized = true;
+            console.log(`[AnimalDetector] ✅ Initialized (det:${detW}x${detH}, pose:${poseW}x${poseH})`);
+        }
+        catch (error) {
+            console.error('[AnimalDetector] ❌ Initialization failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Detect animals from HTMLCanvasElement
+     */
+    async detectFromCanvas(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.detect(new Uint8Array(imageData.data.buffer), canvas.width, canvas.height);
+    }
+    /**
+     * Detect animals from HTMLVideoElement
+     */
+    async detectFromVideo(video, targetCanvas) {
+        if (video.readyState < 2) {
+            throw new Error('Video not ready. Ensure video is loaded and playing.');
+        }
+        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.detect(new Uint8Array(imageData.data.buffer), canvas.width, canvas.height);
+    }
+    /**
+     * Detect animals from HTMLImageElement
+     */
+    async detectFromImage(image, targetCanvas) {
+        if (!image.complete || !image.naturalWidth) {
+            throw new Error('Image not loaded. Ensure image is fully 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.detect(new Uint8Array(imageData.data.buffer), canvas.width, canvas.height);
+    }
+    /**
+     * Detect animals from ImageBitmap
+     */
+    async detectFromBitmap(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.detect(new Uint8Array(imageData.data.buffer), canvas.width, canvas.height);
+    }
+    /**
+     * Detect animals from File
+     */
+    async detectFromFile(file, targetCanvas) {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = async () => {
+                try {
+                    const results = await this.detectFromImage(img, targetCanvas);
+                    resolve(results);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            img.onerror = () => reject(new Error('Failed to load image from file'));
+            img.src = URL.createObjectURL(file);
+        });
+    }
+    /**
+     * Detect animals from Blob
+     */
+    async detectFromBlob(blob, targetCanvas) {
+        const bitmap = await createImageBitmap(blob);
+        const results = await this.detectFromBitmap(bitmap, targetCanvas);
+        bitmap.close();
+        return results;
+    }
+    /**
+     * Detect animals from raw image data
+     */
+    async detect(imageData, width, height) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        const startTime = performance.now();
+        // Step 1: Detect animals
+        const detStart = performance.now();
+        const detections = await this.detectAnimals(imageData, width, height);
+        const detTime = performance.now() - detStart;
+        // Step 2: Estimate poses for each animal
+        const poseStart = performance.now();
+        const animals = [];
+        for (const det of detections) {
+            const keypoints = await this.estimatePose(imageData, width, height, det.bbox);
+            animals.push({
+                bbox: det.bbox,
+                classId: det.classId,
+                className: det.className,
+                keypoints,
+                scores: keypoints.map(k => k.score),
+            });
+        }
+        const poseTime = performance.now() - poseStart;
+        const totalTime = performance.now() - startTime;
+        // Calculate stats
+        const classCounts = {};
+        animals.forEach(animal => {
+            classCounts[animal.className] = (classCounts[animal.className] || 0) + 1;
+        });
+        // Attach stats
+        animals.stats = {
+            animalCount: animals.length,
+            classCounts,
+            detTime: Math.round(detTime),
+            poseTime: Math.round(poseTime),
+            totalTime: Math.round(totalTime),
+        };
+        return animals;
+    }
+    /**
+     * Detect animals using YOLO
+     */
+    async detectAnimals(imageData, width, height) {
+        const [inputH, inputW] = this.config.detInputSize;
+        const { tensor, paddingX, paddingY, scaleX, scaleY } = this.preprocessYOLO(imageData, width, height, [inputW, inputH]);
+        const inputTensor = new ort.Tensor('float32', tensor, [1, 3, inputH, inputW]);
+        const inputName = this.detSession.inputNames[0];
+        const feeds = {};
+        feeds[inputName] = inputTensor;
+        const results = await this.detSession.run(feeds);
+        const output = results[this.detSession.outputNames[0]];
+        return this.postprocessYOLO(output.data, output.dims[1], width, height, paddingX, paddingY, scaleX, scaleY);
+    }
+    /**
+     * Estimate pose for a single animal
+     */
+    async estimatePose(imageData, imgWidth, imgHeight, bbox) {
+        const [inputH, inputW] = this.config.poseInputSize;
+        const { tensor, center, scale } = this.preprocessPose(imageData, imgWidth, imgHeight, bbox, [inputW, inputH]);
+        const inputTensor = new ort.Tensor('float32', tensor, [1, 3, inputH, inputW]);
+        const results = await this.poseSession.run({ input: inputTensor });
+        return this.postprocessPose(results.simcc_x.data, results.simcc_y.data, results.simcc_x.dims, results.simcc_y.dims, center, scale);
+    }
+    preprocessYOLO(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 = '#000000';
+        ctx.fillRect(0, 0, inputW, inputH);
+        const aspectRatio = imgWidth / imgHeight;
+        const targetAspectRatio = inputW / inputH;
+        let drawWidth, drawHeight, offsetX, offsetY;
+        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;
+        }
+        const srcCanvas = document.createElement('canvas');
+        const srcCtx = srcCanvas.getContext('2d');
+        srcCanvas.width = imgWidth;
+        srcCanvas.height = imgHeight;
+        const srcImageData = srcCtx.createImageData(imgWidth, imgHeight);
+        srcImageData.data.set(imageData);
+        srcCtx.putImageData(srcImageData, 0, 0);
+        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);
+        for (let i = 0; i < paddedData.data.length; i += 4) {
+            const pixelIdx = i / 4;
+            tensor[pixelIdx] = paddedData.data[i] / 255;
+            tensor[pixelIdx + inputW * inputH] = paddedData.data[i + 1] / 255;
+            tensor[pixelIdx + 2 * inputW * inputH] = paddedData.data[i + 2] / 255;
+        }
+        const scaleX = imgWidth / drawWidth;
+        const scaleY = imgHeight / drawHeight;
+        return { tensor, paddingX: offsetX, paddingY: offsetY, scaleX, scaleY };
+    }
+    postprocessYOLO(output, numDetections, imgWidth, imgHeight, paddingX, paddingY, scaleX, scaleY) {
+        const detections = [];
+        for (let i = 0; i < numDetections; i++) {
+            const idx = i * 6;
+            const x1 = output[idx];
+            const y1 = output[idx + 1];
+            const x2 = output[idx + 2];
+            const y2 = output[idx + 3];
+            const confidence = output[idx + 4];
+            const classId = Math.round(output[idx + 5]);
+            if (confidence < this.config.detConfidence)
+                continue;
+            if (this.classFilter && !this.classFilter.has(classId))
+                continue;
+            const tx1 = (x1 - paddingX) * scaleX;
+            const ty1 = (y1 - paddingY) * scaleY;
+            const tx2 = (x2 - paddingX) * scaleX;
+            const ty2 = (y2 - paddingY) * scaleY;
+            detections.push({
+                bbox: {
+                    x1: Math.max(0, tx1),
+                    y1: Math.max(0, ty1),
+                    x2: Math.min(imgWidth, tx2),
+                    y2: Math.min(imgHeight, ty2),
+                    confidence,
+                },
+                classId,
+                className: ANIMAL_CLASSES[classId] || `animal_${classId}`,
+            });
+        }
+        return this.applyNMS(detections, this.config.nmsThreshold);
+    }
+    preprocessPose(imageData, imgWidth, imgHeight, bbox, inputSize) {
+        const [inputW, inputH] = inputSize;
+        const bboxWidth = bbox.x2 - bbox.x1;
+        const bboxHeight = bbox.y2 - bbox.y1;
+        const center = [
+            bbox.x1 + bboxWidth / 2,
+            bbox.y1 + bboxHeight / 2,
+        ];
+        const bboxAspectRatio = bboxWidth / bboxHeight;
+        const modelAspectRatio = inputW / inputH;
+        let scaleW, scaleH;
+        if (bboxAspectRatio > modelAspectRatio) {
+            scaleW = bboxWidth * 1.25;
+            scaleH = scaleW / modelAspectRatio;
+        }
+        else {
+            scaleH = bboxHeight * 1.25;
+            scaleW = scaleH * modelAspectRatio;
+        }
+        const scale = [scaleW, scaleH];
+        if (!this.poseCanvas || !this.poseCtx) {
+            this.poseCanvas = document.createElement('canvas');
+            this.poseCanvas.width = inputW;
+            this.poseCanvas.height = inputH;
+            this.poseCtx = this.poseCanvas.getContext('2d', { willReadFrequently: true, alpha: false });
+            this.poseTensorBuffer = new Float32Array(3 * inputW * inputH);
+        }
+        const ctx = this.poseCtx;
+        ctx.clearRect(0, 0, inputW, inputH);
+        const srcCanvas = document.createElement('canvas');
+        const srcCtx = srcCanvas.getContext('2d');
+        srcCanvas.width = imgWidth;
+        srcCanvas.height = imgHeight;
+        const srcImageData = srcCtx.createImageData(imgWidth, imgHeight);
+        srcImageData.data.set(imageData);
+        srcCtx.putImageData(srcImageData, 0, 0);
+        const srcX = center[0] - scaleW / 2;
+        const srcY = center[1] - scaleH / 2;
+        ctx.drawImage(srcCanvas, srcX, srcY, scaleW, scaleH, 0, 0, inputW, inputH);
+        const croppedData = ctx.getImageData(0, 0, inputW, inputH);
+        const tensor = this.poseTensorBuffer;
+        const len = croppedData.data.length;
+        const planeSize = inputW * inputH;
+        const mean0 = 123.675, mean1 = 116.28, mean2 = 103.53;
+        const stdInv0 = 1 / 58.395, stdInv1 = 1 / 57.12, stdInv2 = 1 / 57.375;
+        for (let i = 0; i < len; i += 16) {
+            const p1 = i / 4, p2 = p1 + 1, p3 = p1 + 2, p4 = p1 + 3;
+            tensor[p1] = (croppedData.data[i] - mean0) * stdInv0;
+            tensor[p2] = (croppedData.data[i + 4] - mean0) * stdInv0;
+            tensor[p3] = (croppedData.data[i + 8] - mean0) * stdInv0;
+            tensor[p4] = (croppedData.data[i + 12] - mean0) * stdInv0;
+            tensor[p1 + planeSize] = (croppedData.data[i + 1] - mean1) * stdInv1;
+            tensor[p2 + planeSize] = (croppedData.data[i + 5] - mean1) * stdInv1;
+            tensor[p3 + planeSize] = (croppedData.data[i + 9] - mean1) * stdInv1;
+            tensor[p4 + planeSize] = (croppedData.data[i + 13] - mean1) * stdInv1;
+            tensor[p1 + planeSize * 2] = (croppedData.data[i + 2] - mean2) * stdInv2;
+            tensor[p2 + planeSize * 2] = (croppedData.data[i + 6] - mean2) * stdInv2;
+            tensor[p3 + planeSize * 2] = (croppedData.data[i + 10] - mean2) * stdInv2;
+            tensor[p4 + planeSize * 2] = (croppedData.data[i + 14] - mean2) * stdInv2;
+        }
+        return { tensor, center, scale };
+    }
+    postprocessPose(simccX, simccY, shapeX, shapeY, center, scale) {
+        const numKeypoints = shapeX[1];
+        const wx = shapeX[2];
+        const wy = shapeY[2];
+        const keypoints = [];
+        for (let k = 0; k < numKeypoints; k++) {
+            let maxX = -Infinity, argmaxX = 0;
+            for (let i = 0; i < wx; i++) {
+                const val = simccX[k * wx + i];
+                if (val > maxX) {
+                    maxX = val;
+                    argmaxX = i;
+                }
+            }
+            let maxY = -Infinity, argmaxY = 0;
+            for (let i = 0; i < wy; i++) {
+                const val = simccY[k * wy + i];
+                if (val > maxY) {
+                    maxY = val;
+                    argmaxY = i;
+                }
+            }
+            const score = 0.5 * (maxX + maxY);
+            const visible = score > this.config.poseConfidence;
+            const normX = argmaxX / wx;
+            const normY = argmaxY / wy;
+            const x = (normX - 0.5) * scale[0] + center[0];
+            const y = (normY - 0.5) * scale[1] + center[1];
+            keypoints.push({
+                x,
+                y,
+                score,
+                visible,
+                name: KEYPOINT_NAMES[k] || `keypoint_${k}`,
+            });
+        }
+        return keypoints;
+    }
+    applyNMS(detections, iouThreshold) {
+        if (detections.length === 0)
+            return [];
+        detections.sort((a, b) => b.bbox.confidence - a.bbox.confidence);
+        const selected = [];
+        const used = new Set();
+        for (let i = 0; i < detections.length; i++) {
+            if (used.has(i))
+                continue;
+            selected.push(detections[i]);
+            used.add(i);
+            for (let j = i + 1; j < detections.length; j++) {
+                if (used.has(j))
+                    continue;
+                const iou = this.calculateIoU(detections[i].bbox, detections[j].bbox);
+                if (iou > iouThreshold) {
+                    used.add(j);
+                }
+            }
+        }
+        return selected;
+    }
+    calculateIoU(box1, box2) {
+        const x1 = Math.max(box1.x1, box2.x1);
+        const y1 = Math.max(box1.y1, box2.y1);
+        const x2 = Math.min(box1.x2, box2.x2);
+        const y2 = Math.min(box1.y2, box2.y2);
+        if (x2 <= x1 || y2 <= y1)
+            return 0;
+        const intersection = (x2 - x1) * (y2 - y1);
+        const area1 = (box1.x2 - box1.x1) * (box1.y2 - box1.y1);
+        const area2 = (box2.x2 - box2.x1) * (box2.y2 - box2.y1);
+        const union = area1 + area2 - intersection;
+        return intersection / union;
+    }
+    /**
+     * Dispose resources
+     */
+    dispose() {
+        if (this.detSession) {
+            this.detSession.release();
+            this.detSession = null;
+        }
+        if (this.poseSession) {
+            this.poseSession.release();
+            this.poseSession = null;
+        }
+        this.initialized = false;
+    }
+}

package/dist/solution/body.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Body solution - body pose estimation with 17 or 26 keypoints
+ */
+import { ModeType } from '../types/index';
+export declare class Body {
+    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=body.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../src/solution/body.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAQ,QAAQ,EAAe,MAAM,gBAAgB,CAAC;AAE7D,qBAAa,IAAI;IACf,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"}