Hu Chunming / src

/*
 * @Author: yangzilong
 * @LastEdit: yangzilong
 * @Date: 2021-11-24 16:42:38
 * @Email: yangzilong@objecteye.com
 * @Description:
 */

#ifdef _MSC_VER

#include <windows.h>
#endif
#include "header.h"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/opencv.hpp"
#include "stl_aiplatform.h"
#include "sy_common.h"
#include "time.h"
#include <chrono>
#include <iostream>
#include <memory>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#ifdef PRINT_LOG
#include "spdlog/spdlog.h"
#endif
#ifdef _MSC_VER
#include <direct.h>
#include <io.h>
#define ACCESS _access
#define MKDIR(a) _mkdir((a))
#else
#include <stdarg.h>
#include <sys/stat.h>
#include <unistd.h>
#define ACCESS access
#define MKDIR(a) mkdir((a), 0755)
#define TRUE 1
#define FALSE 0
#define Sleep(a) usleep((a)*1000)
typedef int BOOL;
typedef unsigned int DWORD;
typedef void *LPVOID;
typedef char _TCHAR;
#endif
#ifdef _DEBUG

#else
#pragma comment(lib, "mvpt.lib") //???
#endif

using namespace std;

#include "./utils.hpp"
#include <chrono>
#include <random>
#include <thread>



algorithm_type_t algor_index_to_algor_type(const int &idx) {
  switch (idx) {
  case 0:
    return algorithm_type_t::FACE_SNAPSHOT;
  case 1:
    return algorithm_type_t::HUMAN_SNAPSHOT;
  case 2:
    return algorithm_type_t::VEHICLE_SNAPSHOT;
  case 3:
    return algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT;
  default:
    return algorithm_type_t::UNKNOWN;
  }
}

void init_mq_conn(void *handle) {
  for (auto key : {mq_type_t::ALARM_MQ, mq_type_t::GET_TASK_MQ, mq_type_t::HEART_BEAT_MQ}) {
    rabbitmq_conn_params_t mq_conn_params;
    
    mq_conn_params.port = 5673;
    strcpy(mq_conn_params.ip, "192.168.10.8");
    strcpy(mq_conn_params.uname, "guest");
    strcpy(mq_conn_params.passwd, "guest");
    strcpy(mq_conn_params.vhost, "/");
    strcpy(mq_conn_params.exchange, "tsl.test.topic");
    strcpy(mq_conn_params.exchange_type, "topic");

    switch (key) {

    case mq_type_t::ALARM_MQ: {
      strcpy(mq_conn_params.queue, "tsl.test.queue.alarm");
      strcpy(mq_conn_params.routing_key, "tsl.test.queue.alarm.key");
    } break;
    case mq_type_t::GET_TASK_MQ: {
      strcpy(mq_conn_params.queue, "tsl.test.queue.get");
      strcpy(mq_conn_params.routing_key, "tsl.test.queue.get.key");
    } break;
    case mq_type_t::HEART_BEAT_MQ: {
      strcpy(mq_conn_params.queue, "tsl.test.queue.hb");
      strcpy(mq_conn_params.routing_key, "tsl.test.queue.hb.key");
    } break;
    }

    mq_conn_params.durable_exchange = false;
    mq_conn_params.durable_queue = false;

    if (0 != add_mq_conn(handle, key, mq_conn_params))
      fprintf(stderr, "ip is %s port is %d\n", mq_conn_params.ip, mq_conn_params.port);
  }
}

void set_ipc_url(task_param &tparam, const algorithm_type_t &algor_type) {

#if 1
  if (algor_type == algorithm_type_t::FACE_SNAPSHOT) {
    tparam.ipc_url = "../../data/duan1.avi";
  } else if (algor_type == algorithm_type_t::HUMAN_SNAPSHOT) {
    tparam.ipc_url = "../../data/duan1.avi";
  } 
  else if (algor_type == algorithm_type_t::VEHICLE_SNAPSHOT)
    tparam.ipc_url = "../../data/duan1.avi";
  else if (algor_type == algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT)
    tparam.ipc_url = "../../data/duan1.avi";
 
#else
  tparam.ipc_url = "rtmp://192.168.10.56:1935/objecteye/1";
#endif
}

