rtmlib-ts 0.0.2

package/dist/core/postprocessing.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Post-processing utilities for object detection
+ */
+export declare function multiclassNms(boxes: number[][], scores: number[][], nmsThr: number, scoreThr: number): {
+    boxes: number[][];
+    scores: number[];
+    classIds: number[];
+} | null;
+export declare function nms(boxes: number[][], scores: number[], nmsThr: number): number[];
+//# sourceMappingURL=postprocessing.d.ts.map

package/dist/core/postprocessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postprocessing.d.ts","sourceRoot":"","sources":["../../src/core/postprocessing.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EAAE,EAAE,EACjB,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf;IAAE,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CA4CpE;AAmBD,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBjF"}

package/dist/core/postprocessing.js

@@ -0,0 +1,70 @@
+/**
+ * Post-processing utilities for object detection
+ */
+export function multiclassNms(boxes, scores, nmsThr, scoreThr) {
+    const numClasses = scores[0].length;
+    const numBoxes = boxes.length;
+    const allDetections = [];
+    for (let c = 0; c < numClasses; c++) {
+        for (let i = 0; i < numBoxes; i++) {
+            if (scores[i][c] > scoreThr) {
+                allDetections.push({
+                    box: boxes[i],
+                    score: scores[i][c],
+                    classId: c,
+                });
+            }
+        }
+    }
+    allDetections.sort((a, b) => b.score - a.score);
+    const keep = [];
+    while (allDetections.length > 0) {
+        const current = allDetections.shift();
+        keep.push(current);
+        for (let i = allDetections.length - 1; i >= 0; i--) {
+            const other = allDetections[i];
+            if (current.classId !== other.classId)
+                continue;
+            const iou = calculateIoU(current.box, other.box);
+            if (iou > nmsThr) {
+                allDetections.splice(i, 1);
+            }
+        }
+    }
+    if (keep.length === 0)
+        return null;
+    return {
+        boxes: keep.map(d => d.box),
+        scores: keep.map(d => d.score),
+        classIds: keep.map(d => d.classId),
+    };
+}
+function calculateIoU(box1, box2) {
+    const x1 = Math.max(box1[0], box2[0]);
+    const y1 = Math.max(box1[1], box2[1]);
+    const x2 = Math.min(box1[2], box2[2]);
+    const y2 = Math.min(box1[3], box2[3]);
+    const interWidth = Math.max(0, x2 - x1);
+    const interHeight = Math.max(0, y2 - y1);
+    const interArea = interWidth * interHeight;
+    const box1Area = (box1[2] - box1[0]) * (box1[3] - box1[1]);
+    const box2Area = (box2[2] - box2[0]) * (box2[3] - box2[1]);
+    const unionArea = box1Area + box2Area - interArea;
+    return unionArea > 0 ? interArea / unionArea : 0;
+}
+export function nms(boxes, scores, nmsThr) {
+    const indices = [];
+    const sortedIndices = scores.map((s, i) => i).sort((a, b) => scores[b] - scores[a]);
+    while (sortedIndices.length > 0) {
+        const current = sortedIndices.shift();
+        indices.push(current);
+        for (let i = sortedIndices.length - 1; i >= 0; i--) {
+            const other = sortedIndices[i];
+            const iou = calculateIoU(boxes[current], boxes[other]);
+            if (iou > nmsThr) {
+                sortedIndices.splice(i, 1);
+            }
+        }
+    }
+    return indices;
+}

package/dist/core/preprocessing.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pre-processing utilities for pose estimation
+ */
+export declare function bboxXyxy2cs(bbox: [number, number, number, number], padding?: number): {
+    center: [number, number];
+    scale: [number, number];
+};
+export declare function topDownAffine(imageSize: [number, number], scale: [number, number], center: [number, number], img: Uint8Array, imgWidth: number, imgHeight: number): {
+    resizedImg: Float32Array;
+    scale: [number, number];
+};
+export declare function normalizeImage(img: Float32Array, mean: number[], std: number[]): Float32Array;
+export declare function transposeImage(img: Float32Array, height: number, width: number): Float32Array;
+//# sourceMappingURL=preprocessing.d.ts.map

package/dist/core/preprocessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocessing.d.ts","sourceRoot":"","sources":["../../src/core/preprocessing.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,WAAW,CACzB,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACtC,OAAO,GAAE,MAAa,GACrB;IAAE,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAYvD;AAED,wBAAgB,aAAa,CAC3B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACxB,GAAG,EAAE,UAAU,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB;IAAE,UAAU,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAkDvD;AAgBD,wBAAgB,cAAc,CAC5B,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,EAAE,MAAM,EAAE,GACZ,YAAY,CASd;AAED,wBAAgB,cAAc,CAC5B,GAAG,EAAE,YAAY,EACjB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,YAAY,CAad"}

