FetchContainers.hpp

Go to the documentation of this file.

 
#ifndef FETCH_CONTAINERS_HPP
#define FETCH_CONTAINERS_HPP
 
#include <future>
#include <opencv2/opencv.hpp>
#include <sl/Camera.hpp>
 
 
// Declare global/file-scope enumerator.
enum class PIXEL_FORMATS
{
    eRGB,
    eBGR,
    eRGBA,
    eBGRA,
    eARGB,
    eABGR,
    eRGBE,
    eXYZ,
    eXYZBGRA,
    eXYZRGBA,
    eZED,
    eGrayscale,
    eDepthImage,
    eDepthMeasure,
    eCMYK,
    eYUV,
    eYUYV,
    eYUVJ,
    eHSV,
    eHSL,
    eSRGB,
    eLAB,
    eArucoDetection,
    eObjectDetection,
    eObstacleDetection,
    eDepthDetection,
    eTensorflowDetection,
    eTorchDetection,
    eUNKNOWN
};
 
 
 
namespace containers
{
 
    template<typename T>
    struct FrameFetchContainer
    {
        public:
            // Declare and define public struct member variables.
            T* pFrame;
            PIXEL_FORMATS eFrameType;
            std::shared_ptr<std::promise<bool>> pCopiedFrameStatus;
 
 
            FrameFetchContainer(T& tFrame, PIXEL_FORMATS eFrameType) : pFrame(&tFrame), eFrameType(eFrameType), pCopiedFrameStatus(std::make_shared<std::promise<bool>>())
            {}
 
 
            FrameFetchContainer(const FrameFetchContainer& stOtherFrameContainer) :
                pFrame(stOtherFrameContainer.pFrame), eFrameType(stOtherFrameContainer.eFrameType), pCopiedFrameStatus(stOtherFrameContainer.pCopiedFrameStatus)
            {}
 
 
            FrameFetchContainer& operator=(const FrameFetchContainer& stOtherFrameContainer)
            {
                // Check if the passed in container is the same as this one.
                if (this != &stOtherFrameContainer)
                {
                    // Copy struct attributes.
                    this->pFrame             = stOtherFrameContainer.pFrame;
                    this->eFrameType         = stOtherFrameContainer.eFrameType;
                    this->pCopiedFrameStatus = stOtherFrameContainer.pCopiedFrameStatus;
                }
 
                // Return pointer to this object which now contains the copied values.
                return *this;
            }
    };
 
 
    template<typename T>
    struct DataFetchContainer
    {
        public:
            // Declare and define public struct member variables.
            T* pData;
            std::shared_ptr<std::promise<bool>> pCopiedDataStatus;
 
 
            DataFetchContainer(T& tData) : pData(&tData), pCopiedDataStatus(std::make_shared<std::promise<bool>>()) {}
 
 
            DataFetchContainer(const DataFetchContainer& stOtherDataContainer) :
                pData(stOtherDataContainer.pData), pCopiedDataStatus(stOtherDataContainer.pCopiedDataStatus)
            {}
 
 
            DataFetchContainer& operator=(const DataFetchContainer& stOtherDataContainer)
            {
                // Check if the passed in container is the same as this one.
                if (this != &stOtherDataContainer)
                {
                    // Copy struct attributes.
                    this->pData             = stOtherDataContainer.pData;
                    this->pCopiedDataStatus = stOtherDataContainer.pCopiedDataStatus;
                }
 
                // Return pointer to this object which now contains the copied values.
                return *this;
            }
    };
}    // namespace containers
 
#endif