Hu Chunming / vpt_ascend_arm

Commit afd07f06f52edb35ddfea046b54ad502fd954e11

Authored by Hu Chunming
2 parents 002f9498 3d73904f

Merge branch 'dev-shzhao' into dev-cmhu

Inline Side-by-side
Showing 10 changed files with 26 additions and 2356 deletions
bin/libhcp_vdec.so
View file @afd07f0
No preview for this file type
bin/libhs_motor_process.so
View file @afd07f0
No preview for this file type
bin/libhs_tri_process.so
View file @afd07f0
No preview for this file type
bin/libhs_truck_process.so
View file @afd07f0
No preview for this file type
bin/libmotor_rainshed_vdec.so
View file @afd07f0
No preview for this file type
bin/libphone_motor_det.so
View file @afd07f0
No preview for this file type
bin/libtraffic_light_vdec.so
View file @afd07f0
No preview for this file type
bin/libvpt_det_vdec.so
View file @afd07f0
No preview for this file type
src/ai_platform/MultiSourceProcess.cpp-- deleted
View file @002f949
1   -#include "MultiSourceProcess.h"
2   -#include "../common/logger.hpp"
3   -
4   -#include <string>
5   -#include <queue>
6   -#include <mutex>
7   -#include <chrono>
8   -#include <thread>
9   -
10   -#include "../decoder/interface/DecoderManager.h"
11   -#include "../decoder/interface/utiltools.hpp"
12   -#include "../helpers/time_helper.hpp"
13   -#include "../helpers/os_helper.hpp"
14   -#include "../helpers/gen_json.hpp"
15   -#include "../helpers/str_helper.hpp"
16   -#include "../reprocessing_module/save_snapshot_reprocessing.h"
17   -
18   -#include "macro_definition.h"
19   -#include "ErrorInfo.h"
20   -#include "SourceSingleton.hpp"
21   -#include "mvpt_process_assist.h"
22   -
23   -#include "../util/vpc_util.h"
24   -
25   -// #define VEHICLE_MULTI_BOXES
26   -
27   -#define WITH_FACE_DET_SS
28   -
29   -#define productSN "51C4B28135604F649671727185949A91" //linux 通途抓拍引擎产品序列号
30   -
31   -using namespace std;
32   -
33   -map<int, algo_type> index_to_algo_type = {{0, algorithm_type_t::HUMAN_SNAPSHOT},
34   - {1, algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT},
35   - {2, algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT},
36   - {3, algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT},
37   - {4, algorithm_type_t::VEHICLE_SNAPSHOT},
38   - {5, algorithm_type_t::VEHICLE_SNAPSHOT},
39   - {6, algorithm_type_t::VEHICLE_SNAPSHOT},
40   - {7, algorithm_type_t::VEHICLE_SNAPSHOT},
41   - {8, algorithm_type_t::VEHICLE_SNAPSHOT},
42   - {9, algorithm_type_t::FACE_SNAPSHOT}};
43   -
44   -
45   -struct decode_cbk_userdata{
46   - string task_id;
47   - void* opaque;
48   - void* opaque1;
49   -};
50   -
51   -
52   -/**
53   - * 注意： gpuFrame 在解码器设置的显卡上，后续操作要十分注意这一点，尤其是多线程情况
54   - * */
55   -void post_decod_cbk(const void * userPtr, DeviceMemory* devFrame){
56   - decode_cbk_userdata* ptr = (decode_cbk_userdata*)userPtr;
57   - if (ptr!= nullptr)
58   - {
59   - CMultiSourceProcess* _this = (CMultiSourceProcess*)ptr->opaque;
60   - if(nullptr != _this){
61   - _this->decoded_cbk(devFrame);
62   - }
63   - }
64   -}
65   -
66   -void decode_finished_cbk(const void * userPtr){
67   - decode_cbk_userdata* ptr = (decode_cbk_userdata*)userPtr;
68   - if (ptr!= nullptr)
69   - {
70   - CMultiSourceProcess* _this = (CMultiSourceProcess*)ptr->opaque;
71   - if(nullptr != _this){
72   - _this->task_finished(ptr->task_id);
73   - }
74   - }
75   - delete ptr;
76   - ptr = nullptr;
77   -}
78   -
79   -CMultiSourceProcess::CMultiSourceProcess(){
80   - m_timing_snapshot_thread = nullptr;
81   -}
82   -
83   -CMultiSourceProcess::~CMultiSourceProcess(){
84   -}
85   -
86   -int CMultiSourceProcess::InitAlgorthim(tsl_aiplatform_param vptParam){
87   -#ifdef USE_VILLAGE
88   - if (!CheckTime()) {
89   - std::cout << "sy_licence_check failed." << std::endl;
90   - return AUTHOR_ERROR;
91   - }
92   -#else
93   - //授权相关------------------------------------
94   - //授权init-----------
95   - const char *token_password = "Capture_atlas_arm_2023";
96   - std::string guid = std::string("Capture_atlas_arm")+std::to_string(vptParam.gpuid);
97   - atlas_licence_param lic_param;
98   - memset(&lic_param, 0, sizeof(atlas_licence_param));
99   - sprintf(lic_param.product_id, "%s", productSN);
100   - sprintf(lic_param.guid, "%s",guid.c_str());
101   - sprintf(lic_param.token_pwd, "%s", token_password);
102   - lic_param.channel_num = 1;
103   - atlas_licence_token param_token;
104   - memset(&param_token, 0, sizeof(atlas_licence_token));
105   -
106   - int result = atlas_licence_connect(&(skt_handle), lic_param, &param_token);
107   - //printf("result:%d,code:%d,msg:%s \n", result, param_token.code, param_token.msg);
108   - //printf("token:%s\n", param_token.token);
109   - std::string recv_token = std::string(param_token.token);
110   -
111   - //atlas_licence_check_param check_param;
112   - memset(&(check_param), 0, sizeof(atlas_licence_check_param));
113   - sprintf(check_param.token_pwd, "%s", token_password);
114   - sprintf(check_param.time, "%s", "2023-01-10 20:00:00");
115   - sprintf(check_param.token, "%s", recv_token .c_str());
116   - check_param.consume = 2;
117   -
118   - //授权check------------
119   - check_label = -1;//初始值
120   - std::cout << "sy_licence_check start." << std::endl;
121   - atlas_licence_check_result check_result;
122   - memset(&check_result, 0, sizeof(atlas_licence_check_result));
123   - check_result.code = -1;
124   -
125   - int res = atlas_licence_check(skt_handle, check_param, &check_result);
126   - if(res!=0) {
127   - std::cout << "sy_licence_check failed." << std::endl;
128   - return AUTHOR_ERROR;
129   - }
130   - //std::cout << "code:" << check_result.code << ",msg:" << check_result.msg << std::endl;
131   - if(check_result.code!=0) {
132   - std::cout << "code:" << check_result.code << ",msg:" << check_result.msg << std::endl;
133   - return AUTHOR_ERROR;
134   - }
135   - std::cout << "sy_licence_check end." << std::endl;
136   -
137   - check_label = 0;//授权成功
138   - //授权相关------------------------------------
139   -#endif
140   - set_default_logger(LogLevel(vptParam.log_level), "multi_source_process", vptParam.log_path, vptParam.log_mem, vptParam.log_mem);
141   - LOG_INFO("编译时间：{} {}", __DATE__, __TIME__);
142   -
143   - SourceSingleton::getInstance();
144   -
145   - skip_frame_ = 5;
146   - m_batch_size = 20;
147   -
148   - m_devId = vptParam.gpuid;
149   -
150   - string models_dir = vptParam.models_dir;
151   -
152   - VPTProcess_PARAM vparam;
153   - vparam.gpuid = m_devId;
154   - vparam.max_batch = m_batch_size;
155   - vparam.threshold = 0.4;
156   - vparam.model_dir = models_dir;
157   -
158   - aclrtSetDevice(m_devId);
159   -
160   - int ret = vpt_process.init(vparam);
161   - if (ret < 0){
162   - return ret;
163   - }
164   -
165   -#ifdef USE_VILLAGE
166   - //道路分割
167   - if(seg_process.init(vptParam.gpuid, models_dir) != 0) {
168   - LOG_FATAL("Init road_seg failed");
169   - return -1;
170   - }
171   - if(seg3cls_process.init(vptParam.gpuid, models_dir) != 0) {
172   - LOG_FATAL("Init road_3clsseg failed");
173   - return -1;
174   - }
175   -
176   -
177   - //三轮车头肩检测
178   - if (!tricycle_manned_.init(vptParam.gpuid, models_dir)) {
179   - LOG_FATAL("Init tricycle_hs failed");
180   - return -1;
181   - }
182   - //货车头肩检测
183   - if (!truck_manned_.init(vptParam.gpuid, models_dir)) {
184   - LOG_FATAL("Init truck_hs failed");
185   - return -1;
186   - }
187   - //二轮车头肩检测
188   - if (!motor_hsprocess_.init(vptParam.gpuid, models_dir)) {
189   - LOG_FATAL("Init motor_hs failed");
190   - return -1;
191   - }
192   -
193   - //二轮车使用手机及加雨棚
194   - if (!motor_refit_phoneprocess_.init(vptParam.gpuid, models_dir)) {
195   - LOG_FATAL("Init motor_phone failed");
196   - return -1;
197   - }
198   - /*
199   - //二轮车使用手机检测
200   - if (!motor_phoneprocess_.init(vptParam.gpuid, models_dir)) {
201   - LOG_FATAL("Init motor_phone failed");
202   - return -1;
203   - }*/
204   - //电动车改装(加雨棚)
205   - if (!motor_refitprocess_.init(vptParam.gpuid, models_dir)) {
206   - LOG_FATAL("Init motor_refit failed");
207   - return -1;
208   - }
209   - // 行人/二轮车闯红灯
210   - if (!traffic_lightprocess_.init(vptParam.gpuid, models_dir)) {
211   - LOG_FATAL("Init traffic_light failed");
212   - return -1;
213   - }
214   - // 与道路分割相关的算法
215   - if (!roadseg_corrprocess_.init(vptParam.gpuid, models_dir)) {
216   - LOG_FATAL("Init roadseg_corrprocess failed");
217   - return -1;
218   - }
219   -#endif
220   -
221   - #ifdef WITH_FACE_DET_SS
222   - // 人脸检测初始化
223   - facedet_ai_engine_param fd_param;
224   - char model_path_yolov5s[100];
225   - strcpy(model_path_yolov5s, (models_dir + "/models/face_detect/face_det_yolov5s_310p.om").c_str());
226   - fd_param.sdk_param.det_modelNames = model_path_yolov5s;
227   - char model_path_ldmk[100];
228   - strcpy(model_path_ldmk, (models_dir + "/models/face_detect/face_ldmk_310p.om").c_str());
229   - fd_param.sdk_param.ldmk_modelNames = model_path_ldmk;
230   - char model_path_pose[100];
231   - strcpy(model_path_pose, (models_dir + "/models/face_detect/face_pose_310p.om").c_str());
232   - fd_param.sdk_param.pose_modelNames = model_path_pose;
233   - char model_path_score[100];
234   - strcpy(model_path_score, (models_dir + "/models/face_detect/face_score_310p.om").c_str());
235   - fd_param.sdk_param.score_modelNames = model_path_score;
236   - char model_path_fuzzy[100];
237   - strcpy(model_path_fuzzy, (models_dir + "/models/face_detect/face_fuzzy_310p.om").c_str());
238   - fd_param.sdk_param.fuzzy_modelNames = model_path_fuzzy;
239   - char model_path_occlusion[100];
240   - strcpy(model_path_occlusion, (models_dir + "/models/face_detect/face_occlusion_310p.om").c_str());
241   - fd_param.sdk_param.occlusion_modelNames = model_path_occlusion;
242   - fd_param.sdk_param.thresld = 0.6;
243   - fd_param.sdk_param.devId = m_devId;
244   - fd_param.sdk_param.auth_license = "sy_tongtu_aiplatform_sdk_2023";
245   - fd_param.sdk_param.facial_fea_point_config = SY_CONFIG_OPEN; //是否启动关键点检测
246   - fd_param.sdk_param.pose_config = SY_CONFIG_OPEN; //是否启动姿态角
247   - fd_param.sdk_param.quality_config = SY_CONFIG_OPEN; //是否启动质量检测
248   - fd_param.sdk_param.score_config = SY_CONFIG_OPEN; //是否启动人脸置信度 //SY_CONFIG_OPEN SY_CONFIG_CLOSE
249   - fd_param.sdk_param.max_result_count = 50;
250   - ret = m_face_det_ai_engine.init_ai_engine(fd_param);
251   - if (ret < 0 ) {
252   - LOG_FATAL("Init face detection failed");
253   - return ret;
254   - }
255   -#endif
256   -
257   - m_task_param_manager = task_param_manager::getInstance();
258   - m_snapshot_reprocessing = new snapshot_reprocessing(m_devId);
259   - m_save_snapshot_reprocessing = new save_snapshot_reprocessing(m_devId);
260   -
261   -#ifdef POST_USE_RABBITMQ
262   - mq_manager_ = new mq::Manager();
263   -#endif
264   -
265   - VPCUtil* pVpcUtil = VPCUtil::getInstance();
266   - pVpcUtil->init(m_devId);
267   -
268   - m_pAlgorthimThread = new thread([](void* arg) {
269   - CMultiSourceProcess* process = (CMultiSourceProcess*)arg ;
270   - process->algorthim_process_thread();
271   - return (void*)0;
272   - }
273   - , this);
274   -
275   - m_recode_thread = new thread([](void* arg) {
276   - CMultiSourceProcess* process = (CMultiSourceProcess*)arg ;
277   - process->recode_thread();
278   - return (void*)0;
279   - }
280   - , this);
281   -
282   - m_timing_snapshot_thread = new std::thread(
283   - [](void* arg)
284   - {
285   - CMultiSourceProcess* _this=(CMultiSourceProcess*)arg;
286   - if(_this != nullptr){
287   - _this->timing_snapshot_thread();
288   - }else{
289   - LOG_ERROR("定时抓拍线程启动失败 !");
290   - }
291   - return (void*)0;
292   - }, this);
293   -
294   - if(nullptr == m_timing_snapshot_thread){
295   - LOG_ERROR("定时抓拍线程启动失败 !");
296   - }
297   -
298   - LOG_INFO("InitAlgorthim succeed !");
299   -
300   - return 0;
301   -}
302   -
303   -#ifdef POST_USE_RABBITMQ
304   -/* MQ队列的初始化 */
305   -int CMultiSourceProcess::AddMqConn(mq_type_t mq_type, rabbitmq_conn_params_t mq_conn_param) {
306   - /* 初始化MQ队列 */
307   - LOG_INFO("初始化MQ队列");
308   - if(mq_manager_ == nullptr){
309   - LOG_ERROR("mq_manager_ is null");
310   - return FAILED;
311   - }
312   -
313   - if (!mq_manager_->add_conn(mq_type, mq_conn_param)) {
314   - LOG_ERROR("Connection MQ failed, ip: {} port: {} uname: {} passwd: {}", mq_conn_param.ip, mq_conn_param.port,
315   - mq_conn_param.uname, mq_conn_param.passwd);
316   - return MQ_CONN_ERROR;
317   - }
318   -
319   - LOG_INFO("为报警类 绑定MQ回调");
320   - /* 为报警类 绑定回调 传入mq_manager_.publish 内部直接调用*/
321   - if (m_save_snapshot_reprocessing!= nullptr && mq_type_t::ALARM_MQ == mq_type) {
322   - m_save_snapshot_reprocessing->set_callback(
323   - std::bind(&mq::Manager::publish, mq_manager_, mq_type, std::placeholders::_1, true));
324   - LOG_INFO("为报警类 绑定MQ回调 成功！");
325   - }
326   -
327   - LOG_INFO("初始化MQ队列成功！");
328   -
329   - return SUCCESS;
330   -}
331   -
332   -/* 获取任务的状态 MQ返回 */
333   -int CMultiSourceProcess::GetTaskStatus(const string taskID) {
334   -
335   - DecoderManager* pDecManager = DecoderManager::getInstance();
336   -
337   - std::vector<std::string> taskids;
338   - std::vector<int> statues;
339   - if(pDecManager->isPausing(taskID)){
340   - taskids.emplace_back(taskID);
341   - statues.emplace_back(2);
342   - }else if(pDecManager->isRunning(taskID)){
343   - taskids.emplace_back(taskID);
344   - statues.emplace_back(1);
345   - }
346   -
347   - if (!taskids.empty()) {
348   - auto json_str = helpers::gen_json::gen_task_status_json(taskids, statues);
349   - mq_manager_->publish(mq_type_t::GET_TASK_MQ, json_str.c_str(),true);
350   - }
351   -
352   - return SUCCESS;
353   -}
354   -#endif
355   -
356   -bool CMultiSourceProcess::AddTask(task_param _cur_task_param){
357   - DecoderManager* pDecManager = DecoderManager::getInstance();
358   -
359   - const char* task_id = _cur_task_param.task_id;
360   -
361   - MgrDecConfig config;
362   - config.name = task_id;
363   - config.cfg.uri = _cur_task_param.ipc_url;
364   - config.cfg.post_decoded_cbk = post_decod_cbk;
365   - config.cfg.decode_finished_cbk = decode_finished_cbk;
366   - config.cfg.force_tcp = true; // rtsp用tcp
367   - config.cfg.gpuid = to_string(m_devId);
368   - config.cfg.skip_frame = skip_frame_;
369   -
370   - if (1 == _cur_task_param.dec_type){
371   - config.cfg.port = _cur_task_param.port;
372   - config.dec_type = DECODER_TYPE_GB28181;
373   - config.cfg.uri = task_id;
374   - if(_cur_task_param.protocal == 0){
375   - // 指定用udp协议
376   - config.cfg.force_tcp = false;
377   - }
378   - config.cfg.request_stream_cbk = _cur_task_param.gb28181_request_stream_callback ;
379   - }else if (2 == _cur_task_param.dec_type){
380   - config.dec_type = DECODER_TYPE_DVPP;
381   - }else {
382   - config.dec_type = DECODER_TYPE_FFMPEG;
383   - }
384   -
385   - AbstractDecoder* dec = pDecManager->createDecoder(config);
386   - if (!dec){
387   - return false;
388   - }
389   -
390   - decode_cbk_userdata* userPtr = new decode_cbk_userdata;
391   - userPtr->task_id = string(task_id);
392   - userPtr->opaque = this;
393   - userPtr->opaque1 = dec;
394   - pDecManager->setPostDecArg(config.name, userPtr);
395   - pDecManager->setFinishedDecArg(config.name, userPtr);
396   -
397   - // pDecManager->setDecKeyframe(config.name, true); // 只对关键帧解码
398   -
399   -
400   - // 保存新添加任务的配置参数
401   - m_task_param_manager->add_task_param(task_id, _cur_task_param);
402   -
403   - int input_image_width = 0;
404   - int input_image_height = 0;
405   - pDecManager->getResolution(config.name, input_image_width, input_image_height);
406   - LOG_INFO("task_id: {} width: {} height:{}", task_id, input_image_width, input_image_height);
407   -
408   - // 所有参数都准备好之后再启动解码
409   - bool bStart = pDecManager->startDecodeByName(config.name);
410   - if (!bStart){
411   - LOG_INFO("started task {} failed!", config.name);
412   - pDecManager->closeDecoderByName(config.name);
413   - return false;
414   - }
415   -
416   -#ifdef POST_USE_RABBITMQ
417   - mq_type_t mq_type = mq_type_t::ALARM_MQ;
418   - pDecManager->set_mq_callback(config.name, std::bind(&mq::Manager::publish, mq_manager_, mq_type, std::placeholders::_1, true));
419   -#endif
420   -
421   - // 人车物跟踪
422   - if (task_has_vpt_algor(task_id))
423   - vpt_process.addTaskTracker(task_id, 1, 1, skip_frame_);
424   -
425   - // 人脸跟踪
426   -#ifdef WITH_FACE_DET_SS
427   - if (task_has_face_algor(task_id))
428   - m_face_det_ai_engine.add_tracker(task_id, skip_frame_); // 跳帧数暂时写死
429   -#endif
430   -
431   - m_FinishedTaskMtx.lock();
432   - m_FinishedTaskMap[task_id] = false;
433   - m_FinishedTaskMtx.unlock();
434   -
435   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
436   - if (algor_map != nullptr){
437   - /* 如果开启了行人 机动车非法闯入功能 生成闯入区域mask */
438   - if (algor_map->find(algorithm_type_t::PEDESTRIAN_TRESPASS) != algor_map->end()) {
439   - pedestrian_vehicle_trespass_.pedestrianvehicletrespass_init_region(
440   - task_id, algorithm_type_t::PEDESTRIAN_TRESPASS, input_image_width, input_image_height);
441   - }
442   -
443   - if (algor_map->find(algorithm_type_t::VEHICLE_TRESPASS) != algor_map->end()) {
444   - pedestrian_vehicle_trespass_.pedestrianvehicletrespass_init_region(
445   - task_id, algorithm_type_t::VEHICLE_TRESPASS, input_image_width, input_image_height);
446   - }
447   -
448   - // 设置定时截图的时间间隔
449   - auto algor = algor_map->find(algorithm_type_t::VIDEO_TIMING_SNAPSHOT);
450   - if(algor != algor_map->end()){
451   - task_param_manager::algo_param_type_t_* cur_task_params = algor->second;
452   - if(cur_task_params){
453   - int frame_stride = ((algor_config_video_timing_snapshot*)cur_task_params->algor_param)->frame_stride;
454   - LOG_INFO("task {} snap time interval: {} s", config.name, frame_stride);
455   - // 单位是ms, 乘以 1000 编成s
456   - dec->setSnapTimeInterval(frame_stride * 1000);
457   - }
458   - }
459   -
460   - // 测试代码
461   - // auto algor_face = algor_map->find(algorithm_type_t::FACE_SNAPSHOT);
462   - // if(algor_face != algor_map->end()){
463   - // const algor_basic_config_param_t *cur_param = ((algor_init_config_param_t *)(algor_face->second))->basic_param;
464   - // LOG_INFO("face_snapshot, result_folder: {} result_folder_little: {}", cur_param->result_folder, cur_param->result_folder_little);
465   - // }
466   - }
467   -
468   - LOG_INFO("started task {} successed!", config.name);
469   -
470   - return true;
471   -}
472   -
473   -int CMultiSourceProcess::CountRunningTask() {
474   - DecoderManager* pDecManager = DecoderManager::getInstance();
475   - return pDecManager->count();
476   -}
477   -
478   -bool CMultiSourceProcess::task_has_vpt_algor(const std::string &task_id){
479   - //! TODO: create enum iterator.
480   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
481   - if (algor_map == nullptr)
482   - return false;
483   -
484   - return (algor_map->find(algorithm_type_t::HUMAN_GATHER) != algor_map->end() ||
485   - algor_map->find(algorithm_type_t::HUMAN_SNAPSHOT) != algor_map->end() ||
486   - algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT) != algor_map->end() ||
487   - algor_map->find(algorithm_type_t::SMOKING_DET) != algor_map->end() ||
488   - algor_map->find(algorithm_type_t::NO_REFLECTIVE_CLOTHING) != algor_map->end() ||
489   - algor_map->find(algorithm_type_t::NO_SAFETY_HELMET) != algor_map->end() ||
490   - algor_map->find(algorithm_type_t::CALL_PHONE_DET) != algor_map->end() ||
491   - algor_map->find(algorithm_type_t::VEHICLE_SNAPSHOT) != algor_map->end() ||
492   - algor_map->find(algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION) != algor_map->end() ||
493   - algor_map->find(algorithm_type_t::PEDESTRIAN_FALL) != algor_map->end() ||
494   - algor_map->find(algorithm_type_t::PEDESTRIAN_FIGHT) != algor_map->end() ||
495   - algor_map->find(algorithm_type_t::PEDESTRIAN_RETROGRADE) != algor_map->end() ||
496   - algor_map->find(algorithm_type_t::VEHICLE_RETROGRADE) != algor_map->end() ||
497   - algor_map->find(algorithm_type_t::PEDESTRIAN_TRESPASS) != algor_map->end() ||
498   - algor_map->find(algorithm_type_t::VEHICLE_TRESPASS) != algor_map->end() ||
499   - algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET) != algor_map->end() ||
500   - algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN) != algor_map->end() ||
501   - algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE) != algor_map->end() ||
502   - algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_REFIT) != algor_map->end() ||
503   - algor_map->find(algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS) != algor_map->end() ||
504   - algor_map->find(algorithm_type_t::NONMOTOR_CEOSSPARKLINE) != algor_map->end() ||
505   - algor_map->find(algorithm_type_t::NONMOTOR_IN_VEHICLELANE) != algor_map->end() ||
506   - algor_map->find(algorithm_type_t::NONMOTOR_WRONGDIRECTION) != algor_map->end() ||
507   - algor_map->find(algorithm_type_t::PERSON_IN_VEHICLELANE) != algor_map->end() ||
508   - algor_map->find(algorithm_type_t::PERSON_RUNNING_REDLIGHTS) != algor_map->end() ||
509   - algor_map->find(algorithm_type_t::PERSON_CROSS) != algor_map->end() ||
510   - algor_map->find(algorithm_type_t::VEHICLE_WRONGDIRECTION) != algor_map->end() ||
511   - algor_map->find(algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND) != algor_map->end() ||
512   - algor_map->find(algorithm_type_t::VEHICLE_NOTGIVEWAY) != algor_map->end() ||
513   - algor_map->find(algorithm_type_t::VEHICLE_NOTDECELERATION) != algor_map->end() ||
514   - algor_map->find(algorithm_type_t::TRICYCLE_MANNED) != algor_map->end() ||
515   - algor_map->find(algorithm_type_t::TRUCK_MANNED) != algor_map->end());
516   -}
517   -
518   -bool CMultiSourceProcess::task_has_face_algor(const std::string &task_id){
519   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
520   - if (nullptr != algor_map){
521   - return algor_map->find(algorithm_type_t::FACE_SNAPSHOT) != algor_map->end();
522   - }
523   -
524   - return false;
525   -}
526   -
527   -void CMultiSourceProcess::decoded_cbk(DeviceMemory* devFrame){
528   -
529   - do{
530   - if(m_bfinish){
531   - break;
532   - }
533   - m_DataListMtx.lock();
534   - if(m_RgbDataList.size() >= 100){ //缓存100帧
535   - m_DataListMtx.unlock();
536   - std::this_thread::sleep_for(std::chrono::milliseconds(3));
537   - continue;
538   - }
539   - m_RgbDataList.push_back(devFrame);
540   - m_DataListMtx.unlock();
541   - break;
542   - }while (true);
543   -}
544   -
545   -void CMultiSourceProcess::task_finished(const string task_id){
546   -
547   - std::lock_guard<std::mutex> l(m_FinishedTaskMtx);
548   -
549   - m_FinishedTaskMap[task_id] = true;
550   -
551   - LOG_INFO("task {} finished!", task_id);
552   -}
553   -
554   -bool CMultiSourceProcess::PauseTask(const string taskID){
555   - DecoderManager* pDecManager = DecoderManager::getInstance();
556   - return pDecManager->pauseDecoder(taskID);
557   -}
558   -
559   -bool CMultiSourceProcess::RestartTask(const string taskID){
560   - DecoderManager* pDecManager = DecoderManager::getInstance();
561   - return pDecManager->resumeDecoder(taskID);
562   -}
563   -
564   -bool CMultiSourceProcess::FinishTask(const string taskID){
565   - DecoderManager* pDecManager = DecoderManager::getInstance();
566   - // return pDecManager->closeDecoderByName(taskID);
567   -
568   - // 记录主动结束的任务
569   - bool flag = pDecManager->closeDecoderByName(taskID);
570   -#ifdef POST_USE_RABBITMQ
571   - if (flag) {
572   - std::lock_guard<std::mutex> l1(m_ActiveFinishedTaskMtx);
573   - m_ActiveFinishedTaskMap[taskID] = true;
574   - }
575   -#endif
576   - return flag;
577   -}
578   -
579   -int CMultiSourceProcess::snapshot_task(std::string& uri_or_name, const std::string& file_name, bool bInTask) {
580   - DecoderManager* pDecManager = DecoderManager::getInstance();
581   -
582   - DeviceMemory* devMem = nullptr;
583   - if(bInTask) {
584   - LOG_INFO("snap in task");
585   - devMem = pDecManager->snapshot_in_task(uri_or_name);
586   - } else {
587   - LOG_INFO("snap out task");
588   - devMem = pDecManager->snapshot_out_task(uri_or_name, m_devId);
589   - }
590   - if(devMem != nullptr) {
591   - JpegUtil jpegUtil;
592   - jpegUtil.jpeg_init(m_devId);
593   -
594   - acldvppPicDesc *vpcDesc= acldvppCreatePicDesc();
595   - acldvppSetPicDescData(vpcDesc, devMem->getMem());
596   - acldvppSetPicDescFormat(vpcDesc, PIXEL_FORMAT_YUV_SEMIPLANAR_420);
597   - acldvppSetPicDescWidth(vpcDesc, devMem->getWidth());
598   - acldvppSetPicDescHeight(vpcDesc, devMem->getHeight());
599   - acldvppSetPicDescWidthStride(vpcDesc, devMem->getWidthStride());
600   - acldvppSetPicDescHeightStride(vpcDesc, devMem->getHeightStride());
601   - acldvppSetPicDescSize(vpcDesc, devMem->getSize());
602   -
603   - jpegUtil.jpeg_encode(vpcDesc, file_name);
604   -
605   - acldvppDestroyPicDesc(vpcDesc);
606   -
607   - jpegUtil.jpeg_release();
608   -
609   - delete devMem;
610   - devMem = nullptr;
611   -
612   - return SUCCESS;
613   - }
614   -
615   - return FAILED;
616   -}
617   -
618   -int CMultiSourceProcess::SnapShot(task_param _cur_task_param) {
619   - LOG_INFO("begin SnapShot task: {}", _cur_task_param.task_id);
620   -
621   - /* 添加任务参数 */
622   - auto &algor_config_param = _cur_task_param.algor_config_params[0]; // 默认算法数量为1
623   -
624   - /* 拷贝通用的算法参数 */
625   - auto src_basic_param = algor_config_param.algor_init_config_param->basic_param;
626   - if (src_basic_param->result_folder) {
627   - CreateResultFolder(src_basic_param->result_folder, "");
628   - } else {
629   - src_basic_param->result_folder = "";
630   - }
631   -
632   - std::string cur_timestamp_ms = std::to_string(helpers::timer::get_timestamp<std::chrono::milliseconds>());
633   - std::string file_name = std::string(src_basic_param->result_folder) + helpers::os::sep + _cur_task_param.task_id + "_snap_" + cur_timestamp_ms + ".jpg";
634   -
635   - // file_name = "/mnt/data/cmhu/tongtu/Linux_3rdparty/tsl_sdk_20220801/res/snap.jpg";
636   - string task_id = _cur_task_param.task_id;
637   - int bSnapShot = snapshot_task(task_id, file_name, true);
638   - if (FAILED == bSnapShot){
639   - string url = _cur_task_param.ipc_url;
640   - bSnapShot = snapshot_task(url, file_name, false);
641   - }
642   - if(SUCCESS == bSnapShot){
643   -#ifdef POST_USE_RABBITMQ
644   - auto json_str = helpers::gen_json::gen_screen_json(task_id, file_name);
645   - // mq_manager_->publish(mq_type_t::GET_TASK_MQ, json_str.c_str(), true);
646   - mq_manager_->publish(mq_type_t::SCREENSHORT_TASK_MQ, json_str.c_str(), true);
647   -#endif
648   - LOG_INFO("SnapShot task: {} success", task_id);
649   - } else {
650   - LOG_ERROR("SnapShot task: {} failed !", task_id);
651   - }
652   -
653   - return bSnapShot;
654   -}
655   -
656   -void CMultiSourceProcess::CloseAllTask(){
657   - m_bfinish = true;
658   - atlas_licence_close(&(skt_handle)); //授权
659   - DecoderManager* pDecManager = DecoderManager::getInstance();
660   - pDecManager->closeAllDecoder();
661   -
662   - if(m_pAlgorthimThread){
663   - m_pAlgorthimThread->join();
664   - m_pAlgorthimThread = nullptr;
665   - }
666   -
667   - if(m_recode_thread){
668   - m_recode_thread->join();
669   - m_recode_thread = nullptr;
670   - }
671   -
672   - if(m_timing_snapshot_thread != nullptr && m_timing_snapshot_thread->joinable()){
673   - m_timing_snapshot_thread->join();
674   - m_timing_snapshot_thread = nullptr;
675   - }
676   -
677   - m_DataListMtx.lock();
678   - while (!m_RgbDataList.empty()){
679   - DeviceMemory* gpuMem = m_RgbDataList.front();
680   - delete gpuMem;
681   - gpuMem = nullptr;
682   - m_RgbDataList.pop_front();
683   - }
684   - m_DataListMtx.unlock();
685   -
686   - int size = m_RgbDataList.size();
687   - bool bEmpty = m_RgbDataList.empty();
688   -
689   - LOG_INFO("CloseAllTask exit.");
690   -}
691   -
692   -void CMultiSourceProcess::CloseAllTask2() {
693   - DecoderManager* pDecManager = DecoderManager::getInstance();
694   - pDecManager->closeAllDecoder();
695   -}
696   -
697   -void CMultiSourceProcess::clear_finished_task(){// 清理已经结束的任务
698   -
699   - std::lock_guard<std::mutex> l1(m_FinishedTaskMtx);
700   - std::lock_guard<std::mutex> l2(m_DataListMtx);
701   -
702   - for (auto iter_finished = m_FinishedTaskMap.begin(); iter_finished!=m_FinishedTaskMap.end(); ){
703   - if(iter_finished->second){
704   - // 解码已经结束
705   - // 判断数据对列中是否还有数据
706   - string task_id = iter_finished->first;
707   - bool bFinished = true;
708   - for (auto iter = m_RgbDataList.begin(); iter!=m_RgbDataList.end(); ++ iter){
709   - DeviceMemory* gpuMem = *iter;
710   - if(task_id == gpuMem->getId()){
711   - bFinished = false;
712   - break;
713   - }
714   - }
715   -
716   - if (bFinished){
717   - // 解码器已经结束，且数据队列中没有改任务的数据，则做最后任务清理工作
718   - finish_task(task_id,false);
719   - iter_finished = m_FinishedTaskMap.erase(iter_finished);
720   - continue;
721   - }
722   - }
723   -
724   - ++ iter_finished;
725   - }
726   -}
727   -
728   -bool CMultiSourceProcess::finish_task(const string taskID, const bool delete_snapshot){
729   -
730   - // 任务结束，关闭跟踪
731   - if (!vpt_process.finishTaskTracker(taskID))
732   - LOG_ERROR("Finish VPT Tracker failed, task_id: {}", taskID);
733   -
734   -#ifdef WITH_FACE_DET_SS
735   - // 人脸任务结束
736   - if (task_has_face_algor(taskID))
737   - m_face_det_ai_engine.finish_task(taskID);
738   -#endif
739   -
740   -#ifdef POST_USE_RABBITMQ
741   - {
742   - // 外部主动结束的任务不推送mq
743   - std::lock_guard<std::mutex> mlock(m_ActiveFinishedTaskMtx);
744   - if (!(m_ActiveFinishedTaskMap.count(taskID) && m_ActiveFinishedTaskMap[taskID])) {
745   - auto json_str = helpers::gen_json::gen_office_task_heart_beat_json({taskID});
746   - mq_manager_->publish(mq_type_t::HEART_BEAT_MQ, json_str.c_str(), true);
747   - }
748   - if (m_ActiveFinishedTaskMap.count(taskID)) m_ActiveFinishedTaskMap.erase(taskID);
749   - }
750   -#endif
751   -
752   -// #ifdef WITH_SECOND_PROCESS
753   - pedestrian_vehicle_retrograde_.force_release_result(taskID); //221024 byzsh
754   -// #endif
755   -#ifdef USE_VILLAGE
756   - tricycle_manned_.force_release_result(taskID);
757   - truck_manned_.force_release_result(taskID);
758   - motor_hsprocess_.force_release_result(taskID);
759   - motor_refit_phoneprocess_.force_release_result(taskID);
760   - // motor_phoneprocess_.force_release_result(taskID);
761   - motor_refitprocess_.force_release_result(taskID);
762   - traffic_lightprocess_.force_release_result(taskID);
763   - roadseg_corrprocess_.force_release_result(taskID);
764   -
765   - m_RoadSegTaskMtx.lock();
766   - if (m_RoadSegTaskMap.count(taskID)) {
767   - for (int i = 0; i < m_RoadSegTaskMap[taskID].traffic_region.size(); i++) {
768   - vector<int>().swap(m_RoadSegTaskMap[taskID].traffic_region[i]);
769   - }
770   - for (int i = 0; i < m_RoadSegTaskMap[taskID].fence_region.size(); i++) {
771   - vector<int>().swap(m_RoadSegTaskMap[taskID].fence_region[i]);
772   - }
773   - vector<int>().swap(m_RoadSegTaskMap[taskID].labels);
774   - vector<int>().swap(m_RoadSegTaskMap[taskID].fence_labels);
775   - vector<vector<int>>().swap(m_RoadSegTaskMap[taskID].traffic_region);
776   - vector<vector<int>>().swap(m_RoadSegTaskMap[taskID].fence_region);
777   - m_RoadSegTaskMap.erase(taskID);
778   - }
779   - m_RoadSegTaskMtx.unlock();
780   - m_TotalObjMtx.lock();
781   - for(auto ss = m_total_obj_info.begin(); ss != m_total_obj_info.end(); ) {
782   - if (strcmp(ss->first.video_id.c_str(), taskID.c_str()) == 0) {
783   - vector<sy_point>().swap(ss->second.center_points);
784   - m_total_obj_info.erase(ss++);
785   - }
786   - else ss++;
787   - }
788   - m_TotalObjMtx.unlock();
789   -#endif
790   - m_task_param_manager->delete_task_param(taskID);
791   - m_snapshot_reprocessing->release_finished_locus_snapshot(taskID);
792   - m_snapshot_reprocessing->release_finished_face_locus_snapshot(taskID);
793   - m_snapshot_reprocessing->release_village_finished_locus_snapshot(taskID);
794   -
795   - return true;
796   -}
797   -
798   -int CMultiSourceProcess::algorthim_process_thread(){
799   - LOG_INFO("algorthim_process_thread start...");
800   -
801   - ACL_CALL(aclrtSetDevice(m_devId), ACL_SUCCESS, 1);
802   - aclrtContext ctx;
803   - ACL_CALL(aclrtCreateContext(&ctx, m_devId), ACL_SUCCESS, 1);
804   -
805   - while (true){
806   -#ifdef USE_VILLAGE
807   - if (!CheckTime()) {
808   - LOG_FATAL("authority failed!");
809   - break;
810   - }
811   -#else
812   - //授权相关------------------------------------
813   - if(check_label == -1) {
814   - printf("sy_atlas_licence_check failed.\n");
815   - break;
816   - }
817   - //获取系统时间，每个月1号check一次授权
818   - struct tm* info;
819   - int nYear, nMonth, nDay;
820   - time_t raw;
821   - time(&raw);
822   - info = localtime(&raw);
823   - //nYear = info->tm_year + 1900;
824   - //nMonth = info->tm_mon + 1;
825   - nDay = info->tm_mday;
826   - if(nDay==1) {
827   - if(check_label ==0) {
828   - std::cout << "atlas_licence_check start." << std::endl;
829   - atlas_licence_check_result check_result;
830   - memset(&check_result, 0, sizeof(atlas_licence_check_result));
831   - check_result.code = -1;
832   -
833   - int res = atlas_licence_check(skt_handle, check_param, &check_result);
834   - if(res!=0) {
835   - std::cout << "sy_licence_check failed." << std::endl;
836   - break;
837   - }
838   - //std::cout << "code:" << check_result.code << ",msg:" << check_result.msg << std::endl;
839   - if(check_result.code!=0) {
840   - check_label = -1;
841   - std::cout << "code:" << check_result.code << ",msg:" << check_result.msg << std::endl;
842   - break;
843   - }
844   - std::cout << "atlas_licence_check end." << std::endl;
845   - check_label =1;
846   - }
847   - }
848   - else {
849   - check_label =0;
850   - }
851   - //授权相关------------------------------------
852   -#endif
853   - if(m_bfinish){
854   - break;
855   - }
856   -
857   - clear_finished_task();
858   -
859   - vector<DeviceMemory*> vec_gpuMem;
860   - m_DataListMtx.lock();
861   -
862   - while (!m_RgbDataList.empty()){
863   - DeviceMemory* gpuMem = m_RgbDataList.front();
864   - // if(gpuMem->getMem() == nullptr) {
865   - if(gpuMem->getMem() == nullptr || gpuMem->getFrameNb() % skip_frame_) { //跳帧
866   - // 错误数据，直接删除
867   - if(gpuMem->getMem() == nullptr) LOG_WARN("mem is null");
868   - delete gpuMem;
869   - gpuMem = nullptr;
870   - } else {
871   - vec_gpuMem.push_back(gpuMem);
872   - }
873   -
874   - m_RgbDataList.pop_front();
875   - if(vec_gpuMem.size() >= m_batch_size){
876   - break;
877   - }
878   - }
879   - m_DataListMtx.unlock();
880   -
881   - if(vec_gpuMem.size() <= 0){
882   - std::this_thread::sleep_for(std::chrono::milliseconds(3));
883   - continue;
884   - }
885   -
886   - aclrtSetCurrentContext(ctx);
887   - // auto record_t1 = std::chrono::system_clock::now();
888   -#ifdef USE_VILLAGE
889   - algorthim_road_seg(vec_gpuMem);
890   -#endif
891   - auto vptprocess1 = std::chrono::system_clock::now();
892   - algorthim_vpt(vec_gpuMem);
893   - auto vptprocess2 = std::chrono::system_clock::now();
894   - auto vptprocess_time = std::chrono::duration_cast<std::chrono::milliseconds>(vptprocess2 - vptprocess1).count();
895   - LOG_INFO("Process per frame cost time: {} ms fps: {}", vptprocess_time/vec_gpuMem.size(), 1000/(vptprocess_time/vec_gpuMem.size()));
896   -
897   -#ifdef WITH_FACE_DET_SS
898   - algorthim_face_detect(vec_gpuMem);
899   -#endif
900   - // auto record_t2 = std::chrono::system_clock::now();
901   - // auto record_time = std::chrono::duration_cast<std::chrono::milliseconds>(record_t2 - record_t1).count();
902   - // LOG_INFO("Record per frame cost time: {} ms fps: {}", record_time/vec_gpuMem.size(), 1000/(record_time/vec_gpuMem.size()));
903   - for(int i=0;i < vec_gpuMem.size(); i++){
904   - DeviceMemory* mem = vec_gpuMem[i];
905   - if(mem->getSize() <= 0){
906   - continue;
907   - }
908   - delete mem;
909   - mem = nullptr;
910   - }
911   - vec_gpuMem.clear();
912   - vector<DeviceMemory*>().swap(vec_gpuMem); // free.
913   -
914   - }
915   -
916   - aclrtDestroyContext(ctx);
917   - aclrtResetDevice(m_devId);
918   - LOG_INFO("algorthim_process_thread exit.");
919   -
920   - return 0;
921   -}
922   -
923   -
924   -int CMultiSourceProcess::algorthim_road_seg(vector<DeviceMemory*> vec_gpuMem) {
925   -
926   - vector<string> roadSeg_task_id;
927   - vector<sy_img> roadSeg_imgs;
928   - vector<DeviceMemory*> vec_segMem;
929   - m_RoadSegTaskMtx.lock();
930   - for (int i = 0; i < vec_gpuMem.size(); i++) {
931   - DeviceMemory* mem = vec_gpuMem[i];
932   - long long frame_number = mem->getFrameNb();
933   - if (m_RoadSegTaskMap[mem->getId()].isseg && frame_number % 15000) { //10min重复一次
934   - continue;
935   - }
936   - LOG_INFO("task: {} frame_num: {} perform road_seg.", mem->getId(), mem->getFrameNb());
937   - sy_img img;
938   - img.w_ = mem->getWidth(); img.h_ = mem->getHeight();
939   - img.c_ = mem->getChannel(); img.data_ = mem->getMem();
940   - roadSeg_imgs.push_back(img);
941   - roadSeg_task_id.push_back(mem->getId());
942   - vec_segMem.push_back(mem);
943   - m_RoadSegTaskMap[mem->getId()].isseg = true; //
944   - }
945   - m_RoadSegTaskMtx.unlock();
946   -
947   - /* 待检测的图片不为空 开始检测 */
948   - if (!roadSeg_imgs.empty()) {
949   - vector<vector<vector<int>>> traffic_region, fence_region; //道路区域(多个)
950   - vector<vector<int>> labels, fence_labels; //道路区域对应的类别：机动车道、非机动车道等
951   - seg_process.process_gpu(roadSeg_imgs.data(), vec_segMem, roadSeg_task_id, traffic_region, labels);
952   - seg3cls_process.process_gpu(roadSeg_imgs.data(), vec_segMem, roadSeg_task_id, fence_region, fence_labels);
953   -
954   - int bidx = 0;
955   - m_RoadSegTaskMtx.lock();
956   - for (auto _task_id_iter = roadSeg_task_id.begin(); _task_id_iter != roadSeg_task_id.end(); ++_task_id_iter, ++ bidx) {
957   - auto task_id = *_task_id_iter;
958   - m_RoadSegTaskMap[task_id].traffic_region.assign(traffic_region[bidx].begin(), traffic_region[bidx].end());
959   - m_RoadSegTaskMap[task_id].labels.assign(labels[bidx].begin(), labels[bidx].end());
960   - m_RoadSegTaskMap[task_id].fence_region.assign(fence_region[bidx].begin(), fence_region[bidx].end());
961   - m_RoadSegTaskMap[task_id].fence_labels.assign(fence_labels[bidx].begin(), fence_labels[bidx].end());
962   - m_RoadSegTaskMap[task_id].isseg = true;
963   - }
964   - m_RoadSegTaskMtx.unlock();
965   - }
966   - vec_segMem.clear();
967   - roadSeg_task_id.clear();
968   - roadSeg_imgs.clear();
969   -
970   - return 0;
971   -}
972   -
973   -int CMultiSourceProcess::algorthim_vpt(vector<DeviceMemory*> vec_gpuMem){
974   -
975   - vector<string> vpt_interest_task_id;
976   - vector<sy_img> vpt_interest_imgs;
977   - vector<DeviceMemory*> vec_vptMem;
978   - for (int i = 0; i < vec_gpuMem.size(); i++) {
979   - DeviceMemory* mem = vec_gpuMem[i];
980   - if (!task_has_vpt_algor(mem->getId())){
981   - continue;
982   - }
983   -
984   - sy_img img;
985   - img.w_ = mem->getWidth(); img.h_ = mem->getHeight();
986   - img.c_ = mem->getChannel(); img.data_ = mem->getMem();
987   - vpt_interest_imgs.push_back(img);
988   - vpt_interest_task_id.push_back(mem->getId());
989   - vec_vptMem.push_back(mem);
990   - }
991   -
992   - /* 待检测的图片不为空 开始检测 */
993   - if (!vpt_interest_imgs.empty()) {
994   - vector<vector<int>> deleteObjectID;
995   - deleteObjectID.resize(vpt_interest_task_id.size());
996   - vector<vector<onelevel_det_result>> unUsedResult;
997   - vector<onelevel_det_result> vptResult(0);
998   -
999   - /* 一级检测器，内部已完成跟踪操作 */
1000   - vpt_process.process_gpu(vpt_interest_imgs.data(), vpt_interest_task_id, vptResult, deleteObjectID, unUsedResult); // do det & track.
1001   - // vpt_process.process_gpu(vpt_interest_imgs.data(), vec_vptMem, vpt_interest_task_id, vptResult, deleteObjectID, unUsedResult); // debug
1002   - m_snapshot_reprocessing->screen_effective_snapshot(vptResult);
1003   -
1004   -#ifndef VEHICLE_MULTI_BOXES
1005   - /* 快照优选（内部可实现不同的快照优选策略） */
1006   - m_snapshot_reprocessing->update_bestsnapshot(vec_vptMem, vptResult, deleteObjectID);
1007   - /* for snapshot algorithm. 轨迹结束目标 做最后的结果返回（当前返回算法结果+快照保存路径）*/
1008   - vehicle_snapshot(vpt_interest_task_id, deleteObjectID);
1009   -#else
1010   - algorithm_vehicle_relult(vec_vptMem, vptResult, deleteObjectID);
1011   -
1012   - send_locus_finished_msg(vpt_interest_task_id, deleteObjectID);
1013   -#endif
1014   -
1015   -// #ifdef WITH_SECOND_PROCESS
1016   - /* for pedestrian safety det. 行人安全分析算法模块 */
1017   - // algorthim_pedestrian_safety(vpt_interest_task_id, vpt_interest_imgs,vptResult);
1018   -
1019   - // 逆行
1020   - algorthim_retrograde(vpt_interest_task_id, vec_vptMem, vptResult);
1021   - retrograde_snapshot(vpt_interest_task_id, deleteObjectID);
1022   - // 闯入
1023   - algorthim_trespass(vpt_interest_task_id, vec_vptMem, vptResult, deleteObjectID);
1024   - trespass_snapshot(vpt_interest_task_id, deleteObjectID);
1025   -
1026   -// #endif
1027   -#ifdef USE_VILLAGE
1028   - // 轨迹记录
1029   - trace_record(vpt_interest_task_id, vptResult);
1030   - // 农村违法分析的快照缓存
1031   - m_snapshot_reprocessing->update_village_bestsnapshot(vec_vptMem, vptResult, deleteObjectID);
1032   - // 三轮车载人
1033   - algorithm_tricycle_manned(vpt_interest_task_id, vec_vptMem, vptResult);
1034   - // 货车载人
1035   - algorithm_truck_manned(vpt_interest_task_id, vec_vptMem, vptResult);
1036   - // 二轮车超员/未戴盔
1037   - algorithm_motor_hs_process(vpt_interest_task_id, vec_vptMem, vptResult);
1038   - // 二轮车驾乘人员使用手机(人骑车辅助版本)
1039   - algorithm_motor_refit_phone_process(vpt_interest_task_id, vec_vptMem, vptResult);
1040   - /*// 二轮车驾乘人员使用手机
1041   - algorithm_motor_phone_process(vpt_interest_task_id, vec_vptMem, vptResult);*/
1042   - // 电动车改装(加雨棚)
1043   - algorithm_motor_refit_process(vpt_interest_task_id, vec_vptMem, vptResult);
1044   - // 行人/二轮车闯红灯
1045   - algorithm_traffic_light_process(vpt_interest_task_id, vec_vptMem, vptResult);
1046   - // 与道路分割相关的算法
1047   - algorithm_roadseg_correlation_process(vpt_interest_task_id, vec_vptMem, vptResult);
1048   - village_snapshot(vpt_interest_task_id, vec_vptMem, deleteObjectID);
1049   -#endif
1050   -
1051   - vptResult.clear();
1052   - unUsedResult.clear();
1053   - // deleteObjectID.clear();
1054   - for (int i = 0; i < deleteObjectID.size(); i++) {
1055   - vector<int>().swap(deleteObjectID[i]); // free.
1056   - }
1057   - vector<vector<int>>().swap(deleteObjectID); // free.
1058   - }
1059   -
1060   - vec_vptMem.clear();
1061   - vpt_interest_task_id.clear();
1062   - vpt_interest_imgs.clear();
1063   -
1064   - return 0;
1065   -}
1066   -
1067   -int CMultiSourceProcess::algorithm_vehicle_relult(vector<DeviceMemory*> vec_devMem, vector<onelevel_det_result>& vptResult, vector<vector<int>>& delete_object_id) {
1068   -
1069   - vector<multi_obj_data_t> results = m_snapshot_reprocessing->get_vehicle_snapshot(vec_devMem, vptResult, skip_frame_);
1070   -
1071   - VPCUtil* pVPCUtil = VPCUtil::getInstance();
1072   - for (auto &result : results) {
1073   - if(result.objs.size() <= 0){
1074   - continue;
1075   - }
1076   - auto task_id = result.task_id;
1077   - auto task_other_params = m_task_param_manager->get_task_other_param(task_id);
1078   - const auto &algor_other_params = task_other_params->find(algorithm_type_t::VEHICLE_SNAPSHOT);
1079   - if (algor_other_params == task_other_params->end()) {
1080   - LOG_ERROR("taskId {} not found algor {}", task_id.c_str(), (int)algorithm_type_t::VEHICLE_SNAPSHOT);
1081   - continue;
1082   - }
1083   -
1084   - vector<vpc_img_info> vec_obj_info_list = pVPCUtil->crop_batch(result.memPtr, result.objs);
1085   - if(vec_obj_info_list.size() != result.objs.size()){
1086   - LOG_ERROR("vpc_crop size error !");
1087   - VPCUtil::vpc_imgList_release(vec_obj_info_list);
1088   - continue;
1089   - }
1090   -
1091   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
1092   -
1093   - std::string cur_timestamp_ms = std::to_string(helpers::timer::get_cur_time_ms());
1094   - const std::string fpath_origin = basic_param->result_folder + helpers::os::sep + task_id + "_" +
1095   - std::to_string(result.objs.size()) + "_" + std::to_string(result.id) + "_" + cur_timestamp_ms + ".jpg";
1096   -
1097   - ImgSaveInfo saveInfo;
1098   - saveInfo.file_path = fpath_origin;
1099   - saveInfo.img_info = VPCUtil::vpc_devMem2vpcImg(result.memPtr);
1100   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(saveInfo);
1101   -
1102   - // 保存抠图并发MQ
1103   - for(int i =0; i < result.objs.size(); i++){
1104   - video_object_info obj = result.objs[i];
1105   -
1106   - std::string cur_timestamp_ms = std::to_string(helpers::timer::get_cur_time_ms());
1107   - const std::string fpath_roi = basic_param->result_folder_little + helpers::os::sep + task_id + "_" +
1108   - std::to_string(obj.object_id) + "_" + cur_timestamp_ms + ".jpg";
1109   -
1110   - video_object_snapshot new_obj_ss_info;
1111   - new_obj_ss_info.analysisRes = nullptr;
1112   - new_obj_ss_info.object_id = obj.object_id;
1113   - new_obj_ss_info.obj_info.set_data(obj.index, obj.confidence, obj.left, obj.top, obj.right, obj.bottom);
1114   - strcpy(new_obj_ss_info.task_id, task_id.c_str());
1115   - strcpy(new_obj_ss_info.video_image_path, fpath_origin.c_str());
1116   - strcpy(new_obj_ss_info.snapshot_image_path, fpath_roi.c_str());
1117   - new_obj_ss_info.nFinished = 0;
1118   - string json_str = helpers::gen_json::gen_multi_obj_json(algorithm_type_t::VEHICLE_SNAPSHOT, new_obj_ss_info);
1119   -
1120   - ImgSaveInfo save_info;
1121   - save_info.file_path = fpath_roi;
1122   - save_info.img_info = vec_obj_info_list[i];
1123   - save_info.json_str = json_str;
1124   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(save_info);
1125   -
1126   - OBJ_KEY obj_key{task_id, obj.object_id};
1127   - // 保存有轨迹的object记录，轨迹结束时需要发消息
1128   - std::lock_guard<std::mutex> l(m_total_mutex);
1129   - m_total_snapshot_info_multi_object.insert(obj_key);
1130   - }
1131   -
1132   - vec_obj_info_list.clear();
1133   - }
1134   -
1135   - return 0;
1136   -}
1137   -
1138   -void CMultiSourceProcess::send_locus_finished_msg(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID){
1139   - auto task_iter = vpt_interest_task_id.begin();
1140   -
1141   - for (int i = 0; i < deleteObjectID.size(); i++, ++task_iter) // loop taskId.
1142   - {
1143   - string task_id = *task_iter;
1144   - for (int &j : deleteObjectID[i]) // loop algor type.
1145   - {
1146   - OBJ_KEY obj_key = {task_id, j};
1147   -
1148   - auto task_param_ptr = m_task_param_manager->get_task_algor_param(task_id);
1149   -
1150   - // 该路任务开启了抓拍功能 开始抓拍保存；若未开启抓拍，清空显存资源
1151   - if (task_param_ptr->vehicle_algors.find(algorithm_type_t::VEHICLE_SNAPSHOT) != task_param_ptr->vehicle_algors.end()) {
1152   - std::lock_guard<std::mutex> l(m_total_mutex);
1153   - if (m_total_snapshot_info_multi_object.find(obj_key) != m_total_snapshot_info_multi_object.end()) {
1154   - video_object_snapshot new_obj_ss_info;
1155   - new_obj_ss_info.object_id = j;
1156   - new_obj_ss_info.nFinished = 1;
1157   - strcpy(new_obj_ss_info.task_id, task_id.c_str());
1158   - string json_str = helpers::gen_json::gen_multi_obj_json(algorithm_type_t::VEHICLE_SNAPSHOT, new_obj_ss_info);
1159   - // 通知结束的轨迹
1160   - ImgSaveInfo save_info;
1161   - save_info.json_str = json_str;
1162   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(save_info);
1163   -
1164   - m_total_snapshot_info_multi_object.erase(obj_key);
1165   - }
1166   - }
1167   - }
1168   - }
1169   -}
1170   -
1171   -// for snapshot algorithm. 轨迹结束目标 做最后的结果返回（当前返回算法结果+快照保存路径）
1172   -void CMultiSourceProcess::vehicle_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID) {
1173   - auto task_iter = vpt_interest_task_id.begin();
1174   -
1175   - for (int i = 0; i < deleteObjectID.size(); i++, ++task_iter) // loop taskId.
1176   - {
1177   - for (int &j : deleteObjectID[i]) // loop algor type.
1178   - {
1179   - OBJ_KEY obj_key = {*task_iter, j};
1180   - // 该路任务开启了抓拍功能 开始抓拍保存；若未开启抓拍，清空显存资源
1181   - vehicle_locus_finished(obj_key);
1182   - }
1183   - }
1184   -}
1185   -
1186   -void CMultiSourceProcess::vehicle_locus_finished(const OBJ_KEY obj_key) {
1187   -
1188   - auto task_param_ptr = m_task_param_manager->get_task_algor_param(obj_key.video_id);
1189   - if (task_param_ptr == nullptr){
1190   - return;
1191   - }
1192   -
1193   - // 该路任务开启了抓拍功能 开始抓拍保存；若未开启抓拍，清空显存资源
1194   - if ((task_param_ptr->human_algors.find(algorithm_type_t::HUMAN_SNAPSHOT) == task_param_ptr->human_algors.end() &&
1195   - task_param_ptr->vehicle_algors.find(algorithm_type_t::VEHICLE_SNAPSHOT) != task_param_ptr->vehicle_algors.end() &&
1196   - task_param_ptr->nonmotor_vehicle_algors.find(algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT) != task_param_ptr->nonmotor_vehicle_algors.end())) {
1197   - return;
1198   - }
1199   -
1200   - map<OBJ_KEY, OBJ_VALUE> _total_snapshot_info = m_snapshot_reprocessing->get_total_snapshot_info();
1201   - if(_total_snapshot_info.size() <= 0){
1202   - return;
1203   - }
1204   -
1205   - LOG_DEBUG("_total_snapshot_info size: {}", _total_snapshot_info.size());
1206   -
1207   - auto it = _total_snapshot_info.find(obj_key);
1208   - if (it == _total_snapshot_info.end()) {
1209   - return;
1210   - }
1211   -
1212   - const OBJ_VALUE obj_value = it->second;
1213   -
1214   - auto task_other_param_map = m_task_param_manager->get_task_other_params();
1215   - auto it_other_param = task_other_param_map.find(obj_key.video_id);
1216   - if(it_other_param == task_other_param_map.end()){
1217   - return;
1218   - }
1219   - auto task_other_param = it_other_param->second;
1220   -
1221   - LOG_DEBUG("algor_type");
1222   - auto algor_type = index_to_algo_type[obj_value.index.index];
1223   -
1224   - LOG_DEBUG("task_other_param");
1225   - auto it_algor_type = task_other_param.find(algor_type);
1226   - if(it_algor_type == task_other_param.end()) {
1227   - return;
1228   - }
1229   -
1230   - LOG_DEBUG("algor_param");
1231   - auto algor_param = (algor_config_param_snapshot *)it_algor_type->second->algor_param;
1232   - if(algor_param == nullptr) {
1233   - return;
1234   - }
1235   -
1236   - if (obj_value.confidence <= algor_param->threshold) {
1237   - LOG_DEBUG("Snapshot conf filter ({} vs {})", obj_value.confidence, algor_param->threshold);
1238   - // 删除记录，同时释放显存
1239   - m_snapshot_reprocessing->release_finished_locus_snapshot(obj_key.video_id, obj_key.obj_id, true);
1240   - return;
1241   - }
1242   -
1243   - LOG_DEBUG("cur_param");
1244   - const algor_basic_config_param_t *cur_param = it_algor_type->second->basic_param;
1245   - // const algor_basic_config_param_t *cur_param = task_other_param[algor_type]->basic_param;
1246   - if(cur_param == nullptr) {
1247   - return;
1248   - }
1249   -
1250   - // 原图
1251   - LOG_DEBUG("原图");
1252   - std::string cur_timestamp_ms = std::to_string(helpers::timer::get_cur_time_ms());
1253   - std::string fpath_origin = std::string(cur_param->result_folder) + helpers::os::sep + obj_key.video_id + "_" +
1254   - std::to_string(obj_key.obj_id) + "_" + cur_timestamp_ms + ".jpg";
1255   -
1256   - ImgSaveInfo origin_save_info;
1257   - origin_save_info.file_path = fpath_origin;
1258   - origin_save_info.img_info = obj_value.snapShot;
1259   - origin_save_info.obj_rect = obj_value.obj_pos;
1260   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(origin_save_info);
1261   -
1262   - {
1263   - LOG_DEBUG("抠图");
1264   - // 抠图
1265   - string json_str = "";
1266   - string object_file_name = std::string(cur_param->result_folder_little) + helpers::os::sep + obj_key.video_id + "_" +
1267   - std::to_string(obj_key.obj_id) + "_" + cur_timestamp_ms + ".jpg";
1268   -
1269   -#ifdef POST_USE_RABBITMQ
1270   - video_object_snapshot new_obj_ss_info;
1271   - new_obj_ss_info.analysisRes = nullptr;
1272   - new_obj_ss_info.object_id = obj_key.obj_id;
1273   - new_obj_ss_info.obj_info.set_data(obj_value.index.index, obj_value.confidence, obj_value.obj_pos.left_,
1274   - obj_value.obj_pos.top_, obj_value.obj_pos.left_ + obj_value.obj_pos.width_,
1275   - obj_value.obj_pos.top_ + obj_value.obj_pos.height_);
1276   - strcpy(new_obj_ss_info.task_id, obj_key.video_id.c_str());
1277   - strcpy(new_obj_ss_info.video_image_path, fpath_origin.c_str());
1278   - strcpy(new_obj_ss_info.snapshot_image_path, object_file_name.c_str());
1279   - json_str = helpers::gen_json::gen_snapshot_json(algor_type, new_obj_ss_info);
1280   -#endif
1281   -
1282   - ImgSaveInfo obj_save_info;
1283   - obj_save_info.file_path = object_file_name;
1284   - obj_save_info.img_info = obj_value.snapShotLittle;
1285   - obj_save_info.json_str = json_str;
1286   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(obj_save_info);
1287   - }
1288   -
1289   - LOG_DEBUG("仅删除记录，显存会在保存线程中删除");
1290   - // 仅删除记录，显存会在保存线程中删除
1291   - m_snapshot_reprocessing->release_finished_locus_snapshot(obj_key.video_id, obj_key.obj_id, false);
1292   -
1293   -}
1294   -
1295   -void CMultiSourceProcess::timing_snapshot_thread(){
1296   - LOG_INFO("timing_snapshot_thread start.");
1297   -
1298   - JpegUtil jpegUtil;
1299   - jpegUtil.jpeg_init(m_devId);
1300   -
1301   - DecoderManager* pDecManager = DecoderManager::getInstance();
1302   - while(!m_bfinish){
1303   - vector<DeviceMemory*> vec_devMem = pDecManager->timing_snapshot_all();
1304   - for (auto devMem : vec_devMem) {
1305   - auto task_id = devMem->getId();
1306   - auto task_other_params = m_task_param_manager->get_task_other_param(task_id);
1307   - if (task_other_params == nullptr)
1308   - continue;
1309   - const auto &algor_other_params = task_other_params->find(algorithm_type_t::VIDEO_TIMING_SNAPSHOT);
1310   - if(algor_other_params != task_other_params->end()){
1311   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
1312   - std::string cur_timestamp_ms = std::to_string(devMem->getTimesstamp());
1313   - const std::string fpath_ori = basic_param->result_folder + helpers::os::sep + task_id + "_" + cur_timestamp_ms + ".jpg";
1314   -
1315   - // LOG_DEBUG("snapshot save path: {}", fpath_ori.c_str());
1316   -
1317   - acldvppPicDesc *vpcDesc= acldvppCreatePicDesc();
1318   - acldvppSetPicDescData(vpcDesc, devMem->getMem());
1319   - acldvppSetPicDescFormat(vpcDesc, PIXEL_FORMAT_YUV_SEMIPLANAR_420);
1320   - acldvppSetPicDescWidth(vpcDesc, devMem->getWidth());
1321   - acldvppSetPicDescHeight(vpcDesc, devMem->getHeight());
1322   - acldvppSetPicDescWidthStride(vpcDesc, devMem->getWidthStride());
1323   - acldvppSetPicDescHeightStride(vpcDesc, devMem->getHeightStride());
1324   - acldvppSetPicDescSize(vpcDesc, devMem->getSize());
1325   -
1326   - jpegUtil.jpeg_encode(vpcDesc, fpath_ori);
1327   -
1328   - acldvppDestroyPicDesc(vpcDesc);
1329   - vpcDesc = nullptr;
1330   -
1331   - #ifdef POST_USE_RABBITMQ
1332   - auto json_str = helpers::gen_json::gen_vtsnapshot_json(task_id, fpath_ori);
1333   - mq_manager_->publish(mq_type_t::TIMING_SCREENSHORT_TASK_MQ, json_str.c_str(), true);
1334   - #endif
1335   - }
1336   - }
1337   -
1338   - for(auto devMem : vec_devMem){
1339   - delete devMem;
1340   - devMem = nullptr;
1341   - }
1342   - vec_devMem.clear();
1343   -
1344   - std::this_thread::sleep_for(std::chrono::milliseconds(600));
1345   - }
1346   -
1347   - jpegUtil.jpeg_release();
1348   -
1349   - LOG_INFO("timing_snapshot_thread end.");
1350   -}
1351   -
1352   -// 逆行
1353   -void CMultiSourceProcess::algorthim_retrograde(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1354   - vector<onelevel_det_result>& vptResult){
1355   - vector<string> interest_task_id;
1356   - vector<onelevel_det_result> interest_vpt_result;
1357   - vector<DeviceMemory*> interest_imgs;
1358   -
1359   - int _idx = 0;
1360   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1361   - ++_task_id_iter, ++_idx) // loop task_id;
1362   - {
1363   - auto task_id = *_task_id_iter;
1364   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1365   -
1366   - if (algor_map->find(algorithm_type_t::PEDESTRIAN_RETROGRADE) != algor_map->end() ||
1367   - algor_map->find(algorithm_type_t::VEHICLE_RETROGRADE) != algor_map->end()) {
1368   - interest_task_id.emplace_back(task_id);
1369   - interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1370   - interest_vpt_result.emplace_back(vptResult[_idx]);
1371   - }
1372   - }
1373   -
1374   - // LOG_DEBUG("retrograde interest_vpt_result size: {}", interest_vpt_result.size());
1375   -
1376   - if (!interest_imgs.empty()){
1377   - pedestrian_vehicle_retrograde_.update_mstreams(interest_task_id, interest_imgs, interest_vpt_result);
1378   - }
1379   -}
1380   -
1381   -// 闯入
1382   -void CMultiSourceProcess::algorthim_trespass(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1383   - vector<onelevel_det_result>& vptResult ,vector<vector<int>>& deleteObjectID){
1384   -
1385   - vector<string> trespass_interest_task_id;
1386   - vector<onelevel_det_result> trespass_interest_vpt_result;
1387   - vector<vector<int>> trespass_interest_deleteobjs;
1388   - vector<DeviceMemory*> trespass_interest_imgs;
1389   -
1390   - int _idx = 0;
1391   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1392   - ++_task_id_iter, ++_idx) // loop task_id;
1393   - {
1394   - auto task_id = *_task_id_iter;
1395   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1396   -
1397   - if (algor_map->find(algorithm_type_t::PEDESTRIAN_TRESPASS) != algor_map->end() ||
1398   - algor_map->find(algorithm_type_t::VEHICLE_TRESPASS) != algor_map->end()) {
1399   - trespass_interest_task_id.emplace_back(task_id);
1400   - trespass_interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1401   - trespass_interest_vpt_result.emplace_back(vptResult[_idx]);
1402   - trespass_interest_deleteobjs.emplace_back(deleteObjectID[_idx]);
1403   - }
1404   - }
1405   -
1406   - // LOG_DEBUG("trespass interest_vpt_result size: {}", trespass_interest_vpt_result.size());
1407   -
1408   - if (!trespass_interest_imgs.empty()) {
1409   - pedestrian_vehicle_trespass_.update_mstreams( trespass_interest_task_id, trespass_interest_imgs,
1410   - trespass_interest_vpt_result, trespass_interest_deleteobjs);
1411   - }
1412   -}
1413   -
1414   -// 轨迹记录
1415   -void CMultiSourceProcess::trace_record(vector<string>& vpt_interest_task_id, vector<onelevel_det_result>& vptResult) {
1416   - int bidx = 0;
1417   - for (auto iter = vpt_interest_task_id.begin(); iter != vpt_interest_task_id.end(); ++ iter, ++ bidx) {
1418   - auto task_id = *iter;
1419   - for (int c = 0; c < vptResult[bidx].obj_count; c++) {
1420   - //计算检测框坐标中心点
1421   - sy_point center_point;
1422   - center_point.x_ = vptResult[bidx].obj[c].left + (vptResult[bidx].obj[c].right - vptResult[bidx].obj[c].left) * 0.5;
1423   - // center_point.y_ = vptResult[bidx].obj[c].top + (vptResult[bidx].obj[c].bottom - vptResult[bidx].obj[c].top) * 0.85;
1424   - center_point.y_ = vptResult[bidx].obj[c].bottom;
1425   -
1426   - OBJ_KEY new_obj = { task_id, vptResult[bidx].obj[c].id };
1427   - m_TotalObjMtx.lock();
1428   - m_total_obj_info[new_obj].index = vptResult[bidx].obj[c].index;
1429   - m_total_obj_info[new_obj].center_points.push_back(center_point);
1430   - m_TotalObjMtx.unlock();
1431   -
1432   - }
1433   - }
1434   -}
1435   -
1436   -// 三轮车载人
1437   -void CMultiSourceProcess::algorithm_tricycle_manned(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1438   - vector<onelevel_det_result>& vptResult) {
1439   -
1440   - vector<string> interest_task_id;
1441   - vector<onelevel_det_result> interest_vpt_result;
1442   - vector<DeviceMemory*> interest_imgs;
1443   -
1444   - int _idx = 0;
1445   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1446   - ++_task_id_iter, ++_idx) // loop task_id;
1447   - {
1448   - auto task_id = *_task_id_iter;
1449   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1450   -
1451   - if (algor_map->find(algorithm_type_t::TRICYCLE_MANNED) != algor_map->end()) {
1452   - interest_task_id.emplace_back(task_id);
1453   - interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1454   - interest_vpt_result.emplace_back(vptResult[_idx]);
1455   - }
1456   - }
1457   -
1458   - // LOG_DEBUG("tricycle_manned interest_vpt_result size: {}", interest_vpt_result.size());
1459   -
1460   - if (!interest_imgs.empty()){
1461   - tricycle_manned_.update_mstreams(interest_task_id, interest_imgs, interest_vpt_result);
1462   - }
1463   -}
1464   -
1465   -
1466   -// 货车载人
1467   -void CMultiSourceProcess::algorithm_truck_manned(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1468   - vector<onelevel_det_result>& vptResult) {
1469   -
1470   - vector<string> interest_task_id;
1471   - vector<onelevel_det_result> interest_vpt_result;
1472   - vector<DeviceMemory*> interest_imgs;
1473   -
1474   - int _idx = 0;
1475   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1476   - ++_task_id_iter, ++_idx) // loop task_id;
1477   - {
1478   - auto task_id = *_task_id_iter;
1479   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1480   -
1481   - if (algor_map->find(algorithm_type_t::TRUCK_MANNED) != algor_map->end()) {
1482   - interest_task_id.emplace_back(task_id);
1483   - interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1484   - interest_vpt_result.emplace_back(vptResult[_idx]);
1485   - }
1486   - }
1487   -
1488   - // LOG_DEBUG("truck_manned interest_vpt_result size: {}", interest_vpt_result.size());
1489   -
1490   - if (!interest_imgs.empty()){
1491   - m_TotalObjMtx.lock();
1492   - truck_manned_.update_mstreams(interest_task_id, interest_imgs, m_total_obj_info, interest_vpt_result);
1493   - m_TotalObjMtx.unlock();
1494   - }
1495   -}
1496   -
1497   -
1498   -// 二轮车超员/未戴盔
1499   -void CMultiSourceProcess::algorithm_motor_hs_process(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1500   - vector<onelevel_det_result>& vptResult) {
1501   -
1502   - vector<string> interest_task_id;
1503   - vector<onelevel_det_result> interest_vpt_result;
1504   - vector<DeviceMemory*> interest_imgs;
1505   -
1506   - int _idx = 0;
1507   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1508   - ++_task_id_iter, ++_idx) // loop task_id;
1509   - {
1510   - auto task_id = *_task_id_iter;
1511   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1512   -
1513   - if (algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET) != algor_map->end() ||
1514   - algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN) != algor_map->end()) {
1515   - interest_task_id.emplace_back(task_id);
1516   - interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1517   - interest_vpt_result.emplace_back(vptResult[_idx]);
1518   - }
1519   - }
1520   -
1521   - // LOG_DEBUG("motor_hsprocess interest_vpt_result size: {}", interest_vpt_result.size());
1522   -
1523   - if (!interest_imgs.empty()){
1524   - motor_hsprocess_.update_mstreams(interest_task_id, interest_imgs, interest_vpt_result);
1525   - }
1526   -}
1527   -
1528   -// 二轮车驾乘人员使用手机(人骑车辅助版)
1529   -void CMultiSourceProcess::algorithm_motor_refit_phone_process(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1530   - vector<onelevel_det_result>& vptResult) {
1531   -
1532   - vector<string> interest_task_id;
1533   - vector<onelevel_det_result> interest_vpt_result;
1534   - vector<DeviceMemory*> interest_imgs;
1535   -
1536   - int _idx = 0;
1537   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1538   - ++_task_id_iter, ++_idx) // loop task_id;
1539   - {
1540   - auto task_id = *_task_id_iter;
1541   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1542   -
1543   - // if (algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE) != algor_map->end() ||
1544   - // algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_REFIT) != algor_map->end()) {
1545   - if (algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE) != algor_map->end()) {
1546   - interest_task_id.emplace_back(task_id);
1547   - interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1548   - interest_vpt_result.emplace_back(vptResult[_idx]);
1549   - }
1550   - }
1551   -
1552   - if (!interest_imgs.empty()){
1553   - motor_refit_phoneprocess_.update_mstreams(interest_task_id, interest_imgs, interest_vpt_result);
1554   - }
1555   -}
1556   -/*// 二轮车驾乘人员使用手机
1557   -void CMultiSourceProcess::algorithm_motor_phone_process(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1558   - vector<onelevel_det_result>& vptResult) {
1559   -
1560   - vector<string> interest_task_id;
1561   - vector<onelevel_det_result> interest_vpt_result;
1562   - vector<DeviceMemory*> interest_imgs;
1563   -
1564   - int _idx = 0;
1565   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1566   - ++_task_id_iter, ++_idx) // loop task_id;
1567   - {
1568   - auto task_id = *_task_id_iter;
1569   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1570   -
1571   - if (algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE) != algor_map->end()) {
1572   - interest_task_id.emplace_back(task_id);
1573   - interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1574   - interest_vpt_result.emplace_back(vptResult[_idx]);
1575   - }
1576   - }
1577   -
1578   - if (!interest_imgs.empty()){
1579   - motor_phoneprocess_.update_mstreams(interest_task_id, interest_imgs, interest_vpt_result);
1580   - }
1581   -}*/
1582   -
1583   -// 电动车改装(加雨棚)
1584   -void CMultiSourceProcess::algorithm_motor_refit_process(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1585   - vector<onelevel_det_result>& vptResult) {
1586   -
1587   - vector<string> interest_task_id;
1588   - vector<onelevel_det_result> interest_vpt_result;
1589   - vector<DeviceMemory*> interest_imgs;
1590   -
1591   - int _idx = 0;
1592   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1593   - ++_task_id_iter, ++_idx) // loop task_id;
1594   - {
1595   - auto task_id = *_task_id_iter;
1596   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1597   -
1598   - if (algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_REFIT) != algor_map->end()) {
1599   - interest_task_id.emplace_back(task_id);
1600   - interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1601   - interest_vpt_result.emplace_back(vptResult[_idx]);
1602   - }
1603   - }
1604   -
1605   - if (!interest_imgs.empty()){
1606   - motor_refitprocess_.update_mstreams(interest_task_id, interest_imgs, interest_vpt_result);
1607   - }
1608   -}
1609   -
1610   -
1611   -// 行人/二轮车闯红灯
1612   -void CMultiSourceProcess::algorithm_traffic_light_process(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1613   - vector<onelevel_det_result>& vptResult) {
1614   -
1615   - vector<string> interest_task_id;
1616   - vector<onelevel_det_result> interest_vpt_result;
1617   - vector<DeviceMemory*> interest_imgs;
1618   - vector<sy_img> sy_interest_imgs;
1619   - vector<vector<vector<int>>> interest_traffic_region;
1620   - vector<vector<int>> interest_labels;
1621   -
1622   - int _idx = 0;
1623   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1624   - ++_task_id_iter, ++_idx) // loop task_id;
1625   - {
1626   - auto task_id = *_task_id_iter;
1627   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1628   -
1629   - if (algor_map->find(algorithm_type_t::PERSON_RUNNING_REDLIGHTS) != algor_map->end() ||
1630   - algor_map->find(algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS) != algor_map->end()) {
1631   -
1632   - m_RoadSegTaskMtx.lock();
1633   - if (!m_RoadSegTaskMap[task_id].isseg) continue;
1634   - else {
1635   - interest_traffic_region.push_back(m_RoadSegTaskMap[task_id].traffic_region);
1636   - interest_labels.push_back(m_RoadSegTaskMap[task_id].labels);
1637   - }
1638   - m_RoadSegTaskMtx.unlock();
1639   -
1640   - DeviceMemory* mem = vpt_interest_imgs[_idx];
1641   - sy_img img;
1642   - img.w_ = mem->getWidth(); img.h_ = mem->getHeight();
1643   - img.c_ = mem->getChannel(); img.data_ = mem->getMem();
1644   - sy_interest_imgs.push_back(img);
1645   -
1646   - interest_task_id.emplace_back(task_id);
1647   - interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1648   - interest_vpt_result.emplace_back(vptResult[_idx]);
1649   - }
1650   - }
1651   -
1652   - if (!interest_imgs.empty()){
1653   - m_TotalObjMtx.lock();
1654   - traffic_lightprocess_.update_mstreams(interest_task_id, sy_interest_imgs, interest_imgs, interest_traffic_region, interest_labels, m_total_obj_info, interest_vpt_result);
1655   - m_TotalObjMtx.unlock();
1656   - }
1657   -}
1658   -
1659   -
1660   -// 与道路分割相关的算法
1661   -void CMultiSourceProcess::algorithm_roadseg_correlation_process(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs,
1662   - vector<onelevel_det_result>& vptResult) {
1663   -
1664   - vector<string> interest_task_id;
1665   - vector<onelevel_det_result> interest_vpt_result;
1666   - vector<DeviceMemory*> interest_imgs;
1667   - vector<sy_img> sy_interest_imgs;
1668   - vector<vector<vector<int>>> interest_traffic_region, interest_fence_region;
1669   - vector<vector<int>> interest_labels, interest_fence_labels;
1670   -
1671   - int _idx = 0;
1672   - for (auto _task_id_iter = vpt_interest_task_id.begin(); _task_id_iter != vpt_interest_task_id.end();
1673   - ++_task_id_iter, ++_idx) // loop task_id;
1674   - {
1675   - auto task_id = *_task_id_iter;
1676   - auto algor_map = m_task_param_manager->get_task_other_param(task_id);
1677   -
1678   - if (algor_map->find(algorithm_type_t::PERSON_IN_VEHICLELANE) != algor_map->end() ||
1679   - algor_map->find(algorithm_type_t::NONMOTOR_IN_VEHICLELANE) != algor_map->end() ||
1680   - algor_map->find(algorithm_type_t::NONMOTOR_CEOSSPARKLINE) != algor_map->end() ||
1681   - algor_map->find(algorithm_type_t::PERSON_CROSS) != algor_map->end() ||
1682   - algor_map->find(algorithm_type_t::NONMOTOR_WRONGDIRECTION) != algor_map->end() ||
1683   - algor_map->find(algorithm_type_t::VEHICLE_WRONGDIRECTION) != algor_map->end() ||
1684   - algor_map->find(algorithm_type_t::VEHICLE_NOTGIVEWAY) != algor_map->end() ||
1685   - algor_map->find(algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND) != algor_map->end() ||
1686   - algor_map->find(algorithm_type_t::VEHICLE_NOTDECELERATION) != algor_map->end()
1687   - ) {
1688   -
1689   - m_RoadSegTaskMtx.lock();
1690   - if (!m_RoadSegTaskMap[task_id].isseg) continue;
1691   - else {
1692   - interest_traffic_region.push_back(m_RoadSegTaskMap[task_id].traffic_region);
1693   - interest_labels.push_back(m_RoadSegTaskMap[task_id].labels);
1694   - interest_fence_region.push_back(m_RoadSegTaskMap[task_id].fence_region);
1695   - interest_fence_labels.push_back(m_RoadSegTaskMap[task_id].fence_labels);
1696   - }
1697   - m_RoadSegTaskMtx.unlock();
1698   -
1699   - DeviceMemory* mem = vpt_interest_imgs[_idx];
1700   - sy_img img;
1701   - img.w_ = mem->getWidth(); img.h_ = mem->getHeight();
1702   - img.c_ = mem->getChannel(); img.data_ = mem->getMem();
1703   - sy_interest_imgs.push_back(img);
1704   -
1705   - interest_task_id.emplace_back(task_id);
1706   - interest_imgs.emplace_back(vpt_interest_imgs[_idx]);
1707   - interest_vpt_result.emplace_back(vptResult[_idx]);
1708   - }
1709   - }
1710   -
1711   - if (!interest_imgs.empty()){
1712   - m_TotalObjMtx.lock();
1713   - roadseg_corrprocess_.update_mstreams(interest_task_id, sy_interest_imgs, interest_imgs, interest_traffic_region, interest_labels, interest_fence_region, interest_fence_labels, m_total_obj_info, interest_vpt_result);
1714   - m_TotalObjMtx.unlock();
1715   - }
1716   -}
1717   -
1718   -// for snapshot algorithm. 轨迹结束目标 做最后的结果返回（当前返回算法结果+快照保存路径）
1719   -void CMultiSourceProcess::village_snapshot(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vec_vptMem, vector<vector<int>> deleteObjectID) {
1720   - auto task_iter = vpt_interest_task_id.begin();
1721   - for (int i = 0; i < deleteObjectID.size(); i++, ++task_iter) // loop taskId.
1722   - {
1723   - auto task_id = *task_iter;
1724   - for (int &j : deleteObjectID[i]) // loop algor type.
1725   - {
1726   - OBJ_KEY obj_key = {*task_iter, j};
1727   - auto task_param_ptr = m_task_param_manager->get_task_algor_param(obj_key.video_id);
1728   - auto algor_config_param = m_task_param_manager->get_task_algor_params();
1729   - auto algor_param = m_task_param_manager->get_task_other_params();
1730   - if (!(algor_config_param.count(task_id) && algor_param.count(task_id))) continue;
1731   - bool village_alarm = false;
1732   - std::string video_folder = "", result_folder = "", result_folder_little = ""; //要求各事件使用同一个视频保存地址，否则会被最后一个事件的地址覆盖
1733   - auto task_other_params = m_task_param_manager->get_task_other_param(task_id);
1734   - std::vector<int> algorithm_types;
1735   - bool save_single_algor_pic = false; // 是否保存单算法的报警图片(若设置为true需先去掉算法内部注释!!!)
1736   -
1737   - if (task_param_ptr->nonmotor_vehicle_algors.find(algorithm_type_t::TRICYCLE_MANNED) != task_param_ptr->nonmotor_vehicle_algors.end()) {
1738   - const auto &algor_other_params = task_other_params->find(algorithm_type_t::TRICYCLE_MANNED);
1739   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
1740   -
1741   - auto result = tricycle_manned_.get_result_by_objectid(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, algorithm_type_t::TRICYCLE_MANNED});
1742   - if (result.get()) {
1743   - village_alarm = true;
1744   - algorithm_types.push_back((int)algorithm_type_t::TRICYCLE_MANNED);
1745   - video_folder = basic_param->video_folder; result_folder = basic_param->result_folder; result_folder_little = basic_param->result_folder_little;
1746   - // 原图及抠图
1747   - vpc_img_info src_img; src_img.pic_desc = result->origin_img_desc; src_img.task_id = obj_key.video_id;
1748   - vpc_img_info roi_img; roi_img.pic_desc = result->roi_img_desc; roi_img.task_id = obj_key.video_id; roi_img.object_id = obj_key.obj_id;
1749   -
1750   - if (save_single_algor_pic) {
1751   - auto json_str = helpers::gen_json::gen_manned_json(obj_key.video_id, obj_key.obj_id, result->box, algorithm_type_t::TRICYCLE_MANNED);
1752   - save_snapshot_process(obj_key, algorithm_type_t::TRICYCLE_MANNED, src_img, roi_img, 0, json_str);
1753   - } else {
1754   - VPCUtil::vpc_img_release(src_img); VPCUtil::vpc_img_release(roi_img);
1755   - }
1756   -
1757   - }
1758   - }
1759   -
1760   - if (task_param_ptr->vehicle_algors.find(algorithm_type_t::TRUCK_MANNED) != task_param_ptr->vehicle_algors.end()) {
1761   - const auto &algor_other_params = task_other_params->find(algorithm_type_t::TRUCK_MANNED);
1762   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
1763   -
1764   - auto result = truck_manned_.get_result_by_objectid(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, algorithm_type_t::TRUCK_MANNED});
1765   - if (result.get()) {
1766   - village_alarm = true;
1767   - algorithm_types.push_back((int)algorithm_type_t::TRUCK_MANNED);
1768   - video_folder = basic_param->video_folder; result_folder = basic_param->result_folder; result_folder_little = basic_param->result_folder_little;
1769   - // 原图及抠图
1770   - vpc_img_info src_img; src_img.pic_desc = result->origin_img_desc; src_img.task_id = obj_key.video_id;
1771   - vpc_img_info roi_img; roi_img.pic_desc = result->roi_img_desc; roi_img.task_id = obj_key.video_id; roi_img.object_id = obj_key.obj_id;
1772   -
1773   - if (save_single_algor_pic) {
1774   - auto json_str = helpers::gen_json::gen_manned_json(obj_key.video_id, obj_key.obj_id, result->box, algorithm_type_t::TRUCK_MANNED);
1775   - save_snapshot_process(obj_key, algorithm_type_t::TRUCK_MANNED, src_img, roi_img, 0, json_str);
1776   - } else {
1777   - VPCUtil::vpc_img_release(src_img); VPCUtil::vpc_img_release(roi_img);
1778   - }
1779   -
1780   - }
1781   - }
1782   -
1783   - vector<algo_type> motorhs_algor = {algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET, algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN};
1784   - for (size_t idx = 0; idx < motorhs_algor.size(); ++idx) {
1785   - if (algor_param[task_id].count(motorhs_algor.at(idx))) {
1786   - const auto &algor_other_params = task_other_params->find(motorhs_algor.at(idx));
1787   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
1788   -
1789   - auto result = motor_hsprocess_.get_result_by_objectid(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, motorhs_algor.at(idx)});
1790   - if (result.get()) {
1791   - village_alarm = true;
1792   - algorithm_types.push_back((int)motorhs_algor.at(idx));
1793   - video_folder = basic_param->video_folder; result_folder = basic_param->result_folder; result_folder_little = basic_param->result_folder_little;
1794   - // 原图及抠图
1795   - vpc_img_info src_img; src_img.pic_desc = result->origin_img_desc; src_img.task_id = obj_key.video_id;
1796   - vpc_img_info roi_img; roi_img.pic_desc = result->roi_img_desc; roi_img.task_id = obj_key.video_id; roi_img.object_id = obj_key.obj_id;
1797   -
1798   - if (save_single_algor_pic) {
1799   - auto json_str = helpers::gen_json::gen_manned_json(obj_key.video_id, obj_key.obj_id, result->box, motorhs_algor.at(idx));
1800   - save_snapshot_process(obj_key, motorhs_algor.at(idx), src_img, roi_img, 0, json_str);
1801   - } else {
1802   - VPCUtil::vpc_img_release(src_img); VPCUtil::vpc_img_release(roi_img);
1803   - }
1804   -
1805   - }
1806   - }
1807   - }
1808   -
1809   - if (task_param_ptr->nonmotor_vehicle_algors.find(algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE) != task_param_ptr->nonmotor_vehicle_algors.end()) {
1810   - const auto &algor_other_params = task_other_params->find(algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE);
1811   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
1812   -
1813   - // auto result = motor_phoneprocess_.get_result_by_objectid(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE});
1814   - auto result = motor_refit_phoneprocess_.get_result_by_objectid(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE});
1815   - if (result.get()) {
1816   - village_alarm = true;
1817   - algorithm_types.push_back((int)algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE);
1818   - video_folder = basic_param->video_folder; result_folder = basic_param->result_folder; result_folder_little = basic_param->result_folder_little;
1819   - // 原图及抠图
1820   - vpc_img_info src_img; src_img.pic_desc = result->origin_img_desc; src_img.task_id = obj_key.video_id;
1821   - vpc_img_info roi_img; roi_img.pic_desc = result->roi_img_desc; roi_img.task_id = obj_key.video_id; roi_img.object_id = obj_key.obj_id;
1822   -
1823   - if (save_single_algor_pic) {
1824   - auto json_str = helpers::gen_json::gen_manned_json(obj_key.video_id, obj_key.obj_id, result->box, algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE);
1825   - save_snapshot_process(obj_key, algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE, src_img, roi_img, 0, json_str);
1826   - } else {
1827   - VPCUtil::vpc_img_release(src_img); VPCUtil::vpc_img_release(roi_img);
1828   - }
1829   -
1830   - }
1831   - }
1832   -
1833   - if (task_param_ptr->nonmotor_vehicle_algors.find(algorithm_type_t::NONMOTOR_VEHICLE_REFIT) != task_param_ptr->nonmotor_vehicle_algors.end()) {
1834   - const auto &algor_other_params = task_other_params->find(algorithm_type_t::NONMOTOR_VEHICLE_REFIT);
1835   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
1836   -
1837   - auto result = motor_refitprocess_.get_result_by_objectid(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, algorithm_type_t::NONMOTOR_VEHICLE_REFIT});
1838   - // auto result = motor_refit_phoneprocess_.get_result_by_objectid(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, algorithm_type_t::NONMOTOR_VEHICLE_REFIT});
1839   - if (result.get()) {
1840   - village_alarm = true;
1841   - algorithm_types.push_back((int)algorithm_type_t::NONMOTOR_VEHICLE_REFIT);
1842   - video_folder = basic_param->video_folder; result_folder = basic_param->result_folder; result_folder_little = basic_param->result_folder_little;
1843   - // 原图及抠图
1844   - vpc_img_info src_img; src_img.pic_desc = result->origin_img_desc; src_img.task_id = obj_key.video_id;
1845   - vpc_img_info roi_img; roi_img.pic_desc = result->roi_img_desc; roi_img.task_id = obj_key.video_id; roi_img.object_id = obj_key.obj_id;
1846   -
1847   - if (save_single_algor_pic) {
1848   - auto json_str = helpers::gen_json::gen_manned_json(obj_key.video_id, obj_key.obj_id, result->box, algorithm_type_t::NONMOTOR_VEHICLE_REFIT);
1849   - save_snapshot_process(obj_key, algorithm_type_t::NONMOTOR_VEHICLE_REFIT, src_img, roi_img, 0, json_str);
1850   - } else {
1851   - VPCUtil::vpc_img_release(src_img); VPCUtil::vpc_img_release(roi_img);
1852   - }
1853   -
1854   - }
1855   - }
1856   -
1857   - vector<algo_type> trafficlight_algor = {algorithm_type_t::PERSON_RUNNING_REDLIGHTS, algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS};
1858   - for (size_t idx = 0; idx < trafficlight_algor.size(); ++idx) {
1859   - if (algor_param[task_id].count(trafficlight_algor.at(idx))) {
1860   - const auto &algor_other_params = task_other_params->find(trafficlight_algor.at(idx));
1861   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
1862   -
1863   - auto result = traffic_lightprocess_.get_result_by_objectid(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, trafficlight_algor.at(idx)});
1864   - if (result.get()) {
1865   - village_alarm = true;
1866   - algorithm_types.push_back((int)trafficlight_algor.at(idx));
1867   - video_folder = basic_param->video_folder; result_folder = basic_param->result_folder; result_folder_little = basic_param->result_folder_little;
1868   - // 原图及抠图
1869   - vpc_img_info src_img; src_img.pic_desc = result->origin_img_desc; src_img.task_id = obj_key.video_id;
1870   - vpc_img_info roi_img; roi_img.pic_desc = result->roi_img_desc; roi_img.task_id = obj_key.video_id; roi_img.object_id = obj_key.obj_id;
1871   -
1872   - if (save_single_algor_pic) {
1873   - auto json_str = helpers::gen_json::gen_manned_json(obj_key.video_id, obj_key.obj_id, result->box, trafficlight_algor.at(idx));
1874   - save_snapshot_process(obj_key, trafficlight_algor.at(idx), src_img, roi_img, 0, json_str);
1875   - } else {
1876   - VPCUtil::vpc_img_release(src_img); VPCUtil::vpc_img_release(roi_img);
1877   - }
1878   -
1879   - }
1880   - }
1881   - }
1882   -
1883   - vector<algo_type> roadseg_algor = {algorithm_type_t::PERSON_IN_VEHICLELANE, algorithm_type_t::PERSON_CROSS, algorithm_type_t::NONMOTOR_IN_VEHICLELANE, algorithm_type_t::NONMOTOR_CEOSSPARKLINE,
1884   - algorithm_type_t::NONMOTOR_WRONGDIRECTION, algorithm_type_t::VEHICLE_WRONGDIRECTION, algorithm_type_t::VEHICLE_NOTGIVEWAY, algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND, algorithm_type_t::VEHICLE_NOTDECELERATION };
1885   - for (size_t idx = 0; idx < roadseg_algor.size(); ++idx) {
1886   - if (algor_param[task_id].count(roadseg_algor.at(idx))) {
1887   - const auto &algor_other_params = task_other_params->find(roadseg_algor.at(idx));
1888   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
1889   -
1890   - auto result = roadseg_corrprocess_.get_result_by_objectid(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, roadseg_algor.at(idx)});
1891   - if (result.get()) {
1892   - village_alarm = true;
1893   - algorithm_types.push_back((int)roadseg_algor.at(idx));
1894   - video_folder = basic_param->video_folder; result_folder = basic_param->result_folder; result_folder_little = basic_param->result_folder_little;
1895   - // 原图及抠图
1896   - vpc_img_info src_img; src_img.pic_desc = result->origin_img_desc; src_img.task_id = obj_key.video_id;
1897   - vpc_img_info roi_img; roi_img.pic_desc = result->roi_img_desc; roi_img.task_id = obj_key.video_id; roi_img.object_id = obj_key.obj_id;
1898   -
1899   - if (save_single_algor_pic) {
1900   - auto json_str = helpers::gen_json::gen_manned_json(obj_key.video_id, obj_key.obj_id, result->box, roadseg_algor.at(idx));
1901   - save_snapshot_process(obj_key, roadseg_algor.at(idx), src_img, roi_img, 0, json_str);
1902   - } else {
1903   - VPCUtil::vpc_img_release(src_img); VPCUtil::vpc_img_release(roi_img);
1904   - }
1905   -
1906   - }
1907   - }
1908   - }
1909   -
1910   - m_TotalObjMtx.lock();
1911   - if (m_total_obj_info.find(obj_key) != m_total_obj_info.end()) {
1912   - vector<sy_point>().swap(m_total_obj_info[obj_key].center_points);
1913   - m_total_obj_info.erase(obj_key);
1914   - }
1915   - m_TotalObjMtx.unlock();
1916   -
1917   -
1918   - map<OBJ_KEY, OBJ_VALUES> _total_snapshot_info = m_snapshot_reprocessing->get_total_village_snapshot_info();
1919   - if(_total_snapshot_info.size() <= 0){
1920   - continue;
1921   - }
1922   -
1923   - LOG_DEBUG("_total_snapshot_info size: {}", _total_snapshot_info.size());
1924   - auto it = _total_snapshot_info.find(obj_key);
1925   - if (it == _total_snapshot_info.end()) {
1926   - continue;
1927   - }
1928   -
1929   -
1930   - // 推送轨迹结束的目标用于数量统计
1931   - {
1932   - const OBJ_VALUES obj_value = it->second;
1933   - std::vector<video_object_snapshot> algo_results;
1934   - std::vector<int> algorithm_types;
1935   - algorithm_types.push_back((int)algorithm_type_t::FLOW_STATISTICS);
1936   -#ifdef POST_USE_RABBITMQ
1937   - video_object_snapshot new_obj_ss_info;
1938   - new_obj_ss_info.analysisRes = nullptr;
1939   - new_obj_ss_info.object_id = obj_key.obj_id;
1940   - new_obj_ss_info.obj_info.set_data(obj_value.snapShots[1].index.index, obj_value.snapShots[1].confidence, 0, 0, 0, 0);
1941   - strcpy(new_obj_ss_info.task_id, obj_key.video_id.c_str());
1942   - strcpy(new_obj_ss_info.video_image_path, "");
1943   - strcpy(new_obj_ss_info.snapshot_image_path, "");
1944   - algo_results.push_back(new_obj_ss_info);
1945   - auto json_str = helpers::gen_json::gen_village_json(task_id, obj_key.obj_id, algorithm_types, algo_results, "");
1946   - mq_manager_->publish(mq_type_t::ALARM_MQ, json_str.c_str(), true);
1947   -#endif
1948   - }
1949   -
1950   -
1951   - if (village_alarm) {
1952   - const OBJ_VALUES obj_value = it->second;
1953   - std::string cur_timestamp_ms = std::to_string(helpers::timer::get_cur_time_ms());
1954   - // 视频
1955   - string video_file_name = video_folder + helpers::os::sep + obj_key.video_id + "_" +
1956   - std::to_string(obj_key.obj_id) + "_" + cur_timestamp_ms + ".mp4";
1957   -
1958   - string json_str = "";
1959   - std::vector<video_object_snapshot> algo_results;
1960   - for (int sp_idx = 0; sp_idx < 3; sp_idx ++) {
1961   - int num = sp_idx + 1;
1962   - // 原图
1963   - LOG_DEBUG("原图");
1964   - std::string fpath_origin = result_folder + helpers::os::sep + obj_key.video_id + "_" +
1965   - std::to_string(obj_key.obj_id) + "_" + cur_timestamp_ms + "_picnum_" + std::to_string(num) + ".jpg";
1966   -
1967   - ImgSaveInfo origin_save_info;
1968   - origin_save_info.file_path = fpath_origin;
1969   - origin_save_info.img_info = obj_value.snapShots[sp_idx].snapShot;
1970   - origin_save_info.obj_rect = obj_value.snapShots[sp_idx].obj_pos;
1971   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(origin_save_info);
1972   -
1973   -
1974   - LOG_DEBUG("抠图");
1975   - // 抠图
1976   - string object_file_name = result_folder_little + helpers::os::sep + obj_key.video_id + "_" +
1977   - std::to_string(obj_key.obj_id) + "_" + cur_timestamp_ms + "_picnum_" + std::to_string(num) + ".jpg";
1978   - ImgSaveInfo obj_save_info;
1979   - obj_save_info.file_path = object_file_name;
1980   - obj_save_info.img_info = obj_value.snapShots[sp_idx].snapShotLittle;
1981   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(obj_save_info);
1982   -
1983   -#ifdef POST_USE_RABBITMQ
1984   - video_object_snapshot new_obj_ss_info;
1985   - new_obj_ss_info.analysisRes = nullptr;
1986   - new_obj_ss_info.object_id = obj_key.obj_id;
1987   - new_obj_ss_info.obj_info.set_data(obj_value.snapShots[sp_idx].index.index, obj_value.snapShots[sp_idx].confidence, obj_value.snapShots[sp_idx].obj_pos.left_,
1988   - obj_value.snapShots[sp_idx].obj_pos.top_, obj_value.snapShots[sp_idx].obj_pos.left_ + obj_value.snapShots[sp_idx].obj_pos.width_,
1989   - obj_value.snapShots[sp_idx].obj_pos.top_ + obj_value.snapShots[sp_idx].obj_pos.height_);
1990   - strcpy(new_obj_ss_info.task_id, obj_key.video_id.c_str());
1991   - strcpy(new_obj_ss_info.video_image_path, fpath_origin.c_str());
1992   - strcpy(new_obj_ss_info.snapshot_image_path, object_file_name.c_str());
1993   - algo_results.push_back(new_obj_ss_info);
1994   -#endif
1995   - }
1996   -
1997   -#ifdef POST_USE_RABBITMQ
1998   - json_str = helpers::gen_json::gen_village_json(task_id, obj_key.obj_id, algorithm_types, algo_results, video_file_name);
1999   -#endif
2000   -
2001   - DeviceMemory* mem = vec_vptMem[i];
2002   - // string task_id = mem->getId();
2003   - RecoderInfo recoderInfo;
2004   - recoderInfo.task_id = task_id;
2005   - recoderInfo.object_id = std::to_string(j);
2006   - recoderInfo.recoderPath = video_file_name;
2007   - recoderInfo.frame_nb = mem->getFrameNb();
2008   - recoderInfo.mq_info = json_str;
2009   -
2010   - m_recoderinfo_queue_mtx.lock();
2011   - m_recoderinfo_queue.push_back(recoderInfo);
2012   - m_recoderinfo_queue_mtx.unlock();
2013   -
2014   - LOG_DEBUG("仅删除记录，显存会在保存线程中删除");
2015   - // 仅删除记录，显存会在保存线程中删除
2016   - m_snapshot_reprocessing->release_village_finished_locus_snapshot(obj_key.video_id, obj_key.obj_id, false);
2017   - }
2018   - else {
2019   - // 删除记录，同时释放显存
2020   - m_snapshot_reprocessing->release_village_finished_locus_snapshot(obj_key.video_id, obj_key.obj_id, true);
2021   - }
2022   -
2023   - }
2024   - }
2025   -
2026   -}
2027   -
2028   -
2029   -// for snapshot algorithm. 轨迹结束目标 做最后的结果返回（当前返回算法结果+快照保存路径）
2030   -void CMultiSourceProcess::retrograde_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID) {
2031   - auto task_iter = vpt_interest_task_id.begin();
2032   -
2033   - for (int i = 0; i < deleteObjectID.size(); i++, ++task_iter) // loop taskId.
2034   - {
2035   - for (int &j : deleteObjectID[i]) // loop algor type.
2036   - {
2037   - OBJ_KEY obj_key = {*task_iter, j};
2038   - auto task_param_ptr = m_task_param_manager->get_task_algor_param(obj_key.video_id);
2039   -
2040   - /* 开启行人&机动车逆行算法模块，获取该目标的算法分析结果 返回结果+快照 最后释放资源 */
2041   - if (task_param_ptr->human_algors.find(algorithm_type_t::PEDESTRIAN_RETROGRADE) != task_param_ptr->human_algors.end()){
2042   - retrograde_trespass_alarm(obj_key, algorithm_type_t::PEDESTRIAN_RETROGRADE);
2043   - }
2044   -
2045   - if (task_param_ptr->vehicle_algors.find(algorithm_type_t::VEHICLE_RETROGRADE) != task_param_ptr->vehicle_algors.end()){
2046   - retrograde_trespass_alarm(obj_key, algorithm_type_t::VEHICLE_RETROGRADE);
2047   - }
2048   - }
2049   - }
2050   -}
2051   -
2052   -// for snapshot algorithm. 轨迹结束目标 做最后的结果返回（当前返回算法结果+快照保存路径）
2053   -void CMultiSourceProcess::trespass_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID) {
2054   - auto task_iter = vpt_interest_task_id.begin();
2055   -
2056   - for (int i = 0; i < deleteObjectID.size(); i++, ++task_iter) // loop taskId.
2057   - {
2058   - for (int &j : deleteObjectID[i]) // loop algor type.
2059   - {
2060   - OBJ_KEY obj_key = {*task_iter, j};
2061   - auto task_param_ptr = m_task_param_manager->get_task_algor_param(obj_key.video_id);
2062   -
2063   - if (task_param_ptr->human_algors.find(algorithm_type_t::PEDESTRIAN_TRESPASS) != task_param_ptr->human_algors.end()){
2064   - retrograde_trespass_alarm(obj_key, algorithm_type_t::PEDESTRIAN_TRESPASS);
2065   - }
2066   -
2067   - if (task_param_ptr->vehicle_algors.find(algorithm_type_t::VEHICLE_TRESPASS) != task_param_ptr->vehicle_algors.end()){
2068   - retrograde_trespass_alarm(obj_key, algorithm_type_t::VEHICLE_TRESPASS);
2069   - }
2070   - }
2071   - }
2072   -}
2073   -
2074   -
2075   -void CMultiSourceProcess::retrograde_trespass_alarm(const OBJ_KEY &obj_key, const algorithm_type_t &algor_type) {
2076   -
2077   - vector<ai_engine_module::result_data_t> results ;
2078   - if(algor_type == algorithm_type_t::PEDESTRIAN_RETROGRADE || algor_type == algorithm_type_t::VEHICLE_RETROGRADE){
2079   - results = pedestrian_vehicle_retrograde_.get_results_by_id(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, algor_type});
2080   - } else if(algor_type == algorithm_type_t::PEDESTRIAN_TRESPASS || algor_type == algorithm_type_t::VEHICLE_TRESPASS){
2081   - results = pedestrian_vehicle_trespass_.get_results_by_id(ai_engine_module::obj_key_t{obj_key.obj_id, obj_key.video_id, algor_type});
2082   - } else {
2083   - return ;
2084   - }
2085   -
2086   -
2087   - bool bRetroGrade = true ;
2088   - for (unsigned idx = 0; idx < results.size(); ++idx) {
2089   - auto &result = results[idx];
2090   -
2091   - vpc_img_info src_img;
2092   - src_img.pic_desc = result.origin_img_desc;
2093   - src_img.task_id = obj_key.video_id;
2094   -
2095   - vpc_img_info roi_img;
2096   - roi_img.pic_desc = result.roi_img_desc;
2097   - roi_img.task_id = obj_key.video_id;
2098   - roi_img.object_id = obj_key.obj_id;
2099   -
2100   - if(bRetroGrade){
2101   - auto &&json_str = helpers::gen_json::gen_retrograde_json(obj_key.video_id, obj_key.obj_id, result.box, algor_type);
2102   - save_snapshot_process(obj_key, algor_type, src_img, roi_img, idx, json_str);
2103   - } else {
2104   - VPCUtil::vpc_img_release(src_img);
2105   - VPCUtil::vpc_img_release(roi_img);
2106   - }
2107   -
2108   - if (bRetroGrade == true) {
2109   - bRetroGrade = false;
2110   - }
2111   - }
2112   -}
2113   -
2114   -bool CMultiSourceProcess::save_snapshot_process(const OBJ_KEY &obj_key, const algorithm_type_t &algorithm_type, vpc_img_info src_img, vpc_img_info roi_img,
2115   - const long long id,const std::string &json_str) {
2116   - auto task_other_params = m_task_param_manager->get_task_other_param(obj_key.video_id);
2117   - const auto &algor_other_params = task_other_params->find(algorithm_type);
2118   - if (algor_other_params == task_other_params->end()) {
2119   - LOG_ERROR("task_id {} not found {} error", obj_key.video_id, int(algorithm_type));
2120   - return false;
2121   - }
2122   -
2123   - const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param;
2124   -
2125   - std::string cur_time1 = std::to_string(helpers::timer::get_timestamp<std::chrono::milliseconds>());
2126   - const std::string fpath_origin = basic_param->result_folder + helpers::os::sep + obj_key.video_id + "_" +
2127   - std::to_string(obj_key.obj_id) + "_" + std::to_string(id) + "_" + cur_time1 + ".jpg";
2128   -
2129   - ImgSaveInfo obj_save_info;
2130   - obj_save_info.file_path = fpath_origin;
2131   - obj_save_info.img_info = src_img;
2132   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(obj_save_info);
2133   -
2134   - {
2135   - // 抠图保存
2136   - std::string cur_time2 = std::to_string(helpers::timer::get_timestamp<std::chrono::milliseconds>());
2137   - const std::string fpath_roi = basic_param->result_folder_little + helpers::os::sep + obj_key.video_id + "_" +
2138   - std::to_string(obj_key.obj_id) + "_" + std::to_string(id) + "_" + cur_time2 + ".jpg";
2139   -
2140   - // 调用快照保存后处理模块 将快照保存
2141   - ImgSaveInfo obj_save_info;
2142   - obj_save_info.file_path = fpath_roi;
2143   - obj_save_info.img_info = roi_img;
2144   - obj_save_info.json_str = json_str;
2145   -
2146   -#ifdef POST_USE_RABBITMQ
2147   - if(json_str.length() > 0) {
2148   - auto json_str_tmp = helpers::string::replace_all(json_str, helpers::gen_json::ORI_IMAGE_PATH_PLACEHOLDER, fpath_origin);
2149   - obj_save_info.json_str = helpers::string::replace_all(json_str_tmp, helpers::gen_json::ROI_IMAGE_PATH_PLACEHOLDER, fpath_roi);
2150   - }
2151   -#endif
2152   -
2153   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(obj_save_info);
2154   - }
2155   -
2156   - return true;
2157   -}
2158   -
2159   -// 人脸检测抓拍算法模块
2160   -void CMultiSourceProcess::algorthim_face_detect(vector<DeviceMemory*> vec_gpuMem) {
2161   -
2162   - vector<string> interest_task_list;
2163   - vector<sy_img> interest_imgs;
2164   - vector<DeviceMemory*> vec_vptMem;
2165   - for (int i = 0; i < vec_gpuMem.size(); i++) {
2166   - DeviceMemory* mem = vec_gpuMem[i];
2167   - if (!task_has_face_algor(mem->getId())){
2168   - continue;
2169   - }
2170   -
2171   - sy_img img;
2172   - img.w_ = mem->getWidth();
2173   - img.h_ = mem->getHeight();
2174   - img.c_ = mem->getChannel();
2175   - img.data_ = mem->getMem();
2176   - interest_imgs.push_back(img);
2177   - interest_task_list.push_back(mem->getId());
2178   - vec_vptMem.push_back(mem);
2179   - }
2180   -
2181   - if (!interest_imgs.empty()) {
2182   -
2183   - unsigned image_size = interest_imgs.size();
2184   -
2185   - // 人脸检测、跟踪
2186   - std::vector<onelevel_det_result> facedet_result(image_size);
2187   - std::vector<std::vector<int>> face_deleteObjectID(image_size);
2188   -
2189   - int ret = m_face_det_ai_engine.ai_engine_process_batch(interest_task_list, interest_imgs.data(), facedet_result, face_deleteObjectID);
2190   - if(ret <= 0){
2191   - LOG_ERROR("face detect error!!!");
2192   - return;
2193   - }
2194   -
2195   - // 跟踪结果送入快照更新
2196   - m_snapshot_reprocessing->update_face_bestsnapshot(vec_vptMem, facedet_result, face_deleteObjectID);
2197   -
2198   - // 保存已结束轨迹的目标
2199   - auto task_iter_face = interest_task_list.begin(); //debug by zsh
2200   - for (int i = 0; i < face_deleteObjectID.size(); i++) {
2201   - for (int j = 0; j < face_deleteObjectID[i].size(); ++j) {
2202   - OBJ_KEY deleteObj = {*task_iter_face, face_deleteObjectID[i][j]};
2203   - LOG_TRACE("{}: {}",*task_iter_face,face_deleteObjectID[i][j]);
2204   - face_locus_finished(deleteObj);
2205   - }
2206   - ++task_iter_face;
2207   - }
2208   -
2209   - for (int i = 0; i < face_deleteObjectID.size(); ++i){
2210   - std::vector<int>().swap(face_deleteObjectID[i]);
2211   - }
2212   - std::vector<std::vector<int>>().swap(face_deleteObjectID);
2213   - std::vector<onelevel_det_result>().swap(facedet_result);
2214   - }
2215   -}
2216   -
2217   -void CMultiSourceProcess::face_locus_finished(const OBJ_KEY obj_key) {
2218   - map<OBJ_KEY, OBJ_VALUE> _total_face_snapshot_info = m_snapshot_reprocessing->get_total_face_snapshot_info();
2219   -
2220   - auto it = _total_face_snapshot_info.find(obj_key);
2221   - if ( it == _total_face_snapshot_info.end()) {
2222   - return;
2223   - }
2224   -
2225   - LOG_DEBUG("face reprocessing {}:{}.", obj_key.video_id, obj_key.obj_id);
2226   -
2227   - auto task_other_params = m_task_param_manager->get_task_other_params();
2228   -
2229   - const algor_basic_config_param_t *cur_param =
2230   - ((algor_init_config_param_t *)(task_other_params[obj_key.video_id][algorithm_type_t::FACE_SNAPSHOT]))->basic_param;
2231   -
2232   - OBJ_VALUE obj_value = it->second;
2233   -
2234   - std::string cur_time1 = std::to_string(helpers::timer::get_timestamp<std::chrono::milliseconds>());
2235   -
2236   - // 原图
2237   - string fpath_src = std::string(cur_param->result_folder) + helpers::os::sep + obj_key.video_id + "_" +
2238   - std::to_string(obj_key.obj_id) + "_" + cur_time1 + ".jpg";
2239   -
2240   - ImgSaveInfo origin_save_info;
2241   - origin_save_info.file_path = fpath_src;
2242   - origin_save_info.img_info = obj_value.snapShot;
2243   - origin_save_info.obj_rect = obj_value.obj_pos;
2244   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(origin_save_info);
2245   -
2246   - // 抠图
2247   - string json_str = "";
2248   - std::string cur_time2 = std::to_string(helpers::timer::get_timestamp<std::chrono::milliseconds>());
2249   - string fpath_snapShotLittle = std::string(cur_param->result_folder_little) + helpers::os::sep + obj_key.video_id + "_" +
2250   - std::to_string(obj_key.obj_id) + "_" + cur_time2 + ".jpg";
2251   -
2252   -#ifdef POST_USE_RABBITMQ
2253   - json_str = helpers::gen_json::gen_face_detection_json( obj_key.video_id, obj_key.obj_id, fpath_snapShotLittle, fpath_src,
2254   - obj_value.position, obj_value.confidence, obj_value.landmark_point, 25);
2255   -#endif
2256   -
2257   - ImgSaveInfo roi_save_info;
2258   - roi_save_info.file_path = fpath_snapShotLittle;
2259   - roi_save_info.img_info = obj_value.snapShotLittle;
2260   - roi_save_info.json_str = json_str;
2261   - m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(roi_save_info);
2262   -
2263   - // 删除结束轨迹的数据
2264   - m_snapshot_reprocessing->release_finished_face_locus_snapshot(obj_key.video_id, obj_key.obj_id, false);
2265   -}
2266   -
2267   -int CMultiSourceProcess::recode_thread() {
2268   - LOG_INFO("recode_thread start...");
2269   -
2270   - while(true) {
2271   -
2272   - if(m_bfinish){
2273   - break;
2274   - }
2275   -
2276   - m_recoderinfo_queue_mtx.lock();
2277   - if(m_recoderinfo_queue.size() <= 0) {
2278   - m_recoderinfo_queue_mtx.unlock();
2279   - std::this_thread::sleep_for(std::chrono::milliseconds(5));
2280   - continue;
2281   - }
2282   -
2283   - RecoderInfo info = m_recoderinfo_queue.front();
2284   - m_recoderinfo_queue.pop_front();
2285   - m_recoderinfo_queue_mtx.unlock();
2286   -
2287   - DecoderManager* pDecManager = DecoderManager::getInstance();
2288   - pDecManager->doRecode(info);
2289   - }
2290   -
2291   - LOG_INFO("recode_thread end.");
2292   -}
2293   -
2294   -bool CMultiSourceProcess::CheckTime() {
2295   - struct tm* info;
2296   - int nYear, nMonth, nDay;
2297   - time_t raw;
2298   - time(&raw);
2299   - info = localtime(&raw);
2300   - nYear = info->tm_year + 1900;
2301   - nMonth = info->tm_mon + 1;
2302   - nDay = info->tm_mday;
2303   - if ((nYear == 2023 && nMonth <= 12) || (nYear == 2024 && nMonth <= 2))
2304   - {
2305   - return true;
2306   - }
2307   - else
2308   - {
2309   - return false;
2310   - }
2311   -}
2312 0 \ No newline at end of file
src/demo/demo.cpp
  View file @afd07f0
