WebCamera Class Reference

Interface to access the camera in the browser. More...

#include <WebCamera.h>

Public Member Functions
void	open (WebCameraFacing facing)
	Acquires a video stream. More...
bool	isReady ()
	Returns whether the video stream has been acquired. More...
CVMat	read ()
	Reads the current frame. More...
CVSize2i	getSize ()
	Gets the size of the video input. More...
void	setSize (CVSize2i size)
	Requests a video size from the browser. More...
void	close ()
	Closes the video stream. More...
bool	isOpened ()

Private Attributes
bool	_isOpened = false
CVMat	_image
CVMat	_imageBGR
bool	_waitingForResize = false

Detailed Description

Interface to access the camera in the browser.

Definition at line 25 of file WebCamera.h.

Member Function Documentation

close()

void WebCamera::close

(

)

Closes the video stream.

After calling this function, the camera must be reopened before accessing any of the other member functions.

Definition at line 192 of file WebCamera.cpp.

{
    // clang-format off
    EM_ASM({
        let video = document.querySelector("#capture-video");
        let stream = video.srcObject;
 
        if (stream === null) {
            console.log("[WebCamera] Stream is already closed");
        }
 
        stream.getVideoTracks().forEach(track => {
            if (track.readyState == "live") {
                track.stop();
                stream.removeTrack(track);
            }
        });
 
        console.log("[WebCamera] Stream closed");
    });
    // clang-format on
}

getSize()

CVSize2i WebCamera::getSize

(

)

Gets the size of the video input.

The size is determined by getting the width and height of the HTML video element.

Returns

The size of the video input

Definition at line 123 of file WebCamera.cpp.

{
    int32_t width;
    int32_t height;
 
    // clang-format off
    EM_ASM({
        let video = document.querySelector("#capture-video");
        let width = video.videoWidth;
        let height = video.videoHeight;
 
        setValue($0, video.videoWidth, "i32");
        setValue($1, video.videoHeight, "i32");
    }, &width, &height);
    // clang-format on
 
    return CVSize2i(width, height);
}

isOpened()

bool WebCamera::isOpened ( )

inline

Definition at line 36 of file WebCamera.h.

{ return _isOpened; }

isReady()

bool WebCamera::isReady

(

)

Returns whether the video stream has been acquired.

The video stream is not immediately available when calling WebCamera::open. This function can be used to determine if the user has allowed camera access and if it is ready for reading.

Returns

True if the stream has been acquired

Definition at line 57 of file WebCamera.cpp.

{
    return _image.cols != 0 && _image.rows != 0;
}

open()

void WebCamera::open

(

WebCameraFacing

facing

)

Acquires a video stream.

Requests a video stream from the browser and assigns it to the HTML video object as soon as it is ready. It must be called before accessing any of the other member functions. The function does not block, so the stream may not be ready yet after it returns.

Parameters

facing

Preferred facing mode on mobile

Definition at line 23 of file WebCamera.cpp.

{
    // clang-format off
    EM_ASM({
        console.log("[WebCamera] Requesting stream...");
 
        let facingMode;
        if ($0 == 0) facingMode = "user";
        else if ($0 == 1) facingMode = "environment";
 
        navigator.mediaDevices.getUserMedia({ "video": { "facingMode": facingMode } })
            .then(stream => {
                console.log("[WebCamera] Stream acquired");
 
                let video = document.querySelector("#capture-video");
                video.srcObject = stream;
            })
            .catch(error => {
                console.log("[WebCamera] Failed to acquire stream");
                console.log(error);
            });
    }, facing);
    // clang-format on
 
    _isOpened = true;
}

read()

CVMat WebCamera::read

(

)

Reads the current frame.

If the video stream is ready, copies the current frame from the video HTML element into a CVMat in BGR format. Returns an empty image otherwise.

Returns

The CVMat containing the image data in BGR format

Definition at line 68 of file WebCamera.cpp.

{
    CVSize2i size = getSize();
 
    // If the width or the height is zero, the video is not ready
    if (size.width == 0 || size.height == 0)
        return CVMat(0, 0, CV_8UC3);
 
    // Recreate the image if the size has changed
    if (size.width != _image.cols || size.height != _image.rows)
    {
        _image            = CVMat(size.height,
                       size.width,
                       CV_8UC4);
        _waitingForResize = false;
    }
 
    // clang-format off
    EM_ASM({
        let video = document.querySelector("#capture-video");
        let canvas = document.querySelector("#capture-canvas");
        
        // the last parameter canvas_will_read_frequently is set to true
        // https://html.spec.whatwg.org/multipage/canvas.html#concept-canvas-will-read-frequently
        let ctx = canvas.getContext("2d", true, false, "srgb", true);
 
        let width = video.videoWidth;
        let height = video.videoHeight;
 
        if (width == 0 || height == 0)
            return;
 
        canvas.width = width;
        canvas.height = height;
        ctx.drawImage(video, 0, 0, width, height);
        let imageData = ctx.getImageData(0, 0, width, height);
 
        writeArrayToMemory(imageData.data, $0);
    }, _image.data);
    // clang-format on
 
    if (_imageBGR.size != _image.size)
        _imageBGR = CVMat(_image.rows, _image.cols, CV_8UC3);
 
    cv::cvtColor(_image, _imageBGR, cv::COLOR_RGBA2BGR);
 
    return _imageBGR;
}

setSize()

void WebCamera::setSize

(

CVSize2i

size

)

Requests a video size from the browser.

The function tries to resize the video size. It is not guaranteed that this will have any effect or that the size after resizing will be equal to the size provided because the browser may not support it.

Parameters

size	Preferred size of the video

Definition at line 149 of file WebCamera.cpp.

{
    // Return if the stream is still loading
    if (!isReady())
        return;
 
    // Return if we are already waiting for the resize
    if (_waitingForResize)
        return;
 
    // Return if the new size is equal to the old size
    if (size.width == _image.cols && size.height == _image.rows)
        return;
 
    _waitingForResize = true;
 
    // clang-format off
    EM_ASM({
        let video = document.querySelector("#capture-video");
        let stream = video.srcObject;
 
        if (stream === null)
            return;
 
        // We can't use object literals because that breaks EM_ASM for some reason
        let constraints = {};
        constraints["width"] = $0;
        constraints["height"] = $1;
 
        stream.getVideoTracks().forEach(track => {
            track.applyConstraints(constraints);
        });
 
        console.log("[WebCamera] Applied resolution " + $0 + "x" + $1);
    }, size.width, size.height);
    // clang-format on
}

Member Data Documentation

_image

CVMat WebCamera::_image

private

Definition at line 40 of file WebCamera.h.

_imageBGR

CVMat WebCamera::_imageBGR

private

Definition at line 41 of file WebCamera.h.

_isOpened

bool WebCamera::_isOpened = false

private

Definition at line 39 of file WebCamera.h.

_waitingForResize

bool WebCamera::_waitingForResize = false

private

Definition at line 42 of file WebCamera.h.

---

The documentation for this class was generated from the following files:

• WebCamera.h
• WebCamera.cpp