TagDetector.h

Go to the documentation of this file.

 
#ifndef TAG_DETECTOR_H
#define TAG_DETECTOR_H
 
#include "../../interfaces/BasicCamera.hpp"
#include "../../interfaces/ZEDCamera.hpp"
#include "../../util/vision/BoundingBoxTracking.h"
#include "../../util/vision/TagDetectionUtilty.hpp"
#include "../../util/vision/YOLOModel.hpp"
 
#include <future>
#include <shared_mutex>
#include <vector>
 
 
 
class TagDetector : public AutonomyThread<void>
{
    public:
        // Declare public methods.
        TagDetector(std::shared_ptr<BasicCamera> pBasicCam,
                    const int nArucoCornerRefinementMaxIterations = 30,
                    const int nArucoCornerRefinementMethod        = cv::aruco::CORNER_REFINE_NONE,
                    const int nArucoMarkerBorderBits              = 1,
                    const bool bArucoDetectInvertedMarkers        = false,
                    const bool bUseAruco3Detection                = false,
                    const bool bEnableTracking                    = false,
                    const int nDetectorMaxFPS                     = 30,
                    const bool bEnableRecordingFlag               = false,
                    const int nNumDetectedTagsRetrievalThreads    = 5,
                    const bool bUsingGpuMats                      = false);
        TagDetector(std::shared_ptr<ZEDCamera> pZEDCam,
                    const int nArucoCornerRefinementMaxIterations = 30,
                    const int nArucoCornerRefinementMethod        = cv::aruco::CORNER_REFINE_NONE,
                    const int nArucoMarkerBorderBits              = 1,
                    const bool bArucoDetectInvertedMarkers        = false,
                    const bool bUseAruco3Detection                = false,
                    const bool bEnableTracking                    = false,
                    const int nDetectorMaxFPS                     = 30,
                    const bool bEnableRecordingFlag               = false,
                    const int nNumDetectedTagsRetrievalThreads    = 5,
                    const bool bUsingGpuMats                      = false);
        ~TagDetector();
        std::future<bool> RequestDetectionOverlayFrame(cv::Mat& cvFrame);
        std::future<bool> RequestLastGoodOverlayFrame(cv::Mat& cvFrame);
        std::future<bool> RequestDetectedArucoTags(std::vector<tagdetectutils::ArucoTag>& vArucoTags);
        bool InitTorchDetection(const std::string& szModelPath,
                                yolomodel::pytorch::PyTorchInterpreter::HardwareDevices eDevice = yolomodel::pytorch::PyTorchInterpreter::HardwareDevices::eCUDA);
 
        // Mutators.
 
        void EnableTorchDetection(const float fMinObjectConfidence = 0.4f, const float fNMSThreshold = 0.6f);
        void DisableTorchDetection();
        void SetDetectorMaxFPS(const int nRecordingFPS);
        void SetEnableRecordingFlag(const bool bEnableRecordingFlag);
 
        // Accessors.
 
        bool GetIsReady();
        int GetDetectorMaxFPS() const;
        bool GetEnableRecordingFlag() const;
        std::string GetCameraName();
        cv::Size GetProcessFrameResolution() const;
 
    private:
        // Declare private methods.
 
        void ThreadedContinuousCode() override;
        void PooledLinearCode() override;
        void UpdateDetectedTags(std::vector<tagdetectutils::ArucoTag>& vNewlyDetectedTags);
 
        // Declare private member variables.
        // Class member variables.
 
        std::shared_ptr<Camera<cv::Mat>> m_pCamera;
        cv::aruco::ArucoDetector m_cvArucoDetector;
        cv::aruco::DetectorParameters m_cvArucoDetectionParams;
        cv::aruco::Dictionary m_cvTagDictionary;
        std::shared_ptr<yolomodel::pytorch::PyTorchInterpreter> m_pTorchDetector;
        std::atomic<float> m_fTorchMinObjectConfidence;
        std::atomic<float> m_fTorchNMSThreshold;
        std::atomic_bool m_bTorchInitialized;
        std::atomic_bool m_bTorchEnabled;
        std::shared_ptr<tracking::MultiTracker> m_pMultiTracker;
        bool m_bUsingZedCamera;
        bool m_bUsingGpuMats;
        bool m_bCameraIsOpened;
        bool m_bEnableTracking;
        int m_nNumDetectedTagsRetrievalThreads;
        std::string m_szCameraName;
        std::atomic_bool m_bEnableRecordingFlag;
 
        // Detected tags storage.
 
        std::vector<tagdetectutils::ArucoTag> m_vNewlyDetectedTags;
        std::vector<tagdetectutils::ArucoTag> m_vDetectedArucoTags;
 
        // Rover position for tag geolocalization.
        geoops::RoverPose m_stRoverPose;
 
        // Create frames for storing images and point clouds.
 
        cv::Mat m_cvFrame;
        cv::cuda::GpuMat m_cvGPUFrame;
        cv::Mat m_cvArucoProcFrame;
        cv::Mat m_cvLastGoodDetectionOverlayFrame;
        cv::Mat m_cvPointCloud;
        cv::cuda::GpuMat m_cvGPUPointCloud;
 
        // Queues and mutexes for scheduling and copying data to other threads.
 
        std::queue<containers::FrameFetchContainer<cv::Mat>> m_qDetectionOverlayFramesCopySchedule;
        std::queue<containers::FrameFetchContainer<cv::Mat>> m_qLastGoodDetectionOverlayFramesCopySchedule;
        std::queue<containers::DataFetchContainer<std::vector<tagdetectutils::ArucoTag>>> m_qDetectedArucoTagCopySchedule;
        std::shared_mutex m_muPoolScheduleMutex;
        std::shared_mutex m_muDetectionOverlayCopyMutex;
        std::shared_mutex m_muLastGoodDetectionOverlayCopyMutex;
        std::shared_mutex m_muArucoDataCopyMutex;
};
 
#endif