Elysia Tools

在一个清晰的工作台里浏览工具、案例、可视化和主题指南。

热门分类

专题

语言
ZHESPTRUFRDEEN

Elysia Tools

导航

计算机视觉

OpenCV 计算机视觉示例

OpenCV.js示例,用于JavaScript中的图像处理、计算机视觉和实时视频分析

案例

这个案例集合中的条目

代码javascript简单

OpenCV.js 基础操作

OpenCV.js入门,用于图像处理和基础计算机视觉任务

难度

4/10

预计时间

30 min

标签

opencv, image processing, computer vision

前置条件

Basic JavaScript, HTML Canvas, OpenCV concepts

javascript
// OpenCV.js Basic Operations

// 1. Load OpenCV.js
// In HTML: <script async src="https://docs.opencv.org/4.5.0/opencv.js" onload="onOpenCvReady();"></script>

let cv;

function onOpenCvReady() {
    cv = window.cv;
    console.log('OpenCV.js is ready');
    runBasicExamples();
}

// 2. Load and Display Image
function loadImageAndDisplay(imageElementId, canvasId) {
    const imgElement = document.getElementById(imageElementId);
    const canvasElement = document.getElementById(canvasId);

    const src = cv.imread(imgElement);
    cv.imshow(canvasId, src);

    src.delete();
}

// 3. Basic Image Operations
function basicImageOperations() {
    console.log('=== Basic Image Operations ===');

    const imgElement = document.getElementById('inputImage');
    const src = cv.imread(imgElement);

    // Create destination mat
    const dst = new cv.Mat();

    // Convert to grayscale
    cv.cvtColor(src, dst, cv.COLOR_RGBA2GRAY, 0);
    cv.imshow('grayCanvas', dst);

    // Apply Gaussian blur
    const blurred = new cv.Mat();
    const ksize = new cv.Size(5, 5);
    cv.GaussianBlur(dst, blurred, ksize, 0, 0, cv.BORDER_DEFAULT);
    cv.imshow('blurCanvas', blurred);

    // Edge detection with Canny
    const edges = new cv.Mat();
    cv.Canny(dst, edges, 50, 150, 3, false);
    cv.imshow('edgesCanvas', edges);

    // Clean up
    src.delete();
    dst.delete();
    blurred.delete();
    edges.delete();
}

// 4. Image Filtering and Enhancement
function imageFiltering() {
    console.log('\n=== Image Filtering ===');

    const imgElement = document.getElementById('inputImage');
    const src = cv.imread(imgElement);

    // Histogram Equalization
    const gray = new cv.Mat();
    cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY, 0);

    const equalized = new cv.Mat();
    cv.equalizeHist(gray, equalized);
    cv.imshow('equalizedCanvas', equalized);

    // Brightness and Contrast Adjustment
    const adjusted = new cv.Mat();
    src.convertTo(adjusted, -1, 1.2, 30); // alpha=1.2 (contrast), beta=30 (brightness)
    cv.imshow('adjustedCanvas', adjusted);

    // Sepia Tone Effect
    const sepia = new cv.Mat();
    const kernel = cv.matFromArray(3, 3, cv.CV_32FC1, [
        0.272, 0.534, 0.131,
        0.349, 0.686, 0.168,
        0.393, 0.769, 0.189
    ]);
    cv.transform(src, sepia, kernel);
    cv.imshow('sepiaCanvas', sepia);

    // Clean up
    src.delete();
    gray.delete();
    equalized.delete();
    adjusted.delete();
    sepia.delete();
    kernel.delete();
}

// 5. Geometric Transformations
function geometricTransformations() {
    console.log('\n=== Geometric Transformations ===');

    const imgElement = document.getElementById('inputImage');
    const src = cv.imread(imgElement);

    // Rotation
    const rotated = new cv.Mat();
    const center = new cv.Point(src.cols / 2, src.rows / 2);
    const rotationMatrix = cv.getRotationMatrix2D(center, 45, 1); // 45 degrees
    cv.warpAffine(src, rotated, rotationMatrix, src.size(), cv.INTER_LINEAR, cv.BORDER_CONSTANT, new cv.Scalar());
    cv.imshow('rotatedCanvas', rotated);

    // Scaling
    const scaled = new cv.Mat();
    const scaleFactor = 0.5;
    const newSize = new cv.Size(src.cols * scaleFactor, src.rows * scaleFactor);
    cv.resize(src, scaled, newSize, 0, 0, cv.INTER_AREA);
    cv.imshow('scaledCanvas', scaled);

    // Translation (shifting)
    const translated = new cv.Mat();
    const translationMatrix = cv.matFromArray(2, 3, cv.CV_64FC1, [
        1, 0, 50,  // shift right by 50
        0, 1, 30   // shift down by 30
    ]);
    cv.warpAffine(src, translated, translationMatrix, src.size());
    cv.imshow('translatedCanvas', translated);

    // Flipping
    const flipped = new cv.Mat();
    cv.flip(src, flipped, 1); // 0 = vertical, 1 = horizontal, -1 = both
    cv.imshow('flippedCanvas', flipped);

    // Clean up
    src.delete();
    rotated.delete();
    scaled.delete();
    translated.delete();
    flipped.delete();
    rotationMatrix.delete();
    translationMatrix.delete();
}

// 6. Morphological Operations
function morphologicalOperations() {
    console.log('\n=== Morphological Operations ===');

    const imgElement = document.getElementById('inputImage');
    const src = cv.imread(imgElement);
    const gray = new cv.Mat();
    cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY, 0);

    // Binary threshold
    const binary = new cv.Mat();
    cv.threshold(gray, binary, 127, 255, cv.THRESH_BINARY);

    // Erosion
    const eroded = new cv.Mat();
    const kernel = cv.getStructuringElement(cv.MORPH_RECT, new cv.Size(3, 3));
    cv.erode(binary, eroded, kernel);
    cv.imshow('erodedCanvas', eroded);

    // Dilation
    const dilated = new cv.Mat();
    cv.dilate(binary, dilated, kernel);
    cv.imshow('dilatedCanvas', dilated);

    // Opening (Erosion followed by Dilation)
    const opened = new cv.Mat();
    cv.morphologyEx(binary, opened, cv.MORPH_OPEN, kernel);
    cv.imshow('openedCanvas', opened);

    // Closing (Dilation followed by Erosion)
    const closed = new cv.Mat();
    cv.morphologyEx(binary, closed, cv.MORPH_CLOSE, kernel);
    cv.imshow('closedCanvas', closed);

    // Clean up
    src.delete();
    gray.delete();
    binary.delete();
    eroded.delete();
    dilated.delete();
    opened.delete();
    closed.delete();
    kernel.delete();
}

// 7. Face Detection
function faceDetection() {
    console.log('\n=== Face Detection ===');

    const imgElement = document.getElementById('inputImage');
    const src = cv.imread(imgElement);
    const gray = new cv.Mat();

    // Convert to grayscale
    cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY, 0);

    // Load face cascade classifier
    const faceCascade = new cv.CascadeClassifier();
    faceCascade.load('haarcascade_frontalface_default.xml');

    // Detect faces
    const faces = new cv.RectVector();
    const msize = new cv.Size(0, 0);
    faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0);

    // Draw rectangles around faces
    for (let i = 0; i < faces.size(); ++i) {
        const face = faces.get(i);
        const point1 = new cv.Point(face.x, face.y);
        const point2 = new cv.Point(face.x + face.width, face.y + face.height);
        cv.rectangle(src, point1, point2, [255, 0, 0, 255], 3);
    }

    cv.imshow('faceDetectionCanvas', src);

    console.log(`Detected ${faces.size()} faces`);

    // Clean up
    src.delete();
    gray.delete();
    faces.delete();
    faceCascade.delete();
}