void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_type_t &algor_type) {
  auto algor_init_params = new algor_init_config_param_t;
  switch (algor_type) {
  case algorithm_type_t::FACE_SNAPSHOT: {
    auto basic_params = new algor_basic_config_param_t;
    {
      basic_params->algor_valid_rect.top_ = 0;
      basic_params->algor_valid_rect.left_ = 0;
      basic_params->algor_valid_rect.width_ = 1920;
      basic_params->algor_valid_rect.height_ = 1080;

      basic_params->result_folder = "res/face";
      ;
      basic_params->result_folder_little = "res/face_little";
      ;
    }
    auto algor_params = new algor_config_param_snapshot;
    { algor_params->threshold = 0.5f; }

    algor_init_params->algor_param = algor_params;
    algor_init_params->basic_param = basic_params;
  } break;

  case algorithm_type_t::HUMAN_SNAPSHOT: {
    auto basic_params = new algor_basic_config_param_t;
    {
      basic_params->algor_valid_rect.top_ = 0;
      basic_params->algor_valid_rect.left_ = 0;
      basic_params->algor_valid_rect.width_ = 1920;
      basic_params->algor_valid_rect.height_ = 1080;

      basic_params->result_folder = "res/human";
      basic_params->result_folder_little = "res/human_little";
    }
    auto algor_params = new algor_config_param_snapshot;
    { algor_params->threshold = 0.5f; }

    algor_init_params->algor_param = algor_params;
    algor_init_params->basic_param = basic_params;
  } break;

  case algorithm_type_t::HUMAN_GATHER: {

    auto algor_params = new algor_config_param_human_gather;
    {
      algor_params->frame_stride = 1;
      // algor_params->human_count_threshold = 3;
      algor_params->human_count_threshold = 1;
    }

    auto basic_params = new algor_basic_config_param_t;
    {
      basic_params->algor_valid_rect.top_ = 0;
      basic_params->algor_valid_rect.left_ = 0;
      basic_params->algor_valid_rect.width_ = 1920;
      basic_params->algor_valid_rect.height_ = 1080;
      basic_params->result_folder = "res/gather";
      basic_params->result_folder_little = "res/gather_little";
    }

    algor_init_params->algor_param = algor_params;
    algor_init_params->basic_param = basic_params;
  } break;

  case algorithm_type_t::VEHICLE_SNAPSHOT: {

    auto basic_params = new algor_basic_config_param_t;
    {
      basic_params->algor_valid_rect.top_ = 0;
      basic_params->algor_valid_rect.left_ = 0;
      basic_params->algor_valid_rect.width_ = 1920;
      basic_params->algor_valid_rect.height_ = 1080;
      basic_params->result_folder = "res/vehicle";
      basic_params->result_folder_little = "res/vehicle_little";
    }

    auto algor_params = new algor_config_param_snapshot;
    { algor_params->threshold = 0.5f; }

    algor_init_params->algor_param = algor_params;
    algor_init_params->basic_param = basic_params;
  } break;

  case algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT: {

    auto basic_params = new algor_basic_config_param_t;
    {
      basic_params->algor_valid_rect.top_ = 0;
      basic_params->algor_valid_rect.left_ = 0;
      basic_params->algor_valid_rect.width_ = 1920;
      basic_params->algor_valid_rect.height_ = 1080;
      basic_params->result_folder = "res/nonmotor";
      basic_params->result_folder_little = "res/nonmotor_little";
    }

    auto algor_params = new algor_config_param_snapshot;
    { algor_params->threshold = 0.5f; }

    algor_init_params->algor_param = algor_params;
    algor_init_params->basic_param = basic_params;
  } break;

  default: {
    if (algor_init_params != nullptr) {
      delete algor_init_params;
      algor_init_params = nullptr;
    }
    return;
  } break;
  }

  tparam.algor_config_params[idx].algor_type = algor_type;
  tparam.algor_config_params[idx].algor_init_config_param = algor_init_params;
}

int main(int argc, char *argv[]) {
  printf("new test\n");
  if (argc < 4) {
    fprintf(stderr, "./xxx 0 2 10 1 ## [start_ai_id, end_ai_id) repeat_num gpu_id\n");
    return -1;
  }

  //! load params.
  int start_id = atoi(argv[1]);
  int end_id = atoi(argv[2]);
  int repeat_num = atoi(argv[3]);
  int gpuID = atoi(argv[4]);

  void *handle;

  tsl_aiplatform_param vptParam;
  vptParam.gpuid = gpuID;
  vptParam.trt_serialize_file = "";

  vptParam.log_days = 1;
  vptParam.log_level = AI_LOG_LEVEL_TRACE;
  // vptParam.log_level = AI_LOG_LEVEL_DEBUG;
  vptParam.log_mem = 64 * 1024 * 1024; // 64MB.
  vptParam.log_path = "logs/main.log";

#ifdef PRINT_LOG
  spdlog::set_level(spdlog::level::debug);
  spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
#endif

  int flag = tsl_aiplatform_init(&handle, vptParam);

  if (0 != flag) {
    printf("Init Failed! Error Code: %d\n", flag);
    system("pause");
    return 0;
  } else {
    printf("Init Success\n");
  }

#ifdef POST_USE_RABBITMQ

#if 1
  init_mq_conn(handle);
#endif

#endif // #ifdef POST_USE_RABBITMQ

  printf("Finish init mq\n");
  srand(time(nullptr));
  printf("begin add task\n");
  unsigned g_idx = 0;


  for (int i = start_id; i < end_id; i++) {
    for (int j = 0; j < repeat_num; ++j) {
      auto sleep_time = 0;
      printf("Add Task Sleep time is %d sec.\n", sleep_time);
      std::this_thread::sleep_for(std::chrono::seconds(sleep_time));

      task_param tparam;

      const auto algor_type = algor_index_to_algor_type(i);
      set_ipc_url(tparam, algor_type);

      tparam.algor_counts = 1;

      const std::string task_id_str = "test_task_id_" + to_string(g_idx++);
      tparam.task_id = task_id_str.c_str();
      tparam.algor_config_params = new algor_config_param[tparam.algor_counts];

      for (int idx = 0; idx < tparam.algor_counts; ++idx) {
        set_task_params(tparam, idx, algor_type);
        // printf("[set_task_params]: Start taskId: %s algor type is %d\n", tparam.task_id,
        // (int)tparam.algor_config_params[idx].algor_type);
      }

      const int result_code = add_task(handle, tparam);
      if (result_code != 0)
        printf("[Error]: ");
      printf("task_id: %s algort type %d result code: %d\n", tparam.task_id, int(algor_type), result_code);

#ifdef _MSC_VER
      Sleep(2000);
#else
      usleep(40000);
#endif
    }
  }


  while (1) {
#ifdef _MSC_VER
    Sleep(100);
#else
    usleep(2000);

#endif
  }

  tsl_aiplatform_release(&handle);
  printf("Done.\n");

  return 0;
}