Driver Monitoring System

function preprocess(img) {
    const INPUT_SIZE = 640;
    const canvas = document.createElement('canvas');
    canvas.width = INPUT_SIZE;
    canvas.height = INPUT_SIZE;
    const ctx = canvas.getContext('2d');
    
    // Fill canvas with neutral gray background
    ctx.fillStyle = '#808080';
    ctx.fillRect(0, 0, INPUT_SIZE, INPUT_SIZE);
    
    // Calculate aspect-ratio preserving scale
    const scale = Math.min(
        INPUT_SIZE / img.width,
        INPUT_SIZE / img.height
    );
    
    const newWidth = img.width * scale;
    const newHeight = img.height * scale;
    
    // Center the image on canvas (letterbox technique)
    const offsetX = (INPUT_SIZE - newWidth) / 2;
    const offsetY = (INPUT_SIZE - newHeight) / 2;
    
    ctx.drawImage(img, offsetX, offsetY, newWidth, newHeight);
    
    // Extract pixel data and convert to tensor
    const imageData = ctx.getImageData(0, 0, INPUT_SIZE, INPUT_SIZE);
    const tensor = new Float32Array(3 * INPUT_SIZE * INPUT_SIZE);
    
    // Normalize to [0, 1] and separate RGB channels
    // Format: [R, R, R...], [G, G, G...], [B, B, B...]
    for (let i = 0; i < imageData.data.length; i += 4) {
        const idx = i / 4;
        tensor[idx] = imageData.data[i] / 255.0;  // R channel
        tensor[INPUT_SIZE * INPUT_SIZE + idx] = imageData.data[i + 1] / 255.0;  // G channel
        tensor[2 * INPUT_SIZE * INPUT_SIZE + idx] = imageData.data[i + 2] / 255.0;  // B channel
    }
    
    return { tensor, scale, offsetX, offsetY };
}

// Enhanced NMS with center containment check
function boxesOverlap(box1, box2, iouThreshold) {
    // Method 1: Traditional IoU calculation
    const iou = calculateIoU(box1, box2);
    if (iou > iouThreshold) {
        return true;  // Boxes overlap significantly
    }
    
    // Method 2: Center containment check (our innovation)
    const center1 = {
        x: (box1.x1 + box1.x2) / 2,
        y: (box1.y1 + box1.y2) / 2
    };
    const center2 = {
        x: (box2.x1 + box2.x2) / 2,
        y: (box2.y1 + box2.y2) / 2
    };
    
    // Check if box1 center is inside box2
    if (center1.x >= box2.x1 && center1.x <= box2.x2 &&
        center1.y >= box2.y1 && center1.y <= box2.y2) {
        return true;  // Same object detected
    }
    
    // Check if box2 center is inside box1
    if (center2.x >= box1.x1 && center2.x <= box1.x2 &&
        center2.y >= box1.y1 && center2.y <= box1.y2) {
        return true;  // Same object detected
    }
    
    return false;  // Different objects
}

function enhancedNMS(detections, iouThreshold) {
    // Sort detections by confidence score (highest first)
    const sorted = [...detections].sort((a, b) => 
        b.confidence - a.confidence
    );
    
    const keep = [];
    
    while (sorted.length > 0) {
        // Take the highest confidence detection
        const best = sorted.shift();
        keep.push(best);
        
        // Remove overlapping boxes using enhanced overlap check
        sorted = sorted.filter(box => 
            !boxesOverlap(best.bbox, box.bbox, iouThreshold)
        );
    }
    
    return keep;
}

// Main merging function - applies NMS per unified class
function mergeDetections(chaitanyaResults, sohamResults) {
    // Step 1: Combine all detections and unify class names
    const allDetections = unifyClassNames([
        ...chaitanyaResults,
        ...sohamResults
    ]);
    
    // Step 2: Group detections by unified class
    const grouped = groupByClass(allDetections);
    
    // Step 3: Apply Enhanced NMS to each class separately
    const final = {};
    for (const [className, detections] of Object.entries(grouped)) {
        final[className] = enhancedNMS(detections, 0.45);
    }
    
    return final;
}