nndeploy：一款最新上线的支持多平台、简单易用、高性能的机器学习部署框架

int main(int argc, char *argv[]) {
   // 有向无环图pipeline名称，例如:
  // NNDEPLOY_YOLOV5/NNDEPLOY_YOLOV6/NNDEPLOY_YOLOV8
  std::string name = demo::getName();
  // 推理后端类型，例如:
  // kInferenceTypeOpenVino / kInferenceTypeTensorRt / kInferenceTypeOnnxRuntime
  base::InferenceType inference_type = demo::getInferenceType();
  // 推理设备类型，例如:
  // kDeviceTypeCodeX86:0/kDeviceTypeCodeCuda:0/...
  base::DeviceType device_type = demo::getDeviceType();
  // 模型类型，例如:
  // kModelTypeOnnx/kModelTypeMnn/...
  base::ModelType model_type = demo::getModelType();
  // 模型是否是路径
  bool is_path = demo::isPath();
  // 模型路径或者模型字符串
  std::vector<std::string> model_value = demo::getModelValue();
  // 有向无环图pipeline的输入边packert
  model::Packet input("detect_in");
  // 有向无环图pipeline的输出边packert
  model::Packet output("detect_out");
  // 创建模型有向无环图pipeline
  model::Pipeline *pipeline =
      model::createPipeline(name, inference_type, device_type, &input, &output,
                          model_type, is_path, model_value);

  // 初始化有向无环图pipeline
  base::Status status = pipeline->init();

  // 输入图片
  cv::Mat input_mat = cv::imread(input_path);
  // 将图片写入有向无环图pipeline输入边
  input.set(input_mat);
  // 定义有向无环图pipeline的输出结果
  model::DetectResult result;
  // 将输出结果写入有向无环图pipeline输出边
  output.set(result);

  // 有向无环图Pipeline运行
  status = pipeline->run();

  // 有向无环图pipelinez反初始化
  status = pipeline->deinit();

  // 有向无环图pipeline销毁
  delete pipeline;

  return 0;
}

model::Pipeline* createYoloV5Pipeline(const std::string& name,
                                    base::InferenceType inference_type,
                                    base::DeviceType device_type,
                                    Packet* input, Packet* output,
                                    base::ModelType model_type, bool is_path,
                                    std::vector<std::string>& model_value) {
  model::Pipeline* pipeline = new model::Pipeline(name, input, output); // 有向无环图

  model::Packet* infer_input = pipeline->createPacket("infer_input"); // 推理模板的输入边
  model::Packet* infer_output = pipeline->createPacket("infer_output"); // 推理模板的输出

  // 搭建有向无图（preprocess->infer->postprocess）
  // 模型前处理模板model::CvtColrResize，输入边为input，输出边为infer_input
  model::Task* pre = pipeline->createTask<model::CvtColrResize>(
      "preprocess", input, infer_input);
  // 模型推理模板model::Infer(通用模板)，输入边为infer_input，输出边为infer_output
  model::Task* infer = pipeline->createInfer<model::Infer>(
      "infer", inference_type, infer_input, infer_output);
  // 模型后处理模板YoloPostProcess，输入边为infer_output，输出边为output
  model::Task* post = pipeline->createTask<YoloPostProcess>(
      "postprocess", infer_output, output);

  // 模型前处理任务pre的参数配置
  model::CvtclorResizeParam* pre_param =
      dynamic_cast<model::CvtclorResizeParam*>(pre->getParam());
  pre_param->src_pixel_type_ = base::kPixelTypeBGR;
  pre_param->dst_pixel_type_ = base::kPixelTypeRGB;
  pre_param->interp_type_ = base::kInterpTypeLinear;
  pre_param->h_ = 640;
  pre_param->w_ = 640;

  // 模型推理任务infer的参数配置
  inference::InferenceParam* inference_param =
      (inference::InferenceParam*)(infer->getParam());
  inference_param->is_path_ = is_path;
  inference_param->model_value_ = model_value;
  inference_param->device_type_ = device_type;

  // 模型后处理任务post的参数配置
  YoloPostParam* post_param = dynamic_cast<YoloPostParam*>(post->getParam());
  post_param->score_threshold_ = 0.5;
  post_param->nms_threshold_ = 0.45;
  post_param->num_classes_ = 80;
  post_param->model_h_ = 640;
  post_param->model_w_ = 640;
  post_param->version_ = 5;

  return pipeline;
}