MyCameraCalibComputer.cpp

#include <future>

class MyThreadedCameraCalibComputer 
{
public:
    struct GuiCalibInfo 
    {
        cv::Mat mImage;
        std::string result;
        std::string userInstruction; 
        HintId hintId = HintId::NoHint;
    };

    MyThreadedCameraCalibComputer() 
    {
        // on lance le background thread a la creation
        mProcessAsyncWorkResult = std::async(
                [this] { this->ProcessAsyncWork(); }, 
                std::launch::async);
    }

    virtual ~MyCameraCalibComputer() 
    {
        mStopRequired = true; // on arrete le background thread a la destruction
    }

    virtual void EnqueueImage(const cv::Mat &image)
    {
        // On ne fait que stocker la prochaine image a traiter
        mNextImageToProcess_Mutex.lock();
        mNextImageToProcess_Mutex = image.clone();
        mNextImageToProcess_Mutex.unlock();
    }
    virtual void EnqueueAcceleration(const cv::Vec3d &accel)
    {
        // Pas géré pour l'instant      
    }

    virtual GuiCalibInfo GetGuiCalibInfo()
    {
        GuiCalibInfo r;
        mLastGuiCalibInfo_Mutex.lock();
        r = mLastGuiCalibInfo;
        mLastGuiCalibInfo_Mutex.unlock();
        return r;
    }

    virtual bool IsProcessFinished()
    {
        return false;
    }

    private:
    // Fonction qui tourne en continu dans un thread et qui est lancee a la creation
    void ProcessAsyncWork() 
    {
        while( ! mStopRequired) // Elle sera arretee par le destructeur
        { 
            mNextImageToProcess_Mutex.lock();
            cv::Mat nextImageToProcessClone = mNextImageToProcess.clone();
            mNextImageToProcess_Mutex.unlock();

            if ( ! nextImageToProcessClone.empty())
            {
                // Call process image
                ...
                // (Ne pas rajouter de code métier ici! faire un simple
                // appel d'une méthode dans une autre classe: cette classe en fait déja assez
                // avec la gestion des thread)

                // Fill mLastGuiCalibInfo, with a mutex
                mLastGuiCalibInfo_Mutex.lock();
                mLastGuiCalibInfo = ...
                // Pareil ici, appeler une méthode ou fonction dans une autre classe.
                mLastGuiCalibInfo_Mutex.unlock();

            }  
       
        }
    }
    


    private:
    // Thread variables
    // mProcessAsyncWorkResult est important ! Il *faut* stocker le resultat
    // d'un appel a std::async (même si c'est un void), sinon la destruction de l'async
    // attendra la fin de l'appel asynchrone (et dans notre cas, c'est une boucle infinie !)
    std::future<void> mProcessAsyncWorkResult;
    std::atomic<bool> mStopRequired = false; // vaudra true quand on veut arreter

    // Next image top process, protected by a mutex
    cv::Mat mNextImageToProcess; 
    std::mutex mNextImageToProcess_Mutex; // pour proteger les acces concurrents !

    // Next Gui Status, also protected by a mutex
    GuiCalibInfo mLastGuiCalibInfo;
    std::mutex mLastGuiCalibInfo_Mutex;  // pour proteger les acces concurrents !
};