... ... @@ -1122,61 +1122,42 @@ void test_gpu(int gpuID){
1122 1122 std::vector<algorithm_type_t> algor_vec3 = {algorithm_type_t::PERSON_CROSS, algorithm_type_t::NONMOTOR_WRONGDIRECTION, algorithm_type_t::VEHICLE_WRONGDIRECTION, algorithm_type_t::VEHICLE_NOTGIVEWAY,
1123 1123 algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND};
1124 1124  
1125   -/*
  1125 +
1126 1126 int repeat_num = 1000;
  1127 + createTask(handle, algor_vec2, 0, false);
  1128 + createTask(handle, algor_vec2, 2, false);
1127 1129 while(repeat_num--) {
1128   - printf("============================:%d\n",repeat_num);
1129   - string task_id = createTask(handle, algor_vec, 3 + gpuID * 10);
1130   - string task_id1 = createTask(handle, algor_vec2, 5);
1131   - string task_id2 = createTask(handle, algor_vec2, 6);
1132   -*/
1133   -
1134   - // string task_id = createTask(handle, algor_vec, 3 + gpuID * 10);
1135   - // string task_id1 = createTask(handle, algor_vec2, 5);
1136   - // createTask(handle, algor_vec, 18, false);
1137   - // createTask(handle, algor_vec, 20, false);
1138   - // createTask(handle, algor_vec, 20, false);
1139   - // createTask(handle, algor_vec, 20, false);
1140   - // createTask(handle, algor_vec, 20, false);
1141   - createTask(handle, algor_vec, 0);
1142   - // createTask(handle, algor_vec, 1);
1143   - // createTask(handle, algor_vec, 2);
1144   - // createTask(handle, algor_vec, 3);
1145   -/*
1146   -
1147   - createTask(handle, algor_vec, 0, false);
1148   - createTask(handle, algor_vec, 0, false);
1149   - createTask(handle, algor_vec, 0, false);
1150   - createTask(handle, algor_vec, 0, false);
1151   - createTask(handle, algor_vec, 0, false);
1152   - createTask(handle, algor_vec, 0, false);
1153   - createTask(handle, algor_vec, 2, false);
1154   - createTask(handle, algor_vec, 2, false);
1155   - createTask(handle, algor_vec, 2, false);
1156   - createTask(handle, algor_vec, 2, false);
1157   - createTask(handle, algor_vec, 2, false);
1158   - createTask(handle, algor_vec, 2, false);
1159   -
1160   -/*
  1130 + printf("============================:%d\n",repeat_num);
  1131 + vector<string> task_ids;
  1132 + for (int i = 4; i < 10; i ++) {
  1133 + string task_id = createTask(handle, algor_vec2, i, false);
  1134 + task_ids.push_back(task_id);
  1135 + }
  1136 +
1161 1137 // test_snapshot(handle);
1162 1138 sleep(60); //60s
1163   - finish_task(handle, (char*)task_id2.data(), 0);
1164   - finish_task(handle, (char*)task_id1.data(), 0);
1165   - }*/
  1139 + close_all_task(handle);
  1140 + for (auto& task_id : task_ids) {
  1141 + finish_task(handle, (char*)task_id.data(), 0);
  1142 + sleep(5);
  1143 + }
1166 1144  
  1145 + }
  1146 +
  1147 + /*
1167 1148 char ch = 'a';
1168 1149 while (ch != 'q') {
1169 1150 ch = getchar();
1170 1151 switch (ch)
1171 1152 {
1172 1153 case 'a':
1173   - createTask(handle, algor_vec3, 4, false);
1174   - createTask(handle, algor_vec3, 5, false);
1175   - createTask(handle, algor_vec3, 6, false);
1176   - createTask(handle, algor_vec3, 7, false);
1177   - createTask(handle, algor_vec3, 8, false);
1178   - createTask(handle, algor_vec3, 9, false);
1179   - createTask(handle, algor_vec3, 10, false);
  1154 + createTask(handle, algor_vec2, 4, false);
  1155 + createTask(handle, algor_vec2, 5, false);
  1156 + createTask(handle, algor_vec2, 6, false);
  1157 + createTask(handle, algor_vec2, 7, false);
  1158 + createTask(handle, algor_vec2, 8, false);
  1159 + createTask(handle, algor_vec2, 9, false);
  1160 + createTask(handle, algor_vec2, 10, false);
1180 1161 // createTask(handle, algor_vec2, 11, false);
1181 1162 // createTask(handle, algor_vec2, 12, false);
1182 1163 // createTask(handle, algor_vec2, 13, false);
... ... @@ -1193,7 +1174,7 @@ void test_gpu(int gpuID){
1193 1174 break;
1194 1175 }
1195 1176  
1196   - }
  1177 + }*/
1197 1178  
1198 1179 // finish_task(handle, (char*)task_id.data(), 0);
1199 1180  
... ...