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 structs specific to this class.
 
 
        struct Pose
        {
            public:
                double dPosX;    // Position X in meters.
                double dPosY;    // Position Y in meters.
                double dPosZ;    // Position Z in meters.
                double dQX;      // Quaternion X.
                double dQY;      // Quaternion Y.
                double dQZ;      // Quaternion Z.
                double dQW;      // Quaternion W.
        };
 
        // 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;
            m_stCameraPoseOffset        = Pose{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0};
        }
 
 
        virtual ~Camera() {}
 
 
        void SetEnableRecordingFlag(const bool bEnableRecordingFlag) { m_bEnableRecordingFlag = bEnableRecordingFlag; }
 
 
        void SetCameraPoseOffset(const Pose& stPoseOffset) { m_stCameraPoseOffset = stPoseOffset; }
 
 
        void SetCameraPoseOffset(const double dPosX, const double dPosY, const double dPosZ, const double dQX, const double dQY, const double dQZ, const double dQW)
        {
            // Update member variable.
            m_stCameraPoseOffset.dPosX = dPosX;
            m_stCameraPoseOffset.dPosY = dPosY;
            m_stCameraPoseOffset.dPosZ = dPosZ;
            m_stCameraPoseOffset.dQX   = dQX;
            m_stCameraPoseOffset.dQY   = dQY;
            m_stCameraPoseOffset.dQZ   = dQZ;
            m_stCameraPoseOffset.dQW   = dQW;
        }
 
 
        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; }
 
 
        Pose GetCameraPoseOffset() const { return m_stCameraPoseOffset; }
 
 
        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;
        Pose m_stCameraPoseOffset;
        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