SENSSimulatedCamera Class Reference

#include <SENSSimulated.h>

Inheritance diagram for SENSSimulatedCamera:

Public Member Functions
	~SENSSimulatedCamera ()
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...
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 ()
Public Member Functions inherited from SENSSimulated< int >
virtual	~SENSSimulated ()
Public Member Functions inherited from SENSSimulatedBase
virtual	~SENSSimulatedBase ()

Private Member Functions
	SENSSimulatedCamera (StartSimCB startSimCB, SensorSimStoppedCB sensorSimStoppedCB, std::vector< std::pair< SENSTimePt, int >> &&data, std::string videoFileName, SENSCameraConfig cameraConfig, const SENSSimClock &clock)
void	feedSensorData (const int counter) override
	feed new sensor data to sensor More...
void	prepareSensorData (const int counter) override
void	onLatencyProblem (int &counter) override
	when feeding camera frames from cv::videocapture updating the frame pos may take ages. So we skip one more frame and update the next frame counter More...

Private Attributes
std::string	_videoFileName
cv::VideoCapture	_cap
cv::Mat	_preparedFrame
int	_preparedFrameIndex = -1
cv::Mat	_frame
std::mutex	_frameMutex

Friends
class	SENSSimulator

Additional Inherited Members
Protected Types inherited from SENSSimulated< int >
using	StartSimCB = std::function< void(void)>
using	SensorSimStoppedCB = std::function< void(void)>
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 Member Functions inherited from SENSSimulated< int >
	SENSSimulated (const std::string name, StartSimCB startSimCB, SensorSimStoppedCB sensorSimStoppedCB, std::vector< std::pair< SENSTimePt, int >> &&data, const SENSSimClock &clock)
void	startSim ()
	start the sensor simulation thread More...
void	stopSim ()
	stop the sensor simulation thread More...
bool	getErrorMsg (std::string &msg) override
	get error msg (valid if function returns true) More...
bool	isThreadRunning () const override
	indicates if simulation thread is running 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
Protected Attributes inherited from SENSSimulated< int >
std::vector< std::pair< SENSTimePt, int > >	_data
SensorSimStoppedCB	_sensorSimStoppedCB
StartSimCB	_startSimCB
std::thread	_thread
std::condition_variable	_condVar
std::mutex	_mutex
bool	_stop
SENSTimePt	_commonSimStartTimePt
bool	_threadIsRunning
const SENSSimClock &	_clock
std::string	_name
std::mutex	_msgMutex
std::string	_errorMsg

Detailed Description

SENSSimulatedCamera SENSSimulated implementation for Camera sensor simulation. Implements the SENSBaseCamera interface to make it a full camera sensor and the SENSSimulated interface for the sensor simulation backend.

Definition at line 158 of file SENSSimulated.h.

Constructor & Destructor Documentation

~SENSSimulatedCamera()

SENSSimulatedCamera::~SENSSimulatedCamera

(

)

Definition at line 234 of file SENSSimulated.cpp.

{
    stop();
}

SENSSimulatedCamera()

SENSSimulatedCamera::SENSSimulatedCamera ( StartSimCB  startSimCB, SensorSimStoppedCB  sensorSimStoppedCB, std::vector< std::pair< SENSTimePt, int >> &&  data, std::string  videoFileName, SENSCameraConfig  cameraConfig, const SENSSimClock &  clock  )

private

Definition at line 292 of file SENSSimulated.cpp.

  : SENSSimulated("camera", startSimCB, sensorSimStoppedCB, std::move(data), clock),
    _videoFileName(videoFileName)
{
    _config            = cameraConfig;
    _permissionGranted = true;
}

Member Function Documentation

captureProperties()

const SENSCaptureProps & SENSSimulatedCamera::captureProperties ( )

overridevirtual

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

Implements SENSCamera.

Definition at line 280 of file SENSSimulated.cpp.

{
    if (!_captureProperties.size())
    {
        SENSCameraDeviceProps characteristics(_config.deviceId, _config.facing);
        characteristics.add(_config.streamConfig.widthPix, _config.streamConfig.heightPix, _config.streamConfig.focalLengthPix);
        _captureProperties.push_back(characteristics);
    }
 
    return _captureProperties;
}

feedSensorData()

void SENSSimulatedCamera::feedSensorData ( const int  counter )

overrideprivatevirtual

feed new sensor data to sensor

Implements SENSSimulated< int >.

Definition at line 305 of file SENSSimulated.cpp.

{
    HighResTimer t;
    //prepare if not yet prepared (e.g. when while loop writes multiple lines)
    if (_data[counter].second != _preparedFrameIndex)
    {
        SENS_DEBUG("preparing in feedSensorData");
        prepareSensorData(counter);
    }
 
    updateFrame(_preparedFrame, cv::Mat(), false, _preparedFrame.size().width, _preparedFrame.size().height);
 
    SENS_DEBUG("feedSensorData %lld us", t.elapsedTimeInMicroSec());
}

onLatencyProblem()

void SENSSimulatedCamera::onLatencyProblem ( int &  counter )