// 8. Object Detection with Template Matching
function templateMatching() {
    console.log('\n=== Template Matching ===');

    const mainImageElement = document.getElementById('mainImage');
    const templateElement = document.getElementById('templateImage');

    const mainImage = cv.imread(mainImageElement);
    const template = cv.imread(templateElement);
    const grayMain = new cv.Mat();
    const grayTemplate = new cv.Mat();

    // Convert to grayscale
    cv.cvtColor(mainImage, grayMain, cv.COLOR_RGBA2GRAY, 0);
    cv.cvtColor(template, grayTemplate, cv.COLOR_RGBA2GRAY, 0);

    // Template matching
    const result = new cv.Mat();
    cv.matchTemplate(grayMain, grayTemplate, result, cv.TM_CCOEFF_NORMED);

    // Find best match
    const minMax = cv.minMaxLoc(result);
    const maxLoc = minMax.maxLoc;
    const color = new cv.Scalar(255, 0, 0, 255);

    // Draw rectangle around match
    const point1 = maxLoc;
    const point2 = new cv.Point(maxLoc.x + template.cols, maxLoc.y + template.rows);
    cv.rectangle(mainImage, point1, point2, color, 2, cv.LINE_8, 0);

    cv.imshow('templateMatchCanvas', mainImage);

    console.log(`Template match found at (${maxLoc.x}, ${maxLoc.y}) with confidence ${minMax.maxVal.toFixed(4)}`);

    // Clean up
    mainImage.delete();
    template.delete();
    grayMain.delete();
    grayTemplate.delete();
    result.delete();
}

// 9. Color Detection and Segmentation
function colorDetection() {
    console.log('\n=== Color Detection ===');

    const imgElement = document.getElementById('inputImage');
    const src = cv.imread(imgElement);
    const hsv = new cv.Mat();

    // Convert to HSV color space
    cv.cvtColor(src, hsv, cv.COLOR_RGBA2RGB);
    cv.cvtColor(hsv, hsv, cv.COLOR_RGB2HSV);

    // Define range for blue color (adjust as needed)
    const lower = new cv.Mat(hsv.rows, hsv.cols, hsv.type(), [100, 50, 50, 0]);
    const upper = new cv.Mat(hsv.rows, hsv.cols, hsv.type(), [130, 255, 255, 255]);

    // Create mask
    const mask = new cv.Mat();
    cv.inRange(hsv, lower, upper, mask);

    // Apply mask to original image
    const result = new cv.Mat();
    src.copyTo(result, mask);

    cv.imshow('colorDetectionCanvas', result);
    cv.imshow('colorMaskCanvas', mask);

    // Find contours
    const contours = new cv.MatVector();
    const hierarchy = new cv.Mat();
    cv.findContours(mask, contours, hierarchy, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE);

    // Draw contours
    const contourImage = src.clone();
    for (let i = 0; i < contours.size(); ++i) {
        const color = new cv.Scalar(Math.random() * 255, Math.random() * 255, Math.random() * 255, 255);
        cv.drawContours(contourImage, contours, i, color, 2, cv.LINE_8, hierarchy, 100);
    }

    cv.imshow('contoursCanvas', contourImage);

    console.log(`Found ${contours.size()} blue objects`);

    // Clean up
    src.delete();
    hsv.delete();
    lower.delete();
    upper.delete();
    mask.delete();
    result.delete();
    contours.delete();
    hierarchy.delete();
    contourImage.delete();
}

// 10. Image Histogram Analysis
function histogramAnalysis() {
    console.log('\n=== Histogram Analysis ===');

    const imgElement = document.getElementById('inputImage');
    const src = cv.imread(imgElement);

    // Calculate histogram for each channel
    const histSize = [256];
    const ranges = [0, 255];
    const channels = [0, 1, 2];

    const hist = new cv.MatVector();
    const mask = new cv.Mat(); // Empty mask
    cv.calcHist(src, channels, mask, hist, histSize, ranges);

    // Create histogram visualization
    const histW = 512;
    const histH = 400;
    const histImage = new cv.Mat.zeros(histH, histW, cv.CV_8UC3);

    // Normalize histogram
    cv.normalize(hist, hist, 0, histImage.rows, cv.NORM_MINMAX);

    // Draw histogram lines
    const binW = Math.round(histW / histSize[0]);
    for (let i = 1; i < histSize[0]; i++) {
        const h = Math.round(hist.get(0, i, 0));
        const h1 = Math.round(hist.get(0, i - 1, 0));
        cv.line(histImage, new cv.Point((i - 1) * binW, histH - h1),
                        new cv.Point(i * binW, histH - h),
                        new cv.Scalar(255, 0, 0, 255), 2, cv.LINE_8, 0);
    }

    cv.imshow('histogramCanvas', histImage);

    // Calculate image statistics
    const mean = cv.mean(src);
    const stddev = new cv.Mat();
    const mean2 = new cv.Mat();
    cv.meanStdDev(src, mean2, stddev);

    console.log('Image Statistics:');
    console.log(`Mean (R,G,B,A): (${mean[0].toFixed(2)}, ${mean[1].toFixed(2)}, ${mean[2].toFixed(2)}, ${mean[3].toFixed(2)})`);
    console.log(`Std Dev: (${stddev.floatAt(0, 0).toFixed(2)}, ${stddev.floatAt(0, 1).toFixed(2)}, ${stddev.floatAt(0, 2).toFixed(2)})`);

    // Clean up
    src.delete();
    hist.delete();
    mask.delete();
    histImage.delete();
    stddev.delete();
    mean2.delete();
}

// 11. Utility Functions
class OpenCVUtils {
    static loadImageFromFile(file, callback) {
        const reader = new FileReader();
        reader.onload = function(e) {
            const imgElement = document.createElement('img');
            imgElement.onload = function() {
                callback(imgElement);
            };
            imgElement.src = e.target.result;
        };
        reader.readAsDataURL(file);
    }

    static downloadCanvas(canvasId, filename) {
        const canvas = document.getElementById(canvasId);
        const link = document.createElement('a');
        link.download = filename;
        link.href = canvas.toDataURL();
        link.click();
    }

    static getCanvasImageData(canvasId) {
        const canvas = document.getElementById(canvasId);
        const ctx = canvas.getContext('2d');
        return ctx.getImageData(0, 0, canvas.width, canvas.height);
    }

    static performanceTimer(start) {
        const end = performance.now();
        return (end - start).toFixed(2) + 'ms';
    }

    static logMemoryUsage() {
        if (performance.memory) {
            console.log('Memory Usage:', {
                used: (performance.memory.usedJSHeapSize / 1048576).toFixed(2) + ' MB',
                total: (performance.memory.totalJSHeapSize / 1048576).toFixed(2) + ' MB',
                limit: (performance.memory.jsHeapSizeLimit / 1048576).toFixed(2) + ' MB'
            });
        }
    }
}

// Main function to run all examples
function runBasicExamples() {
    console.log('Starting OpenCV.js Basic Examples...');

    // Wait for images to load
    setTimeout(() => {
        const startTime = performance.now();

        try {
            basicImageOperations();
            imageFiltering();
            geometricTransformations();
            morphologicalOperations();
            colorDetection();
            histogramAnalysis();

            console.log('\nAll basic examples completed successfully!');
            console.log('Total execution time:', OpenCVUtils.performanceTimer(startTime));
            OpenCVUtils.logMemoryUsage();

        } catch (error) {
            console.error('Error running examples:', error);
        }
    }, 1000);
}

// Export functions for external use
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        loadImageAndDisplay,
        basicImageOperations,
        imageFiltering,
        geometricTransformations,
        morphologicalOperations,
        faceDetection,
        templateMatching,
        colorDetection,
        histogramAnalysis,
        OpenCVUtils
    };
}

console.log('OpenCV.js Basic Samples module loaded');
console.log('Make sure to include OpenCV.js in your HTML: <script async src="https://docs.opencv.org/4.5.0/opencv.js"></script>');
代码javascript中等

使用OpenCV.js进行视频处理

使用WebRTC和OpenCV.js进行实时视频处理、对象跟踪和运动检测

难度

7/10

预计时间

40 min

标签

opencv, video, real-time, webcam

前置条件

Advanced JavaScript, WebRTC, OpenCV basics

javascript
// Video Processing with OpenCV.js

let cv;
let video;
let canvas;
let canvasContext;
let streaming = false;
let processingEnabled = true;