package/dist/core/preprocessing.js

@@ -0,0 +1,79 @@
+/**
+ * Pre-processing utilities for pose estimation
+ */
+export function bboxXyxy2cs(bbox, padding = 1.25) {
+    const [x1, y1, x2, y2] = bbox;
+    const center = [(x1 + x2) / 2, (y1 + y2) / 2];
+    const w = x2 - x1;
+    const h = y2 - y1;
+    // Python: scale = w * padding, h * padding (different values!)
+    const scale = [w * padding, h * padding];
+    return { center, scale };
+}
+export function topDownAffine(imageSize, scale, center, img, imgWidth, imgHeight) {
+    const [w, h] = imageSize;
+    const srcW = scale[0];
+    const srcH = scale[1];
+    // Calculate transformation matrix
+    const scaleX = w / srcW;
+    const scaleY = h / srcH;
+    // Create output array
+    const outputSize = w * h * 3;
+    const resizedImg = new Float32Array(outputSize);
+    // Simple bilinear interpolation
+    for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+            // Map output coordinates to input coordinates
+            const srcX = (x / w) * srcW + (center[0] - srcW / 2);
+            const srcY = (y / h) * srcH + (center[1] - srcH / 2);
+            // Get the four nearest pixels
+            const x0 = Math.floor(srcX);
+            const y0 = Math.floor(srcY);
+            const x1 = x0 + 1;
+            const y1 = y0 + 1;
+            const dx = srcX - x0;
+            const dy = srcY - y0;
+            // Sample from input image with bounds checking
+            for (let c = 0; c < 3; c++) {
+                const p00 = getPixel(img, imgWidth, imgHeight, x0, y0, c);
+                const p10 = getPixel(img, imgWidth, imgHeight, x1, y0, c);
+                const p01 = getPixel(img, imgWidth, imgHeight, x0, y1, c);
+                const p11 = getPixel(img, imgWidth, imgHeight, x1, y1, c);
+                // Bilinear interpolation
+                const value = p00 * (1 - dx) * (1 - dy) +
+                    p10 * dx * (1 - dy) +
+                    p01 * (1 - dx) * dy +
+                    p11 * dx * dy;
+                resizedImg[y * w * 3 + x * 3 + c] = value;
+            }
+        }
+    }
+    // Return original scale (not model dimensions) for postprocess
+    return { resizedImg, scale };
+}
+function getPixel(img, width, height, x, y, channel) {
+    if (x < 0 || x >= width || y < 0 || y >= height) {
+        return 0;
+    }
+    return img[y * width * 3 + x * 3 + channel];
+}
+export function normalizeImage(img, mean, std) {
+    const normalized = new Float32Array(img.length);
+    for (let i = 0; i < img.length; i++) {
+        const channel = i % 3;
+        normalized[i] = (img[i] - mean[channel]) / std[channel];
+    }
+    return normalized;
+}
+export function transposeImage(img, height, width) {
+    // HWC to CHW
+    const transposed = new Float32Array(img.length);
+    for (let c = 0; c < 3; c++) {
+        for (let h = 0; h < height; h++) {
+            for (let w = 0; w < width; w++) {
+                transposed[c * height * width + h * width + w] = img[h * width * 3 + w * 3 + c];
+            }
+        }
+    }
+    return transposed;
+}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * rtmlib-ts - Real-Time Multi-Person Pose Estimation Library
+ *
+ * TypeScript port of rtmlib Python library
+ * Based on RTMPose, DWPose, RTMO, RTMW models
+ */
+export { YOLOX } from './models/yolox';
+export { YOLO12 } from './models/yolo12';
+export { RTMPose } from './models/rtmpose';
+export { RTMPose3D } from './models/rtmpose3d';
+export { ObjectDetector, COCO_CLASSES } from './solution/objectDetector';
+export { PoseDetector } from './solution/poseDetector';
+export { Pose3DDetector, type Person3D, type Pose3DStats } from './solution/pose3dDetector';
+export { CustomDetector, type CustomDetectorConfig, type DetectionResult } from './solution/customDetector';
+export { AnimalDetector, ANIMAL_CLASSES, VITPOSE_MODELS, type VitPoseModelType, type DetectedAnimal, type AnimalKeypoint } from './solution/animalDetector';
+export { Wholebody } from './solution/wholebody';
+export { Wholebody3D, type Wholebody3DResult } from './solution/wholebody3d';
+export { Body } from './solution/body';
+export { Hand } from './solution/hand';
+export { BodyWithFeet } from './solution/bodyWithFeet';
+export { PoseTracker } from './solution/poseTracker';
+export { drawBbox, drawSkeleton, drawDetectionsOnCanvas, drawPoseOnCanvas, drawResultsOnCanvas } from './visualization/draw';
+export { getCachedModel, isModelCached, preloadModels, clearModelCache, getCacheSize, getCacheInfo, } from './core/modelCache';
+export type { Keypoint, BodyResult, HandResult, FaceResult, PoseResult, BBox, Detection, ModelConfig, ModeType, BackendType, DeviceType, ImageData, RGBImage, BGRImage, } from './types/index';
+export { coco17, coco133, hand21, halpe26, openpose18, openpose134, } from './visualization/skeleton/index';
+export declare const VERSION = "0.0.1";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG/C,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EAAE,cAAc,EAAE,KAAK,oBAAoB,EAAE,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5G,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC5J,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC7E,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAGrD,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAG7H,OAAO,EACL,cAAc,EACd,aAAa,EACb,aAAa,EACb,eAAe,EACf,YAAY,EACZ,YAAY,GACb,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EACV,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,EACV,IAAI,EACJ,SAAS,EACT,WAAW,EACX,QAAQ,EACR,WAAW,EACX,UAAU,EACV,SAAS,EACT,QAAQ,EACR,QAAQ,GACT,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,MAAM,EACN,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,WAAW,GACZ,MAAM,gCAAgC,CAAC;AAGxC,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,31 @@
+/**
+ * rtmlib-ts - Real-Time Multi-Person Pose Estimation Library
+ *
+ * TypeScript port of rtmlib Python library
+ * Based on RTMPose, DWPose, RTMO, RTMW models
+ */
+// Models
+export { YOLOX } from './models/yolox';
+export { YOLO12 } from './models/yolo12';
+export { RTMPose } from './models/rtmpose';
+export { RTMPose3D } from './models/rtmpose3d';
+// Solutions (High-level APIs)
+export { ObjectDetector, COCO_CLASSES } from './solution/objectDetector';
+export { PoseDetector } from './solution/poseDetector';
+export { Pose3DDetector } from './solution/pose3dDetector';
+export { CustomDetector } from './solution/customDetector';
+export { AnimalDetector, ANIMAL_CLASSES, VITPOSE_MODELS } from './solution/animalDetector';
+export { Wholebody } from './solution/wholebody';
+export { Wholebody3D } from './solution/wholebody3d';
+export { Body } from './solution/body';
+export { Hand } from './solution/hand';
+export { BodyWithFeet } from './solution/bodyWithFeet';
+export { PoseTracker } from './solution/poseTracker';
+// Visualization
+export { drawBbox, drawSkeleton, drawDetectionsOnCanvas, drawPoseOnCanvas, drawResultsOnCanvas } from './visualization/draw';
+// Model caching utilities
+export { getCachedModel, isModelCached, preloadModels, clearModelCache, getCacheSize, getCacheInfo, } from './core/modelCache';
+// Skeleton configurations
+export { coco17, coco133, hand21, halpe26, openpose18, openpose134, } from './visualization/skeleton/index';
+// Version
+export const VERSION = '0.0.1';