overrideprivatevirtual

when feeding camera frames from cv::videocapture updating the frame pos may take ages. So we skip one more frame and update the next frame counter

Reimplemented from SENSSimulated< int >.

Definition at line 351 of file SENSSimulated.cpp.

{
    //Setting the next frame position may take a lot of time.
    //Thats why we need this special treatment for camera feed.
 
    //update the frame pos with current counter and measure needed time
    SENSTimePt t0 = SENSClock::now();
    prepareSensorData(counter);
    SENSTimePt       t1         = SENSClock::now();
    SENSMicroseconds neededTime = std::chrono::duration_cast<SENSMicroseconds>(t1 - t0);
 
    //SENS_DEBUG("update CAP_PROP_POS_FRAMES %d: %lld", counter, t.elapsedTimeInMicroSec());
    counter++;
    SENSTimePt now = _clock.now();
    while (counter < _data.size() - 1 && _data[counter].first < now)
    {
        //when we enter this loop the frame the neededTime for pos update took longer than the availableTime between too values.
        //we measure how much longer and update the counter accordingly
        SENSMicroseconds availableTime = std::chrono::duration_cast<SENSMicroseconds>(_data[counter + 1].first - _data[counter].first);
        auto             factor        = neededTime.count() / availableTime.count();
        factor++;
        SENS_DEBUG("factor %lld neededTime %lld available time %lld", factor, neededTime.count(), availableTime.count());
        counter += factor;
 
        if (counter < _data.size())
        {
            t0 = SENSClock::now();
            prepareSensorData(counter);
            t1         = SENSClock::now();
            neededTime = std::chrono::duration_cast<SENSMicroseconds>(t1 - t0);
        }
 
        now = _clock.now();
    }
}

prepareSensorData()

void SENSSimulatedCamera::prepareSensorData ( const int  counter )

overrideprivatevirtual

prepare things that may take some time for the next writing of sensor data (e.g. for video reading we can already read the frame and do decoding and maybe it also blocks for some reasons..)

Reimplemented from SENSSimulated< int >.

Definition at line 320 of file SENSSimulated.cpp.

{
    if (counter >= _data.size())
        return;
 
    int frameIndex = _data[counter].second;
    if (frameIndex == _preparedFrameIndex)
        return;
 
    HighResTimer t;
 
    int nextFramePos = _cap.get(cv::CAP_PROP_POS_FRAMES);
    if (nextFramePos != frameIndex)
    {
        SENS_DEBUG("updating frame pos");
        _cap.set(cv::CAP_PROP_POS_FRAMES, frameIndex);
    }
 
    cv::Mat frame;
 
    _cap.read(frame);
 
    {
        _preparedFrameIndex = frameIndex;
        std::lock_guard<std::mutex> lock(_frameMutex);
        _preparedFrame = frame;
    }
 
    SENS_DEBUG("prepared index %d: %lld", frameIndex, t.elapsedTimeInMicroSec());
}

start()

const SENSCameraConfig & SENSSimulatedCamera::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 239 of file SENSSimulated.cpp.

{
    if (_started)
    {
        Utils::warnMsg("SENSWebCamera", "Call to start was ignored. Camera is currently running!", __LINE__, __FILE__);
        return _config;
    }
 
    if (!_cap.isOpened())
    {
        if (!_cap.open(_videoFileName))
            throw SENSException(SENSType::CAM, "Could not open camera simulator for filename: " + _videoFileName, __LINE__, __FILE__);
    }
 
    //retrieve all camera characteristics
    if (_captureProperties.size() == 0)
        captureProperties();
 
    //CONFIG SHOULD HAVE BEEN LOADED FROM FILE
 
    processStart();
 
    //start the sensor simulation
    startSim();
 
    _started = true;
 
    return _config;
}

stop()

void SENSSimulatedCamera::stop ( )

overridevirtual

Stop a started camera device.

Implements SENSCamera.

Definition at line 271 of file SENSSimulated.cpp.

{
    if (_started)
    {
        stopSim();
        _started = false;
    }
}

Friends And Related Function Documentation

SENSSimulator

friend class SENSSimulator

friend

Definition at line 161 of file SENSSimulated.h.

Member Data Documentation

_cap

cv::VideoCapture SENSSimulatedCamera::_cap

private

Definition at line 188 of file SENSSimulated.h.

_frame

cv::Mat SENSSimulatedCamera::_frame

private

Definition at line 192 of file SENSSimulated.h.

_frameMutex

std::mutex SENSSimulatedCamera::_frameMutex

private

Definition at line 193 of file SENSSimulated.h.

_preparedFrame

cv::Mat SENSSimulatedCamera::_preparedFrame

private

Definition at line 190 of file SENSSimulated.h.

_preparedFrameIndex

int SENSSimulatedCamera::_preparedFrameIndex = -1

private

Definition at line 191 of file SENSSimulated.h.

_videoFileName

std::string SENSSimulatedCamera::_videoFileName

private

Definition at line 187 of file SENSSimulated.h.

---

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

• SENSSimulated.h
• SENSSimulated.cpp