SENSCaptureProps Class Reference

#include <SENSCamera.h>

Inherits std::vector< SENSCameraDeviceProps >.

Public Member Functions
bool	containsDeviceId (const std::string &deviceId) const
bool	supportsCameraFacing (const SENSCameraFacing &facing) const
const SENSCameraDeviceProps *	camPropsForDeviceId (const std::string &deviceId) const
std::pair< const SENSCameraDeviceProps *const, const SENSCameraStreamConfig *const >	findBestMatchingConfig (SENSCameraFacing facing, const float horizFov, const int width, const int height) const
	Helper function to find a camera device and stream configuration with certain characteristics. More...

Detailed Description

Definition at line 136 of file SENSCamera.h.

Member Function Documentation

camPropsForDeviceId()

const SENSCameraDeviceProps * SENSCaptureProps::camPropsForDeviceId

(

const std::string &

deviceId

)

const

Definition at line 73 of file SENSCamera.cpp.

{
    auto camPropsIt = std::find_if(begin(), end(), [&](const SENSCameraDeviceProps& comp)
                                   { return comp.deviceId() == deviceId; });
    if (camPropsIt != end())
        return &*camPropsIt;
    else
        return nullptr;
}

containsDeviceId()

bool SENSCaptureProps::containsDeviceId

(

const std::string &

deviceId

)

const

Definition at line 61 of file SENSCamera.cpp.

{
    return std::find_if(begin(), end(), [&](const SENSCameraDeviceProps& comp)
                        { return comp.deviceId() == deviceId; }) != end();
}

findBestMatchingConfig()

std::pair< const SENSCameraDeviceProps *const, const SENSCameraStreamConfig *const > SENSCaptureProps::findBestMatchingConfig	(	SENSCameraFacing	facing,
		const float	horizFov,
		const int	width,
		const int	height
	)		const

Helper function to find a camera device and stream configuration with certain characteristics.

Returns a pair on nullptrs if characteristics were not fulfilled. Possible reasons: the facing is not available or if the transferred width and height would require an extrapolation.

Definition at line 89 of file SENSCamera.cpp.

{
    struct SortElem
    {
        // corresponding camera characteristics
        const SENSCameraDeviceProps* camChars;
        // corresponding index in stream configurations
        const SENSCameraStreamConfig* streamConfig;
        int                           streamConfigIdx;
        // cropped width (using stream configuration referenced by streamConfigIdx)
        int widthCropped;
        // cropped height (using stream configuration referenced by streamConfigIdx)
        int heightCropped;
        // horizontal and vertical field of view using cropped width
        float horizFov = -1.f;
        // scale factor between stream config and target resolutions
        float scale;
 
        // difference to target field of view
        float fovScore = 0.f;
        // summed crop (used as later as score to make decision)
        int cropScore;
        // score that respecs necessary scale complexity
        int scaleScore;
 
        void print(int idx) const
        {
            std::stringstream ss;
            ss << "Sort Elem " << idx;
            ss << " fovV: " << horizFov;
            ss << " fovV score: " << fovScore;
            ss << " crop score: " << cropScore;
            ss << " scale score " << scaleScore;
            ss << " widthCropped: " << widthCropped;
            ss << " heightCropped: " << heightCropped;
            ss << " scale: " << scale;
            ss << " width orig " << camChars->streamConfigs()[streamConfigIdx].widthPix;
            ss << " height orig " << camChars->streamConfigs()[streamConfigIdx].heightPix;
            Utils::log("SENSCaptureProps", ss.str().c_str());
        }
    };
    auto printSortElems = [](const std::vector<SortElem>& sortElems, std::string id)
    {
        std::cout << id << std::endl;
        for (int i = 0; i < sortElems.size(); ++i)
            sortElems.at(i).print(i);
    };
 
    std::vector<SortElem> sortElems;
 
    // make cropped versions of all stream configurations
    for (auto itChars = begin(); itChars != end(); ++itChars)
    {
        if (facing != itChars->facing())
            continue;
 
        const auto& streams              = itChars->streamConfigs();
        float       targetWidthDivHeight = (float)width / (float)height;
 
        for (auto itStream = streams.begin(); itStream != streams.end(); ++itStream)
        {
            const SENSCameraStreamConfig& config = *itStream;
 
            SortElem sortElem;
            int      cropW, cropH;
            SENS::calcCrop({config.widthPix,
                            config.heightPix},
                           targetWidthDivHeight,
                           cropW,
                           cropH,
                           sortElem.widthCropped,
                           sortElem.heightCropped);
            sortElem.scale = (float)width / (float)sortElem.widthCropped;
 
            if (sortElem.scale <= 1.f)
            {
                sortElem.camChars        = &*itChars;
                sortElem.streamConfigIdx = (int)(&*itStream - &*streams.begin());
                sortElem.streamConfig    = &*itStream;
                if (config.focalLengthPix > 0)
                {
                    // we have to use the cropped and unscaled width of the stream config because of the resolution of the focalLengthPix
                    sortElem.horizFov = SENS::calcFOVDegFromFocalLengthPix(config.focalLengthPix,
                                                                           sortElem.widthCropped);
                    sortElem.fovScore = std::abs(sortElem.horizFov - horizFov);
                }
                sortElem.cropScore = cropW + cropH;
                // if we have to scale add a score for it
                if (!isEqualToOne(sortElem.scale))
                    sortElem.scaleScore = width * height;
                else
                    sortElem.scaleScore = 0.f;
 
                sortElems.push_back(sortElem);
            }
        }
    }
 
    if (sortElems.size())
    {
        // sort by difference to target fovV
        std::sort(sortElems.begin(), sortElems.end(), [](const SortElem& lhs, const SortElem& rhs) -> bool
                  { return lhs.fovScore < rhs.fovScore; });
        // printSortElems(sortElems, "sortElems");
 
        // extract all in a range of +-3 degree compared to the closest to target fovV
        std::vector<SortElem> closeFovSortElems;
        float                 maxFovDiff = sortElems.front().fovScore + 3;
        for (SortElem elem : sortElems)
        {
            if (elem.fovScore < maxFovDiff)
                closeFovSortElems.push_back(elem);
        }
 
        // now extract the one with the best scale score from the remaining
        std::sort(closeFovSortElems.begin(), closeFovSortElems.end(), [](const SortElem& lhs, const SortElem& rhs) -> bool
                  { return lhs.scale > rhs.scale; });
        // printSortElems(closeFovSortElems, "closeFovSortElems");
 
        const SortElem& bestSortElem = closeFovSortElems.front();
        return std::make_pair(bestSortElem.camChars, bestSortElem.streamConfig);
    }
    else
    {
        return std::make_pair(nullptr, nullptr);
    }
}

supportsCameraFacing()

bool SENSCaptureProps::supportsCameraFacing

(

const SENSCameraFacing &

facing

)

const

Definition at line 67 of file SENSCamera.cpp.

{
    return std::find_if(begin(), end(), [&](const SENSCameraDeviceProps& comp)
                        { return comp.facing() == facing; }) != end();
}

---

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

• SENSCamera.h
• SENSCamera.cpp