USB_UVC_DETECT/ImageTest/ImageTest.h

#ifndef IMAGE_TEST_H
#define IMAGE_TEST_H

#include <opencv4/opencv2/opencv.hpp>
#include <string>
#include <sys/time.h>
#include <chrono>
#include <fstream>
#include <atomic>
#include <thread>
#include <mutex>

namespace UsbTest
{

    void saveImageFromData(unsigned char *data, int width, int height, const std::string &filename = "./output.png");

    class HighResolutionTimer
    {
    public:
        // 开始计时
        void start()
        {
            start_time = std::chrono::high_resolution_clock::now();
        }

        // 停止计时
        void stop()
        {
            end_time = std::chrono::high_resolution_clock::now();
        }

        // 获取经过的时间（以秒为单位）
        double elapsed() const
        {
            return std::chrono::duration<double>(end_time - start_time).count();
        }

        // 获取经过的时间（以毫秒为单位）
        double elapsed_milliseconds() const
        {
            return std::chrono::duration<double, std::milli>(end_time - start_time).count();
        }

        // 获取经过的时间（以微秒为单位）
        double elapsed_microseconds() const
        {
            return std::chrono::duration<double, std::micro>(end_time - start_time).count();
        }

    protected:
        std::chrono::high_resolution_clock::time_point start_time;
        std::chrono::high_resolution_clock::time_point end_time;
    };

    class GlobalResolutionTimer : public HighResolutionTimer
    {
    public:
        static GlobalResolutionTimer &getInstance()
        {
            static GlobalResolutionTimer instance;
            return instance;
        }

        void start()
        {
            start_time = std::chrono::high_resolution_clock::now();
        }

        std::string pressStopWatchString()
        {
            end_time = std::chrono::high_resolution_clock::now();
            return "Elapsed Time: " + std::to_string(elapsed_milliseconds()) + " ms";
        }
    };

    // class SimulateTrigger
    // {
    // public:
    //     static SimulateTrigger &getInstance()
    //     {
    //         static SimulateTrigger instance;
    //         return instance;
    //     }

    //     void startTrigger()
    //     {
    //         if (!triggering)
    //         {
    //             triggering = true;
    //             triggerStatus.resize(3);
    //             triggerStatus[0] = false;
    //             triggerStatus[1] = false;
    //             triggerStatus[2] = false;
    //             triggerThread = std::thread(&SimulateTrigger::triggerLoop, this);
    //         }
    //     }

    //     void stopTrigger()
    //     {
    //         if (triggering)
    //         {
    //             triggering = false;
    //             if (triggerThread.joinable())
    //             {
    //                 triggerThread.join();
    //             }
    //         }
    //     }

    //     bool isTriggering(int index)
    //     {
    //         bool status = triggerStatus[index];
    //         std::lock_guard<std::mutex> lock(triggerMutex);
    //         triggerStatus[index] = false;
    //         return status;
    //     }

    // private:
    //     SimulateTrigger() : triggering(false) {}
    //     ~SimulateTrigger()
    //     {
    //         stopTrigger();
    //     }

    //     // Delete copy constructor and assignment operator to prevent copying
    //     SimulateTrigger(const SimulateTrigger &) = delete;
    //     SimulateTrigger &operator=(const SimulateTrigger &) = delete;

    //     void triggerLoop()
    //     {
    //         while (triggering)
    //         {
    //             std::this_thread::sleep_for(std::chrono::milliseconds(188));
    //             if (triggering)
    //             {
    //                 // Simulate the trigger signal
    //                 std::lock_guard<std::mutex> lock(triggerMutex);
    //                 triggerStatus[0] = true;
    //                 triggerStatus[1] = true;
    //                 triggerStatus[2] = true;
    //             }
    //         }
    //     }

    //     std::atomic<bool> triggering;
    //     std::thread triggerThread;
    //     std::mutex triggerMutex;
    //     std::vector<bool> triggerStatus;
    // };

    // class GlobalResolutionTimer : public HighResolutionTimer
    // {
    // public:
    //     static GlobalResolutionTimer &getInstance()
    //     {
    //         static GlobalResolutionTimer instance;
    //         return instance;
    //     }

    //     void start()
    //     {
    //         start_time = std::chrono::high_resolution_clock::now();
    //     }

    //     std::string pressStopWatchString()
    //     {
    //         end_time = std::chrono::high_resolution_clock::now();
    //         return "Elapsed Time: " + std::to_string(elapsed_milliseconds()) + " ms";
    //     }
    // };

    class SimulateTrigger
    {
    public:
        static SimulateTrigger &getInstance()
        {
            static SimulateTrigger instance;
            return instance;
        }

        void startTrigger()
        {
            if (!triggering)
            {
                triggering = true;
                triggerStatus.resize(3);
                triggerStatus[0] = false;
                triggerStatus[1] = false;
                triggerStatus[2] = false;
                triggerThread = std::thread(&SimulateTrigger::triggerLoop, this);
            }
        }

        void stopTrigger()
        {
            if (triggering)
            {
                triggering = false;
                if (triggerThread.joinable())
                {
                    triggerThread.join();
                }
            }
        }

        bool isTriggering(int index)
        {
            bool status = triggerStatus[index];
            std::lock_guard<std::mutex> lock(triggerMutex);
            triggerStatus[index] = false;
            return status;
        }

    private:
        SimulateTrigger() : triggering(false) {}
        ~SimulateTrigger()
        {
            stopTrigger();
        }

        // Delete copy constructor and assignment operator to prevent copying
        SimulateTrigger(const SimulateTrigger &) = delete;
        SimulateTrigger &operator=(const SimulateTrigger &) = delete;

        void triggerLoop()
        {
            while (triggering)
            {
                std::this_thread::sleep_for(std::chrono::milliseconds(1000));
                if (triggering)
                {
                    // Simulate the trigger signal
                    std::lock_guard<std::mutex> lock(triggerMutex);
                    triggerStatus[0] = true;
                    triggerStatus[1] = true;
                    triggerStatus[2] = true;
                }
            }
        }

        std::atomic<bool> triggering;
        std::thread triggerThread;
        std::mutex triggerMutex;
        std::vector<bool> triggerStatus;
    };

    class TimeRecorder
    {
    public:
        static TimeRecorder &getInstance()
        {
            static TimeRecorder instance;
            return instance;
        }

        bool init()
        {
            log_file = std::fstream("TimeLog.txt", std::ios::app);
        }

        void recordTime(std::string &message)
        {
            if (log_file.is_open())
            {
                log_file << message << std::endl;
            }
        }

    private:
        TimeRecorder() {}
        ~TimeRecorder()
        {
            if (log_file.is_open())
            {
                log_file.close();
            }
        }

        std::fstream log_file;
    };

}
#endif // IMAGE_TEST_H