Hu Chunming / vpt_ascend

  #include "header.h"
  #include "acl/acl.h"
  #include "acl/ops/acl_dvpp.h"
  #include "task_param_manager.h"
  #include "../ai_engine_module/VPTProcess.h"
  #include "../reprocessing_module/snapshot_reprocessing.h"
  #include "../reprocessing_module/save_snapshot_reprocessing.h"

  #include "../ai_engine_module/ai_engine_module.h"

  #include "../util/JpegUtil.h"

  
  #include <map>
  #include <mutex>
  #include <thread>
  #include <list>
  #include <vector>
  #include <deque>

  #include <set>

  #ifdef POST_USE_RABBITMQ
  #include "../reprocessing_module/mq_manager.hpp"
  #endif
  

  
  using namespace std;
  
  class DeviceMemory;
  
  class CMultiSourceProcess {
  public:
    CMultiSourceProcess();
    ~CMultiSourceProcess();
  
    int InitAlgorthim(tsl_aiplatform_param vptParam);
    bool AddTask(task_param _cur_task_param);
    bool PauseTask(const string taskID);
    bool RestartTask(const string taskID);
    bool FinishTask(const string taskID);
    void CloseAllTask();
    int SnapShot(task_param param);
  
  #ifdef POST_USE_RABBITMQ
    int AddMqConn(mq_type_t mq_type, rabbitmq_conn_params_t mq_conn_param);

  #endif
  

    int GetTaskStatus(const string taskID);
  
    int CountRunningTask();
    void CloseAllTask2();
  

  public:
    int algorthim_process_thread();  // 算法处理线程
    void task_finished(const string task_id);
    void decoded_cbk(DeviceMemory* devFrame);

    void timing_snapshot_thread();

  
  private:
    // 算法相关
    int algorthim_vpt(vector<DeviceMemory*> vec_gpuMem);

    // 逆行
    void algorthim_retrograde(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs, vector<onelevel_det_result>& vptResult);
    // 闯入
    void algorthim_trespass(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs, 
                                                    vector<onelevel_det_result>& vptResult ,vector<vector<int>>& deleteObjectID);  

  
  private:
    // 工具处理函数
    bool task_has_vpt_algor(const std::string &task_id);
    void clear_finished_task();
    bool finish_task(const string taskID, const bool delete_snapshot);
    int algorithm_vehicle_relult(vector<DeviceMemory*> vec_devMem, vector<onelevel_det_result>& vptResult, vector<vector<int>>& delete_object_id);
    void send_locus_finished_msg(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID);

    void vehicle_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID);
    void vehicle_locus_finished(const OBJ_KEY obj_key);
  

    bool save_snapshot_process(const OBJ_KEY &obj_key, const algorithm_type_t &algorithm_type, vpc_img_info img_info,  vpc_img_info roi_img,
                                         const long long id,const std::string &json_str);
  

    void retrograde_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID);
    void trespass_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID);

    void void retrograde_trespass_alarm(const OBJ_KEY &obj_key, const algorithm_type_t &algor_type) ;(const OBJ_KEY &obj_key, const algorithm_type_t &algor_type) void retrograde_trespass_alarm(const OBJ_KEY &obj_key, const algorithm_type_t &algor_type) ;  

    void cross_line_process(vector<DeviceMemory*> vec_devMem, vector<onelevel_det_result>& vptResult, algorithm_type_t eType);
  
    void wander_detect(vector<DeviceMemory*>& vec_gpuMem, vector<onelevel_det_result>& vptResult, algorithm_type_t eType);
  
    int gather_process(vector<DeviceMemory*>& vec_gpuMem, vector<onelevel_det_result> &ol_det_result, algorithm_type_t algor_type);
  
    // 轨迹记录
    void trace_record(vector<DeviceMemory*>& vec_gpuMem, vector<onelevel_det_result>& vptResult);
  

  private:
    int m_devId; 
  
    snapshot_reprocessing *m_snapshot_reprocessing{nullptr};
    task_param_manager *m_task_param_manager{nullptr};
    save_snapshot_reprocessing *m_save_snapshot_reprocessing{nullptr};
  

    std::thread* m_timing_snapshot_thread;
  

    VPTProcess vpt_process;
    int skip_frame_ = 5; // 控制跳帧参数
  
    deque<DeviceMemory*> m_RgbDataList;
    mutex m_DataListMtx; 
  
    mutex m_FinishedTaskMtx;
    map<string,bool> m_FinishedTaskMap;
  
    thread* m_pAlgorthimThread;
    bool m_bfinish{false};
  
    int m_batch_size{1};
  

    set<OBJ_KEY> m_total_snapshot_info_multi_object;
    mutex m_total_mutex;
  

    mutex m_TotalObjMtx ;
    map<OBJ_KEY, OBJ_INDEX> m_total_obj_info; // 记录目标轨迹
  

    JpegUtil jpegUtil;

  #ifdef POST_USE_RABBITMQ
    mq::Manager *mq_manager_{nullptr};
  #endif
  

  
    ai_engine_module::pedestrian_vehicle_retrograde::PedestrianVehicleRetrograde pedestrian_vehicle_retrograde_;
    ai_engine_module::pedestrian_vehicle_trespass::PedestrianVehicleTrespass pedestrian_vehicle_trespass_;
  

    ai_engine_module::RegionLeave m_algorthim_region_leave;
    ai_engine_module::RegionLeave m_algorthim_region_dismiss;
    ai_engine_module::RegionLeave m_algorthim_region_fastmoving;
  
    GatherDetect m_human_gather;
    GatherDetect m_human_density;
    GatherDetect m_human_region_gather;
    GatherDetect m_vehicle_gather;
  

  };