// 1. Initialize Video Capture
class VideoProcessor {
    constructor(videoId, canvasId) {
        this.video = document.getElementById(videoId);
        this.canvas = document.getElementById(canvasId);
        this.ctx = this.canvas.getContext('2d');
        this.cap = new cv.VideoCapture(this.video);
        this.processingEnabled = true;
        this.currentFilter = 'normal';
    }

    // Start video stream
    async startVideo() {
        try {
            const stream = await navigator.mediaDevices.getUserMedia({
                video: { width: 640, height: 480 },
                audio: false
            });

            this.video.srcObject = stream;
            this.video.play();

            this.video.addEventListener('loadeddata', () => {
                this.canvas.width = this.video.videoWidth;
                this.canvas.height = this.video.videoHeight;
                streaming = true;
                this.processVideo();
            });

            console.log('Video stream started successfully');
        } catch (error) {
            console.error('Error accessing camera:', error);
        }
    }

    // Stop video stream
    stopVideo() {
        if (this.video.srcObject) {
            this.video.srcObject.getTracks().forEach(track => track.stop());
            this.video.srcObject = null;
            streaming = false;
        }
    }

    // Main processing loop
    processVideo() {
        if (!streaming || !this.processingEnabled) {
            requestAnimationFrame(() => this.processVideo());
            return;
        }

        // Capture frame from video
        const src = new cv.Mat(this.video.height, this.video.width, cv.CV_8UC4);
        this.cap.read(src);

        // Apply selected filter
        let dst = src.clone();
        switch (this.currentFilter) {
            case 'grayscale':
                dst = this.applyGrayscale(src);
                break;
            case 'edge':
                dst = this.applyEdgeDetection(src);
                break;
            case 'blur':
                dst = this.applyBlur(src);
                break;
            case 'cartoon':
                dst = this.applyCartoonEffect(src);
                break;
            case 'motion':
                dst = this.detectMotion(src);
                break;
            default:
                dst = src;
        }

        // Display result
        cv.imshow(this.canvas, dst);

        // Clean up
        if (dst !== src) dst.delete();
        src.delete();

        // Continue processing
        requestAnimationFrame(() => this.processVideo());
    }

    // Apply grayscale filter
    applyGrayscale(src) {
        const gray = new cv.Mat();
        cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY);
        const dst = new cv.Mat();
        cv.cvtColor(gray, dst, cv.COLOR_GRAY2RGBA);
        gray.delete();
        return dst;
    }

    // Apply edge detection
    applyEdgeDetection(src) {
        const gray = new cv.Mat();
        cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY);
        const edges = new cv.Mat();
        cv.Canny(gray, edges, 50, 150);
        const dst = new cv.Mat();
        cv.cvtColor(edges, dst, cv.COLOR_GRAY2RGBA);
        gray.delete();
        edges.delete();
        return dst;
    }

    // Apply blur filter
    applyBlur(src) {
        const dst = new cv.Mat();
        const ksize = new cv.Size(15, 15);
        cv.GaussianBlur(src, dst, ksize, 0, 0, cv.BORDER_DEFAULT);
        return dst;
    }

    // Apply cartoon effect
    applyCartoonEffect(src) {
        const gray = new cv.Mat();
        cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY);

        // Apply bilateral filter multiple times
        let filtered = new cv.Mat();
        cv.bilateralFilter(src, filtered, 15, 80, 80, cv.BORDER_DEFAULT);

        for (let i = 0; i < 2; i++) {
            const temp = filtered.clone();
            cv.bilateralFilter(temp, filtered, 15, 80, 80, cv.BORDER_DEFAULT);
            temp.delete();
        }

        // Create edges
        const edges = new cv.Mat();
        const gray2 = new cv.Mat();
        cv.cvtColor(filtered, gray2, cv.COLOR_RGBA2GRAY);
        cv.medianBlur(gray2, edges, 5);
        const adaptive = new cv.Mat();
        cv.adaptiveThreshold(gray2, adaptive, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY, 9, 2);

        // Combine edges and filtered image
        const dst = new cv.Mat();
        cv.bitwise_and(filtered, filtered, dst, adaptive);

        // Clean up
        gray.delete();
        filtered.delete();
        edges.delete();
        gray2.delete();
        adaptive.delete();

        return dst;
    }

    // Motion detection
    detectMotion(src) {
        if (!this.previousFrame) {
            this.previousFrame = new cv.Mat();
            cv.cvtColor(src, this.previousFrame, cv.COLOR_RGBA2GRAY);
            return src;
        }

        const gray = new cv.Mat();
        cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY);

        // Calculate difference
        const diff = new cv.Mat();
        cv.absdiff(gray, this.previousFrame, diff);

        // Threshold
        const thresh = new cv.Mat();
        cv.threshold(diff, thresh, 25, 255, cv.THRESH_BINARY);

        // Find contours
        const contours = new cv.MatVector();
        const hierarchy = new cv.Mat();
        cv.findContours(thresh, contours, hierarchy, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE);

        // Draw rectangles around moving objects
        const dst = src.clone();
        for (let i = 0; i < contours.size(); ++i) {
            const contour = contours.get(i);
            const area = cv.contourArea(contour);

            if (area > 500) { // Filter small movements
                const rect = cv.boundingRect(contour);
                const point1 = new cv.Point(rect.x, rect.y);
                const point2 = new cv.Point(rect.x + rect.width, rect.y + rect.height);
                cv.rectangle(dst, point1, point2, [0, 255, 0, 255], 2);
            }
        }

        // Update previous frame
        this.previousFrame.delete();
        this.previousFrame = gray.clone();

        // Clean up
        gray.delete();
        diff.delete();
        thresh.delete();
        contours.delete();
        hierarchy.delete();

        return dst;
    }

    // Set filter
    setFilter(filterName) {
        this.currentFilter = filterName;
        console.log('Filter changed to:', filterName);
    }

    // Toggle processing
    toggleProcessing() {
        this.processingEnabled = !this.processingEnabled;
        console.log('Processing enabled:', this.processingEnabled);
    }

    // Take snapshot
    takeSnapshot() {
        const dataURL = this.canvas.toDataURL('image/png');
        const link = document.createElement('a');
        link.download = `snapshot_${Date.now()}.png`;
        link.href = dataURL;
        link.click();
        console.log('Snapshot saved');
    }
}

// 2. Face Detection in Video
class FaceDetectionVideo {
    constructor(videoId, canvasId) {
        this.video = document.getElementById(videoId);
        this.canvas = document.getElementById(canvasId);
        this.cap = new cv.VideoCapture(this.video);
        this.faceCascade = null;
        this.eyeCascade = null;
        this.detectionEnabled = true;
    }

    async initialize() {
        try {
            // Load cascade classifiers
            this.faceCascade = new cv.CascadeClassifier();
            this.faceCascade.load('haarcascade_frontalface_default.xml');

            this.eyeCascade = new cv.CascadeClassifier();
            this.eyeCascade.load('haarcascade_eye.xml');

            console.log('Face detection models loaded');
            return true;
        } catch (error) {
            console.error('Error loading face detection models:', error);
            return false;
        }
    }

    startDetection() {
        const processFrame = () => {
            if (!this.detectionEnabled) {
                requestAnimationFrame(processFrame);
                return;
            }

            const src = new cv.Mat(this.video.height, this.video.width, cv.CV_8UC4);
            const gray = new cv.Mat();
            this.cap.read(src);

            // Convert to grayscale
            cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY, 0);

            // Detect faces
            const faces = new cv.RectVector();
            this.faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0);

            // Draw rectangles around faces and detect eyes
            for (let i = 0; i < faces.size(); ++i) {
                const face = faces.get(i);
                const point1 = new cv.Point(face.x, face.y);
                const point2 = new cv.Point(face.x + face.width, face.y + face.height);
                cv.rectangle(src, point1, point2, [255, 0, 0, 255], 3);

                // Detect eyes within face region
                const faceROI = gray.roi(face);
                const eyes = new cv.RectVector();
                this.eyeCascade.detectMultiScale(faceROI, eyes, 1.1, 10, 0);

                // Draw eye rectangles
                for (let j = 0; j < eyes.size(); ++j) {
                    const eye = eyes.get(j);
                    const eyePoint1 = new cv.Point(
                        face.x + eye.x,
                        face.y + eye.y
                    );
                    const eyePoint2 = new cv.Point(
                        face.x + eye.x + eye.width,
                        face.y + eye.y + eye.height
                    );
                    cv.rectangle(src, eyePoint1, eyePoint2, [0, 255, 255, 255], 2);
                }

                faceROI.delete();
                eyes.delete();
            }

