Camera.hpp

Go to the documentation of this file.

 
#ifndef CAMERA_HPP
#define CAMERA_HPP
 
#include "../util/vision/FetchContainers.hpp"
#include "./AutonomyThread.hpp"
 
#include <atomic>
#include <future>
#include <shared_mutex>
 
 
 
template<class T>
class Camera : public AutonomyThread<void>
{
    public:
        // Declare public methods and member variables.
 
        Camera(const int nPropResolutionX,
               const int nPropResolutionY,
               const int nPropFramesPerSecond,
               const PIXEL_FORMATS ePropPixelFormat,
               const double dPropHorizontalFOV,
               const double dPropVerticalFOV,
               const bool bEnableRecordingFlag,
               const int nNumFrameRetrievalThreads = 5)
        {
            // Initialize member variables.
            m_nPropResolutionX          = nPropResolutionX;
            m_nPropResolutionY          = nPropResolutionY;
            m_nPropFramesPerSecond      = nPropFramesPerSecond;
            m_ePropPixelFormat          = ePropPixelFormat;
            m_dPropHorizontalFOV        = dPropHorizontalFOV;
            m_dPropVerticalFOV          = dPropVerticalFOV;
            m_bEnableRecordingFlag      = bEnableRecordingFlag;
            m_nNumFrameRetrievalThreads = nNumFrameRetrievalThreads;
        }
 
 
        virtual ~Camera() {}
 
 
        cv::Size GetPropResolution() const { return cv::Size(m_nPropResolutionX, m_nPropResolutionY); }
 
 
        int GetPropFramesPerSecond() const { return m_nPropFramesPerSecond; }
 
 
        PIXEL_FORMATS GetPropPixelFormat() const { return m_ePropPixelFormat; }
 
 
        double GetPropHorizontalFOV() const { return m_dPropHorizontalFOV; }
 
 
        double GetPropVerticalFOV() const { return m_dPropVerticalFOV; }
 
 
        bool GetEnableRecordingFlag() const { return m_bEnableRecordingFlag; }
 
 
        void SetEnableRecordingFlag(const bool bEnableRecordingFlag) { m_bEnableRecordingFlag = bEnableRecordingFlag; }
 
 
        virtual bool GetCameraIsOpen() = 0;    // This is where the code to check if the camera is currently open goes.
 
    protected:
        // Declare protected methods and member variables.
        int m_nPropResolutionX;
        int m_nPropResolutionY;
        int m_nPropFramesPerSecond;
        int m_nNumFrameRetrievalThreads;
        PIXEL_FORMATS m_ePropPixelFormat;
        double m_dPropHorizontalFOV;
        double m_dPropVerticalFOV;
        std::atomic_bool m_bEnableRecordingFlag;
 
        // Queues and mutexes for scheduling and copying camera frames and data to other threads.
        std::queue<containers::FrameFetchContainer<T>> m_qFrameCopySchedule;
        std::shared_mutex m_muPoolScheduleMutex;
        std::shared_mutex m_muFrameCopyMutex;
 
        // Declare interface class pure virtual functions. (These must be overriden by inheritor.)
        virtual std::future<bool> RequestFrameCopy(T& tFrame) = 0;    // This is where the code to retrieve an image from the camera is put.
 
    private:
        // Declare private methods and member variables.
};
#endif