ArucoGenerateTags.hpp

Go to the documentation of this file.

 
#include "../../src/interfaces/AutonomyThread.hpp"
#include "../../src/util/ExampleChecker.h"
#include "../opencv/TagGenerator.hpp"
 
#include <chrono>
#include <filesystem>
#include <iostream>
 
 
 
class ArucoGenerateTagsThreaded : public AutonomyThread<void>
{
    private:
        // Declare and define private member variables.
        int m_nNumTagsToGenerate = 0;
        std::vector<cv::aruco::PredefinedDictionaryType> m_vDictionaries;
        std::mutex m_muDictMutex;    // This mutex is used for locking write access to the dictionary in threads.
 
 
        void ThreadedContinuousCode() override
        {
            // Start thread pool. Run detached since the threads aren't returning anything.
            // This is much faster than the normal RunPool function.
            this->RunDetachedPool(m_vDictionaries.size(), m_vDictionaries.size());
 
            // Wait for pool tasks to finish.
            this->JoinPool();
 
            // Stop threaded code.
            this->RequestStop();
        }
 
 
        void PooledLinearCode() override
        {
            // Acquire resource lock for dictionary vector.
            std::unique_lock<std::mutex> lock(m_muDictMutex);
            // Get dictionary enum from back of dictionary vector.
            cv::aruco::PredefinedDictionaryType cvDictType = m_vDictionaries.back();
            m_vDictionaries.pop_back();
            // Release resource lock.
            lock.unlock();
 
            // Change this bool to test the two different
            // blocks of code!
            bool bUseParallelLoop = false;
            if (bUseParallelLoop)
            {
                // This code splits the loop into parts and
                // completes it in different threads.
                this->ParallelizeLoop(50,
                                      m_nNumTagsToGenerate,
                                      [&cvDictType](const int a, const int b)
                                      {
                                          // Loop through and generate each of the tags.
                                          for (int i = a; i < b; ++i)
                                              GenerateOpenCVArucoMarker(cvDictType, i);
                                      });
            }
            else
            {
                // This code linearly runs through every tag.
                for (int i = 0; i < m_nNumTagsToGenerate; ++i)
                {
                    GenerateOpenCVArucoMarker(cvDictType, i);
                }
            }
        }
 
    public:
        // Declare and define public methods and variables.
        ArucoGenerateTagsThreaded() = default;
 
 
        void SetNumTagsToGenerate(const int nNumTags) { m_nNumTagsToGenerate = nNumTags; }
 
 
        void AddTagDictionaryType(const cv::aruco::PredefinedDictionaryType eDictionary) { m_vDictionaries.emplace_back(eDictionary); }
};
 
 
class ArucoGenerateTagsLinear
{
    private:
        // Declare and define private member variables.
        int m_nNumTagsToGenerate = 0;
        std::vector<cv::aruco::PredefinedDictionaryType> m_vDictionaries;
 