            cv.imshow(this.canvas, src);

            // Display face count
            document.getElementById('faceCount').textContent = faces.size();

            src.delete();
            gray.delete();
            faces.delete();

            requestAnimationFrame(processFrame);
        };

        processFrame();
    }

    toggleDetection() {
        this.detectionEnabled = !this.detectionEnabled;
        console.log('Face detection enabled:', this.detectionEnabled);
    }
}

// 3. Object Tracking
class ObjectTracker {
    constructor(videoId, canvasId) {
        this.video = document.getElementById(videoId);
        this.canvas = document.getElementById(canvasId);
        this.cap = new cv.VideoCapture(this.video);
        this.tracker = null;
        this.tracking = false;
        this.roi = null;
    }

    initializeTracker(trackerType = 'KCF') {
        const trackerTypes = ['BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW', 'GOTURN', 'MOSSE', 'CSRT'];
        const trackerTypeIndex = trackerTypes.indexOf(trackerType);

        if (trackerTypeIndex === -1) {
            console.error('Invalid tracker type');
            return false;
        }

        try {
            this.tracker = new cv.TrackerCSRT_create(); // CSRT is more reliable
            console.log(`${trackerType} tracker initialized`);
            return true;
        } catch (error) {
            console.error('Error initializing tracker:', error);
            return false;
        }
    }

    selectROI(event) {
        if (!this.tracker) {
            alert('Please initialize tracker first');
            return;
        }

        const rect = cv.selectROI('ObjectTracking', this.video, false, false);
        if (rect.width > 0 && rect.height > 0) {
            this.roi = rect;
            this.startTracking();
        }
    }

    startTracking() {
        if (!this.tracker || !this.roi) return;

        // Initialize tracker with ROI
        this.tracker.init(this.roi, this.cap.read());
        this.tracking = true;
        this.track();
    }

    track() {
        if (!this.tracking) return;

        const processFrame = () => {
            if (!this.tracking) return;

            const frame = this.cap.read();
            if (frame.empty) {
                console.log('Video ended');
                return;
            }

            // Update tracker
            const ok = this.tracker.update(frame);

            if (ok) {
                // Draw tracked object
                const trackedRect = this.tracker.getRegion();
                cv.rectangle(frame,
                    new cv.Point(trackedRect.x, trackedRect.y),
                    new cv.Point(trackedRect.x + trackedRect.width, trackedRect.y + trackedRect.height),
                    [0, 255, 0, 255], 3);
            } else {
                cv.putText(frame, 'Tracking failure detected', new cv.Point(100, 80),
                    cv.FONT_HERSHEY_SIMPLEX, 0.75, [0, 0, 255, 255], 2);
            }

            cv.imshow(this.canvas, frame);
            frame.delete();

            requestAnimationFrame(processFrame);
        };

        processFrame();
    }

    stopTracking() {
        this.tracking = false;
        console.log('Tracking stopped');
    }
}

// 4. Motion Detection and Alert System
class MotionDetector {
    constructor(videoId, canvasId) {
        this.video = document.getElementById(videoId);
        this.canvas = document.getElementById(canvasId);
        this.cap = new cv.VideoCapture(this.video);
        this.previousFrame = null;
        this.motionThreshold = 25;
        this.minContourArea = 500;
        this.alertCallback = null;
        this.detectionEnabled = true;
        this.motionHistory = [];
        this.maxHistoryLength = 10;
    }

    setAlertCallback(callback) {
        this.alertCallback = callback;
    }

    startDetection() {
        const processFrame = () => {
            if (!this.detectionEnabled) {
                requestAnimationFrame(processFrame);
                return;
            }

            const frame = this.cap.read();
            if (frame.empty) {
                requestAnimationFrame(processFrame);
                return;
            }

            const gray = new cv.Mat();
            cv.cvtColor(frame, gray, cv.COLOR_RGBA2GRAY, 0);
            cv.GaussianBlur(gray, gray, new cv.Size(21, 21), 0);

            let motionDetected = false;
            const output = frame.clone();

            if (this.previousFrame) {
                // Calculate difference
                const diff = new cv.Mat();
                cv.absdiff(gray, this.previousFrame, diff);

                // Threshold
                const thresh = new cv.Mat();
                cv.threshold(diff, thresh, this.motionThreshold, 255, cv.THRESH_BINARY);

                // Dilate to fill holes
                const dilated = new cv.Mat();
                cv.dilate(thresh, dilated, cv.getStructuringElement(cv.MORPH_RECT, new cv.Size(7, 7)));

                // Find contours
                const contours = new cv.MatVector();
                const hierarchy = new cv.Mat();
                cv.findContours(dilated, contours, hierarchy, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE);

                let totalMotionArea = 0;
                for (let i = 0; i < contours.size(); ++i) {
                    const contour = contours.get(i);
                    const area = cv.contourArea(contour);

                    if (area > this.minContourArea) {
                        motionDetected = true;
                        totalMotionArea += area;

                        // Draw bounding rectangle
                        const rect = cv.boundingRect(contour);
                        cv.rectangle(output,
                            new cv.Point(rect.x, rect.y),
                            new cv.Point(rect.x + rect.width, rect.y + rect.height),
                            [0, 255, 0, 255], 2);
                    }
                }

                // Update motion history
                this.motionHistory.push({
                    detected: motionDetected,
                    area: totalMotionArea,
                    timestamp: Date.now()
                });

                if (this.motionHistory.length > this.maxHistoryLength) {
                    this.motionHistory.shift();
                }

                // Trigger alert if significant motion
                if (motionDetected && totalMotionArea > 5000) {
                    if (this.alertCallback) {
                        this.alertCallback({
                            detected: true,
                            area: totalMotionArea,
                            timestamp: Date.now()
                        });
                    }

                    // Draw alert text
                    cv.putText(output, 'MOTION DETECTED', new cv.Point(10, 30),
                        cv.FONT_HERSHEY_SIMPLEX, 1, [0, 0, 255, 255], 2);
                }

                // Display motion indicator
                const motionLevel = Math.min(255, totalMotionArea / 100);
                cv.rectangle(output, new cv.Point(10, output.rows - 40),
                    new cv.Point(10 + motionLevel, output.rows - 20),
                    [0, motionLevel, 255 - motionLevel, 255], -1);

                // Clean up
                diff.delete();
                thresh.delete();
                dilated.delete();
                contours.delete();
                hierarchy.delete();
            }

            // Update previous frame
            if (this.previousFrame) {
                this.previousFrame.delete();
            }
            this.previousFrame = gray.clone();

            cv.imshow(this.canvas, output);

            frame.delete();
            output.delete();

            requestAnimationFrame(processFrame);
        };

        processFrame();
    }

    getMotionStatistics() {
        if (this.motionHistory.length === 0) {
            return { averageMotion: 0, motionFrequency: 0 };
        }

        const recentMotion = this.motionHistory.slice(-5);
        const motionCount = recentMotion.filter(m => m.detected).length;
        const averageArea = recentMotion.reduce((sum, m) => sum + m.area, 0) / recentMotion.length;

        return {
            motionFrequency: (motionCount / recentMotion.length) * 100,
            averageMotionArea: averageArea
        };
    }
}

// 5. Video Recorder
class VideoRecorder {
    constructor(canvasId) {
        this.canvas = document.getElementById(canvasId);
        this.mediaRecorder = null;
        this.recordedChunks = [];
        this.recording = false;
    }

