SENSWebCamera Class Reference

#include <SENSWebCamera.h>

Inheritance diagram for SENSWebCamera:

Public Member Functions
	SENSWebCamera ()
const SENSCameraConfig &	start (std::string deviceId, const SENSCameraStreamConfig &streamConfig, bool provideIntrinsics=true) override
void	stop () override
	Stop a started camera device. More...
const SENSCaptureProps &	captureProperties () override
	Get SENSCaptureProps which contains necessary information about all available camera devices and their capabilities. More...
void	grab ()
Public Member Functions inherited from SENSBaseCamera
SENSFrameBasePtr	latestFrame () override
	Get the latest captured frame. If no frame was captured the frame will be empty (null). More...
const SENSCameraConfig &	config () const override
	defines how the camera was configured during start More...
void	registerListener (SENSCameraListener *listener) override
void	unregisterListener (SENSCameraListener *listener) override
bool	started () const override
bool	permissionGranted () const override
void	setPermissionGranted () override
Public Member Functions inherited from SENSCamera
virtual	~SENSCamera ()

Private Attributes
cv::VideoCapture	_videoCapture
std::atomic_bool	_stop {false}
std::thread	_cameraThread

Additional Inherited Members
Protected Member Functions inherited from SENSBaseCamera
void	updateFrame (cv::Mat bgrImg, cv::Mat intrinsics, int width, int height, bool intrinsicsChanged)
void	processStart ()
	call from start function to do startup preprocessing More...
Protected Attributes inherited from SENSBaseCamera
SENSCaptureProps	_captureProperties
std::atomic< bool >	_started {false}
	flags if camera was started More...
SENSCameraConfig	_config
	indicates what is currently running More...
std::atomic< bool >	_permissionGranted {false}
std::vector< SENSCameraListener * >	_listeners
std::mutex	_listenerMutex
SENSFrameBasePtr	_frame
	current frame More...
std::mutex	_frameMutex

Detailed Description

Definition at line 11 of file SENSWebCamera.h.

Constructor & Destructor Documentation

SENSWebCamera()

SENSWebCamera::SENSWebCamera ( )

inline

Definition at line 14 of file SENSWebCamera.h.

    {
        _permissionGranted = true;
    }

Member Function Documentation

captureProperties()

const SENSCaptureProps & SENSWebCamera::captureProperties ( )

overridevirtual

Get SENSCaptureProps which contains necessary information about all available camera devices and their capabilities.

Implements SENSCamera.

Definition at line 93 of file SENSWebCamera.cpp.

{
    if (!_captureProperties.size())
    {
        //definition of standard frame sizes that we want to test for support
        static std::vector<cv::Size> testSizes = {
          {640, 480},
          {640, 360},
          {960, 540},
          {1280, 960},
          {1280, 720},
          {1920, 1080}};
 
        //There is an invisible list of devices populated from your os and your webcams appear there in the order you plugged them in.
        //If you're e.g on a laptop with a builtin camera, that will be id 0, if you plug in an additional one, that's id 1.
        for (int i = 0; i < 10; ++i)
        {
            _videoCapture.open(i);
 
            if (_videoCapture.isOpened())
            {
                SENSCameraDeviceProps characteristics(std::to_string(i), SENSCameraFacing::UNKNOWN);
 
                //try some standard capture sizes
                for (auto s : testSizes)
                {
                    _videoCapture.set(cv::CAP_PROP_FRAME_WIDTH, s.width);
                    _videoCapture.set(cv::CAP_PROP_FRAME_HEIGHT, s.height);
                    cv::Mat frame;
                    _videoCapture >> frame;
                    cv::Size newSize = frame.size();
                    if (!characteristics.contains(newSize) &&
                        newSize != cv::Size(0, 0))
                    {
                        //-1 means unknown focal length
                        characteristics.add(newSize.width, newSize.height, -1.f);
                    }
                }
 
                _captureProperties.push_back(characteristics);
                _videoCapture.release();
            }
        }
 
        //if still no caputure properties add a dummy
        if (_captureProperties.size() == 0)
        {
            SENSCameraDeviceProps dummyProps("0", SENSCameraFacing::UNKNOWN);
            dummyProps.add(640, 480, -1.f);
            _captureProperties.push_back(dummyProps);
        }
    }
 
    return _captureProperties;
}