    public:
        // Declare and define public methods and variables.
        ArucoGenerateTagsLinear() = default;
 
 
        void Start()
        {
            while (m_vDictionaries.size() > 0)
            {
                // Get dictionary enum from back of dictionary vector.
                cv::aruco::PredefinedDictionaryType cvDictType = m_vDictionaries.back();
                m_vDictionaries.pop_back();
 
                // Loop through and generate each of the tags.
                for (int i = 0; i < m_nNumTagsToGenerate; ++i)
                    GenerateOpenCVArucoMarker(cvDictType, i);
            }
        }
 
 
        void SetNumTagsToGenerate(const int nNumTags) { m_nNumTagsToGenerate = nNumTags; }
 
 
        void AddTagDictionaryType(const cv::aruco::PredefinedDictionaryType eDictionary) { m_vDictionaries.emplace_back(eDictionary); }
};
 
 
void RunExample()
{
    // Start the timer
    std::chrono::time_point tmStartTime = std::chrono::high_resolution_clock::now();
 
    // Create generator.
    ArucoGenerateTagsLinear LinearTagGenerator;
 
    // Configure tag generator for first run.
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_4X4_50);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_5X5_50);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_6X6_50);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_7X7_50);
    LinearTagGenerator.SetNumTagsToGenerate(50);
    // Start first run.
    LinearTagGenerator.Start();
 
    // Add new dictionary to generator.
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_4X4_100);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_5X5_100);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_6X6_100);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_7X7_100);
    LinearTagGenerator.SetNumTagsToGenerate(100);
    // Start second run.
    LinearTagGenerator.Start();
 
    // Add new dictionary to generator.
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_4X4_250);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_5X5_250);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_6X6_250);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_7X7_250);
    LinearTagGenerator.SetNumTagsToGenerate(250);
    // Start third run.
    LinearTagGenerator.Start();
 
    // Add new dictionary to generator.
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_4X4_1000);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_5X5_1000);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_6X6_1000);
    LinearTagGenerator.AddTagDictionaryType(cv::aruco::DICT_7X7_1000);
    LinearTagGenerator.SetNumTagsToGenerate(1000);
    // Start fourth run.
    LinearTagGenerator.Start();
 
    // End the timer
    std::chrono::time_point tmEndTime = std::chrono::high_resolution_clock::now();
    // Calculate the elapsed time
    int nSingledThreadedDuration = std::chrono::duration_cast<std::chrono::milliseconds>(tmEndTime - tmStartTime).count();
    // Print the result
    std::cout << "Time taken for single threaded generator: " << nSingledThreadedDuration << " milliseconds." << std::endl;
 
    // Remove all png files in the current directory.
    for (const std::filesystem::directory_entry& stdEntry : std::filesystem::directory_iterator("."))
    {
        // Loop all *.png files.
        if (std::filesystem::is_regular_file(stdEntry) && stdEntry.path().extension() == ".png")
        {
            // Delete.
            std::filesystem::remove(stdEntry.path());
        }
    }
 
    // Start the timer
    tmStartTime = std::chrono::high_resolution_clock::now();
 
    // Create Aruco generator threads.
    ArucoGenerateTagsThreaded ThreadedTagGenerator1;
    ArucoGenerateTagsThreaded ThreadedTagGenerator2;
    ArucoGenerateTagsThreaded ThreadedTagGenerator3;
    ArucoGenerateTagsThreaded ThreadedTagGenerator4;
 
    // Configure tag generator for first run.
    ThreadedTagGenerator1.AddTagDictionaryType(cv::aruco::DICT_4X4_50);
    ThreadedTagGenerator1.AddTagDictionaryType(cv::aruco::DICT_5X5_50);
    ThreadedTagGenerator1.AddTagDictionaryType(cv::aruco::DICT_6X6_50);
    ThreadedTagGenerator1.AddTagDictionaryType(cv::aruco::DICT_7X7_50);
    ThreadedTagGenerator1.SetNumTagsToGenerate(50);
    // Start first run.
    ThreadedTagGenerator1.Start();
 
    // Add new dictionary to generator.
    ThreadedTagGenerator2.AddTagDictionaryType(cv::aruco::DICT_4X4_100);
    ThreadedTagGenerator2.AddTagDictionaryType(cv::aruco::DICT_5X5_100);
    ThreadedTagGenerator2.AddTagDictionaryType(cv::aruco::DICT_6X6_100);
    ThreadedTagGenerator2.AddTagDictionaryType(cv::aruco::DICT_7X7_100);
    ThreadedTagGenerator2.SetNumTagsToGenerate(100);
    // Start second run.
    ThreadedTagGenerator2.Start();
 
    // Add new dictionary to generator.
    ThreadedTagGenerator3.AddTagDictionaryType(cv::aruco::DICT_4X4_250);
    ThreadedTagGenerator3.AddTagDictionaryType(cv::aruco::DICT_5X5_250);
    ThreadedTagGenerator3.AddTagDictionaryType(cv::aruco::DICT_6X6_250);
    ThreadedTagGenerator3.AddTagDictionaryType(cv::aruco::DICT_7X7_250);
    ThreadedTagGenerator3.SetNumTagsToGenerate(250);
    // Start third run.
    ThreadedTagGenerator3.Start();
 
    // Add new dictionary to generator.
    ThreadedTagGenerator4.AddTagDictionaryType(cv::aruco::DICT_4X4_1000);
    ThreadedTagGenerator4.AddTagDictionaryType(cv::aruco::DICT_5X5_1000);
    ThreadedTagGenerator4.AddTagDictionaryType(cv::aruco::DICT_6X6_1000);
    ThreadedTagGenerator4.AddTagDictionaryType(cv::aruco::DICT_7X7_1000);
    ThreadedTagGenerator4.SetNumTagsToGenerate(1000);
    // Start fourth run.
    ThreadedTagGenerator4.Start();
 
    // Join all.
    ThreadedTagGenerator1.Join();
    ThreadedTagGenerator2.Join();
    ThreadedTagGenerator3.Join();
    ThreadedTagGenerator4.Join();
 
    // End the timer
    tmEndTime = std::chrono::high_resolution_clock::now();
    // Calculate the elapsed time
    int nMultiThreadedDuration = std::chrono::duration_cast<std::chrono::milliseconds>(tmEndTime - tmStartTime).count();
    // Print the result
    std::cout << "Time taken for multithreaded generator: " << nMultiThreadedDuration << " milliseconds." << std::endl;
    std::cout << "\n\nCheck your build directory for all aruco tags!" << std::endl;
}