package/dist/models/rtmpose.d.ts

@@ -0,0 +1,25 @@
+/**
+ * RTMPose model for pose estimation
+ * Supports RTMPose, DWPose, RTMW variants
+ * Uses onnxruntime-web for browser compatibility
+ */
+import { BaseTool } from '../core/base';
+import { BBox, BackendType } from '../types/index';
+export declare class RTMPose extends BaseTool {
+    private toOpenpose;
+    private simccSplitRatio;
+    private initialized;
+    private readonly defaultMean;
+    private readonly defaultStd;
+    constructor(onnxModel: string, modelInputSize?: [number, number], // [height, width]
+    toOpenpose?: boolean, backend?: BackendType);
+    init(): Promise<void>;
+    call(image: Uint8Array, imgWidth: number, imgHeight: number, bboxes?: BBox[]): Promise<{
+        keypoints: number[][];
+        scores: number[];
+    }>;
+    private preprocess;
+    private postprocess;
+    private convertCocoToOpenpose;
+}
+//# sourceMappingURL=rtmpose.d.ts.map

package/dist/models/rtmpose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtmpose.d.ts","sourceRoot":"","sources":["../../src/models/rtmpose.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEnD,qBAAa,OAAQ,SAAQ,QAAQ;IACnC,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,eAAe,CAAe;IACtC,OAAO,CAAC,WAAW,CAAkB;IAErC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuC;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqC;gBAG9D,SAAS,EAAE,MAAM,EACjB,cAAc,GAAE,CAAC,MAAM,EAAE,MAAM,CAAc,EAAG,kBAAkB;IAClE,UAAU,GAAE,OAAe,EAC3B,OAAO,GAAE,WAAsB;IAM3B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrB,IAAI,CACR,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,IAAI,EAAO,GAClB,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAuCvD,OAAO,CAAC,UAAU;IAsFlB,OAAO,CAAC,WAAW;IAsDnB,OAAO,CAAC,qBAAqB;CA+C9B"}

