main.cpp

#include "threadpool/ThreadPool.hpp"
#include "lockfree/LockFree.hpp"
#include "hikrobot/HikRobot.hpp"
#include "daheng_camera/daheng_camera.hpp"

#include "Detect.hpp"
#include "Track.hpp"
#include "Mouse.hpp"

#include "function/function.hpp"
#ifndef MCAP_IMPLEMENTATION
#define MCAP_IMPLEMENTATION
#endif
#include "Capture.hpp"

#define DUMP
#ifndef DUMP
#define CAPTURE
#else
#include "dump/dump.hpp"
#endif

#include <nlohmann/json.hpp>
#include <fstream>

int main() {

    ThreadPool t_p;
    LfStack<FromData> fd_msgs;
#ifndef DUMP
    LfStack<ImageInfo> image_info_stack;
    LfStack<ImageInfo> mouse_info_stack;
    SerialPort sp;

#ifdef CAPTURE
    LfStack<CaptureInfo> capture_stack;
#endif
    auto receive = [&]() -> void {
        //1、读取json文件
        nlohmann::json config = nlohmann::json::parse(std::ifstream("../config/json/sensors.json"));
        std::string type = config["camera"]["type"];

        //2、动态创建相机
        std::unique_ptr<sensors::BaseCamera> cmaera;
        if (type == "daheng") {
            cmaera = std::make_unique<DahengCamera>(sp);
        }else if (type == "hikrobot"){
            cmaera = std::make_unique<HikRobot>(sp);
        }else{
            std::cerr<<"unknown camera type"<<type<<std::endl;
            exit(-1);
        }

         cmaera->cameraInit();
         
        while (1) {
            //std::cout<< "opening camera"<<std::endl;
            cmaera->refreshImage(fd_msgs);
        }
    };

    auto detect = [&]() -> void {
        Detect detect("debug");

        while (1) {
            detect.detect(
                    fd_msgs,
                    image_info_stack,
                    mouse_info_stack);
        }
    };


    auto track = [&]() -> void {
        Track tracker(sp, "debug");
        while (1) {
#ifdef CAPTURE
            tracker.update(image_info_stack, capture_stack);
#else
            tracker.update(image_info_stack);
#endif
        }
    };


    auto mouse = [&]() -> void {
        Mouse m;
        while (1) {
            m.mouseControl(mouse_info_stack);
        }
    };

#ifdef CAPTURE
    auto capture_func = [&]() -> void {
        std::cout << "capture thread start." << std::endl;
        Capture cap("/Dart",
                    "Vision",
                    "foxglove.CaptureInformation",
                    "/home/ganjie/Vision_Code/config/flatbuffers/CaptureInformation.fbs",
                    "8UC3");
        cap.setMacpPath(function::getBagPath());
        cap.init();
        int frame_count;
        J_CAPTURE.config_["frame_cnt"] >> frame_count;
        while(true) {
            std::optional<CaptureInfo> opt_value = capture_stack.pop();

            if (!opt_value.has_value() || opt_value.value().cd.dune == 1 || !opt_value.value().cd.mode) {
                continue;
            }

            cap.update(opt_value.value());

            if (!(--frame_count)) {
                cap.finish();
                cap.setMacpPath(function::getBagPath());
                cap.init();
                J_CAPTURE.config_["frame_cnt"] >> frame_count;
            }
        }
    };

#endif

    t_p.addTask(receive);
    t_p.addTask(detect);
    t_p.addTask(track);
    t_p.addTask(mouse);
#ifdef CAPTURE
    t_p.addTask(capture_func);
#endif
#else
    auto dump = [&]() -> void {
        std::string directory;
        std::string name;
        std::string type;
        J_CAPTURE.config_["mcap"]["directory"] >> directory;
        J_CAPTURE.config_["mcap"]["name"] >> name;
        J_CAPTURE.config_["mcap"]["type"] >> type;
        std::cout << directory + name + type << std::endl;
        std::ifstream input(directory + name + type, std::ios::binary);
        mcap::FileStreamReader dataSource{input};
        DumpMessages(name, dataSource, fd_msgs);
    };
    t_p.addTask(dump);
#endif
    t_p.run();

    return 0;
}