rtmlib-ts 0.0.2

package/dist/solution/objectDetector.js

@@ -0,0 +1,606 @@
+/**
+ * ObjectDetector - Universal object detection API
+ * Supports YOLO12 and other YOLO models for multi-class detection
+ *
+ * @example
+ * ```typescript
+ * // Initialize with default model (YOLOv12n from HuggingFace)
+ * const detector = new ObjectDetector({
+ *   classes: ['person', 'car', 'dog'],  // Filter specific classes
+ * });
+ * await detector.init();
+ *
+ * // Or with custom model
+ * const detector = new ObjectDetector({
+ *   model: 'models/yolov12n.onnx',
+ *   classes: ['person'],
+ * });
+ * await detector.init();
+ *
+ * // Detect from canvas
+ * const objects = await detector.detectFromCanvas(canvas);
+ *
+ * // Detect all classes
+ * const allObjects = await detector.detectFromCanvas(canvas, { classes: null });
+ * ```
+ */
+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;
+/**
+ * COCO 80-class names
+ */
+export const COCO_CLASSES = [
+    'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat',
+    'traffic light', 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat',
+    'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',
+    'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',
+    'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
+    'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
+    'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
+    'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse',
+    'remote', 'keyboard', 'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator',
+    'book', 'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush',
+];
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+    model: 'https://huggingface.co/demon2233/rtmlib-ts/resolve/main/yolo/yolov12n.onnx',
+    inputSize: [416, 416], // Faster default
+    confidence: 0.5,
+    nmsThreshold: 0.45,
+    classes: ['person'],
+    backend: 'webgpu', // Default to WebGPU for better performance
+    mode: 'balanced',
+    device: 'cpu',
+    cache: true,
+};
+// Performance presets
+const MODE_PRESETS = {
+    performance: { inputSize: [640, 640], confidence: 0.3 }, // High accuracy
+    balanced: { inputSize: [416, 416], confidence: 0.5 }, // Balanced
+    lightweight: { inputSize: [320, 320], confidence: 0.6 }, // Fastest
+};
+export class ObjectDetector {
+    constructor(config) {
+        this.session = null;
+        this.initialized = false;
+        this.classFilter = null;
+        // Pre-allocated reusable resources for performance
+        this.canvas = null;
+        this.ctx = null;
+        this.tensorBuffer = null;
+        this.inputSize = [416, 416];
+        // Apply mode preset if specified
+        let finalConfig = { ...DEFAULT_CONFIG, ...config };
+        // Apply mode preset if specified
+        if (config.mode && MODE_PRESETS[config.mode]) {
+            const preset = MODE_PRESETS[config.mode];
+            // Only override if not explicitly set
+            if (!config.inputSize)
+                finalConfig.inputSize = preset.inputSize;
+            if (!config.confidence)
+                finalConfig.confidence = preset.confidence;
+        }
+        this.config = finalConfig;
+        this.updateClassFilter();
+        console.log(`[ObjectDetector] Initialized with mode: ${config.mode || 'balanced'}, input: ${this.config.inputSize[0]}x${this.config.inputSize[1]}`);
+    }
+    /**
+     * 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 = COCO_CLASSES.indexOf(className.toLowerCase());
+            if (classId !== -1) {
+                this.classFilter.add(classId);
+            }
+            else {
+                console.warn(`[ObjectDetector] Unknown class: ${className}`);
+            }
+        });
+    }
+    /**
+     * Set which classes to detect
+     * @param classes - Array of class names or null for all classes
+     */
+    setClasses(classes) {
+        this.config.classes = classes;
+        this.updateClassFilter();
+    }
+    /**
+     * Get list of available COCO classes
+     */
+    getAvailableClasses() {
+        return [...COCO_CLASSES];
+    }
+    /**
+     * Get currently filtered classes
+     */
+    getFilteredClasses() {
+        return this.config.classes;
+    }
+    /**
+     * Initialize detection model and pre-allocate resources
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        try {
+            console.log(`[ObjectDetector] Loading model from: ${this.config.model}`);
+            let modelBuffer;
+            // Use cached model if caching is enabled
+            if (this.config.cache) {
+                const isCached = await isModelCached(this.config.model);
+                console.log(`[ObjectDetector] Cache ${isCached ? 'hit' : 'miss'} for model`);
+                modelBuffer = await getCachedModel(this.config.model);
+            }
+            else {
+                console.log(`[ObjectDetector] Caching disabled, fetching from network`);
+                const response = await fetch(this.config.model);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch model: HTTP ${response.status} ${response.statusText}`);
+                }
+                modelBuffer = await response.arrayBuffer();
+            }
+            console.log(`[ObjectDetector] Model loaded, size: ${(modelBuffer.byteLength / 1024 / 1024).toFixed(2)} MB`);
+            this.session = await ort.InferenceSession.create(modelBuffer, {
+                executionProviders: [this.config.backend],
+                graphOptimizationLevel: 'all',
+            });
+            // Pre-allocate canvas and tensor buffer for performance
+            const [w, h] = this.config.inputSize;
+            this.inputSize = [w, h];
+            this.canvas = document.createElement('canvas');
+            this.canvas.width = w;
+            this.canvas.height = h;
+            this.ctx = this.canvas.getContext('2d', {
+                willReadFrequently: true,
+                alpha: false // Faster, no transparency
+            });
+            // Pre-allocate tensor buffer (3 channels * width * height)
+            this.tensorBuffer = new Float32Array(3 * w * h);
+            this.initialized = true;
+            console.log(`[ObjectDetector] ✅ Initialized (${w}x${h}, ${this.config.backend})`);
+        }
+        catch (error) {
+            console.error('[ObjectDetector] ❌ Initialization failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Detect objects 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 objects 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 objects 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 objects 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 objects 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 objects from Blob
+     */
+    async detectFromBlob(blob, targetCanvas) {
+        const bitmap = await createImageBitmap(blob);
+        const results = await this.detectFromBitmap(bitmap, targetCanvas);
+        bitmap.close();
+        return results;
+    }
+    /**
+     * Detect objects from raw image data
+     */
+    async detect(imageData, width, height) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        const startTime = performance.now();
+        const [inputH, inputW] = this.config.inputSize;
+        // Preprocess
+        const { tensor, paddingX, paddingY, scaleX, scaleY } = this.preprocess(imageData, width, height, [inputW, inputH]);
+        // Inference - use dynamic input name
+        const inputTensor = new ort.Tensor('float32', tensor, [1, 3, inputH, inputW]);
+        const inputName = this.session.inputNames[0]; // Dynamic: 'images' or 'pixel_values'
+        console.log(`[ObjectDetector] Using input name: ${inputName}`);
+        console.log(`[ObjectDetector] Input shape: [1, 3, ${inputH}, ${inputW}]`);
+        const feeds = {};
+        feeds[inputName] = inputTensor;
+        const results = await this.session.run(feeds);
+        const output = results[this.session.outputNames[0]];
+        console.log(`[ObjectDetector] Output shape: [${output.dims}]`);
+        console.log(`[ObjectDetector] Output type: ${output.type}`);
+        // Postprocess
+        const detections = this.postprocess(output.data, output.dims[1], output.dims, width, height, paddingX, paddingY, scaleX, scaleY);
+        const inferenceTime = performance.now() - startTime;
+        // Attach stats
+        detections.stats = this.calculateStats(detections, inferenceTime);
+        return detections;
+    }
+    /**
+     * Optimized preprocess with resource reuse
+     */
+    preprocess(imageData, imgWidth, imgHeight, inputSize) {
+        const [inputW, inputH] = inputSize;
+        // Reuse pre-allocated canvas
+        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
+            });
+            this.tensorBuffer = new Float32Array(3 * inputW * inputH);
+        }
+        const ctx = this.ctx;
+        // Fast clear
+        ctx.clearRect(0, 0, inputW, inputH);
+        // Calculate letterbox
+        const aspectRatio = imgWidth / imgHeight;
+        const targetAspectRatio = inputW / inputH;
+        let drawWidth, drawHeight, offsetX, offsetY;
+        if (aspectRatio > targetAspectRatio) {
+            drawWidth = inputW;
+            drawHeight = (inputW / aspectRatio) | 0; // Faster than Math.floor
+            offsetX = 0;
+            offsetY = ((inputH - drawHeight) / 2) | 0;
+        }
+        else {
+            drawHeight = inputH;
+            drawWidth = (inputH * aspectRatio) | 0;
+            offsetX = ((inputW - drawWidth) / 2) | 0;
+            offsetY = 0;
+        }
+        // Draw directly without intermediate canvas (faster)
+        const srcCanvas = document.createElement('canvas');
+        srcCanvas.width = imgWidth;
+        srcCanvas.height = imgHeight;
+        const srcCtx = srcCanvas.getContext('2d');
+        const srcImageData = srcCtx.createImageData(imgWidth, imgHeight);
+        srcImageData.data.set(imageData);
+        srcCtx.putImageData(srcImageData, 0, 0);
+        // Draw with letterbox
+        ctx.drawImage(srcCanvas, 0, 0, imgWidth, imgHeight, offsetX, offsetY, drawWidth, drawHeight);
+        const paddedData = ctx.getImageData(0, 0, inputW, inputH);
+        // Optimized normalization loop (reuse buffer)
+        const tensor = this.tensorBuffer;
+        const len = paddedData.data.length;
+        const planeSize = inputW * inputH;
+        // Unroll loop for speed (process 4 pixels at once)
+        for (let i = 0; i < len; i += 16) {
+            const i1 = i, i2 = i + 4, i3 = i + 8, i4 = i + 12;
+            const p1 = i1 / 4, p2 = i2 / 4, p3 = i3 / 4, p4 = i4 / 4;
+            // R channel
+            tensor[p1] = paddedData.data[i1] * 0.003921569; // / 255
+            tensor[p2] = paddedData.data[i2] * 0.003921569;
+            tensor[p3] = paddedData.data[i3] * 0.003921569;
+            tensor[p4] = paddedData.data[i4] * 0.003921569;
+            // G channel
+            tensor[p1 + planeSize] = paddedData.data[i1 + 1] * 0.003921569;
+            tensor[p2 + planeSize] = paddedData.data[i2 + 1] * 0.003921569;
+            tensor[p3 + planeSize] = paddedData.data[i3 + 1] * 0.003921569;
+            tensor[p4 + planeSize] = paddedData.data[i4 + 1] * 0.003921569;
+            // B channel
+            tensor[p1 + planeSize * 2] = paddedData.data[i1 + 2] * 0.003921569;
+            tensor[p2 + planeSize * 2] = paddedData.data[i2 + 2] * 0.003921569;
+            tensor[p3 + planeSize * 2] = paddedData.data[i3 + 2] * 0.003921569;
+            tensor[p4 + planeSize * 2] = paddedData.data[i4 + 2] * 0.003921569;
+        }
+        const scaleX = imgWidth / drawWidth;
+        const scaleY = imgHeight / drawHeight;
+        return {
+            tensor,
+            paddingX: offsetX,
+            paddingY: offsetY,
+            scaleX,
+            scaleY,
+        };
+    }
+    /**
+     * Postprocess YOLO output - supports multiple output formats
+     */
+    postprocess(output, numDetections, outputShape, imgWidth, imgHeight, paddingX, paddingY, scaleX, scaleY) {
+        const detections = [];
+        // Format 1: [batch, boxes, 6] - [x1, y1, x2, y2, conf, class]
+        if (outputShape.length === 3 && outputShape[2] === 6) {
+            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.confidence)
+                    continue;
+                if (this.classFilter && !this.classFilter.has(classId))
+                    continue;
+                if (x2 <= x1 || y2 <= y1)
+                    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: COCO_CLASSES[classId] || `class_${classId}`,
+                    confidence,
+                });
+            }
+        }
+        // Format 2: [batch, boxes, 80+] - YOLOv26 style
+        // Format: [class_scores..., cx, cy, w, h] - center format with width/height
+        else if (outputShape.length === 3 && outputShape[2] >= 80) {
+            const numClasses = outputShape[2] - 4;
+            const [inputH, inputW] = this.config.inputSize;
+            console.log(`[ObjectDetector] Trying YOLOv26 format (center format) with ${numClasses} classes`);
+            for (let i = 0; i < numDetections; i++) {
+                const baseIdx = i * outputShape[2];
+                // Raw bbox values - try direct interpretation first
+                // YOLOv26 may output already decoded coordinates
+                let x1 = output[baseIdx + numClasses];
+                let y1 = output[baseIdx + numClasses + 1];
+                let x2 = output[baseIdx + numClasses + 2];
+                let y2 = output[baseIdx + numClasses + 3];
+                // If values are very small (< 1), they might be logits - apply sigmoid
+                if (Math.abs(x1) < 1 && Math.abs(y1) < 1) {
+                    // Apply sigmoid and scale
+                    x1 = (1 / (1 + Math.exp(-x1))) * inputW;
+                    y1 = (1 / (1 + Math.exp(-y1))) * inputH;
+                    x2 = (1 / (1 + Math.exp(-x2))) * inputW;
+                    y2 = (1 / (1 + Math.exp(-y2))) * inputH;
+                }
+                // If values are negative but large, apply sigmoid only
+                else if (x1 < 0 || y1 < 0) {
+                    x1 = (1 / (1 + Math.exp(-x1))) * inputW;
+                    y1 = (1 / (1 + Math.exp(-y1))) * inputH;
+                    x2 = (1 / (1 + Math.exp(-x2))) * inputW;
+                    y2 = (1 / (1 + Math.exp(-y2))) * inputH;
+                }
+                // Otherwise use as-is (already decoded)
+                // Debug first detection
+                if (i === 0) {
+                    console.log(`[ObjectDetector] Raw bbox: [${output[baseIdx + numClasses]}, ${output[baseIdx + numClasses + 1]}, ${output[baseIdx + numClasses + 2]}, ${output[baseIdx + numClasses + 3]}]`);
+                    console.log(`[ObjectDetector] Decoded bbox: [${x1.toFixed(1)}, ${y1.toFixed(1)}, ${x2.toFixed(1)}, ${y2.toFixed(1)}]`);
+                }
+                // Find best class and confidence
+                let bestClass = 0;
+                let bestScore = -Infinity;
+                for (let c = 0; c < numClasses; c++) {
+                    const score = output[baseIdx + c];
+                    if (score > bestScore) {
+                        bestScore = score;
+                        bestClass = c;
+                    }
+                }
+                // Apply sigmoid to class score
+                const confidence = 1 / (1 + Math.exp(-bestScore));
+                // Debug first few detections
+                if (i < 5 && confidence > 0.05) {
+                    console.log(`[ObjectDetector] Box ${i}: [${x1.toFixed(1)}, ${y1.toFixed(1)}, ${x2.toFixed(1)}, ${y2.toFixed(1)}]`);
+                    console.log(`[ObjectDetector]   -> class=${bestClass} (${COCO_CLASSES[bestClass] || 'unknown'}), confidence=${(confidence * 100).toFixed(1)}%`);
+                }
+                if (confidence < this.config.confidence)
+                    continue;
+                if (this.classFilter && !this.classFilter.has(bestClass))
+                    continue;
+                if (x2 <= x1 || y2 <= y1)
+                    continue;
+                if (x1 < 0 && x2 < 0)
+                    continue;
+                if (y1 < 0 && y2 < 0)
+                    continue;
+                // Transform to original image space
+                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: bestClass,
+                    className: COCO_CLASSES[bestClass] || `class_${bestClass}`,
+                    confidence,
+                });
+            }
+        }
+        // Debug logging
+        if (detections.length > 0) {
+            console.log(`[ObjectDetector] ✅ Found ${detections.length} detections`);
+            console.log(`[ObjectDetector] First:`, detections[0]);
+        }
+        else {
+            console.log(`[ObjectDetector] ❌ No detections above threshold ${this.config.confidence}`);
+            // Log top 3 scores for debugging
+            const topScores = [];
+            const numClasses = outputShape.length === 3 ? outputShape[2] - 4 : 80;
+            for (let i = 0; i < Math.min(3, numDetections); i++) {
+                const baseIdx = i * outputShape[2];
+                let bestScore = -Infinity;
+                for (let c = 0; c < numClasses; c++) {
+                    const score = output[baseIdx + c];
+                    if (score > bestScore)
+                        bestScore = score;
+                }
+                const confidence = bestScore > 0 && bestScore <= 1 ? bestScore : 1 / (1 + Math.exp(-bestScore));
+                topScores.push(confidence);
+            }
+            console.log(`[ObjectDetector] Top 3 confidences: ${topScores.map(s => (s * 100).toFixed(1) + '%').join(', ')}`);
+        }
+        // NMS
+        return this.applyMultiClassNMS(detections, this.config.nmsThreshold);
+    }
+    /**
+     * Multi-class Non-Maximum Suppression
+     */
+    applyMultiClassNMS(detections, iouThreshold) {
+        if (detections.length === 0)
+            return [];
+        // Group by class
+        const byClass = new Map();
+        detections.forEach((det) => {
+            const classDets = byClass.get(det.classId) || [];
+            classDets.push(det);
+            byClass.set(det.classId, classDets);
+        });
+        // Apply NMS per class
+        const selected = [];
+        byClass.forEach((classDets) => {
+            classDets.sort((a, b) => b.confidence - a.confidence);
+            const used = new Set();
+            for (let i = 0; i < classDets.length; i++) {
+                if (used.has(i))
+                    continue;
+                selected.push(classDets[i]);
+                used.add(i);
+                for (let j = i + 1; j < classDets.length; j++) {
+                    if (used.has(j))
+                        continue;
+                    const iou = this.calculateIoU(classDets[i].bbox, classDets[j].bbox);
+                    if (iou > iouThreshold) {
+                        used.add(j);
+                    }
+                }
+            }
+        });
+        return selected;
+    }
+    /**
+     * Calculate IoU between two boxes
+     */
+    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;
+    }
+    /**
+     * Calculate detection statistics
+     */
+    calculateStats(detections, inferenceTime) {
+        const classCounts = {};
+        detections.forEach((det) => {
+            classCounts[det.className] = (classCounts[det.className] || 0) + 1;
+        });
+        return {
+            totalCount: detections.length,
+            classCounts,
+            inferenceTime: Math.round(inferenceTime),
+        };
+    }
+    /**
+     * Get statistics from last detection
+     */
+    getStats() {
+        return null;
+    }
+    /**
+     * Dispose resources
+     */
+    dispose() {
+        if (this.session) {
+            this.session.release();
+            this.session = null;
+        }
+        this.initialized = false;
+    }
+}