552 lines
20 KiB
C++
552 lines
20 KiB
C++
#include "yaml_config_parser.hpp"
|
||
#include "../common/logger.hpp"
|
||
#include <filesystem>
|
||
#include <iostream>
|
||
#include <opencv2/core.hpp>
|
||
#include <unordered_set>
|
||
|
||
namespace pipeline {
|
||
|
||
bool YamlConfigParser::parse(const std::string& config_file) {
|
||
try {
|
||
Logger::info("Parsing config file: " + config_file);
|
||
yaml_config_ = YAML::LoadFile(config_file);
|
||
|
||
// 解析各个配置部分
|
||
if (!parseInputConfig(yaml_config_["input"])) {
|
||
Logger::error("Failed to parse input config");
|
||
return false;
|
||
}
|
||
|
||
if (!parseModelConfig(yaml_config_["inference"])) {
|
||
Logger::error("Failed to parse model config");
|
||
return false;
|
||
}
|
||
|
||
if (!parseRenderConfig(yaml_config_["render"])) {
|
||
Logger::error("Failed to parse render config");
|
||
return false;
|
||
}
|
||
|
||
if (!parseOutputConfig(yaml_config_["output"])) {
|
||
Logger::error("Failed to parse output config");
|
||
return false;
|
||
}
|
||
|
||
if (!parseLogConfig(yaml_config_["log"])) {
|
||
Logger::error("Failed to parse log config");
|
||
return false;
|
||
}
|
||
|
||
Logger::info("Successfully parsed all configurations");
|
||
return true;
|
||
} catch (const YAML::Exception& e) {
|
||
Logger::error("YAML parsing error: " + std::string(e.what()));
|
||
return false;
|
||
} catch (const std::exception& e) {
|
||
Logger::error("Error in parse: " + std::string(e.what()));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
bool YamlConfigParser::validate() {
|
||
// 基本验证
|
||
if (config_.input.sources.empty()) {
|
||
Logger::error("No input sources configured");
|
||
return false;
|
||
}
|
||
|
||
// 验证输入源名称唯一性
|
||
std::unordered_set<std::string> source_names;
|
||
for (const auto& source : config_.input.sources) {
|
||
if (!source_names.insert(source.name).second) {
|
||
Logger::error("Duplicate input source name: " + source.name);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 验证输出目标名称唯一性
|
||
std::unordered_set<std::string> target_names;
|
||
for (const auto& target : config_.output.targets) {
|
||
if (!target_names.insert(target.name).second) {
|
||
Logger::error("Duplicate output target name: " + target.name);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 收集所有有效的输出目标名称
|
||
std::unordered_set<std::string> valid_output_names;
|
||
for (const auto& target : config_.output.targets) {
|
||
valid_output_names.insert(target.name);
|
||
}
|
||
|
||
// 验证输入源配置
|
||
for (auto& source : config_.input.sources) {
|
||
if (source.type.empty() || source.name.empty()) {
|
||
Logger::error("Input source missing type or name");
|
||
return false;
|
||
}
|
||
if (source.type == "rtsp" && source.url.empty()) {
|
||
Logger::error("RTSP source missing URL");
|
||
return false;
|
||
}
|
||
if (source.buffer_size <= 0) {
|
||
Logger::error("Invalid buffer size for source: " + source.name);
|
||
return false;
|
||
}
|
||
|
||
// 如果没有指定输出目标，使用所有可用的输出目标
|
||
if (source.outputs.empty() && !valid_output_names.empty()) {
|
||
Logger::info("No output targets specified for source '" + source.name + "', using all available targets");
|
||
source.outputs.insert(source.outputs.end(),
|
||
valid_output_names.begin(),
|
||
valid_output_names.end());
|
||
}
|
||
// 验证输出目标映射
|
||
else if (!source.outputs.empty()) {
|
||
for (const auto& output : source.outputs) {
|
||
if (valid_output_names.find(output) == valid_output_names.end()) {
|
||
Logger::error("Invalid output target '" + output + "' specified for input source '" + source.name + "'");
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 验证推理配置
|
||
if (config_.inference.engine_path.empty()) {
|
||
Logger::error("Model engine path not specified");
|
||
return false;
|
||
}
|
||
if (config_.inference.input_shape.empty()) {
|
||
Logger::error("Model input shape not specified");
|
||
return false;
|
||
}
|
||
if (config_.inference.threshold.conf < 0.0f || config_.inference.threshold.conf > 1.0f) {
|
||
Logger::error("Invalid confidence threshold (must be between 0.0 and 1.0)");
|
||
return false;
|
||
}
|
||
if (config_.inference.threshold.nms < 0.0f || config_.inference.threshold.nms > 1.0f) {
|
||
Logger::error("Invalid NMS threshold (must be between 0.0 and 1.0)");
|
||
return false;
|
||
}
|
||
|
||
// 验证渲染配置
|
||
// 验证窗口配置
|
||
if (config_.render.window.width <= 0 || config_.render.window.height <= 0) {
|
||
Logger::error("Invalid window dimensions");
|
||
return false;
|
||
}
|
||
if (config_.render.window.name.empty()) {
|
||
Logger::error("Window name not specified");
|
||
return false;
|
||
}
|
||
|
||
// 验证默认样式
|
||
if (config_.render.default_style.transparency < 0.0f ||
|
||
config_.render.default_style.transparency > 1.0f) {
|
||
Logger::error("Invalid default style transparency (must be between 0.0 and 1.0)");
|
||
return false;
|
||
}
|
||
if (config_.render.default_style.box_thickness <= 0 ||
|
||
config_.render.default_style.font_thickness <= 0) {
|
||
Logger::error("Invalid default style thickness values");
|
||
return false;
|
||
}
|
||
if (config_.render.default_style.font_scale <= 0.0) {
|
||
Logger::error("Invalid default style font scale");
|
||
return false;
|
||
}
|
||
|
||
// 验证类别样式
|
||
for (const auto& [class_name, style] : config_.render.class_styles) {
|
||
if (class_name.empty()) {
|
||
Logger::error("Empty class name in style configuration");
|
||
return false;
|
||
}
|
||
if (style.transparency < 0.0f || style.transparency > 1.0f) {
|
||
Logger::error("Invalid transparency for class " + class_name);
|
||
return false;
|
||
}
|
||
if (style.box_thickness <= 0 || style.font_thickness <= 0) {
|
||
Logger::error("Invalid thickness values for class " + class_name);
|
||
return false;
|
||
}
|
||
if (style.font_scale <= 0.0) {
|
||
Logger::error("Invalid font scale for class " + class_name);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 验证性能指标配置
|
||
if (config_.render.metrics.update_interval_ms <= 0) {
|
||
Logger::error("Invalid metrics update interval");
|
||
return false;
|
||
}
|
||
|
||
// 验证输出配置
|
||
for (const auto& target : config_.output.targets) {
|
||
if (target.type.empty() || target.name.empty()) {
|
||
Logger::error("Output target missing type or name");
|
||
return false;
|
||
}
|
||
if (target.type == "video") {
|
||
if (target.path.empty()) {
|
||
Logger::error("Video output target missing path");
|
||
return false;
|
||
}
|
||
if (target.fps <= 0) {
|
||
Logger::error("Invalid video output fps");
|
||
return false;
|
||
}
|
||
if (target.bitrate <= 0) {
|
||
Logger::error("Invalid video output bitrate");
|
||
return false;
|
||
}
|
||
if (target.codec.empty()) {
|
||
Logger::error("Video output codec not specified");
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 验证日志配置
|
||
if (config_.log.level.empty()) {
|
||
Logger::error("Log level not specified");
|
||
return false;
|
||
}
|
||
if (config_.log.save_path.empty()) {
|
||
Logger::error("Log save path not specified");
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool YamlConfigParser::parseInputConfig(const YAML::Node& node) {
|
||
try {
|
||
// 解析输入源
|
||
if (node["sources"]) {
|
||
for (const auto& source : node["sources"]) {
|
||
InputSourceConfig src_config;
|
||
src_config.type = source["type"].as<std::string>();
|
||
src_config.name = source["name"].as<std::string>();
|
||
if (source["url"]) {
|
||
src_config.url = source["url"].as<std::string>();
|
||
}
|
||
if (source["buffer_size"]) {
|
||
src_config.buffer_size = source["buffer_size"].as<int>();
|
||
}
|
||
|
||
// 解析输出目标列表
|
||
if (source["output_targets"]) {
|
||
src_config.outputs = source["output_targets"].as<std::vector<std::string>>();
|
||
}
|
||
// 向后兼容：如果没有output_targets字段，检查旧的outputs字段
|
||
else if (source["outputs"]) {
|
||
src_config.outputs = source["outputs"].as<std::vector<std::string>>();
|
||
}
|
||
// 如果都没有指定，将在validate阶段添加所有可用的输出目标
|
||
|
||
config_.input.sources.push_back(src_config);
|
||
}
|
||
}
|
||
|
||
// 解析批处理大小
|
||
if (node["max_batch_size"]) {
|
||
config_.input.max_batch_size = node["max_batch_size"].as<int>();
|
||
}
|
||
|
||
return true;
|
||
} catch (const YAML::Exception& e) {
|
||
Logger::error("Error parsing input config: " + std::string(e.what()));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
bool YamlConfigParser::parseModelConfig(const YAML::Node& node) {
|
||
try {
|
||
if (!node["model"]) {
|
||
Logger::error("Model configuration section not found");
|
||
return false;
|
||
}
|
||
|
||
const auto& model = node["model"];
|
||
|
||
// 检查必需的字段
|
||
if (!model["onnx_path"]) {
|
||
Logger::error("ONNX path not specified in model config");
|
||
return false;
|
||
}
|
||
if (!model["engine_path"]) {
|
||
Logger::error("Engine path not specified in model config");
|
||
return false;
|
||
}
|
||
if (!model["input_shape"]) {
|
||
Logger::error("Input shape not specified in model config");
|
||
return false;
|
||
}
|
||
|
||
// 读取配置
|
||
config_.inference.engine_path = model["engine_path"].as<std::string>();
|
||
config_.inference.input_shape = model["input_shape"].as<std::vector<int>>();
|
||
config_.inference.precision = model["precision"] ? model["precision"].as<std::string>() : "FP16";
|
||
|
||
// 读取可选的版本和标签配置
|
||
if (model["version"]) {
|
||
config_.inference.version = model["version"].as<std::string>();
|
||
}
|
||
if (model["labels"]) {
|
||
config_.inference.labels = model["labels"].as<std::vector<std::string>>();
|
||
}
|
||
|
||
// 读取阈值配置
|
||
if (node["threshold"]) {
|
||
config_.inference.threshold.conf = node["threshold"]["conf"] ?
|
||
node["threshold"]["conf"].as<float>() : 0.5f;
|
||
config_.inference.threshold.nms = node["threshold"]["nms"] ?
|
||
node["threshold"]["nms"].as<float>() : 0.45f;
|
||
}
|
||
|
||
// 读取GPU设备ID
|
||
config_.inference.gpu_id = node["gpu_id"] ? node["gpu_id"].as<int>() : 0;
|
||
|
||
// 打印加载的配置信息
|
||
Logger::info("Loaded model configuration:");
|
||
Logger::info(" Engine path: " + config_.inference.engine_path);
|
||
Logger::info(" Input shape: " + std::to_string(config_.inference.input_shape[0]) + "," +
|
||
std::to_string(config_.inference.input_shape[1]) + "," +
|
||
std::to_string(config_.inference.input_shape[2]));
|
||
Logger::info(" Precision: " + config_.inference.precision);
|
||
Logger::info(" GPU ID: " + std::to_string(config_.inference.gpu_id));
|
||
Logger::info(" Confidence threshold: " + std::to_string(config_.inference.threshold.conf));
|
||
Logger::info(" NMS threshold: " + std::to_string(config_.inference.threshold.nms));
|
||
if (!config_.inference.version.empty()) {
|
||
Logger::info(" Version: " + config_.inference.version);
|
||
}
|
||
if (!config_.inference.labels.empty()) {
|
||
std::string labels_str = " Labels: ";
|
||
for (const auto& label : config_.inference.labels) {
|
||
labels_str += label + ", ";
|
||
}
|
||
labels_str = labels_str.substr(0, labels_str.length() - 2); // 移除最后的", "
|
||
Logger::info(labels_str);
|
||
}
|
||
|
||
return true;
|
||
} catch (const YAML::Exception& e) {
|
||
Logger::error("Error parsing model config: " + std::string(e.what()));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
bool YamlConfigParser::parseRenderConfig(const YAML::Node& node) {
|
||
try {
|
||
// 解析渲染启用状态
|
||
if (node["enable"]) {
|
||
config_.render.enable = node["enable"].as<bool>();
|
||
}
|
||
|
||
// 解析窗口配置
|
||
if (node["window"]) {
|
||
const auto& window = node["window"];
|
||
if (window["name"]) {
|
||
config_.render.window.name = window["name"].as<std::string>();
|
||
}
|
||
if (window["width"]) {
|
||
config_.render.window.width = window["width"].as<int>();
|
||
}
|
||
if (window["height"]) {
|
||
config_.render.window.height = window["height"].as<int>();
|
||
}
|
||
if (window["fullscreen"]) {
|
||
config_.render.window.fullscreen = window["fullscreen"].as<bool>();
|
||
}
|
||
}
|
||
|
||
// 解析默认样式
|
||
if (node["default_style"]) {
|
||
const auto& style = node["default_style"];
|
||
if (style["box_color"]) {
|
||
auto color = style["box_color"].as<std::vector<int>>();
|
||
if (color.size() >= 3) {
|
||
config_.render.default_style.box_color = cv::Scalar(color[0], color[1], color[2]);
|
||
}
|
||
}
|
||
if (style["text_color"]) {
|
||
auto color = style["text_color"].as<std::vector<int>>();
|
||
if (color.size() >= 3) {
|
||
config_.render.default_style.text_color = cv::Scalar(color[0], color[1], color[2]);
|
||
}
|
||
}
|
||
if (style["transparency"]) {
|
||
config_.render.default_style.transparency = style["transparency"].as<float>();
|
||
}
|
||
if (style["box_thickness"]) {
|
||
config_.render.default_style.box_thickness = style["box_thickness"].as<int>();
|
||
}
|
||
if (style["font_scale"]) {
|
||
config_.render.default_style.font_scale = style["font_scale"].as<double>();
|
||
}
|
||
if (style["font_thickness"]) {
|
||
config_.render.default_style.font_thickness = style["font_thickness"].as<int>();
|
||
}
|
||
}
|
||
|
||
// 解析类别样式
|
||
if (node["class_styles"]) {
|
||
for (const auto& class_style : node["class_styles"]) {
|
||
std::string class_name = class_style.first.as<std::string>();
|
||
const auto& style = class_style.second;
|
||
RenderConfig::ClassStyle class_config;
|
||
|
||
if (style["box_color"]) {
|
||
auto color = style["box_color"].as<std::vector<int>>();
|
||
if (color.size() >= 3) {
|
||
class_config.box_color = cv::Scalar(color[0], color[1], color[2]);
|
||
}
|
||
}
|
||
if (style["text_color"]) {
|
||
auto color = style["text_color"].as<std::vector<int>>();
|
||
if (color.size() >= 3) {
|
||
class_config.text_color = cv::Scalar(color[0], color[1], color[2]);
|
||
}
|
||
}
|
||
if (style["transparency"]) {
|
||
class_config.transparency = style["transparency"].as<float>();
|
||
}
|
||
if (style["box_thickness"]) {
|
||
class_config.box_thickness = style["box_thickness"].as<int>();
|
||
}
|
||
if (style["font_scale"]) {
|
||
class_config.font_scale = style["font_scale"].as<double>();
|
||
}
|
||
if (style["font_thickness"]) {
|
||
class_config.font_thickness = style["font_thickness"].as<int>();
|
||
}
|
||
|
||
config_.render.class_styles[class_name] = class_config;
|
||
}
|
||
}
|
||
|
||
// 解析性能指标配置
|
||
if (node["metrics"]) {
|
||
const auto& metrics = node["metrics"];
|
||
if (metrics["show_fps"]) {
|
||
config_.render.metrics.show_fps = metrics["show_fps"].as<bool>();
|
||
}
|
||
if (metrics["show_inference_time"]) {
|
||
config_.render.metrics.show_inference_time = metrics["show_inference_time"].as<bool>();
|
||
}
|
||
if (metrics["show_gpu_usage"]) {
|
||
config_.render.metrics.show_gpu_usage = metrics["show_gpu_usage"].as<bool>();
|
||
}
|
||
if (metrics["update_interval_ms"]) {
|
||
config_.render.metrics.update_interval_ms = metrics["update_interval_ms"].as<int>();
|
||
}
|
||
}
|
||
|
||
return true;
|
||
} catch (const YAML::Exception& e) {
|
||
Logger::error("Error parsing render config: " + std::string(e.what()));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
bool YamlConfigParser::parseOutputConfig(const YAML::Node& node) {
|
||
try {
|
||
if (node["targets"]) {
|
||
for (const auto& target : node["targets"]) {
|
||
OutputTargetConfig target_config;
|
||
target_config.type = target["type"].as<std::string>();
|
||
target_config.name = target["name"].as<std::string>();
|
||
if (target["path"]) {
|
||
target_config.path = target["path"].as<std::string>();
|
||
}
|
||
if (target["fps"]) {
|
||
target_config.fps = target["fps"].as<int>();
|
||
}
|
||
if (target["codec"]) {
|
||
target_config.codec = target["codec"].as<std::string>();
|
||
}
|
||
if (target["bitrate"]) {
|
||
target_config.bitrate = target["bitrate"].as<int>();
|
||
}
|
||
config_.output.targets.push_back(target_config);
|
||
}
|
||
}
|
||
return true;
|
||
} catch (const YAML::Exception& e) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
bool YamlConfigParser::parseLogConfig(const YAML::Node& node) {
|
||
try {
|
||
// 检查必需的字段
|
||
if (!node["level"]) {
|
||
Logger::error("Log level not specified");
|
||
return false;
|
||
}
|
||
if (!node["save_path"]) {
|
||
Logger::error("Log save path not specified");
|
||
return false;
|
||
}
|
||
|
||
// 读取配置
|
||
std::string level = node["level"].as<std::string>();
|
||
// 验证日志级别是否有效
|
||
if (level.empty() || (level != "debug" && level != "info" && level != "warn" && level != "error")) {
|
||
Logger::error("Invalid log level: " + level);
|
||
return false;
|
||
}
|
||
config_.log.level = level;
|
||
config_.log.save_path = node["save_path"].as<std::string>();
|
||
|
||
return true;
|
||
} catch (const YAML::Exception& e) {
|
||
Logger::error("Error parsing log config: " + std::string(e.what()));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
bool YamlConfigParser::parseRtspConfig(const YAML::Node& config, RtspReader::Config& rtsp_config) {
|
||
try {
|
||
auto rtsp_node = config["rtsp"];
|
||
if (!rtsp_node) {
|
||
return false;
|
||
}
|
||
|
||
// 设置默认值
|
||
rtsp_config = RtspReader::Config();
|
||
|
||
// 读取配置
|
||
if (rtsp_node["buffer_size"]) {
|
||
rtsp_config.buffer_size = rtsp_node["buffer_size"].as<int>();
|
||
}
|
||
if (rtsp_node["max_retry_count"]) {
|
||
rtsp_config.max_retry_count = rtsp_node["max_retry_count"].as<int>();
|
||
}
|
||
if (rtsp_node["retry_interval_ms"]) {
|
||
rtsp_config.retry_interval_ms = rtsp_node["retry_interval_ms"].as<int>();
|
||
}
|
||
if (rtsp_node["frame_timeout_ms"]) {
|
||
rtsp_config.frame_timeout_ms = rtsp_node["frame_timeout_ms"].as<int>();
|
||
}
|
||
if (rtsp_node["target_fps"]) {
|
||
rtsp_config.target_fps = rtsp_node["target_fps"].as<float>();
|
||
}
|
||
|
||
return true;
|
||
} catch (const YAML::Exception& e) {
|
||
Logger::error("Error parsing RTSP config: " + std::string(e.what()));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 工厂函数实现
|
||
std::unique_ptr<ConfigParser> createConfigParser() {
|
||
return std::make_unique<YamlConfigParser>();
|
||
}
|
||
|
||
} // namespace pipeline
|