rtmlib-ts 0.0.2

package/.gitattributes

@@ -0,0 +1 @@
+"models/rtmpose/end2end.onnx" filter=lfs diff=lfs merge=lfs -text

package/README.md

@@ -0,0 +1,202 @@
+# rtmlib-ts
+
+**Real-time Multi-Person Pose Estimation & Object Detection Library**
+
+TypeScript port of [rtmlib](https://github.com/Tau-J/rtmlib) with YOLO12 support for browser-based AI inference.
+
+## 🚀 Features
+
+- 🎯 **Object Detection** - 80 COCO classes with YOLO12n
+- 🧘 **Pose Estimation** - 17 keypoints skeleton tracking
+- 📹 **Video Support** - Real-time camera & video file processing
+- 🌐 **Browser-based** - Pure WebAssembly, no backend required
+- ⚡ **Fast** - Optimized for ~200ms inference (416×416)
+- 🎨 **Beautiful UI** - Modern gradient design
+
+## 📦 Installation
+
+```bash
+npm install rtmlib-ts
+```
+
+## 🎮 Quick Start
+
+### 1. Try the Playground
+
+```bash
+cd playground
+npm install
+npm run dev
+
+# Open http://localhost:3000
+```
+
+### 2. Object Detection
+
+```typescript
+import { ObjectDetector, drawResultsOnCanvas } from 'rtmlib-ts';
+
+// Initialize
+const detector = new ObjectDetector({
+  model: 'https://huggingface.co/demon2233/rtmlib-ts/resolve/main/yolo/yolov12n.onnx',
+  classes: ['person', 'car', 'dog'],  // Filter classes or null for all
+  confidence: 0.5,
+  inputSize: [416, 416],  // 416 for speed, 640 for accuracy
+  backend: 'wasm',
+});
+
+await detector.init();
+
+// Detect from canvas
+const canvas = document.getElementById('canvas') as HTMLCanvasElement;
+const results = await detector.detectFromCanvas(canvas);
+
+// Draw results
+const ctx = canvas.getContext('2d')!;
+drawResultsOnCanvas(ctx, results, 'object');
+
+console.log(`Found ${results.length} objects`);
+results.forEach(obj => {
+  console.log(`${obj.className}: ${(obj.confidence * 100).toFixed(1)}%`);
+});
+```
+
+### 3. Pose Estimation
+
+```typescript
+import { PoseDetector, drawResultsOnCanvas } from 'rtmlib-ts';
+
+// Initialize
+const poseDetector = new PoseDetector({
+  detModel: 'https://huggingface.co/demon2233/rtmlib-ts/resolve/main/yolo/yolov12n.onnx',
+  poseModel: 'https://huggingface.co/demon2233/rtmlib-ts/resolve/main/rtmpose/end2end.onnx',
+  detInputSize: [416, 416],
+  detConfidence: 0.5,
+  poseConfidence: 0.3,
+  backend: 'wasm',
+});
+
+await poseDetector.init();
+
+// Detect poses
+const results = await poseDetector.detectFromCanvas(canvas);
+
+// Draw skeleton
+const ctx = canvas.getContext('2d')!;
+drawResultsOnCanvas(ctx, results, 'pose');
+
+console.log(`Found ${results.length} people`);
+results.forEach(person => {
+  const visibleKpts = person.keypoints.filter(k => k.visible).length;
+  console.log(`Person: ${visibleKpts}/17 keypoints visible`);
+});
+```
+
+### 4. Real-time Video
+
+```typescript
+import { ObjectDetector } from 'rtmlib-ts';
+
+const detector = new ObjectDetector({
+  model: 'https://huggingface.co/demon2233/rtmlib-ts/resolve/main/yolo/yolov12n.onnx',
+  inputSize: [416, 416],  // Faster for video
+});
+await detector.init();
+
+// Camera stream
+const video = document.querySelector('video')!;
+const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+video.srcObject = stream;
+
+// Detection loop (every 500ms)
+setInterval(async () => {
+  const results = await detector.detectFromVideo(video);
+  console.log(`Detected: ${results.map(r => r.className).join(', ')}`);
+}, 500);
+```
+
+### 5. Image Upload
+
+```typescript
+// File input
+<input type="file" accept="image/*" onChange={handleFile} />
+
+// Handler
+const handleFile = async (e: React.ChangeEvent<HTMLInputElement>) => {
+  const file = e.target.files?.[0];
+  if (!file) return;
+  
+  const results = await detector.detectFromFile(file);
+  console.log(`Found ${results.length} objects`);
+};
+```
+
+## 📊 Performance
+
+| Model | Input | Time | Use Case |
+|-------|-------|------|----------|
+| YOLO12n | 416×416 | ~200ms | Real-time video |
+| YOLO12n | 640×640 | ~500ms | High accuracy |
+| RTMW Pose | 384×288 | ~100ms | Per person |
+
+**Optimization Tips:**
+- Use 416×416 for video/real-time
+- Use 640×640 for static images
+- First run is slower (WASM compilation)
+- Filter classes to reduce processing
+
+## 🎯 Supported Classes (COCO 80)
+
+**Common:** person, car, dog, cat, bicycle, bus, truck  
+**Objects:** bottle, chair, couch, potted plant  
+**Animals:** bird, horse, sheep, cow, elephant  
+**Full list:** See `COCO_CLASSES` export
+
+## 🎨 Drawing Utilities
+
+```typescript
+import { 
+  drawDetectionsOnCanvas,
+  drawPoseOnCanvas,
+  drawResultsOnCanvas  // Universal
+} from 'rtmlib-ts';
+
+// Auto-detects mode
+drawResultsOnCanvas(ctx, results, 'object');  // or 'pose'
+
+// Custom drawing
+drawDetectionsOnCanvas(ctx, detections, '#00ff00');
+drawPoseOnCanvas(ctx, people, 0.3);  // 0.3 confidence threshold
+```
+
+## 📁 Project Structure
+
+```
+rtmlib-ts/
+├── src/
+│   ├── solution/
+│   │   ├── objectDetector.ts   # Object detection
+│   │   └── poseDetector.ts     # Pose estimation
+│   └── visualization/
+│       └── draw.ts             # Canvas utilities
+├── playground/                  # Next.js demo
+└── models/
+    ├── yolo/yolov12n.onnx      # Detector
+    └── rtmpose/end2end.onnx    # Pose model
+```
+
+## 🐛 Known Issues
+
+- **YOLOv26n**: Requires model re-export (format mismatch)
+- **First run**: Slow due to WASM compilation
+- **Mobile**: Performance varies by device
+
+## 📝 License
+
+Apache 2.0
+
+## 🙏 Credits
+
+Based on [rtmlib](https://github.com/Tau-J/rtmlib) by Tao Jiang  
+YOLO12 by [Ultralytics](https://ultralytics.com)  
+RTMW by [OpenMMLab](https://openmmlab.com)

package/dist/core/base.d.ts

@@ -0,0 +1,20 @@
+/**
+ * BaseTool - Abstract base class for all models
+ * Handles ONNX model loading and inference
+ * Compatible with onnxruntime-web (browser) and onnxruntime-node
+ */
+import * as ort from 'onnxruntime-web';
+import { BackendType } from '../types/index.js';
+export declare abstract class BaseTool {
+    protected session: ort.InferenceSession | null;
+    protected modelPath: string;
+    protected modelInputSize: [number, number];
+    protected mean: number[] | null;
+    protected std: number[] | null;
+    protected backend: BackendType;
+    constructor(modelPath: string, modelInputSize: [number, number], mean?: number[] | null, std?: number[] | null, backend?: BackendType);
+    protected init(): Promise<void>;
+    protected inference(img: Float32Array, inputSize?: [number, number]): Promise<any[]>;
+    abstract call(...args: unknown[]): Promise<unknown>;
+}
+//# sourceMappingURL=base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/core/base.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,GAAG,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,8BAAsB,QAAQ;IAC5B,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,gBAAgB,GAAG,IAAI,CAAQ;IACtD,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAChC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC/B,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC;gBAG7B,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,IAAI,GAAE,MAAM,EAAE,GAAG,IAAW,EAC5B,GAAG,GAAE,MAAM,EAAE,GAAG,IAAW,EAC3B,OAAO,GAAE,WAAsB;cASjB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;cAerB,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAkB1F,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CACpD"}

package/dist/core/base.js

@@ -0,0 +1,40 @@
+/**
+ * BaseTool - Abstract base class for all models
+ * Handles ONNX model loading and inference
+ * Compatible with onnxruntime-web (browser) and onnxruntime-node
+ */
+import * as ort from 'onnxruntime-web';
+export class BaseTool {
+    constructor(modelPath, modelInputSize, mean = null, std = null, backend = 'webgpu') {
+        this.session = null;
+        this.modelPath = modelPath;
+        this.modelInputSize = modelInputSize;
+        this.mean = mean;
+        this.std = std;
+        this.backend = backend;
+    }
+    async init() {
+        // Configure ONNX Runtime Web - use CDN for WASM files
+        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;
+        // Load model from path/URL
+        this.session = await ort.InferenceSession.create(this.modelPath, {
+            executionProviders: ['wasm'],
+            graphOptimizationLevel: 'all',
+        });
+        console.log(`Loaded model: ${this.modelPath}`);
+    }
+    async inference(img, inputSize) {
+        if (!this.session) {
+            throw new Error('Session not initialized. Call init() first.');
+        }
+        const [h, w] = inputSize || this.modelInputSize;
+        // Build input tensor (1, 3, H, W)
+        const inputTensor = new (await import('onnxruntime-web')).Tensor('float32', img, [1, 3, h, w]);
+        const feeds = {};
+        feeds[this.session.inputNames[0]] = inputTensor;
+        const results = await this.session.run(feeds);
+        return this.session.outputNames.map((name) => results[name]);
+    }
+}

package/dist/core/file.d.ts

@@ -0,0 +1,11 @@
+/**
+ * File utilities for downloading and loading models
+ */
+export declare function downloadCheckpoint(url: string, localPath?: string): Promise<string>;
+export declare function fileExists(filePath: string): boolean;
+export declare function resolveModelPath(modelPath: string): string;
+/**
+ * Extract local zip file and return onnx path
+ */
+export declare function extractLocalZip(zipPath: string): Promise<string>;
+//# sourceMappingURL=file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/core/file.ts"],"names":[],"mappings":"AAAA;;GAEG;AASH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA+BzF;AAkDD,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAK1D;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkCtE"}

package/dist/core/file.js

@@ -0,0 +1,111 @@
+/**
+ * File utilities for downloading and loading models
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import JSZip from 'jszip';
+const CACHE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.rtmlib', 'models');
+export async function downloadCheckpoint(url, localPath) {
+    // If local path provided, use it directly
+    if (localPath && fs.existsSync(localPath)) {
+        console.log(`Using local model: ${localPath}`);
+        return localPath;
+    }
+    const fileName = path.basename(url);
+    const cachePath = path.join(CACHE_DIR, fileName.replace('.zip', '.onnx'));
+    if (fs.existsSync(cachePath)) {
+        console.log(`Using cached model: ${cachePath}`);
+        return cachePath;
+    }
+    console.log(`Downloading model from ${url}`);
+    if (!fs.existsSync(CACHE_DIR)) {
+        fs.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    const tempPath = path.join(CACHE_DIR, fileName);
+    await downloadFile(url, tempPath);
+    if (fileName.endsWith('.zip')) {
+        await extractZip(tempPath, CACHE_DIR);
+        fs.unlinkSync(tempPath);
+    }
+    return cachePath;
+}
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        const download = (url) => {
+            https.get(url, (response) => {
+                if (response.statusCode === 302 || response.statusCode === 301) {
+                    download(response.headers.location);
+                    return;
+                }
+                response.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
+                });
+            }).on('error', reject);
+        };
+        download(url);
+    });
+}
+async function extractZip(zipPath, dest) {
+    const data = fs.readFileSync(zipPath);
+    const zip = await JSZip.loadAsync(data);
+    // Find .onnx file in zip
+    for (const [filename, file] of Object.entries(zip.files)) {
+        if (filename.endsWith('.onnx')) {
+            const content = await file.async('nodebuffer');
+            const onnxPath = path.join(dest, filename);
+            // Create directory if needed
+            const dir = path.dirname(onnxPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(onnxPath, content);
+            console.log(`Extracted: ${filename}`);
+            return;
+        }
+    }
+    throw new Error('No .onnx file found in zip');
+}
+export function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+export function resolveModelPath(modelPath) {
+    if (modelPath.startsWith('http://') || modelPath.startsWith('https://')) {
+        return modelPath;
+    }
+    return path.resolve(modelPath);
+}
+/**
+ * Extract local zip file and return onnx path
+ */
+export async function extractLocalZip(zipPath) {
+    if (!fs.existsSync(zipPath)) {
+        throw new Error(`Zip file not found: ${zipPath}`);
+    }
+    const destDir = path.dirname(zipPath);
+    const data = fs.readFileSync(zipPath);
+    const zip = await JSZip.loadAsync(data);
+    // Find .onnx file in zip
+    for (const [filename, file] of Object.entries(zip.files)) {
+        if (filename.endsWith('.onnx')) {
+            const onnxPath = path.join(destDir, filename);
+            if (fs.existsSync(onnxPath)) {
+                console.log(`Using extracted model: ${onnxPath}`);
+                return onnxPath;
+            }
+            const content = await file.async('nodebuffer');
+            // Create directory if needed
+            const dir = path.dirname(onnxPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(onnxPath, content);
+            console.log(`Extracted: ${filename} -> ${onnxPath}`);
+            return onnxPath;
+        }
+    }
+    throw new Error('No .onnx file found in zip');
+}

package/dist/core/modelCache.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Model caching utility using Cache API
+ * Caches ONNX models in browser to avoid repeated downloads
+ */
+/**
+ * Check if model is available in cache
+ */
+export declare function isModelCached(url: string): Promise<boolean>;
+/**
+ * Get model from cache or fetch from network
+ * @param url - Model URL
+ * @param forceRefresh - Force refresh from network
+ */
+export declare function getCachedModel(url: string, forceRefresh?: boolean): Promise<ArrayBuffer>;
+/**
+ * Preload and cache multiple models
+ */
+export declare function preloadModels(urls: string[]): Promise<void>;
+/**
+ * Clear all cached models
+ */
+export declare function clearModelCache(): Promise<void>;
+/**
+ * Get cache size in bytes
+ */
+export declare function getCacheSize(): Promise<number>;
+/**
+ * Get cache info
+ */
+export declare function getCacheInfo(): Promise<{
+    cachedModels: string[];
+    totalSize: number;
+    totalSizeFormatted: string;
+}>;
+//# sourceMappingURL=modelCache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modelCache.d.ts","sourceRoot":"","sources":["../../src/core/modelCache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAcjE;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,WAAW,CAAC,CAsCrG;AAeD;;GAEG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBjE;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAWrD;AAED;;GAEG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAuBpD;AAED;;GAEG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC;IAC5C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC,CAoBD"}

package/dist/core/modelCache.js

@@ -0,0 +1,161 @@
+/**
+ * Model caching utility using Cache API
+ * Caches ONNX models in browser to avoid repeated downloads
+ */
+const CACHE_NAME = 'rtmlib-ts-models-v1';
+/**
+ * Check if model is available in cache
+ */
+export async function isModelCached(url) {
+    if (typeof caches === 'undefined') {
+        // Cache API not available (e.g., Node.js)
+        return false;
+    }
+    try {
+        const cache = await caches.open(CACHE_NAME);
+        const response = await cache.match(url);
+        return !!response;
+    }
+    catch (error) {
+        console.warn(`[ModelCache] Failed to check cache for ${url}:`, error);
+        return false;
+    }
+}
+/**
+ * Get model from cache or fetch from network
+ * @param url - Model URL
+ * @param forceRefresh - Force refresh from network
+ */
+export async function getCachedModel(url, forceRefresh = false) {
+    if (typeof caches === 'undefined') {
+        // Cache API not available, fetch directly
+        console.log(`[ModelCache] Cache API not available, fetching from network`);
+        return fetchModelFromNetwork(url);
+    }
+    try {
+        const cache = await caches.open(CACHE_NAME);
+        // Try to get from cache first
+        if (!forceRefresh) {
+            const cachedResponse = await cache.match(url);
+            if (cachedResponse) {
+                console.log(`[ModelCache] ✅ Hit for ${url}`);
+                return await cachedResponse.arrayBuffer();
+            }
+            console.log(`[ModelCache] ❌ Miss for ${url}, fetching from network...`);
+        }
+        // Fetch from network
+        const networkResponse = await fetchModelFromNetwork(url);
+        // Cache the response
+        const responseToCache = new Response(networkResponse, {
+            headers: {
+                'Content-Type': 'application/octet-stream',
+            },
+        });
+        await cache.put(url, responseToCache);
+        console.log(`[ModelCache] 💾 Cached ${url}`);
+        return networkResponse;
+    }
+    catch (error) {
+        console.error(`[ModelCache] Failed to get/cache model ${url}:`, error);
+        throw error;
+    }
+}
+/**
+ * Fetch model from network with progress tracking
+ */
+async function fetchModelFromNetwork(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch model: HTTP ${response.status} ${response.statusText}`);
+    }
+    return await response.arrayBuffer();
+}
+/**
+ * Preload and cache multiple models
+ */
+export async function preloadModels(urls) {
+    console.log(`[ModelCache] Preloading ${urls.length} model(s)...`);
+    const results = await Promise.allSettled(urls.map(url => getCachedModel(url)));
+    const success = results.filter(r => r.status === 'fulfilled').length;
+    const failed = results.filter(r => r.status === 'rejected').length;
+    console.log(`[ModelCache] Preload complete: ${success} succeeded, ${failed} failed`);
+    results.forEach((result, index) => {
+        if (result.status === 'rejected') {
+            console.error(`[ModelCache] Failed to preload ${urls[index]}:`, result.reason);
+        }
+    });
+}
+/**
+ * Clear all cached models
+ */
+export async function clearModelCache() {
+    if (typeof caches === 'undefined') {
+        return;
+    }
+    try {
+        await caches.delete(CACHE_NAME);
+        console.log('[ModelCache] Cache cleared');
+    }
+    catch (error) {
+        console.error('[ModelCache] Failed to clear cache:', error);
+    }
+}
+/**
+ * Get cache size in bytes
+ */
+export async function getCacheSize() {
+    if (typeof caches === 'undefined' || !navigator.storage) {
+        return 0;
+    }
+    try {
+        const cache = await caches.open(CACHE_NAME);
+        const keys = await cache.keys();
+        let totalSize = 0;
+        for (const request of keys) {
+            const response = await cache.match(request);
+            if (response) {
+                const blob = await response.blob();
+                totalSize += blob.size;
+            }
+        }
+        return totalSize;
+    }
+    catch (error) {
+        console.warn('[ModelCache] Failed to get cache size:', error);
+        return 0;
+    }
+}
+/**
+ * Get cache info
+ */
+export async function getCacheInfo() {
+    if (typeof caches === 'undefined') {
+        return { cachedModels: [], totalSize: 0, totalSizeFormatted: '0 B' };
+    }
+    try {
+        const cache = await caches.open(CACHE_NAME);
+        const keys = await cache.keys();
+        const cachedModels = keys.map(k => k.url);
+        const totalSize = await getCacheSize();
+        return {
+            cachedModels,
+            totalSize,
+            totalSizeFormatted: formatBytes(totalSize),
+        };
+    }
+    catch (error) {
+        console.warn('[ModelCache] Failed to get cache info:', error);
+        return { cachedModels: [], totalSize: 0, totalSizeFormatted: '0 B' };
+    }
+}
+/**
+ * Format bytes to human-readable string
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}

package/dist/core/posePostprocessing.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Post-processing utilities for pose estimation
+ */
+export declare function getSimccMaximum(simccX: Float32Array, simccY: Float32Array): {
+    locations: number[];
+    scores: number[];
+};
+export declare function convertCocoToOpenpose(keypoints: number[][], scores: number[]): {
+    keypoints: number[][];
+    scores: number[];
+};
+//# sourceMappingURL=posePostprocessing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"posePostprocessing.d.ts","sourceRoot":"","sources":["../../src/core/posePostprocessing.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,GACnB;IAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAkC3C;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EAAE,EAAE,EACrB,MAAM,EAAE,MAAM,EAAE,GACf;IAAE,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CA4C7C"}

package/dist/core/posePostprocessing.js

@@ -0,0 +1,76 @@
+/**
+ * Post-processing utilities for pose estimation
+ */
+export function getSimccMaximum(simccX, simccY) {
+    const numKeypoints = simccX.length / 2; // Assuming split_ratio = 2
+    const locations = [];
+    const scores = [];
+    for (let i = 0; i < numKeypoints; i++) {
+        // Find argmax for x
+        let maxX = -Infinity;
+        let argmaxX = 0;
+        for (let j = 0; j < 2; j++) {
+            const val = simccX[i * 2 + j];
+            if (val > maxX) {
+                maxX = val;
+                argmaxX = j;
+            }
+        }
+        // Find argmax for y
+        let maxY = -Infinity;
+        let argmaxY = 0;
+        for (let j = 0; j < 2; j++) {
+            const val = simccY[i * 2 + j];
+            if (val > maxY) {
+                maxY = val;
+                argmaxY = j;
+            }
+        }
+        locations.push(argmaxX, argmaxY);
+        scores.push((maxX + maxY) / 2);
+    }
+    return { locations, scores };
+}
+export function 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, // right_ear
+        17, // left_ear
+    ];
+    const openposeKeypoints = [];
+    const openposeScores = [];
+    for (let i = 0; i < 18; 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 };
+}