    startRecording() {
        if (this.recording) return;

        const stream = this.canvas.captureStream(30); // 30 FPS
        this.mediaRecorder = new MediaRecorder(stream, {
            mimeType: 'video/webm'
        });

        this.recordedChunks = [];

        this.mediaRecorder.ondataavailable = (event) => {
            if (event.data.size > 0) {
                this.recordedChunks.push(event.data);
            }
        };

        this.mediaRecorder.onstop = () => {
            const blob = new Blob(this.recordedChunks, {
                type: 'video/webm'
            });
            const url = URL.createObjectURL(blob);
            const link = document.createElement('a');
            link.href = url;
            link.download = `recording_${Date.now()}.webm`;
            link.click();
            URL.revokeObjectURL(url);
        };

        this.mediaRecorder.start();
        this.recording = true;
        console.log('Recording started');
    }

    stopRecording() {
        if (!this.recording || !this.mediaRecorder) return;

        this.mediaRecorder.stop();
        this.recording = false;
        console.log('Recording stopped');
    }

    isRecording() {
        return this.recording;
    }
}

// 6. Initialize all components
function initializeVideoProcessing() {
    console.log('Initializing Video Processing...');

    // Wait for OpenCV to load
    if (typeof cv === 'undefined') {
        setTimeout(initializeVideoProcessing, 100);
        return;
    }

    // Initialize video processor
    const videoProcessor = new VideoProcessor('videoInput', 'canvasOutput');
    videoProcessor.startVideo();

    // Set up filter buttons
    document.querySelectorAll('.filter-btn').forEach(btn => {
        btn.addEventListener('click', () => {
            videoProcessor.setFilter(btn.dataset.filter);
        });
    });

    // Set up snapshot button
    document.getElementById('snapshotBtn').addEventListener('click', () => {
        videoProcessor.takeSnapshot();
    });

    // Initialize face detection
    const faceDetector = new FaceDetectionVideo('videoInput', 'faceCanvas');
    faceDetector.initialize().then(success => {
        if (success) {
            faceDetector.startDetection();
        }
    });

    // Initialize motion detector
    const motionDetector = new MotionDetector('videoInput', 'motionCanvas');
    motionDetector.setAlertCallback((alert) => {
        console.log('Motion Alert:', alert);
        document.getElementById('motionAlert').textContent =
            `Motion detected! Area: ${alert.area.toFixed(0)} pixels`;
    });
    motionDetector.startDetection();

    // Initialize video recorder
    const videoRecorder = new VideoRecorder('canvasOutput');

    document.getElementById('recordBtn').addEventListener('click', () => {
        if (videoRecorder.isRecording()) {
            videoRecorder.stopRecording();
            document.getElementById('recordBtn').textContent = 'Start Recording';
        } else {
            videoRecorder.startRecording();
            document.getElementById('recordBtn').textContent = 'Stop Recording';
        }
    });

    console.log('Video processing initialized successfully');
}

// Export classes for external use
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        VideoProcessor,
        FaceDetectionVideo,
        ObjectTracker,
        MotionDetector,
        VideoRecorder
    };
}

// Auto-initialize when page loads
document.addEventListener('DOMContentLoaded', () => {
    initializeVideoProcessing();
});

console.log('OpenCV.js Video Processing module loaded');
代码javascript复杂

高级OpenCV应用

高级计算机视觉应用,包括AR效果、条形码扫描和图像拼接

难度

9/10

预计时间

50 min

标签

opencv, ar, barcode, panorama, 3d, gesture

前置条件

Expert JavaScript, Computer Vision, 3D Graphics

javascript
// Advanced OpenCV.js Applications

let cv;

// 1. Augmented Reality Face Filters
class ARFaceFilters {
    constructor(videoId, canvasId) {
        this.video = document.getElementById(videoId);
        this.canvas = document.getElementById(canvasId);
        this.cap = new cv.VideoCapture(this.video);
        this.faceCascade = null;
        this.currentFilter = 'none';
        this.overlayImage = null;
        this.filterEnabled = true;
    }

    async initialize() {
        try {
            this.faceCascade = new cv.CascadeClassifier();
            this.faceCascade.load('haarcascade_frontalface_default.xml');

            // Load filter overlays
            await this.loadFilterImages();

            console.log('AR Face Filters initialized');
            return true;
        } catch (error) {
            console.error('Error initializing AR filters:', error);
            return false;
        }
    }

    async loadFilterImages() {
        const filters = {
            sunglasses: 'path/to/sunglasses.png',
            mustache: 'path/to/mustache.png',
            hat: 'path/to/hat.png',
            mask: 'path/to/mask.png'
        };

        // Preload filter images (would need actual image files)
        for (const [name, path] of Object.entries(filters)) {
            // This would load actual images in practice
            console.log(`Loading filter: ${name}`);
        }
    }

    applyARFilter() {
        if (!this.filterEnabled) return;

        const src = new cv.Mat(this.video.height, this.video.width, cv.CV_8UC4);
        const gray = new cv.Mat();
        this.cap.read(src);

        cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY, 0);

        // Detect faces
        const faces = new cv.RectVector();
        this.faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0);

        // Apply filter to each detected face
        for (let i = 0; i < faces.size(); ++i) {
            const face = faces.get(i);

            switch (this.currentFilter) {
                case 'sunglasses':
                    this.applySunglasses(src, face);
                    break;
                case 'mustache':
                    this.applyMustache(src, face);
                    break;
                case 'hat':
                    this.applyHat(src, face);
                    break;
                case 'mask':
                    this.applyMask(src, face);
                    break;
                case 'beautify':
                    this.beautifyFace(src, face);
                    break;
            }
        }

        cv.imshow(this.canvas, src);

        // Clean up
        src.delete();
        gray.delete();
        faces.delete();
    }

    applySunglasses(image, face) {
        const glassesWidth = face.width * 0.8;
        const glassesHeight = face.height * 0.3;
        const glassesX = face.x + face.width * 0.1;
        const glassesY = face.y + face.height * 0.3;

        // Draw sunglasses (simplified as rectangle)
        const roi = image.roi(new cv.Rect(glassesX, glassesY, glassesWidth, glassesHeight));
        const darkGlasses = roi.clone();
        darkGlasses.setTo([0, 0, 0, 180]); // Dark black with transparency
        darkGlasses.copyTo(roi);

        roi.delete();
        darkGlasses.delete();
    }

    applyMustache(image, face) {
        const mustacheWidth = face.width * 0.4;
        const mustacheHeight = face.height * 0.1;
        const mustacheX = face.x + face.width * 0.3;
        const mustacheY = face.y + face.height * 0.6;

        // Draw mustache
        cv.rectangle(image,
            new cv.Point(mustacheX, mustacheY),
            new cv.Point(mustacheX + mustacheWidth, mustacheY + mustacheHeight),
            [0, 0, 0, 255], -1);
    }

    applyHat(image, face) {
        const hatWidth = face.width * 1.2;
        const hatHeight = face.height * 0.4;
        const hatX = face.x - face.width * 0.1;
        const hatY = face.y - face.height * 0.3;

        // Draw hat
        cv.rectangle(image,
            new cv.Point(hatX, hatY),
            new cv.Point(hatX + hatWidth, hatY + hatHeight),
            [128, 0, 128, 255], -1);
    }

    applyMask(image, face) {
        const maskWidth = face.width * 0.9;
        const maskHeight = face.height * 0.3;
        const maskX = face.x + face.width * 0.05;
        const maskY = face.y + face.height * 0.4;

        // Draw medical mask
        cv.rectangle(image,
            new cv.Point(maskX, maskY),
            new cv.Point(maskX + maskWidth, maskY + maskHeight),
            [200, 200, 200, 255], -1);
    }

    beautifyFace(image, face) {
        const roi = image.roi(face);
        const beautified = roi.clone();

        // Apply subtle smoothing
        cv.bilateralFilter(beautified, beautified, 15, 30, 30, cv.BORDER_DEFAULT);

        // Slight brightness adjustment
        beautified.convertTo(beautified, -1, 1.1, 10);

        beautified.copyTo(roi);

        roi.delete();
        beautified.delete();
    }

    start() {
        const process = () => {
            if (this.filterEnabled) {
                this.applyARFilter();
            }
            requestAnimationFrame(process);
        };
        process();
    }

    setFilter(filterName) {
        this.currentFilter = filterName;
        console.log('AR Filter changed to:', filterName);
    }

    toggleFilter() {
        this.filterEnabled = !this.filterEnabled;
    }
}