package/dist/models/rtmpose.js

@@ -0,0 +1,185 @@
+/**
+ * RTMPose model for pose estimation
+ * Supports RTMPose, DWPose, RTMW variants
+ * Uses onnxruntime-web for browser compatibility
+ */
+import { BaseTool } from '../core/base';
+export class RTMPose extends BaseTool {
+    constructor(onnxModel, modelInputSize = [384, 288], // [height, width]
+    toOpenpose = false, backend = 'webgpu') {
+        super(onnxModel, modelInputSize, null, null, backend);
+        this.simccSplitRatio = 2.0;
+        this.initialized = false;
+        this.defaultMean = [123.675, 116.28, 103.53];
+        this.defaultStd = [58.395, 57.12, 57.375];
+        this.toOpenpose = toOpenpose;
+    }
+    async init() {
+        // Web version - model path is direct URL
+        await super.init();
+        this.initialized = true;
+    }
+    async call(image, imgWidth, imgHeight, bboxes = []) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        if (bboxes.length === 0) {
+            bboxes = [{ x1: 0, y1: 0, x2: imgWidth, y2: imgHeight }];
+        }
+        const allKeypoints = [];
+        const allScores = [];
+        for (const bbox of bboxes) {
+            const { tensor, center, scale, inputSize } = this.preprocess(image, imgWidth, imgHeight, bbox);
+            const outputs = await this.inference(tensor, inputSize);
+            const { keypoints, scores } = this.postprocess(outputs[0].data, outputs[1].data, outputs[0].dims, outputs[1].dims, center, scale);
+            allKeypoints.push(keypoints);
+            allScores.push(scores);
+        }
+        // Flatten results
+        const keypoints = allKeypoints.flat();
+        const scores = allScores.flat();
+        if (this.toOpenpose) {
+            const converted = this.convertCocoToOpenpose(keypoints, scores);
+            return converted;
+        }
+        return { keypoints, scores };
+    }
+    preprocess(img, imgWidth, imgHeight, bbox) {
+        const [inputH, inputW] = this.modelInputSize; // H=384, W=288
+        // Center and scale from bbox with padding
+        const center = [
+            bbox.x1 + (bbox.x2 - bbox.x1) / 2,
+            bbox.y1 + (bbox.y2 - bbox.y1) / 2,
+        ];
+        const bboxWidth = bbox.x2 - bbox.x1;
+        const bboxHeight = bbox.y2 - bbox.y1;
+        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];
+        // Create canvas for cropping
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        canvas.width = inputW;
+        canvas.height = inputH;
+        ctx.fillStyle = '#FFFFFF';
+        ctx.fillRect(0, 0, inputW, inputH);
+        // Create source canvas from image data
+        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(img);
+        srcCtx.putImageData(srcImageData, 0, 0);
+        // Calculate source region
+        const srcX = center[0] - scaleW / 2;
+        const srcY = center[1] - scaleH / 2;
+        // Draw cropped and scaled region
+        ctx.drawImage(srcCanvas, srcX, srcY, scaleW, scaleH, 0, 0, inputW, inputH);
+        const imageData = ctx.getImageData(0, 0, inputW, inputH);
+        // Normalize with mean/std
+        const data = new Float32Array(inputW * inputH * 3);
+        for (let i = 0; i < imageData.data.length; i += 4) {
+            const pixelIndex = i / 4;
+            for (let c = 0; c < 3; c++) {
+                const value = imageData.data[i + c];
+                data[c * inputW * inputH + pixelIndex] = (value - this.defaultMean[c]) / this.defaultStd[c];
+            }
+        }
+        return {
+            tensor: data,
+            center,
+            scale,
+            inputSize: [inputH, inputW],
+        };
+    }
+    postprocess(simccX, simccY, outputShapeX, outputShapeY, center, scale) {
+        const numKeypoints = outputShapeX[1];
+        const wx = outputShapeX[2];
+        const wy = outputShapeY[2];
+        const keypoints = [];
+        const scores = [];
+        for (let k = 0; k < numKeypoints; k++) {
+            // Find argmax for x
+            let maxX = -Infinity;
+            let argmaxX = 0;
+            for (let i = 0; i < wx; i++) {
+                const val = simccX[k * wx + i];
+                if (val > maxX) {
+                    maxX = val;
+                    argmaxX = i;
+                }
+            }
+            // Find argmax for y
+            let maxY = -Infinity;
+            let 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);
+            // Normalize to [0, 1] and transform to original image coordinates
+            const normX = argmaxX / wx;
+            const normY = argmaxY / wy;
+            const kptX = (normX - 0.5) * scale[0] + center[0];
+            const kptY = (normY - 0.5) * scale[1] + center[1];
+            keypoints.push([kptX, kptY]);
+            scores.push(score);
+        }
+        return { keypoints, scores };
+    }
+    convertCocoToOpenpose(keypoints, scores) {
+        // COCO 17 keypoints to OpenPose 18 keypoints mapping
+        const cocoToOpenpose = [
+            0, // nose
+            1, // neck (average of shoulders)
+            2, // right_shoulder
+            3, // right_elbow
+            4, // right_wrist
+            5, // left_shoulder
+            6, // left_elbow
+            7, // left_wrist
+            8, // right_hip
+            9, // right_knee
+            10, // right_ankle
+            11, // left_hip
+            12, // left_knee
+            13, // left_ankle
+            14, // right_eye
+            15, // left_eye
+            16, // left_ear
+        ];
+        const openposeKeypoints = [];
+        const openposeScores = [];
+        for (let i = 0; i < 17; i++) {
+            if (i === 1) {
+                // Neck is average of shoulders
+                const rightShoulder = keypoints[2];
+                const leftShoulder = keypoints[5];
+                openposeKeypoints.push([
+                    (rightShoulder[0] + leftShoulder[0]) / 2,
+                    (rightShoulder[1] + leftShoulder[1]) / 2,
+                ]);
+                openposeScores.push((scores[2] + scores[5]) / 2);
+            }
+            else {
+                const cocoIdx = cocoToOpenpose[i];
+                openposeKeypoints.push([...keypoints[cocoIdx]]);
+                openposeScores.push(scores[cocoIdx]);
+            }
+        }
+        return { keypoints: openposeKeypoints, scores: openposeScores };
+    }
+}