grab()

void SENSWebCamera::grab

(

)

Definition at line 77 of file SENSWebCamera.cpp.

{
    while (!_stop)
    {
        cv::Mat bgrImg;
        if (_videoCapture.read(bgrImg))
        {
            if (bgrImg.cols == _config.streamConfig.widthPix &&
                bgrImg.rows == _config.streamConfig.heightPix)
                updateFrame(bgrImg, cv::Mat(), false, bgrImg.rows, bgrImg.cols);
            else
                LOG_WEBCAM_WARN("video capture delivers wrong resolution!");
        }
    }
}

start()

const SENSCameraConfig & SENSWebCamera::start ( std::string  deviceId, const SENSCameraStreamConfig &  streamConfig, bool  provideIntrinsics = true  )

overridevirtual

Call this function to configure the camera if you exactly know, what device you want to open and with which stream configuration. You can find out these properties by using SENSCaptureProps object (see getCaptureProperties())

Parameters

deviceId	camera device id to start
streamConfig	SENSCameraStreamConfig from camera device. This defines the size of the image. The image is converted to BGR and assigned to SENSFrame::imgBGR.
provideIntrinsics	specifies if intrinsics estimation should be enabled. The estimated intrinsics are transferred with every SENSFrame as they may be different for every frame (e.g. on iOS). This value has different effects on different architectures.

Returns

the found configuration that is adjusted and used when SENSCamera::start() is called.

Implements SENSCamera.

Definition at line 13 of file SENSWebCamera.cpp.

{
    if (_started)
    {
        Utils::warnMsg("SENSWebCamera", "Call to start was ignored. Camera is currently running!", __LINE__, __FILE__);
        return _config;
    }
 
    //retrieve all camera characteristics
    if (_captureProperties.size() == 0)
        captureProperties();
 
    if (_captureProperties.size() == 0)
        throw SENSException(SENSType::CAM, "Could not retrieve camera properties!", __LINE__, __FILE__);
 
    if (!_captureProperties.containsDeviceId(deviceId))
        throw SENSException(SENSType::CAM, "DeviceId does not exist!", __LINE__, __FILE__);
 
    int id = std::stoi(deviceId);
    _videoCapture.open(id);
 
    if (!_videoCapture.isOpened())
        throw SENSException(SENSType::CAM, "Could not open camera with id: " + deviceId, __LINE__, __FILE__);
 
    _videoCapture.set(cv::CAP_PROP_FRAME_WIDTH, streamConfig.widthPix);
    _videoCapture.set(cv::CAP_PROP_FRAME_HEIGHT, streamConfig.heightPix);
    _started           = true;
    _permissionGranted = true;
 
    //init config here
    _config = SENSCameraConfig(deviceId,
                               streamConfig,
                               SENSCameraFacing::UNKNOWN,
                               SENSCameraFocusMode::UNKNOWN);
 
    processStart();
 
    //start thread
    _cameraThread = std::thread(&SENSWebCamera::grab, this);
 
    return _config;
}

stop()

void SENSWebCamera::stop ( )

overridevirtual

Stop a started camera device.

Implements SENSCamera.

Definition at line 58 of file SENSWebCamera.cpp.

{
    _stop = true;
    if (_cameraThread.joinable())
        _cameraThread.join();
    _stop = false;
 
    if (_videoCapture.isOpened())
    {
        _videoCapture.release();
 
        _started = false;
    }
    else
    {
        LOG_WEBCAM_INFO("stop: ignored because camera is not open!");
    }
}

Member Data Documentation

_cameraThread

std::thread SENSWebCamera::_cameraThread

private

Definition at line 33 of file SENSWebCamera.h.

_stop

std::atomic_bool SENSWebCamera::_stop {false}

private

Definition at line 32 of file SENSWebCamera.h.

_videoCapture

cv::VideoCapture SENSWebCamera::_videoCapture

private

Definition at line 30 of file SENSWebCamera.h.

---

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

• SENSWebCamera.h
• SENSWebCamera.cpp