// 2. Barcode and QR Code Scanner
class BarcodeScanner {
    constructor(videoId, canvasId) {
        this.video = document.getElementById(videoId);
        this.canvas = document.getElementById(canvasId);
        this.cap = new cv.VideoCapture(this.video);
        this.scanning = true;
        this.detectedCodes = [];
        this.onCodeDetected = null;
    }

    startScanning() {
        const processFrame = () => {
            if (!this.scanning) {
                requestAnimationFrame(processFrame);
                return;
            }

            const src = new cv.Mat(this.video.height, this.video.width, cv.CV_8UC4);
            const gray = new cv.Mat();
            this.cap.read(src);

            cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY, 0);

            // Detect barcodes (simplified - would need proper barcode library)
            const barcodes = this.detectBarcodes(gray);

            // Draw bounding boxes
            for (const barcode of barcodes) {
                cv.rectangle(src,
                    new cv.Point(barcode.x, barcode.y),
                    new cv.Point(barcode.x + barcode.width, barcode.y + barcode.height),
                    [0, 255, 0, 255], 3);

                cv.putText(src, barcode.data,
                    new cv.Point(barcode.x, barcode.y - 10),
                    cv.FONT_HERSHEY_SIMPLEX, 0.5, [0, 255, 0, 255], 2);

                // Trigger callback if new code detected
                if (!this.detectedCodes.includes(barcode.data)) {
                    this.detectedCodes.push(barcode.data);
                    if (this.onCodeDetected) {
                        this.onCodeDetected(barcode);
                    }
                }
            }

            cv.imshow(this.canvas, src);

            // Clean up
            src.delete();
            gray.delete();

            requestAnimationFrame(processFrame);
        };

        processFrame();
    }

    detectBarcodes(grayImage) {
        // Simplified barcode detection
        // In practice, you would use a dedicated barcode/QR code library

        const barcodes = [];

        // Apply adaptive threshold
        const binary = new cv.Mat();
        cv.adaptiveThreshold(grayImage, binary, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 11, 2);

        // Find contours
        const contours = new cv.MatVector();
        const hierarchy = new cv.Mat();
        cv.findContours(binary, contours, hierarchy, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE);

        // Filter contours that look like barcodes
        for (let i = 0; i < contours.size(); ++i) {
            const contour = contours.get(i);
            const rect = cv.boundingRect(contour);
            const aspectRatio = rect.width / rect.height;

            // Typical barcode aspect ratios and dimensions
            if (aspectRatio > 2.0 && rect.width > 50 && rect.height > 10) {
                barcodes.push({
                    x: rect.x,
                    y: rect.y,
                    width: rect.width,
                    height: rect.height,
                    data: `BARCODE_${Date.now()}_${i}` // Simulated barcode data
                });
            }
        }

        binary.delete();
        contours.delete();
        hierarchy.delete();

        return barcodes;
    }

    onCodeDetected(callback) {
        this.onCodeDetected = callback;
    }

    clearDetectedCodes() {
        this.detectedCodes = [];
    }

    toggleScanning() {
        this.scanning = !this.scanning;
    }
}

// 3. Image Stitching and Panorama
class ImageStitcher {
    constructor(canvasId) {
        this.canvas = document.getElementById(canvasId);
        this.images = [];
        this.keypoints = [];
        this.descriptors = [];
        this.matcher = null;
    }

    addImage(imageElement) {
        const mat = cv.imread(imageElement);
        this.images.push(mat);

        // Detect keypoints
        const gray = new cv.Mat();
        cv.cvtColor(mat, gray, cv.COLOR_RGBA2GRAY, 0);

        const orb = new cv.ORB(1000);
        const keypoints = new cv.KeyPointVector();
        const descriptors = new cv.Mat();

        orb.detectAndCompute(gray, new cv.Mat(), keypoints, descriptors);

        this.keypoints.push(keypoints);
        this.descriptors.push(descriptors);

        gray.delete();

        console.log(`Added image ${this.images.length} with ${keypoints.size()} keypoints`);
    }

    stitchImages() {
        if (this.images.length < 2) {
            console.error('Need at least 2 images for stitching');
            return null;
        }

        // Match features between consecutive images
        const matches = this.matchFeatures(
            this.descriptors[0],
            this.descriptors[1]
        );

        // Find homography
        const homography = this.findHomography(
            this.keypoints[0],
            this.keypoints[1],
            matches
        );

        // Warp images
        const panorama = this.warpImages(this.images[0], this.images[1], homography);

        // Display result
        cv.imshow(this.canvas, panorama);

        // Clean up
        matches.delete();
        homography.delete();

        return panorama;
    }

    matchFeatures(desc1, desc2) {
        // Use brute-force matcher
        const matcher = new cv.BFMatcher(cv.NORM_HAMMING, false);
        const matches = new cv.DMatchVector();
        matcher.match(desc1, desc2, matches);

        // Filter matches by distance
        const goodMatches = [];
        for (let i = 0; i < matches.size(); ++i) {
            const match = matches.get(i);
            if (match.distance < 30) { // Threshold
                goodMatches.push(match);
            }
        }

        const goodMatchesVector = new cv.DMatchVector();
        goodMatches.forEach(match => goodMatchesVector.push_back(match));

        matches.delete();
        return goodMatchesVector;
    }

    findHomography(kp1, kp2, matches) {
        const srcPoints = [];
        const dstPoints = [];

        for (let i = 0; i < matches.size(); ++i) {
            const match = matches.get(i);
            srcPoints.push(kp1.get(match.queryIdx).pt);
            dstPoints.push(kp2.get(match.trainIdx).pt);
        }

        // Convert to cv.Mat
        const srcMat = cv.matFromArray(srcPoints.length, 1, cv.CV_32FC2,
            srcPoints.flat());
        const dstMat = cv.matFromArray(dstPoints.length, 1, cv.CV_32FC2,
            dstPoints.flat());

        const homography = cv.findHomography(srcMat, dstMat, cv.RANSAC, 5.0);

        srcMat.delete();
        dstMat.delete();

        return homography;
    }

    warpImages(img1, img2, homography) {
        // Get corners of first image
        const corners1 = [
            [0, 0],
            [img1.cols, 0],
            [img1.cols, img1.rows],
            [0, img1.rows]
        ];

        // Transform corners
        const corners2 = [];
        for (const corner of corners1) {
            const mat = cv.matFromArray(1, 1, cv.CV_32FC2, corner);
            const transformed = cv.perspectiveTransform(mat, homography);
            corners2.push(transformed.data32F);
            mat.delete();
            transformed.delete();
        }

        // Calculate output size
        const allCorners = [...corners1, ...corners2];
        const minX = Math.min(...allCorners.map(c => c[0]));
        const minY = Math.min(...allCorners.map(c => c[1]));
        const maxX = Math.max(...allCorners.map(c => c[0]));
        const maxY = Math.max(...allCorners.map(c => c[1]));

        const outputWidth = Math.ceil(maxX - minX);
        const outputHeight = Math.ceil(maxY - minY);

        // Create translation matrix
        const translation = cv.matFromArray(3, 3, cv.CV_64FC1, [
            1, 0, -minX,
            0, 1, -minY,
            0, 0, 1
        ]);

        // Adjust homography
        const adjustedHomography = new cv.Mat();
        cv.gemm(translation, homography, 1, new cv.Mat(), 0, adjustedHomography);

        // Warp images
        const panorama = new cv.Mat();
        cv.warpPerspective(img1, panorama, adjustedHomography,
            new cv.Size(outputWidth, outputHeight));

        // Place second image
        const roi = panorama.roi(new cv.Rect(-minX, -minY, img2.cols, img2.rows));
        img2.copyTo(roi);

        // Clean up
        translation.delete();
        adjustedHomography.delete();
        roi.delete();

        return panorama;
    }

    clearImages() {
        this.images.forEach(img => img.delete());
        this.keypoints.forEach(kp => kp.delete());
        this.descriptors.forEach(desc => desc.delete());

        this.images = [];
        this.keypoints = [];
        this.descriptors = [];
    }
}

