891 lines
32 KiB
C#
891 lines
32 KiB
C#
using Microsoft.Extensions.Logging;
|
||
using Microsoft.Extensions.Options;
|
||
using OrpaonVision.Core.Results;
|
||
using OrpaonVision.SiteApp.Runtime.Contracts;
|
||
using OrpaonVision.SiteApp.Runtime.Options;
|
||
using System.Text.Json;
|
||
|
||
namespace OrpaonVision.SiteApp.Runtime.Services;
|
||
|
||
/// <summary>
|
||
/// 高级规则引擎服务实现。
|
||
/// 支持复杂规则配置、多条件判断、动态规则加载等功能。
|
||
/// </summary>
|
||
public sealed class AdvancedRuleEngineService : IRuleEngineService, IDisposable
|
||
{
|
||
private readonly ILogger<AdvancedRuleEngineService> _logger;
|
||
private readonly RuntimeOptions _options;
|
||
private readonly Dictionary<string, RuleDefinition> _rules;
|
||
private readonly object _lockObject = new();
|
||
private bool _isInitialized;
|
||
|
||
/// <summary>
|
||
/// 构造函数。
|
||
/// </summary>
|
||
public AdvancedRuleEngineService(ILogger<AdvancedRuleEngineService> logger, IOptions<RuntimeOptions> options)
|
||
{
|
||
_logger = logger;
|
||
_options = options.Value;
|
||
_rules = new Dictionary<string, RuleDefinition>();
|
||
|
||
InitializeDefaultRules();
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public Result<RuntimeDecisionDto> Evaluate(int currentLayer, InferenceResultDto inference)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("执行规则引擎评估：当前层={CurrentLayer}，推理结果={Label}，置信度={Confidence:F3}",
|
||
currentLayer, inference.Label, inference.Confidence);
|
||
|
||
if (!_isInitialized)
|
||
{
|
||
_logger.LogWarning("规则引擎未初始化，使用默认规则");
|
||
return EvaluateWithDefaultRule(currentLayer, inference);
|
||
}
|
||
|
||
// 获取当前层的规则
|
||
var layerRules = GetRulesForLayer(currentLayer);
|
||
if (layerRules.Count == 0)
|
||
{
|
||
_logger.LogWarning("第 {CurrentLayer} 层没有配置规则，使用默认规则", currentLayer);
|
||
return EvaluateWithDefaultRule(currentLayer, inference);
|
||
}
|
||
|
||
// 执行规则评估
|
||
var evaluationContext = new RuleEvaluationContext
|
||
{
|
||
CurrentLayer = currentLayer,
|
||
Inference = inference,
|
||
Timestamp = DateTime.UtcNow
|
||
};
|
||
|
||
var results = new List<RuleEvaluationResult>();
|
||
|
||
foreach (var rule in layerRules)
|
||
{
|
||
var result = EvaluateRule(rule, evaluationContext);
|
||
results.Add(result);
|
||
|
||
_logger.LogDebug("规则 {RuleName} 评估结果：{IsPass} - {Message}",
|
||
rule.Name, result.IsPass, result.Message);
|
||
|
||
// 如果是关键规则且失败，可以提前终止
|
||
if (!result.IsPass && rule.IsCritical)
|
||
{
|
||
_logger.LogInformation("关键规则 {RuleName} 失败，提前终止评估", rule.Name);
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 汇总评估结果
|
||
var finalDecision = AggregateEvaluationResults(results, evaluationContext);
|
||
|
||
_logger.LogInformation("规则引擎评估完成：{DecisionCode} - {DecisionMessage}",
|
||
finalDecision.Code, finalDecision.Message);
|
||
|
||
return Result<RuntimeDecisionDto>.Success(finalDecision, message: "规则判定完成");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "规则引擎评估失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "RULE_ENGINE_EVALUATION_FAILED", "规则引擎评估失败", traceId);
|
||
return Result<RuntimeDecisionDto>.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 初始化默认规则。
|
||
/// </summary>
|
||
private void InitializeDefaultRules()
|
||
{
|
||
lock (_lockObject)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogInformation("正在初始化默认规则...");
|
||
|
||
// 添加基础缺陷检测规则
|
||
var defectRule = new RuleDefinition
|
||
{
|
||
Name = "DefectDetection",
|
||
Description = "缺陷检测规则",
|
||
Layer = 0, // 适用于所有层
|
||
Conditions = new List<RuleCondition>
|
||
{
|
||
new()
|
||
{
|
||
Type = ConditionType.LabelEquals,
|
||
Parameter = "defect",
|
||
Operator = "equals",
|
||
ExpectedValue = "defect"
|
||
},
|
||
new()
|
||
{
|
||
Type = ConditionType.ConfidenceThreshold,
|
||
Parameter = "confidence",
|
||
Operator = ">=",
|
||
ExpectedValue = _options.NgConfidenceThreshold.ToString("F3")
|
||
}
|
||
},
|
||
Action = new RuleAction
|
||
{
|
||
Type = ActionType.MarkAsNG,
|
||
Parameters = new Dictionary<string, object>
|
||
{
|
||
["reason"] = "检测到缺陷",
|
||
["severity"] = "high"
|
||
}
|
||
},
|
||
IsCritical = true,
|
||
Priority = 1,
|
||
Enabled = true
|
||
};
|
||
|
||
// 添加置信度规则
|
||
var confidenceRule = new RuleDefinition
|
||
{
|
||
Name = "ConfidenceCheck",
|
||
Description = "置信度检查规则",
|
||
Layer = 0, // 适用于所有层
|
||
Conditions = new List<RuleCondition>
|
||
{
|
||
new()
|
||
{
|
||
Type = ConditionType.ConfidenceThreshold,
|
||
Parameter = "confidence",
|
||
Operator = "<",
|
||
ExpectedValue = _options.NgConfidenceThreshold.ToString("F3")
|
||
}
|
||
},
|
||
Action = new RuleAction
|
||
{
|
||
Type = ActionType.MarkAsNG,
|
||
Parameters = new Dictionary<string, object>
|
||
{
|
||
["reason"] = "置信度过低",
|
||
["severity"] = "medium"
|
||
}
|
||
},
|
||
IsCritical = false,
|
||
Priority = 2,
|
||
Enabled = true
|
||
};
|
||
|
||
// 添加正常通过规则
|
||
var passRule = new RuleDefinition
|
||
{
|
||
Name = "NormalPass",
|
||
Description = "正常通过规则",
|
||
Layer = 0, // 适用于所有层
|
||
Conditions = new List<RuleCondition>
|
||
{
|
||
new()
|
||
{
|
||
Type = ConditionType.LabelEquals,
|
||
Parameter = "normal",
|
||
Operator = "equals",
|
||
ExpectedValue = "normal"
|
||
},
|
||
new()
|
||
{
|
||
Type = ConditionType.ConfidenceThreshold,
|
||
Parameter = "confidence",
|
||
Operator = ">=",
|
||
ExpectedValue = _options.NgConfidenceThreshold.ToString("F3")
|
||
}
|
||
},
|
||
Action = new RuleAction
|
||
{
|
||
Type = ActionType.MarkAsOK,
|
||
Parameters = new Dictionary<string, object>
|
||
{
|
||
["reason"] = "正常检测"
|
||
}
|
||
},
|
||
IsCritical = false,
|
||
Priority = 3,
|
||
Enabled = true
|
||
};
|
||
|
||
// 添加数量检查规则
|
||
var quantityRule = new RuleDefinition
|
||
{
|
||
Name = "QuantityCheck",
|
||
Description = "部件数量检查规则",
|
||
Layer = 0, // 适用于所有层
|
||
Conditions = new List<RuleCondition>
|
||
{
|
||
new()
|
||
{
|
||
Type = ConditionType.QuantityCheck,
|
||
Parameter = "",
|
||
Operator = "equals",
|
||
ExpectedValue = "3-5" // 期望3-5个部件
|
||
}
|
||
},
|
||
Action = new RuleAction
|
||
{
|
||
Type = ActionType.MarkAsNG,
|
||
Parameters = new Dictionary<string, object>
|
||
{
|
||
["reason"] = "部件数量不符合要求",
|
||
["severity"] = "medium"
|
||
}
|
||
},
|
||
IsCritical = false,
|
||
Priority = 4,
|
||
Enabled = true
|
||
};
|
||
|
||
// 添加位置检查规则
|
||
var positionRule = new RuleDefinition
|
||
{
|
||
Name = "PositionCheck",
|
||
Description = "部件位置检查规则",
|
||
Layer = 0,
|
||
Conditions = new List<RuleCondition>
|
||
{
|
||
new()
|
||
{
|
||
Type = ConditionType.PositionCheck,
|
||
Parameter = "screw", // 检查螺丝位置
|
||
Operator = "within",
|
||
ExpectedValue = "100,100,50" // 圆形区域：中心(100,100)，半径50
|
||
}
|
||
},
|
||
Action = new RuleAction
|
||
{
|
||
Type = ActionType.MarkAsNG,
|
||
Parameters = new Dictionary<string, object>
|
||
{
|
||
["reason"] = "部件位置偏离",
|
||
["severity"] = "high"
|
||
}
|
||
},
|
||
IsCritical = true,
|
||
Priority = 5,
|
||
Enabled = true
|
||
};
|
||
|
||
// 添加到位检查规则
|
||
var placementRule = new RuleDefinition
|
||
{
|
||
Name = "PlacementCheck",
|
||
Description = "部件到位检查规则",
|
||
Layer = 0,
|
||
Conditions = new List<RuleCondition>
|
||
{
|
||
new()
|
||
{
|
||
Type = ConditionType.PlacementCheck,
|
||
Parameter = "",
|
||
Operator = "equals",
|
||
ExpectedValue = "bracket=2" // 期望2个支架
|
||
}
|
||
},
|
||
Action = new RuleAction
|
||
{
|
||
Type = ActionType.MarkAsNG,
|
||
Parameters = new Dictionary<string, object>
|
||
{
|
||
["reason"] = "部件未完全到位",
|
||
["severity"] = "medium"
|
||
}
|
||
},
|
||
IsCritical = false,
|
||
Priority = 6,
|
||
Enabled = true
|
||
};
|
||
|
||
// 添加禁装检查规则
|
||
var forbiddenRule = new RuleDefinition
|
||
{
|
||
Name = "ForbiddenCheck",
|
||
Description = "禁装部件检查规则",
|
||
Layer = 0,
|
||
Conditions = new List<RuleCondition>
|
||
{
|
||
new()
|
||
{
|
||
Type = ConditionType.ForbiddenCheck,
|
||
Parameter = "",
|
||
Operator = "not_contains",
|
||
ExpectedValue = "wrong_part,temp_part" // 禁止错误的部件和临时部件
|
||
}
|
||
},
|
||
Action = new RuleAction
|
||
{
|
||
Type = ActionType.MarkAsNG,
|
||
Parameters = new Dictionary<string, object>
|
||
{
|
||
["reason"] = "发现禁装部件",
|
||
["severity"] = "high"
|
||
}
|
||
},
|
||
IsCritical = true,
|
||
Priority = 7,
|
||
Enabled = true
|
||
};
|
||
|
||
// 添加顺序检查规则
|
||
var sequenceRule = new RuleDefinition
|
||
{
|
||
Name = "SequenceCheck",
|
||
Description = "装配顺序检查规则",
|
||
Layer = 0,
|
||
Conditions = new List<RuleCondition>
|
||
{
|
||
new()
|
||
{
|
||
Type = ConditionType.SequenceCheck,
|
||
Parameter = "",
|
||
Operator = "equals",
|
||
ExpectedValue = "base>bracket>screw>cover" // 期望装配顺序
|
||
}
|
||
},
|
||
Action = new RuleAction
|
||
{
|
||
Type = ActionType.MarkAsNG,
|
||
Parameters = new Dictionary<string, object>
|
||
{
|
||
["reason"] = "装配顺序错误",
|
||
["severity"] = "high"
|
||
}
|
||
},
|
||
IsCritical = true,
|
||
Priority = 8,
|
||
Enabled = true
|
||
};
|
||
|
||
_rules["DefectDetection"] = defectRule;
|
||
_rules["ConfidenceCheck"] = confidenceRule;
|
||
_rules["NormalPass"] = passRule;
|
||
_rules["QuantityCheck"] = quantityRule;
|
||
_rules["PositionCheck"] = positionRule;
|
||
_rules["PlacementCheck"] = placementRule;
|
||
_rules["ForbiddenCheck"] = forbiddenRule;
|
||
_rules["SequenceCheck"] = sequenceRule;
|
||
|
||
_isInitialized = true;
|
||
_logger.LogInformation("默认规则初始化完成，共加载 {Count} 条规则", _rules.Count);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "初始化默认规则失败");
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取指定层的规则。
|
||
/// </summary>
|
||
private List<RuleDefinition> GetRulesForLayer(int layer)
|
||
{
|
||
return _rules.Values
|
||
.Where(rule => rule.Layer == 0 || rule.Layer == layer)
|
||
.Where(rule => rule.Enabled)
|
||
.OrderBy(rule => rule.Priority)
|
||
.ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 评估单个规则。
|
||
/// </summary>
|
||
private RuleEvaluationResult EvaluateRule(RuleDefinition rule, RuleEvaluationContext context)
|
||
{
|
||
try
|
||
{
|
||
var conditionResults = new List<bool>();
|
||
|
||
foreach (var condition in rule.Conditions)
|
||
{
|
||
var result = EvaluateCondition(condition, context);
|
||
conditionResults.Add(result);
|
||
|
||
// 如果是AND逻辑且有一个条件失败，可以提前退出
|
||
if (!result && rule.ConditionLogic == ConditionLogic.And)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 根据逻辑运算符确定最终结果
|
||
var isPass = rule.ConditionLogic == ConditionLogic.And
|
||
? conditionResults.All(r => r)
|
||
: conditionResults.Any(r => r);
|
||
|
||
var message = isPass
|
||
? $"规则 {rule.Name} 通过"
|
||
: $"规则 {rule.Name} 失败: {string.Join(", ", rule.Conditions.Select(c => c.Type))}";
|
||
|
||
return new RuleEvaluationResult
|
||
{
|
||
RuleName = rule.Name,
|
||
IsPass = isPass,
|
||
Message = message,
|
||
Action = isPass ? null : rule.Action,
|
||
ExecutionTime = DateTime.UtcNow
|
||
};
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "评估规则 {RuleName} 失败", rule.Name);
|
||
return new RuleEvaluationResult
|
||
{
|
||
RuleName = rule.Name,
|
||
IsPass = false,
|
||
Message = $"规则评估异常: {ex.Message}",
|
||
Action = new RuleAction
|
||
{
|
||
Type = ActionType.MarkAsNG,
|
||
Parameters = new Dictionary<string, object>
|
||
{
|
||
["reason"] = "规则评估异常",
|
||
["severity"] = "high"
|
||
}
|
||
},
|
||
ExecutionTime = DateTime.UtcNow
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 评估条件。
|
||
/// </summary>
|
||
private bool EvaluateCondition(RuleCondition condition, RuleEvaluationContext context)
|
||
{
|
||
return condition.Type switch
|
||
{
|
||
ConditionType.LabelEquals => EvaluateLabelEquals(condition, context),
|
||
ConditionType.ConfidenceThreshold => EvaluateConfidenceThreshold(condition, context),
|
||
ConditionType.QuantityCheck => EvaluateQuantityCheck(condition, context),
|
||
ConditionType.PositionCheck => EvaluatePositionCheck(condition, context),
|
||
ConditionType.PlacementCheck => EvaluatePlacementCheck(condition, context),
|
||
ConditionType.ForbiddenCheck => EvaluateForbiddenCheck(condition, context),
|
||
ConditionType.SequenceCheck => EvaluateSequenceCheck(condition, context),
|
||
_ => false
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 评估标签等于条件。
|
||
/// </summary>
|
||
private bool EvaluateLabelEquals(RuleCondition condition, RuleEvaluationContext context)
|
||
{
|
||
var expectedLabel = condition.ExpectedValue;
|
||
var actualLabel = context.Inference.Label;
|
||
|
||
return condition.Operator switch
|
||
{
|
||
"equals" => actualLabel == expectedLabel,
|
||
"not_equals" => actualLabel != expectedLabel,
|
||
"contains" => actualLabel.Contains(expectedLabel),
|
||
"not_contains" => !actualLabel.Contains(expectedLabel),
|
||
_ => actualLabel == expectedLabel
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 评估置信度阈值条件。
|
||
/// </summary>
|
||
private bool EvaluateConfidenceThreshold(RuleCondition condition, RuleEvaluationContext context)
|
||
{
|
||
if (!decimal.TryParse(condition.ExpectedValue, out var threshold))
|
||
{
|
||
_logger.LogWarning("置信度阈值解析失败: {Value}", condition.ExpectedValue);
|
||
return false;
|
||
}
|
||
|
||
var actualConfidence = (decimal)context.Inference.Confidence;
|
||
|
||
return condition.Operator switch
|
||
{
|
||
">=" => actualConfidence >= threshold,
|
||
"<=" => actualConfidence <= threshold,
|
||
">" => actualConfidence > threshold,
|
||
"<" => actualConfidence < threshold,
|
||
"==" => actualConfidence == threshold,
|
||
"!=" => actualConfidence != threshold,
|
||
_ => actualConfidence >= threshold
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 评估数量检查条件。
|
||
/// </summary>
|
||
private bool EvaluateQuantityCheck(RuleCondition condition, RuleEvaluationContext context)
|
||
{
|
||
try
|
||
{
|
||
// 解析期望数量范围，格式如 "min-max" 或 "exact"
|
||
var expectedRange = condition.ExpectedValue;
|
||
var actualCount = context.Inference.Detections.Count;
|
||
|
||
_logger.LogDebug("数量检查：期望={ExpectedRange}，实际={ActualCount}", expectedRange, actualCount);
|
||
|
||
if (expectedRange.Contains('-'))
|
||
{
|
||
// 范围检查，格式：min-max
|
||
var parts = expectedRange.Split('-');
|
||
if (parts.Length == 2 && int.TryParse(parts[0], out var min) && int.TryParse(parts[1], out var max))
|
||
{
|
||
return actualCount >= min && actualCount <= max;
|
||
}
|
||
}
|
||
else if (int.TryParse(expectedRange, out var exact))
|
||
{
|
||
// 精确数量检查
|
||
return actualCount == exact;
|
||
}
|
||
|
||
_logger.LogWarning("数量检查条件解析失败: {Value}", expectedRange);
|
||
return false;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "数量检查评估失败");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 评估位置检查条件。
|
||
/// </summary>
|
||
private bool EvaluatePositionCheck(RuleCondition condition, RuleEvaluationContext context)
|
||
{
|
||
try
|
||
{
|
||
// 解析期望位置，格式如 "x_min:x_max,y_min:y_max" 或 "center_x,center_y,radius"
|
||
var expectedPosition = condition.ExpectedValue;
|
||
var detections = context.Inference.Detections.Where(d => d.ClassName == condition.Parameter || string.IsNullOrEmpty(condition.Parameter)).ToList();
|
||
|
||
if (!detections.Any())
|
||
{
|
||
_logger.LogDebug("位置检查：未找到匹配的检测对象");
|
||
return false;
|
||
}
|
||
|
||
// 检查是否所有检测对象都在期望位置范围内
|
||
foreach (var detection in detections)
|
||
{
|
||
var isInRange = CheckPositionInRange(detection.CenterX, detection.CenterY, expectedPosition);
|
||
if (!isInRange)
|
||
{
|
||
_logger.LogDebug("位置检查失败：检测对象 {ClassName} 位置 ({X}, {Y}) 不在期望范围内 {Range}",
|
||
detection.ClassName, detection.CenterX, detection.CenterY, expectedPosition);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
_logger.LogDebug("位置检查通过：所有 {Count} 个检测对象都在期望范围内", detections.Count);
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "位置检查评估失败");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 评估到位检查条件。
|
||
/// </summary>
|
||
private bool EvaluatePlacementCheck(RuleCondition condition, RuleEvaluationContext context)
|
||
{
|
||
try
|
||
{
|
||
// 解析期望的到位状态，格式：className=expected_count
|
||
var placementRule = condition.ExpectedValue;
|
||
var parts = placementRule.Split('=');
|
||
|
||
if (parts.Length != 2 || !int.TryParse(parts[1], out var expectedCount))
|
||
{
|
||
_logger.LogWarning("到位检查条件解析失败: {Value}", placementRule);
|
||
return false;
|
||
}
|
||
|
||
var targetClass = parts[0];
|
||
var actualCount = context.Inference.Detections.Count(d => d.ClassName == targetClass);
|
||
|
||
_logger.LogDebug("到位检查：{ClassName} 期望={ExpectedCount}，实际={ActualCount}",
|
||
targetClass, expectedCount, actualCount);
|
||
|
||
return actualCount >= expectedCount;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "到位检查评估失败");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 评估禁装检查条件。
|
||
/// </summary>
|
||
private bool EvaluateForbiddenCheck(RuleCondition condition, RuleEvaluationContext context)
|
||
{
|
||
try
|
||
{
|
||
// 检查是否存在禁用的部件
|
||
var forbiddenClasses = condition.ExpectedValue.Split(',', StringSplitOptions.RemoveEmptyEntries);
|
||
var detections = context.Inference.Detections;
|
||
|
||
foreach (var forbiddenClass in forbiddenClasses)
|
||
{
|
||
var forbiddenDetections = detections.Where(d => d.ClassName.Equals(forbiddenClass.Trim(), StringComparison.OrdinalIgnoreCase)).ToList();
|
||
if (forbiddenDetections.Any())
|
||
{
|
||
_logger.LogDebug("禁装检查失败：发现禁用部件 {ClassName}，数量={Count}", forbiddenClass, forbiddenDetections.Count);
|
||
return false; // 发现禁用部件，检查失败
|
||
}
|
||
}
|
||
|
||
_logger.LogDebug("禁装检查通过：未发现禁用部件");
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "禁装检查评估失败");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 评估顺序检查条件。
|
||
/// </summary>
|
||
private bool EvaluateSequenceCheck(RuleCondition condition, RuleEvaluationContext context)
|
||
{
|
||
try
|
||
{
|
||
// 解析期望顺序，格式如 "class1>class2>class3"
|
||
var expectedSequence = condition.ExpectedValue;
|
||
var sequenceParts = expectedSequence.Split('>', StringSplitOptions.RemoveEmptyEntries);
|
||
|
||
// 按Y坐标排序检测对象（假设装配顺序是从上到下）
|
||
var sortedDetections = context.Inference.Detections
|
||
.Where(d => sequenceParts.Contains(d.ClassName))
|
||
.OrderBy(d => d.CenterY)
|
||
.Select(d => d.ClassName)
|
||
.ToList();
|
||
|
||
var actualSequence = string.Join(">", sortedDetections);
|
||
var isCorrectOrder = actualSequence.Equals(expectedSequence, StringComparison.OrdinalIgnoreCase);
|
||
|
||
_logger.LogDebug("顺序检查：期望={Expected}，实际={Actual}，结果={Result}",
|
||
expectedSequence, actualSequence, isCorrectOrder ? "通过" : "失败");
|
||
|
||
return isCorrectOrder;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "顺序检查评估失败");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查位置是否在指定范围内。
|
||
/// </summary>
|
||
private static bool CheckPositionInRange(float centerX, float centerY, string rangeDefinition)
|
||
{
|
||
if (rangeDefinition.Contains(','))
|
||
{
|
||
// 圆形范围检查，格式：center_x,center_y,radius
|
||
var parts = rangeDefinition.Split(',');
|
||
if (parts.Length == 3 &&
|
||
float.TryParse(parts[0], out var expectedCenterX) &&
|
||
float.TryParse(parts[1], out var expectedCenterY) &&
|
||
float.TryParse(parts[2], out var radius))
|
||
{
|
||
var distance = Math.Sqrt(Math.Pow(centerX - expectedCenterX, 2) + Math.Pow(centerY - expectedCenterY, 2));
|
||
return distance <= radius;
|
||
}
|
||
}
|
||
else if (rangeDefinition.Contains(':'))
|
||
{
|
||
// 矩形范围检查，格式：x_min:x_max,y_min:y_max
|
||
var coordinates = rangeDefinition.Split(',');
|
||
if (coordinates.Length == 2)
|
||
{
|
||
var xRange = coordinates[0].Split(':');
|
||
var yRange = coordinates[1].Split(':');
|
||
|
||
if (xRange.Length == 2 && yRange.Length == 2 &&
|
||
float.TryParse(xRange[0], out var xMin) &&
|
||
float.TryParse(xRange[1], out var xMax) &&
|
||
float.TryParse(yRange[0], out var yMin) &&
|
||
float.TryParse(yRange[1], out var yMax))
|
||
{
|
||
return centerX >= xMin && centerX <= xMax && centerY >= yMin && centerY <= yMax;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 汇总评估结果。
|
||
/// </summary>
|
||
private RuntimeDecisionDto AggregateEvaluationResults(List<RuleEvaluationResult> results, RuleEvaluationContext context)
|
||
{
|
||
var failedRules = results.Where(r => !r.IsPass).ToList();
|
||
var criticalFailures = failedRules.Where(r => r.Action?.Parameters?.ContainsKey("severity") == true &&
|
||
r.Action.Parameters["severity"].ToString() == "high").ToList();
|
||
|
||
var isPass = failedRules.Count == 0;
|
||
var decisionCode = isPass ? "RULE_PASS" : "RULE_NG";
|
||
var decisionMessage = isPass
|
||
? $"第 {context.CurrentLayer} 层所有规则通过"
|
||
: $"第 {context.CurrentLayer} 层规则失败: {string.Join(", ", failedRules.Select(r => r.RuleName))}";
|
||
|
||
// 如果有关键失败，提升消息级别
|
||
if (criticalFailures.Count > 0)
|
||
{
|
||
decisionCode = "RULE_CRITICAL_NG";
|
||
decisionMessage = $"第 {context.CurrentLayer} 层关键规则失败: {string.Join(", ", criticalFailures.Select(r => r.RuleName))}";
|
||
}
|
||
|
||
return new RuntimeDecisionDto
|
||
{
|
||
IsPass = isPass,
|
||
Code = decisionCode,
|
||
Message = decisionMessage
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 使用默认规则评估。
|
||
/// </summary>
|
||
private Result<RuntimeDecisionDto> EvaluateWithDefaultRule(int currentLayer, InferenceResultDto inference)
|
||
{
|
||
var isPass = inference.Label == "normal" || inference.Label == "OK" || inference.Confidence < _options.NgConfidenceThreshold;
|
||
var decision = new RuntimeDecisionDto
|
||
{
|
||
IsPass = isPass,
|
||
Code = isPass ? "DEFAULT_RULE_PASS" : "DEFAULT_RULE_NG",
|
||
Message = isPass
|
||
? $"第 {currentLayer} 层默认规则通过。"
|
||
: $"第 {currentLayer} 层默认规则 NG：{inference.Label} (置信度: {inference.Confidence:F3})"
|
||
};
|
||
|
||
return Result<RuntimeDecisionDto>.Success(decision, message: "默认规则判定完成");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 释放资源。
|
||
/// </summary>
|
||
public void Dispose()
|
||
{
|
||
try
|
||
{
|
||
_rules.Clear();
|
||
_isInitialized = false;
|
||
_logger.LogInformation("规则引擎服务已释放");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "释放规则引擎服务资源时发生错误");
|
||
}
|
||
}
|
||
}
|
||
|
||
#region 规则引擎内部类型
|
||
|
||
/// <summary>
|
||
/// 规则定义。
|
||
/// </summary>
|
||
internal sealed class RuleDefinition
|
||
{
|
||
public string Name { get; init; } = string.Empty;
|
||
public string Description { get; init; } = string.Empty;
|
||
public int Layer { get; init; }
|
||
public List<RuleCondition> Conditions { get; init; } = new();
|
||
public RuleAction Action { get; init; } = new();
|
||
public bool IsCritical { get; init; }
|
||
public int Priority { get; init; }
|
||
public bool Enabled { get; init; }
|
||
public ConditionLogic ConditionLogic { get; init; } = ConditionLogic.And;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 规则条件。
|
||
/// </summary>
|
||
internal sealed class RuleCondition
|
||
{
|
||
public ConditionType Type { get; init; }
|
||
public string Parameter { get; init; } = string.Empty;
|
||
public string Operator { get; init; } = string.Empty;
|
||
public string ExpectedValue { get; init; } = string.Empty;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 规则动作。
|
||
/// </summary>
|
||
internal sealed class RuleAction
|
||
{
|
||
public ActionType Type { get; init; }
|
||
public Dictionary<string, object> Parameters { get; init; } = new();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 规则评估上下文。
|
||
/// </summary>
|
||
internal sealed class RuleEvaluationContext
|
||
{
|
||
public int CurrentLayer { get; init; }
|
||
public InferenceResultDto Inference { get; init; } = new();
|
||
public DateTime Timestamp { get; init; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 规则评估结果。
|
||
/// </summary>
|
||
internal sealed class RuleEvaluationResult
|
||
{
|
||
public string RuleName { get; init; } = string.Empty;
|
||
public bool IsPass { get; init; }
|
||
public string Message { get; init; } = string.Empty;
|
||
public RuleAction? Action { get; init; }
|
||
public DateTime ExecutionTime { get; init; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 条件类型。
|
||
/// </summary>
|
||
internal enum ConditionType
|
||
{
|
||
LabelEquals,
|
||
ConfidenceThreshold,
|
||
QuantityCheck,
|
||
PositionCheck,
|
||
PlacementCheck,
|
||
ForbiddenCheck,
|
||
SequenceCheck
|
||
}
|
||
|
||
/// <summary>
|
||
/// 动作类型。
|
||
/// </summary>
|
||
internal enum ActionType
|
||
{
|
||
MarkAsOK,
|
||
MarkAsNG,
|
||
LogWarning,
|
||
Custom
|
||
}
|
||
|
||
/// <summary>
|
||
/// 条件逻辑。
|
||
/// </summary>
|
||
internal enum ConditionLogic
|
||
{
|
||
And,
|
||
Or
|
||
}
|
||
|
||
#endregion
|