package/dist/models/rtmpose3d.d.ts

@@ -0,0 +1,28 @@
+/**
+ * RTMPose3D model for 3D pose estimation
+ * Extends RTMPose with Z-axis prediction
+ * Based on rtmlib RTMPose3d class
+ */
+import { BaseTool } from '../core/base';
+import { BBox, BackendType } from '../types/index';
+export declare class RTMPose3D extends BaseTool {
+    private toOpenpose;
+    private simccSplitRatio;
+    private zRange;
+    private initialized;
+    private readonly defaultMean;
+    private readonly defaultStd;
+    constructor(onnxModel: string, modelInputSize?: [number, number], // [width=288, height=384] - creates tensor [1,3,384,288]
+    toOpenpose?: boolean, backend?: BackendType, zRange?: number);
+    init(): Promise<void>;
+    call(image: Uint8Array, imgWidth: number, imgHeight: number, bboxes?: BBox[]): Promise<{
+        keypoints: number[][][];
+        scores: number[][];
+        keypointsSimcc: number[][][];
+        keypoints2d: number[][][];
+    }>;
+    private preprocess;
+    private warpAffine;
+    private postprocess;
+}
+//# sourceMappingURL=rtmpose3d.d.ts.map

package/dist/models/rtmpose3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtmpose3d.d.ts","sourceRoot":"","sources":["../../src/models/rtmpose3d.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEnD,qBAAa,SAAU,SAAQ,QAAQ;IACrC,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,eAAe,CAAe;IACtC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,WAAW,CAAkB;IAErC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuC;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqC;gBAG9D,SAAS,EAAE,MAAM,EACjB,cAAc,GAAE,CAAC,MAAM,EAAE,MAAM,CAAc,EAAE,yDAAyD;IACxG,UAAU,GAAE,OAAe,EAC3B,OAAO,GAAE,WAAsB,EAC/B,MAAM,CAAC,EAAE,MAAM;IASX,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,IAAI,CACR,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,IAAI,EAAO,GAClB,OAAO,CAAC;QACT,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;QACxB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;QACnB,cAAc,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;QAC7B,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;KAC3B,CAAC;IAgDF,OAAO,CAAC,UAAU;IAqFlB,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,WAAW;CA6FpB"}