// 4. 3D Object Detection (Simplified)
class Object3DDetector {
    constructor(videoId, canvasId) {
        this.video = document.getElementById(videoId);
        this.canvas = document.getElementById(canvasId);
        this.cap = new cv.VideoCapture(this.video);
        this.objects = [];
        this.detectorEnabled = true;
    }

    add3DObject(name, features) {
        this.objects.push({
            name,
            features: features, // Would be SIFT/SURF features in practice
            color: [Math.random() * 255, Math.random() * 255, Math.random() * 255, 255]
        });
    }

    detect3DObjects() {
        const processFrame = () => {
            if (!this.detectorEnabled) {
                requestAnimationFrame(processFrame);
                return;
            }

            const src = new cv.Mat(this.video.height, this.video.width, cv.CV_8UC4);
            const gray = new cv.Mat();
            this.cap.read(src);

            cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY, 0);

            // Simplified 3D object detection
            // In practice, would use feature matching with 3D reconstruction

            const detectedObjects = this.performObjectDetection(gray);

            // Draw detected objects
            for (const obj of detectedObjects) {
                // Draw bounding box
                cv.rectangle(src,
                    new cv.Point(obj.x, obj.y),
                    new cv.Point(obj.x + obj.width, obj.y + obj.height),
                    obj.color, 3);

                // Draw label
                cv.putText(src, obj.name,
                    new cv.Point(obj.x, obj.y - 10),
                    cv.FONT_HERSHEY_SIMPLEX, 0.7, obj.color, 2);

                // Draw 3D axes (simplified)
                this.draw3DAxes(src, obj);
            }

            // Draw coordinate system
            this.drawCoordinateSystem(src);

            cv.imshow(this.canvas, src);

            src.delete();
            gray.delete();

            requestAnimationFrame(processFrame);
        };

        processFrame();
    }

    performObjectDetection(grayImage) {
        // Simplified object detection
        // Would use SURF/BRISK features and matching in practice

        const detectedObjects = [];

        // Use template matching as simplified approach
        for (const obj of this.objects) {
            // This would be proper feature matching in practice
            if (Math.random() > 0.7) { // Simulate detection
                detectedObjects.push({
                    name: obj.name,
                    x: Math.random() * (grayImage.cols - 100),
                    y: Math.random() * (grayImage.rows - 100),
                    width: 80 + Math.random() * 40,
                    height: 80 + Math.random() * 40,
                    color: obj.color,
                    pose: {
                        pitch: Math.random() * 360,
                        yaw: Math.random() * 360,
                        roll: Math.random() * 360
                    }
                });
            }
        }

        return detectedObjects;
    }

    draw3DAxes(image, object) {
        const centerX = object.x + object.width / 2;
        const centerY = object.y + object.height / 2;
        const axisLength = 50;

        // X-axis (red)
        const xEnd = new cv.Point(
            centerX + axisLength * Math.cos(object.pose.yaw * Math.PI / 180),
            centerY + axisLength * Math.sin(object.pose.yaw * Math.PI / 180)
        );
        cv.arrowedLine(image, new cv.Point(centerX, centerY), xEnd, [0, 0, 255, 255], 3);

        // Y-axis (green)
        const yEnd = new cv.Point(
            centerX + axisLength * Math.cos((object.pose.yaw + 90) * Math.PI / 180),
            centerY + axisLength * Math.sin((object.pose.yaw + 90) * Math.PI / 180)
        );
        cv.arrowedLine(image, new cv.Point(centerX, centerY), yEnd, [0, 255, 0, 255], 3);
    }

    drawCoordinateSystem(image) {
        // Draw small coordinate system in corner
        const origin = new cv.Point(50, image.rows - 50);
        const axisLength = 30;

        // X-axis
        const xEnd = new cv.Point(origin.x + axisLength, origin.y);
        cv.arrowedLine(image, origin, xEnd, [255, 0, 0, 255], 2);

        // Y-axis
        const yEnd = new cv.Point(origin.x, origin.y - axisLength);
        cv.arrowedLine(image, origin, yEnd, [0, 255, 0, 255], 2);

        // Labels
        cv.putText(image, 'X', new cv.Point(xEnd.x + 5, xEnd.y),
            cv.FONT_HERSHEY_SIMPLEX, 0.5, [255, 0, 0, 255], 1);
        cv.putText(image, 'Y', new cv.Point(yEnd.x, yEnd.y - 5),
            cv.FONT_HERSHEY_SIMPLEX, 0.5, [0, 255, 0, 255], 1);
    }

    startDetection() {
        this.detect3DObjects();
    }

    toggleDetection() {
        this.detectorEnabled = !this.detectorEnabled;
    }
}

// 5. Gesture Recognition
class GestureRecognizer {
    constructor(videoId, canvasId) {
        this.video = document.getElementById(videoId);
        this.canvas = document.getElementById(canvasId);
        this.cap = new cv.VideoCapture(this.video);
        this.handCascade = null;
        this.currentGesture = 'none';
        this.gestureCallback = null;
        this.recognitionEnabled = true;
        this.gestureHistory = [];
        this.maxHistoryLength = 10;
    }

    async initialize() {
        try {
            // Load hand cascade classifier
            this.handCascade = new cv.CascadeClassifier();
            this.handCascade.load('palm.xml'); // Would need actual palm detection model

            console.log('Gesture Recognizer initialized');
            return true;
        } catch (error) {
            console.error('Error initializing gesture recognizer:', error);
            return false;
        }
    }

    recognizeGestures() {
        const processFrame = () => {
            if (!this.recognitionEnabled) {
                requestAnimationFrame(processFrame);
                return;
            }

            const src = new cv.Mat(this.video.height, this.video.width, cv.CV_8UC4);
            const gray = new cv.Mat();
            this.cap.read(src);

            cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY, 0);

            // Detect hands (simplified)
            const hands = this.detectHands(gray);

            // Recognize gestures
            const gestures = [];
            for (const hand of hands) {
                const gesture = this.classifyGesture(gray, hand);
                gestures.push(gesture);

                // Draw hand and gesture
                cv.rectangle(src,
                    new cv.Point(hand.x, hand.y),
                    new cv.Point(hand.x + hand.width, hand.y + hand.height),
                    [255, 0, 0, 255], 2);

                cv.putText(src, gesture.name,
                    new cv.Point(hand.x, hand.y - 10),
                    cv.FONT_HERSHEY_SIMPLEX, 0.7, [0, 255, 0, 255], 2);
            }

            // Update gesture history
            if (gestures.length > 0) {
                this.gestureHistory.push({
                    gesture: gestures[0].name,
                    confidence: gestures[0].confidence,
                    timestamp: Date.now()
                });

                if (this.gestureHistory.length > this.maxHistoryLength) {
                    this.gestureHistory.shift();
                }

                // Trigger callback if gesture is consistent
                if (this.gestureHistory.length >= 5) {
                    const recentGestures = this.gestureHistory.slice(-3);
                    const consistent = recentGestures.every(g => g.gesture === recentGestures[0].gesture);

                    if (consistent && recentGestures[0].confidence > 0.7) {
                        this.currentGesture = recentGestures[0].gesture;

                        if (this.gestureCallback) {
                            this.gestureCallback({
                                gesture: this.currentGesture,
                                confidence: recentGestures[0].confidence
                            });
                        }
                    }
                }
            }

            // Display current gesture
            cv.putText(src, `Gesture: ${this.currentGesture}`,
                new cv.Point(10, 30),
                cv.FONT_HERSHEY_SIMPLEX, 1, [255, 255, 255, 255], 2);

            cv.imshow(this.canvas, src);

            src.delete();
            gray.delete();

            requestAnimationFrame(processFrame);
        };

        processFrame();
    }

    detectHands(grayImage) {
        // Simplified hand detection
        // In practice, would use skin color detection or specialized hand detector

        const hands = [];

        // Use adaptive threshold to find hand-like regions
        const binary = new cv.Mat();
        cv.adaptiveThreshold(grayImage, binary, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 11, 2);

        // Find contours
        const contours = new cv.MatVector();
        const hierarchy = new cv.Mat();
        cv.findContours(binary, contours, hierarchy, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE);

        // Filter for hand-like contours
        for (let i = 0; i < contours.size(); ++i) {
            const contour = contours.get(i);
            const area = cv.contourArea(contour);
            const hull = new cv.Mat();
            cv.convexHull(contour, hull);

            // Hand characteristics (simplified)
            const hullArea = cv.contourArea(hull);
            const solidity = area / hullArea;

            if (area > 1000 && solidity < 0.9) {
                const rect = cv.boundingRect(contour);
                hands.push({
                    x: rect.x,
                    y: rect.y,
                    width: rect.width,
                    height: rect.height,
                    contour: contour
                });
            }

            hull.delete();
        }

        binary.delete();
        contours.delete();
        hierarchy.delete();

        return hands;
    }

    classifyGesture(grayImage, hand) {
        // Simplified gesture classification
        // In practice, would analyze finger count, hand shape, etc.

        const handROI = grayImage.roi(hand);
        const moments = cv.moments(handROI);

        // Calculate features
        const huMoments = cv.HuMoments(moments);

        // Simple classification based on contour properties
        let gesture = 'unknown';
        let confidence = 0.5;

        // Random gesture assignment for demonstration
        const gestures = ['fist', 'open_palm', 'peace', 'thumbs_up', 'pointing'];
        gesture = gestures[Math.floor(Math.random() * gestures.length)];
        confidence = 0.6 + Math.random() * 0.4;

        handROI.delete();

        return { gesture, confidence };
    }

    onGestureDetected(callback) {
        this.gestureCallback = callback;
    }

    startRecognition() {
        this.recognizeGestures();
    }

    toggleRecognition() {
        this.recognitionEnabled = !this.recognitionEnabled;
    }

    getGestureHistory() {
        return this.gestureHistory;
    }
}

// 6. Initialize all advanced applications
function initializeAdvancedApps() {
    console.log('Initializing Advanced OpenCV Applications...');

    // Wait for OpenCV
    if (typeof cv === 'undefined') {
        setTimeout(initializeAdvancedApps, 100);
        return;
    }

    // Initialize AR Face Filters
    const arFilters = new ARFaceFilters('videoInput', 'arCanvas');
    arFilters.initialize().then(() => {
        arFilters.start();
    });

    // Set up AR filter controls
    document.querySelectorAll('.ar-filter-btn').forEach(btn => {
        btn.addEventListener('click', () => {
            arFilters.setFilter(btn.dataset.filter);
        });
    });

    // Initialize Barcode Scanner
    const barcodeScanner = new BarcodeScanner('videoInput', 'barcodeCanvas');
    barcodeScanner.onCodeDetected((code) => {
        console.log('Barcode detected:', code);
        document.getElementById('barcodeResult').textContent = `Detected: ${code.data}`;
    });
    barcodeScanner.startScanning();

    // Initialize Image Stitcher
    const imageStitcher = new ImageStitcher('panoramaCanvas');

    document.getElementById('addImage1Btn').addEventListener('click', () => {
        const input = document.createElement('input');
        input.type = 'file';
        input.accept = 'image/*';
        input.onchange = (e) => {
            const file = e.target.files[0];
            const reader = new FileReader();
            reader.onload = (event) => {
                const img = document.createElement('img');
                img.onload = () => {
                    imageStitcher.addImage(img);
                };
                img.src = event.target.result;
            };
            reader.readAsDataURL(file);
        };
        input.click();
    });

    document.getElementById('stitchBtn').addEventListener('click', () => {
        imageStitcher.stitchImages();
    });

    // Initialize 3D Object Detector
    const detector3D = new Object3DDetector('videoInput', '3dCanvas');
    detector3D.add3DObject('Cube', { /* features */ });
    detector3D.add3DObject('Sphere', { /* features */ });
    detector3D.startDetection();

    // Initialize Gesture Recognizer
    const gestureRecognizer = new GestureRecognizer('videoInput', 'gestureCanvas');
    gestureRecognizer.initialize().then(() => {
        gestureRecognizer.onGestureDetected((gesture) => {
            console.log('Gesture detected:', gesture);
            document.getElementById('gestureResult').textContent =
                `Gesture: ${gesture.gesture} (Confidence: ${(gesture.confidence * 100).toFixed(1)}%)`;
        });
        gestureRecognizer.startRecognition();
    });

    console.log('Advanced applications initialized');
}

// Export classes for external use
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        ARFaceFilters,
        BarcodeScanner,
        ImageStitcher,
        Object3DDetector,
        GestureRecognizer
    };
}

// Auto-initialize
document.addEventListener('DOMContentLoaded', () => {
    initializeAdvancedApps();
});

console.log('Advanced OpenCV.js Applications module loaded');

工具

经常与该案例搭配使用的工具

相关内容

相关案例集合

相关内容

相关专题

专题

机械传动与机件尺寸初筛

根据传动类型和已知量,为齿轮、带轮、链轮、扭矩或弹簧刚度问题选择合适的计算路径。所有结果都只是初步计算,不是经过认证的设计。

专题

谜题、游戏与随机抽签生成器

生成谜题材料,随机洗牌掷骰,公平抽奖分组,并为轻量比赛建立对阵表或积分榜。

专题

蛋白定量、酶动力学与序列计算器

把蛋白序列性质、BCA/Bradford 浓度估算、酶活单位、动力学、抑制、周转数、催化效率与结合亲和力计算串成教育和研究审阅流程。

专题

重症血气、氧合与血流动力学计算工作流

把动脉血气酸碱分析与氧合、心排血量及血管阻力计算连接起来,用于结构化学习和结果核对。

首页
工具3208
案例593
可视化469
文件查看器103
专题237
标签333
图像、音频与视频657

图像、音频、视频处理、转换与优化工具

数学、日期与金融646

计算器、数值计算、日期逻辑、统计与金融工具

设计与颜色298

颜色、版式、图形、视觉样式与设计辅助工具

文本与写作209

写作、清洗、格式化、提取与文本分析工具

开发与 Web193

开发者工具、网络处理、Web 调试与自动化辅助工具

转换与编码175

格式、文件、压缩包、单位与编码转换工具

本地习惯记录的备份、恢复演练与分享前检查
长文改编 X 串文与 LinkedIn 帖子的事实复核与交付
Markdown 互动课件审校、离线演示与交付
小房间家具布局复核与搬入方案交付
FLAC/WAV 无损音源疑点筛查与证据交付

© 2026 Elysia Tools. 保留所有权利。

文档价格关于我们服务条款隐私政策Cookie 政策联系我们

Media

视频转图片序列

将视频帧提取为图片序列,支持自定义帧率、质量和输出格式

Media

视频图片水印

为视频添加图片水印,可自定义位置、大小、透明度和显示时间

AI Tools

AI 年龄与性别估计

对检测到的人脸进行年龄与性别预测

Media

音频频谱图生成器

上传音频或视频文件,在服务器上生成 PNG 频谱图。可指定像素尺寸和配色,选择是否显示时间、频率和强度标注。

Development

Data URI 生成器

将文件转换为 Data URI(Base64 或百分号编码),用于直接在 HTML、CSS 或 Markdown 中内联图片、字体等资源

Media

视频抽帧器

按固定间隔、自定义时间戳或前 N 帧从视频中抽取静帧——使用快速输入定位,打包 ZIP 下载。

Media

视频变速

更改视频播放速度(更快或更慢),同时保持音频音调

AI Tools

AI 人脸检测

检测图片中的人脸并返回边框坐标

Web 技术

WebRTC 实时通信示例

全面的 WebRTC 示例,用于点对点音视频通信、数据通道、屏幕共享和信令服务器实现

Java

Android Java 图像处理示例

Android Java 图像处理示例,包括图像读取保存、缩放和格式转换

Python

Web Python 图像处理示例

Web Python 图像处理示例,使用 PIL/Pillow 包括读取、保存、缩放和格式转换

C++

Windows C++ 图像处理示例

Windows C++ 图像处理示例,包括读取/保存图像、调整大小和使用Windows Imaging Component进行格式转换

媒体

二维码示例

用于测试二维码读取和生成工具的示例二维码图像

媒体

AVIF示例

不同宽高比和主题的AVIF图像示例,具有现代压缩技术