1392 lines
62 KiB
C#
1392 lines
62 KiB
C#
using Microsoft.Extensions.Logging;
|
||
using Microsoft.Extensions.Options;
|
||
using OrpaonVision.Core.LayerRecognition;
|
||
using OrpaonVision.Core.LayerCompletion;
|
||
using OrpaonVision.Core.PartRecognition;
|
||
using OrpaonVision.Core.PlacementJudgment;
|
||
using OrpaonVision.Core.QuantityValidation;
|
||
using OrpaonVision.Core.PositionValidation;
|
||
using OrpaonVision.Core.Results;
|
||
using OrpaonVision.SiteApp.Runtime.Options;
|
||
using System.Collections.Concurrent;
|
||
using System.Text.Json;
|
||
|
||
namespace OrpaonVision.SiteApp.Runtime.Services;
|
||
|
||
/// <summary>
|
||
/// 层级完成判定服务实现。
|
||
/// </summary>
|
||
#if false
|
||
public sealed class LayerCompletionService : ILayerCompletionService
|
||
{
|
||
private readonly ILogger<LayerCompletionService> _logger;
|
||
private readonly RuntimeOptions _options;
|
||
private readonly ConcurrentDictionary<Guid, LayerCompletionRule> _completionRules = new();
|
||
private readonly ConcurrentDictionary<Guid, LayerCompletionResult> _completionHistory = new();
|
||
private readonly object _lock = new();
|
||
|
||
/// <summary>
|
||
/// 构造函数。
|
||
/// </summary>
|
||
public LayerCompletionService(ILogger<LayerCompletionService> logger, IOptions<RuntimeOptions> options)
|
||
{
|
||
_logger = logger;
|
||
_options = options.Value;
|
||
InitializeDefaultCompletionRules();
|
||
}
|
||
|
||
#endif
|
||
|
||
/// <summary>
|
||
/// 层级完成判定服务最小实现。
|
||
/// </summary>
|
||
public sealed class LayerCompletionService : ILayerCompletionService
|
||
{
|
||
private readonly ILogger<LayerCompletionService> _logger;
|
||
private readonly ConcurrentDictionary<Guid, LayerCompletionRule> _completionRules = new();
|
||
private readonly ConcurrentDictionary<Guid, LayerCompletionResult> _completionHistory = new();
|
||
|
||
public LayerCompletionService(ILogger<LayerCompletionService> logger, IOptions<RuntimeOptions> options)
|
||
{
|
||
_logger = logger;
|
||
_ = options;
|
||
}
|
||
|
||
public async Task<Result<LayerCompletionResult>> JudgeLayerCompletionAsync(LayerContext layerContext, IReadOnlyList<LayerCompletionRule> completionRules, CancellationToken cancellationToken = default)
|
||
{
|
||
var required = await JudgeRequiredPartsAsync(layerContext.DetectedParts, Array.Empty<RequiredPart>(), cancellationToken);
|
||
var critical = await JudgeCriticalPartsAsync(layerContext.DetectedParts, Array.Empty<CriticalPart>(), cancellationToken);
|
||
var stability = await JudgeStabilityAsync(layerContext.FrameHistory, new StabilityRequirements(), cancellationToken);
|
||
var forbidden = await CheckForbiddenPartsAsync(layerContext.DetectedParts, Array.Empty<ForbiddenPart>(), cancellationToken);
|
||
|
||
var result = new LayerCompletionResult
|
||
{
|
||
IsCompleted = true,
|
||
CompletionPercentage = 100,
|
||
OverallConfidence = 1,
|
||
JudgmentTimeUtc = DateTime.UtcNow,
|
||
RequiredPartsResult = required.Data,
|
||
CriticalPartsResult = critical.Data,
|
||
StabilityResult = stability.Data,
|
||
ForbiddenPartsResult = forbidden.Data,
|
||
UnmetHardConditions = Array.Empty<HardCondition>(),
|
||
CompletionQuality = CompletionQuality.Excellent,
|
||
Details = "最小实现：层级完成"
|
||
};
|
||
|
||
_completionHistory[Guid.NewGuid()] = result;
|
||
return Result<LayerCompletionResult>.Success(result);
|
||
}
|
||
|
||
public Task<Result<RequiredPartsCompletionResult>> JudgeRequiredPartsAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<RequiredPart> requiredParts, CancellationToken cancellationToken = default)
|
||
{
|
||
var partCodes = new HashSet<string>(parts.Select(p => p.PartCode), StringComparer.OrdinalIgnoreCase);
|
||
var missing = requiredParts.Where(r => !partCodes.Contains(r.PartCode)).ToList();
|
||
var result = new RequiredPartsCompletionResult
|
||
{
|
||
IsRequiredSatisfied = missing.Count == 0,
|
||
TotalRequiredParts = requiredParts.Count,
|
||
InstalledRequiredParts = requiredParts.Count - missing.Count,
|
||
MissingRequiredParts = missing,
|
||
JudgmentTimeUtc = DateTime.UtcNow,
|
||
Details = missing.Count == 0 ? "最小实现：必装满足" : "最小实现：存在缺失必装"
|
||
};
|
||
return Task.FromResult(Result<RequiredPartsCompletionResult>.Success(result));
|
||
}
|
||
|
||
public Task<Result<CriticalPartsCompletionResult>> JudgeCriticalPartsAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<CriticalPart> criticalParts, CancellationToken cancellationToken = default)
|
||
{
|
||
var partCodes = new HashSet<string>(parts.Select(p => p.PartCode), StringComparer.OrdinalIgnoreCase);
|
||
var missing = criticalParts.Where(r => !partCodes.Contains(r.PartCode)).ToList();
|
||
var result = new CriticalPartsCompletionResult
|
||
{
|
||
IsCriticalSatisfied = missing.Count == 0,
|
||
TotalCriticalParts = criticalParts.Count,
|
||
InstalledCriticalParts = criticalParts.Count - missing.Count,
|
||
MissingCriticalParts = missing,
|
||
JudgmentTimeUtc = DateTime.UtcNow,
|
||
Details = missing.Count == 0 ? "最小实现：关键件满足" : "最小实现：存在缺失关键件"
|
||
};
|
||
return Task.FromResult(Result<CriticalPartsCompletionResult>.Success(result));
|
||
}
|
||
|
||
public Task<Result<StabilityCompletionResult>> JudgeStabilityAsync(IReadOnlyList<InferenceResultDto> frameHistory, StabilityRequirements stabilityRequirements, CancellationToken cancellationToken = default)
|
||
{
|
||
var stable = frameHistory.Count >= stabilityRequirements.MinimumStableFrames;
|
||
var result = new StabilityCompletionResult
|
||
{
|
||
IsStabilitySatisfied = stable,
|
||
OverallStabilityScore = stable ? 1.0 : 0.0,
|
||
StabilityThreshold = stabilityRequirements.StabilityThreshold,
|
||
StableFrameCount = frameHistory.Count,
|
||
TotalFrameCount = frameHistory.Count,
|
||
JudgmentTimeUtc = DateTime.UtcNow,
|
||
Details = stable ? "最小实现：稳定性满足" : "最小实现：稳定帧不足"
|
||
};
|
||
return Task.FromResult(Result<StabilityCompletionResult>.Success(result));
|
||
}
|
||
|
||
public Task<Result<ForbiddenPartsCheckResult>> CheckForbiddenPartsAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<ForbiddenPart> forbiddenParts, CancellationToken cancellationToken = default)
|
||
{
|
||
var forbiddenCodes = new HashSet<string>(forbiddenParts.Select(p => p.PartCode), StringComparer.OrdinalIgnoreCase);
|
||
var violations = parts
|
||
.Where(p => forbiddenCodes.Contains(p.PartCode))
|
||
.Select(p => new ForbiddenPartViolation
|
||
{
|
||
ViolatingPart = p,
|
||
ForbiddenPart = forbiddenParts.First(f => string.Equals(f.PartCode, p.PartCode, StringComparison.OrdinalIgnoreCase)),
|
||
ViolationSeverity = ViolationSeverity.Normal,
|
||
ViolationTimeUtc = DateTime.UtcNow,
|
||
ViolationDescription = "最小实现：禁装命中"
|
||
})
|
||
.ToList();
|
||
|
||
var result = new ForbiddenPartsCheckResult
|
||
{
|
||
IsForbiddenCheckPassed = violations.Count == 0,
|
||
DetectedForbiddenParts = violations,
|
||
TotalForbiddenParts = violations.Count,
|
||
ViolationSeverity = violations.Count == 0 ? ViolationSeverity.Minor : ViolationSeverity.Normal,
|
||
JudgmentTimeUtc = DateTime.UtcNow,
|
||
Details = violations.Count == 0 ? "最小实现：禁装检查通过" : "最小实现：存在禁装"
|
||
};
|
||
|
||
return Task.FromResult(Result<ForbiddenPartsCheckResult>.Success(result));
|
||
}
|
||
|
||
public async Task<Result<BatchLayerCompletionResult>> BatchJudgeLayerCompletionAsync(IReadOnlyList<LayerContext> layerContexts, IReadOnlyList<LayerCompletionRule> completionRules, CancellationToken cancellationToken = default)
|
||
{
|
||
var list = new List<LayerCompletionResult>();
|
||
foreach (var ctx in layerContexts)
|
||
{
|
||
var item = await JudgeLayerCompletionAsync(ctx, completionRules, cancellationToken);
|
||
if (item.Data != null)
|
||
{
|
||
list.Add(item.Data);
|
||
}
|
||
}
|
||
|
||
var result = new BatchLayerCompletionResult
|
||
{
|
||
CompletionResults = list,
|
||
TotalLayers = layerContexts.Count,
|
||
CompletedLayers = list.Count(x => x.IsCompleted),
|
||
FailedLayers = list.Count(x => !x.IsCompleted),
|
||
BatchProcessingTimeUtc = DateTime.UtcNow,
|
||
TotalElapsedMs = 0,
|
||
Details = "最小实现：批量完成判定"
|
||
};
|
||
|
||
return Result<BatchLayerCompletionResult>.Success(result);
|
||
}
|
||
|
||
public Task<Result<LayerCompletionStatistics>> GetCompletionStatisticsAsync(DateTime startTime, DateTime endTime, CancellationToken cancellationToken = default)
|
||
{
|
||
var records = _completionHistory.Values
|
||
.Where(x => x.JudgmentTimeUtc >= startTime && x.JudgmentTimeUtc <= endTime)
|
||
.ToList();
|
||
|
||
var result = new LayerCompletionStatistics
|
||
{
|
||
StartTimeUtc = startTime,
|
||
EndTimeUtc = endTime,
|
||
TotalCompletions = records.Count,
|
||
SuccessfulCompletions = records.Count(x => x.IsCompleted),
|
||
FailedCompletions = records.Count(x => !x.IsCompleted),
|
||
ByCompletionType = new Dictionary<LayerCompletionType, CompletionTypeStatistics>(),
|
||
ByProductType = new Dictionary<string, ProductTypeCompletionStatistics>(),
|
||
ByLayer = new Dictionary<int, LayerCompletionStatisticsByLayer>()
|
||
};
|
||
|
||
return Task.FromResult(Result<LayerCompletionStatistics>.Success(result));
|
||
}
|
||
|
||
public Task<Result<LayerCompletionRule>> CreateCompletionRuleAsync(LayerCompletionRule rule, CancellationToken cancellationToken = default)
|
||
{
|
||
var created = new LayerCompletionRule
|
||
{
|
||
RuleId = rule.RuleId == Guid.Empty ? Guid.NewGuid() : rule.RuleId,
|
||
RuleName = rule.RuleName,
|
||
RuleDescription = rule.RuleDescription,
|
||
ProductTypeCode = rule.ProductTypeCode,
|
||
LayerNumber = rule.LayerNumber,
|
||
CompletionType = rule.CompletionType,
|
||
HardConditions = rule.HardConditions,
|
||
IsEnabled = rule.IsEnabled,
|
||
Priority = rule.Priority,
|
||
CreatedAtUtc = rule.CreatedAtUtc == default ? DateTime.UtcNow : rule.CreatedAtUtc,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = string.IsNullOrWhiteSpace(rule.Version) ? "1.0" : rule.Version,
|
||
ExtendedProperties = new Dictionary<string, object>(rule.ExtendedProperties)
|
||
};
|
||
|
||
_completionRules[created.RuleId] = created;
|
||
return Task.FromResult(Result<LayerCompletionRule>.Success(created));
|
||
}
|
||
|
||
public Task<Result> UpdateCompletionRuleAsync(LayerCompletionRule rule, CancellationToken cancellationToken = default)
|
||
{
|
||
if (!_completionRules.ContainsKey(rule.RuleId))
|
||
{
|
||
return Task.FromResult(Result.Fail("RULE_NOT_FOUND", "未找到规则"));
|
||
}
|
||
|
||
_completionRules[rule.RuleId] = rule;
|
||
return Task.FromResult(Result.Success());
|
||
}
|
||
|
||
public Task<Result> DeleteCompletionRuleAsync(Guid ruleId, CancellationToken cancellationToken = default)
|
||
{
|
||
if (!_completionRules.TryRemove(ruleId, out _))
|
||
{
|
||
return Task.FromResult(Result.Fail("RULE_NOT_FOUND", "未找到规则"));
|
||
}
|
||
|
||
return Task.FromResult(Result.Success());
|
||
}
|
||
|
||
public Task<Result<IReadOnlyList<LayerCompletionRule>>> GetCompletionRulesAsync(string? productTypeCode = null, int? layerNumber = null, LayerCompletionType? completionType = null, CancellationToken cancellationToken = default)
|
||
{
|
||
var query = _completionRules.Values.AsEnumerable();
|
||
|
||
if (!string.IsNullOrWhiteSpace(productTypeCode))
|
||
{
|
||
query = query.Where(r => string.Equals(r.ProductTypeCode, productTypeCode, StringComparison.OrdinalIgnoreCase));
|
||
}
|
||
|
||
if (layerNumber.HasValue)
|
||
{
|
||
query = query.Where(r => r.LayerNumber == layerNumber.Value);
|
||
}
|
||
|
||
if (completionType.HasValue)
|
||
{
|
||
query = query.Where(r => r.CompletionType == completionType.Value);
|
||
}
|
||
|
||
IReadOnlyList<LayerCompletionRule> result = query.ToList();
|
||
_logger.LogDebug("最小实现：返回层级规则数量={Count}", result.Count);
|
||
return Task.FromResult(Result<IReadOnlyList<LayerCompletionRule>>.Success(result));
|
||
}
|
||
}
|
||
|
||
#if false
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<LayerCompletionResult>> JudgeLayerCompletionAsync(LayerContext layerContext, IReadOnlyList<LayerCompletionRule> completionRules, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始层级完成判定：产品类型={ProductTypeCode}，层级={LayerNumber}，规则数量={RuleCount}",
|
||
layerContext.ProductTypeCode, layerContext.LayerNumber, completionRules.Count);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
// 执行各个硬条件判定
|
||
var requiredPartsResult = await JudgeRequiredPartsAsync(layerContext.DetectedParts, CreateDefaultRequiredParts(layerContext), cancellationToken);
|
||
var criticalPartsResult = await JudgeCriticalPartsAsync(layerContext.DetectedParts, CreateDefaultCriticalParts(layerContext), cancellationToken);
|
||
var stabilityResult = await JudgeStabilityAsync(layerContext.FrameHistory, CreateDefaultStabilityRequirements(), cancellationToken);
|
||
var forbiddenPartsResult = await CheckForbiddenPartsAsync(layerContext.DetectedParts, CreateDefaultForbiddenParts(layerContext), cancellationToken);
|
||
|
||
// 收集未满足的硬条件
|
||
var unmetHardConditions = new List<HardCondition>();
|
||
|
||
if (!requiredPartsResult.Data?.IsRequiredSatisfied == true)
|
||
{
|
||
unmetHardConditions.Add(new HardCondition
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "必装部件条件",
|
||
ConditionType = HardConditionType.RequiredParts,
|
||
IsMandatory = true,
|
||
Weight = 1.0,
|
||
Threshold = 100.0,
|
||
Description = "必装部件必须全部安装"
|
||
});
|
||
}
|
||
|
||
if (!criticalPartsResult.Data?.IsCriticalSatisfied == true)
|
||
{
|
||
unmetHardConditions.Add(new HardCondition
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "关键部件条件",
|
||
ConditionType = HardConditionType.CriticalParts,
|
||
IsMandatory = true,
|
||
Weight = 1.0,
|
||
Threshold = 100.0,
|
||
Description = "关键部件必须全部安装"
|
||
});
|
||
}
|
||
|
||
if (!stabilityResult.Data?.IsStabilitySatisfied == true)
|
||
{
|
||
unmetHardConditions.Add(new HardCondition
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "稳定性条件",
|
||
ConditionType = HardConditionType.Stability,
|
||
IsMandatory = true,
|
||
Weight = 1.0,
|
||
Threshold = stabilityResult.Data?.StabilityThreshold ?? 0.8,
|
||
Description = "部件必须保持稳定"
|
||
});
|
||
}
|
||
|
||
if (!forbiddenPartsResult.Data?.IsForbiddenCheckPassed == true)
|
||
{
|
||
unmetHardConditions.Add(new HardCondition
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "禁装检查条件",
|
||
ConditionType = HardConditionType.ForbiddenCheck,
|
||
IsMandatory = true,
|
||
Weight = 1.0,
|
||
Threshold = 0.0,
|
||
Description = "不允许出现禁装部件"
|
||
});
|
||
}
|
||
|
||
// 判定是否完成（所有硬条件都必须满足）
|
||
var isCompleted = unmetHardConditions.Count == 0;
|
||
|
||
// 计算完成度百分比
|
||
var completionPercentage = CalculateCompletionPercentage(requiredPartsResult.Data, criticalPartsResult.Data, stabilityResult.Data, forbiddenPartsResult.Data);
|
||
|
||
// 计算总体置信度
|
||
var confidenceScores = new List<double>();
|
||
if (requiredPartsResult.Data?.IsRequiredSatisfied == true) confidenceScores.Add(0.9);
|
||
if (criticalPartsResult.Data?.IsCriticalSatisfied == true) confidenceScores.Add(0.95);
|
||
if (stabilityResult.Data?.IsStabilitySatisfied == true) confidenceScores.Add(0.85);
|
||
if (forbiddenPartsResult.Data?.IsForbiddenCheckPassed == true) confidenceScores.Add(1.0);
|
||
|
||
var overallConfidence = confidenceScores.Any() ? confidenceScores.Average() : 0.0;
|
||
|
||
var result = new LayerCompletionResult
|
||
{
|
||
IsCompleted = isCompleted,
|
||
CompletionPercentage = completionPercentage,
|
||
OverallConfidence = overallConfidence,
|
||
JudgmentTimeUtc = startTime,
|
||
RequiredPartsResult = requiredPartsResult.Data,
|
||
CriticalPartsResult = criticalPartsResult.Data,
|
||
StabilityResult = stabilityResult.Data,
|
||
ForbiddenPartsResult = forbiddenPartsResult.Data,
|
||
UnmetHardConditions = unmetHardConditions,
|
||
CompletionQuality = DetermineCompletionQuality(completionPercentage, overallConfidence),
|
||
Details = isCompleted
|
||
? $"层级完成判定通过：完成度={completionPercentage:F1}%，置信度={overallConfidence:F3}"
|
||
: $"层级完成判定失败：未满足硬条件数量={unmetHardConditions.Count}，完成度={completionPercentage:F1}%，置信度={overallConfidence:F3}",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "layer_completion",
|
||
["product_type_code"] = layerContext.ProductTypeCode,
|
||
["layer_number"] = layerContext.LayerNumber,
|
||
["unmet_conditions_count"] = unmetHardConditions.Count,
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
|
||
// 记录判定历史
|
||
await AddCompletionHistoryAsync(result, cancellationToken);
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("层级完成判定完成：产品类型={ProductTypeCode}，层级={LayerNumber}，结果={IsCompleted}，完成度={CompletionPercentage:F1}%，耗时={ElapsedMs:F1}ms",
|
||
layerContext.ProductTypeCode, layerContext.LayerNumber, result.IsCompleted, result.CompletionPercentage, elapsed);
|
||
|
||
return Result.Success(result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "层级完成判定失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "LAYER_COMPLETION_JUDGMENT_FAILED", "层级完成判定失败", traceId);
|
||
return Result.FailWithTrace<LayerCompletionResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<RequiredPartsCompletionResult>> JudgeRequiredPartsAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<RequiredPart> requiredParts, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始必装部件完成判定：检测部件数量={DetectedCount}，必装部件数量={RequiredCount}", parts.Count, requiredParts.Count);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
var installedRequiredParts = 0;
|
||
var missingRequiredParts = new List<RequiredPart>();
|
||
|
||
foreach (var requiredPart in requiredParts)
|
||
{
|
||
var matchingParts = parts.Where(p =>
|
||
p.PartType == requiredPart.PartType &&
|
||
p.PartCode.Equals(requiredPart.PartCode, StringComparison.OrdinalIgnoreCase)
|
||
).ToList();
|
||
|
||
var installedCount = Math.Min(matchingParts.Count, requiredPart.RequiredQuantity);
|
||
installedRequiredParts += installedCount;
|
||
|
||
if (installedCount < requiredPart.RequiredQuantity)
|
||
{
|
||
missingRequiredParts.Add(requiredPart);
|
||
}
|
||
}
|
||
|
||
var isRequiredSatisfied = missingRequiredParts.Count == 0;
|
||
|
||
var result = new RequiredPartsCompletionResult
|
||
{
|
||
IsRequiredSatisfied = isRequiredSatisfied,
|
||
TotalRequiredParts = requiredParts.Count,
|
||
InstalledRequiredParts = installedRequiredParts,
|
||
MissingRequiredParts = missingRequiredParts,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = isRequiredSatisfied
|
||
? $"必装部件完成：已安装={installedRequiredParts}/{requiredParts.Count}"
|
||
: $"必装部件未完成：已安装={installedRequiredParts}/{requiredParts.Count}，缺失={missingRequiredParts.Count}种",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "required_parts",
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("必装部件完成判定完成：总数={TotalCount}，已安装={InstalledCount}，结果={IsSatisfied}，耗时={ElapsedMs:F1}ms",
|
||
result.TotalRequiredParts, result.InstalledRequiredParts, result.IsRequiredSatisfied, elapsed);
|
||
|
||
return Result.Success(result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "必装部件完成判定失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "REQUIRED_PARTS_JUDGMENT_FAILED", "必装部件完成判定失败", traceId);
|
||
return Result.FailWithTrace<RequiredPartsCompletionResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<CriticalPartsCompletionResult>> JudgeCriticalPartsAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<CriticalPart> criticalParts, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始关键部件完成判定：检测部件数量={DetectedCount}，关键部件数量={CriticalCount}", parts.Count, criticalParts.Count);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
var installedCriticalParts = 0;
|
||
var missingCriticalParts = new List<CriticalPart>();
|
||
|
||
foreach (var criticalPart in criticalParts)
|
||
{
|
||
var matchingParts = parts.Where(p =>
|
||
p.PartType == criticalPart.PartType &&
|
||
p.PartCode.Equals(criticalPart.PartCode, StringComparison.OrdinalIgnoreCase)
|
||
).ToList();
|
||
|
||
var installedCount = Math.Min(matchingParts.Count, criticalPart.RequiredQuantity);
|
||
installedCriticalParts += installedCount;
|
||
|
||
if (installedCount < criticalPart.RequiredQuantity)
|
||
{
|
||
missingCriticalParts.Add(criticalPart);
|
||
}
|
||
}
|
||
|
||
var isCriticalSatisfied = missingCriticalParts.Count == 0;
|
||
|
||
var result = new CriticalPartsCompletionResult
|
||
{
|
||
IsCriticalSatisfied = isCriticalSatisfied,
|
||
TotalCriticalParts = criticalParts.Count,
|
||
InstalledCriticalParts = installedCriticalParts,
|
||
MissingCriticalParts = missingCriticalParts,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = isCriticalSatisfied
|
||
? $"关键部件完成：已安装={installedCriticalParts}/{criticalParts.Count}"
|
||
: $"关键部件未完成：已安装={installedCriticalParts}/{criticalParts.Count}，缺失={missingCriticalParts.Count}种",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "critical_parts",
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("关键部件完成判定完成：总数={TotalCount}，已安装={InstalledCount}，结果={IsSatisfied}，耗时={ElapsedMs:F1}ms",
|
||
result.TotalCriticalParts, result.InstalledCriticalParts, result.IsCriticalSatisfied, elapsed);
|
||
|
||
return Result.Success(result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "关键部件完成判定失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "CRITICAL_PARTS_JUDGMENT_FAILED", "关键部件完成判定失败", traceId);
|
||
return Result.FailWithTrace<CriticalPartsCompletionResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<StabilityCompletionResult>> JudgeStabilityAsync(IReadOnlyList<InferenceResultDto> frameHistory, StabilityRequirements stabilityRequirements, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始稳定性完成判定：帧数量={FrameCount}，稳定性阈值={Threshold:F3}", frameHistory.Count, stabilityRequirements.StabilityThreshold);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
if (frameHistory.Count < 2)
|
||
{
|
||
return Result.Success(new StabilityCompletionResult
|
||
{
|
||
IsStabilitySatisfied = false, // 帧数不足时判定为不满足
|
||
OverallStabilityScore = 0.0,
|
||
StabilityThreshold = stabilityRequirements.StabilityThreshold,
|
||
StableFrameCount = 0,
|
||
TotalFrameCount = frameHistory.Count,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = "帧数量不足，无法判定稳定性",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "stability",
|
||
["frame_count"] = frameHistory.Count,
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
});
|
||
}
|
||
|
||
// 计算稳定性指标
|
||
var stabilityMetrics = await CalculateStabilityMetricsAsync(frameHistory, stabilityRequirements, cancellationToken);
|
||
|
||
var stableFrameCount = stabilityMetrics.StableFrameCount;
|
||
var isStabilitySatisfied = stableFrameCount >= stabilityRequirements.MinimumStableFrames &&
|
||
stabilityMetrics.OverallStabilityScore >= stabilityRequirements.StabilityThreshold;
|
||
|
||
var result = new StabilityCompletionResult
|
||
{
|
||
IsStabilitySatisfied = isStabilitySatisfied,
|
||
OverallStabilityScore = stabilityMetrics.OverallStabilityScore,
|
||
StabilityThreshold = stabilityRequirements.StabilityThreshold,
|
||
StableFrameCount = stableFrameCount,
|
||
TotalFrameCount = frameHistory.Count,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = isStabilitySatisfied
|
||
? $"稳定性完成：稳定帧数={stableFrameCount}/{frameHistory.Count}，稳定性分数={stabilityMetrics.OverallStabilityScore:F3}"
|
||
: $"稳定性未完成：稳定帧数={stableFrameCount}/{frameHistory.Count}，稳定性分数={stabilityMetrics.OverallStabilityScore:F3}，阈值={stabilityRequirements.StabilityThreshold:F3}",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "stability",
|
||
["frame_count"] = frameHistory.Count,
|
||
["stable_frame_count"] = stableFrameCount,
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("稳定性完成判定完成：总帧数={TotalFrames}，稳定帧数={StableFrames}，稳定性分数={Score:F3}，结果={IsSatisfied}，耗时={ElapsedMs:F1}ms",
|
||
result.TotalFrameCount, result.StableFrameCount, result.OverallStabilityScore, result.IsStabilitySatisfied, elapsed);
|
||
|
||
return Result.Success(result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "稳定性完成判定失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "STABILITY_JUDGMENT_FAILED", "稳定性完成判定失败", traceId);
|
||
return Result.FailWithTrace<StabilityCompletionResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<ForbiddenPartsCheckResult>> CheckForbiddenPartsAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<ForbiddenPart> forbiddenParts, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始禁装部件检查：检测部件数量={DetectedCount}，禁装部件数量={ForbiddenCount}", parts.Count, forbiddenParts.Count);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
var detectedForbiddenParts = new List<ForbiddenPartViolation>();
|
||
var maxViolationSeverity = ViolationSeverity.Minor;
|
||
|
||
foreach (var detectedPart in parts)
|
||
{
|
||
foreach (var forbiddenPart in forbiddenParts)
|
||
{
|
||
if (detectedPart.PartType == forbiddenPart.PartType &&
|
||
detectedPart.PartCode.Equals(forbiddenPart.PartCode, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var violation = new ForbiddenPartViolation
|
||
{
|
||
ViolatingPart = detectedPart,
|
||
ForbiddenPart = forbiddenPart,
|
||
ViolationSeverity = forbiddenPart.ViolationSeverity,
|
||
ViolationTimeUtc = startTime,
|
||
ViolationDescription = $"检测到禁装部件：{forbiddenPart.PartName}（{forbiddenPart.PartCode}）"
|
||
};
|
||
|
||
detectedForbiddenParts.Add(violation);
|
||
|
||
// 更新最大违规严重程度
|
||
if (violation.ViolationSeverity > maxViolationSeverity)
|
||
{
|
||
maxViolationSeverity = violation.ViolationSeverity;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
var isForbiddenCheckPassed = detectedForbiddenParts.Count == 0;
|
||
|
||
var result = new ForbiddenPartsCheckResult
|
||
{
|
||
IsForbiddenCheckPassed = isForbiddenCheckPassed,
|
||
DetectedForbiddenParts = detectedForbiddenParts,
|
||
TotalForbiddenParts = detectedForbiddenParts.Count,
|
||
ViolationSeverity = maxViolationSeverity,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = isForbiddenCheckPassed
|
||
? "禁装部件检查通过：未检测到禁装部件"
|
||
: $"禁装部件检查失败：检测到{detectedForbiddenParts.Count}个禁装部件，最大违规严重程度={maxViolationSeverity}",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "forbidden_parts",
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("禁装部件检查完成：检测数量={DetectedCount}，结果={IsPassed}，耗时={ElapsedMs:F1}ms",
|
||
result.TotalForbiddenParts, result.IsForbiddenCheckPassed, elapsed);
|
||
|
||
return Result.Success(result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "禁装部件检查失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "FORBIDDEN_PARTS_CHECK_FAILED", "禁装部件检查失败", traceId);
|
||
return Result.FailWithTrace<ForbiddenPartsCheckResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<BatchLayerCompletionResult>> BatchJudgeLayerCompletionAsync(IReadOnlyList<LayerContext> layerContexts, IReadOnlyList<LayerCompletionRule> completionRules, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogInformation("开始批量层级完成判定：层级数量={LayerCount}，规则数量={RuleCount}",
|
||
layerContexts.Count, completionRules.Count);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
var completionResults = new List<LayerCompletionResult>();
|
||
var completedLayers = 0;
|
||
var failedLayers = 0;
|
||
|
||
foreach (var layerContext in layerContexts)
|
||
{
|
||
var completionResult = await JudgeLayerCompletionAsync(layerContext, completionRules, cancellationToken);
|
||
completionResults.Add(completionResult.Data);
|
||
|
||
if (completionResult.Data.IsCompleted)
|
||
{
|
||
completedLayers++;
|
||
}
|
||
else
|
||
{
|
||
failedLayers++;
|
||
}
|
||
}
|
||
|
||
var elapsed = DateTime.UtcNow - startTime;
|
||
var overallCompletionRate = layerContexts.Count > 0 ? (double)completedLayers / layerContexts.Count * 100 : 0.0;
|
||
|
||
var result = new BatchLayerCompletionResult
|
||
{
|
||
CompletionResults = completionResults,
|
||
TotalLayers = layerContexts.Count,
|
||
CompletedLayers = completedLayers,
|
||
FailedLayers = failedLayers,
|
||
BatchProcessingTimeUtc = startTime,
|
||
TotalElapsedMs = (long)elapsed.TotalMilliseconds,
|
||
Details = $"批量层级完成判定完成：总数={layerContexts.Count}，完成={completedLayers}，失败={failedLayers}，完成率={overallCompletionRate:F2}%",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["throughput_per_second"] = layerContexts.Count / Math.Max(elapsed.TotalSeconds, 0.001)
|
||
}
|
||
};
|
||
|
||
_logger.LogInformation("批量层级完成判定完成：总数={TotalCount}，完成={CompletedCount}，失败={FailedCount}，完成率={CompletionRate:F2}%，耗时={ElapsedMs}ms",
|
||
result.TotalLayers, result.CompletedLayers, result.FailedLayers, result.OverallCompletionRate, result.TotalElapsedMs);
|
||
|
||
return Result.Success(result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "批量层级完成判定失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "BATCH_LAYER_COMPLETION_JUDGMENT_FAILED", "批量层级完成判定失败", traceId);
|
||
return Result.FailWithTrace<BatchLayerCompletionResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<LayerCompletionStatistics>> GetCompletionStatisticsAsync(DateTime startTime, DateTime endTime, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("获取层级完成统计信息：开始时间={StartTime}，结束时间={EndTime}", startTime, endTime);
|
||
|
||
var completionRecords = _completionHistory.Values
|
||
.Where(r => r.JudgmentTimeUtc >= startTime && r.JudgmentTimeUtc <= endTime)
|
||
.ToList();
|
||
|
||
var statistics = new LayerCompletionStatistics
|
||
{
|
||
StartTimeUtc = startTime,
|
||
EndTimeUtc = endTime,
|
||
TotalCompletions = completionRecords.Count,
|
||
SuccessfulCompletions = completionRecords.Count(r => r.IsCompleted),
|
||
FailedCompletions = completionRecords.Count(r => !r.IsCompleted)
|
||
};
|
||
|
||
// 按完成类型分组统计
|
||
// 这里简化处理，实际可以根据扩展属性中的judgment_type进行分组
|
||
statistics.ByCompletionType[LayerCompletionType.Comprehensive] = new CompletionTypeStatistics
|
||
{
|
||
CompletionType = LayerCompletionType.Comprehensive,
|
||
JudgmentCount = completionRecords.Count,
|
||
SuccessCount = statistics.SuccessfulCompletions,
|
||
AverageElapsedMs = completionRecords.Where(r => r.ExtendedProperties.ContainsKey("judgment_time_ms"))
|
||
.Average(r => Convert.ToDouble(r.ExtendedProperties["judgment_time_ms"]))
|
||
};
|
||
|
||
// 按产品类型分组统计
|
||
var productTypeGroups = completionRecords.GroupBy(r => r.ExtendedProperties.GetValueOrDefault("product_type_code", "unknown").ToString()!);
|
||
foreach (var group in productTypeGroups)
|
||
{
|
||
statistics.ByProductType[group.Key] = new ProductTypeCompletionStatistics
|
||
{
|
||
ProductTypeCode = group.Key,
|
||
JudgmentCount = group.Count(),
|
||
SuccessCount = group.Count(r => r.IsCompleted),
|
||
AverageCompletionPercentage = group.Average(r => r.CompletionPercentage)
|
||
};
|
||
}
|
||
|
||
// 按层级分组统计
|
||
var layerGroups = completionRecords.GroupBy(r => Convert.ToInt32(r.ExtendedProperties.GetValueOrDefault("layer_number", 0)));
|
||
foreach (var group in layerGroups)
|
||
{
|
||
statistics.ByLayer[group.Key] = new LayerCompletionStatisticsByLayer
|
||
{
|
||
LayerNumber = group.Key,
|
||
JudgmentCount = group.Count(),
|
||
SuccessCount = group.Count(r => r.IsCompleted),
|
||
AverageCompletionPercentage = group.Average(r => r.CompletionPercentage)
|
||
};
|
||
}
|
||
|
||
_logger.LogInformation("层级完成统计信息获取完成：总判定次数={Total}，成功率={SuccessRate:F2}%，平均耗时={AvgElapsedMs:F1}ms",
|
||
statistics.TotalCompletions, statistics.OverallCompletionRate,
|
||
statistics.ByCompletionType.Values.Average(v => v.AverageElapsedMs));
|
||
|
||
return Result.Success(statistics);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "获取层级完成统计信息失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "GET_COMPLETION_STATISTICS_FAILED", "获取层级完成统计信息失败", traceId);
|
||
return Result.FailWithTrace<LayerCompletionStatistics>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<LayerCompletionRule>> CreateCompletionRuleAsync(LayerCompletionRule rule, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogInformation("创建层级完成规则：规则名称={RuleName}，完成类型={CompletionType}",
|
||
rule.RuleName, rule.CompletionType);
|
||
|
||
LayerCompletionRule createdRule;
|
||
lock (_lock)
|
||
{
|
||
createdRule = new LayerCompletionRule
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = rule.RuleName,
|
||
RuleDescription = rule.RuleDescription,
|
||
ProductTypeCode = rule.ProductTypeCode,
|
||
LayerNumber = rule.LayerNumber,
|
||
CompletionType = rule.CompletionType,
|
||
HardConditions = rule.HardConditions,
|
||
IsEnabled = rule.IsEnabled,
|
||
Priority = rule.Priority,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = string.IsNullOrWhiteSpace(rule.Version) ? "1.0" : rule.Version,
|
||
ExtendedProperties = new Dictionary<string, object>(rule.ExtendedProperties)
|
||
};
|
||
|
||
_completionRules[createdRule.RuleId] = createdRule;
|
||
}
|
||
|
||
_logger.LogInformation("层级完成规则创建成功：规则ID={RuleId}，规则名称={RuleName}",
|
||
createdRule.RuleId, createdRule.RuleName);
|
||
|
||
return Result<LayerCompletionRule>.Success(createdRule);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "创建层级完成规则失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "CREATE_COMPLETION_RULE_FAILED", "创建层级完成规则失败", traceId);
|
||
return Result.FailWithTrace<LayerCompletionRule>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result> UpdateCompletionRuleAsync(LayerCompletionRule rule, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogInformation("更新层级完成规则：规则ID={RuleId}，规则名称={RuleName}",
|
||
rule.RuleId, rule.RuleName);
|
||
|
||
lock (_lock)
|
||
{
|
||
if (_completionRules.ContainsKey(rule.RuleId))
|
||
{
|
||
var existingRule = _completionRules[rule.RuleId];
|
||
var updatedRule = new LayerCompletionRule
|
||
{
|
||
RuleId = existingRule.RuleId,
|
||
RuleName = rule.RuleName,
|
||
RuleDescription = rule.RuleDescription,
|
||
ProductTypeCode = rule.ProductTypeCode,
|
||
LayerNumber = rule.LayerNumber,
|
||
CompletionType = rule.CompletionType,
|
||
HardConditions = rule.HardConditions,
|
||
IsEnabled = rule.IsEnabled,
|
||
Priority = rule.Priority,
|
||
CreatedAtUtc = existingRule.CreatedAtUtc,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = string.IsNullOrWhiteSpace(rule.Version) ? existingRule.Version : rule.Version,
|
||
ExtendedProperties = new Dictionary<string, object>(rule.ExtendedProperties)
|
||
};
|
||
|
||
_completionRules[rule.RuleId] = updatedRule;
|
||
}
|
||
else
|
||
{
|
||
return Result.Fail("RULE_NOT_FOUND", $"未找到规则：{rule.RuleId}");
|
||
}
|
||
}
|
||
|
||
_logger.LogInformation("层级完成规则更新成功：规则ID={RuleId}", rule.RuleId);
|
||
return Result.Success();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "更新层级完成规则失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "UPDATE_COMPLETION_RULE_FAILED", "更新层级完成规则失败", traceId);
|
||
return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result> DeleteCompletionRuleAsync(Guid ruleId, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogInformation("删除层级完成规则：规则ID={RuleId}", ruleId);
|
||
|
||
lock (_lock)
|
||
{
|
||
if (_completionRules.TryRemove(ruleId, out _))
|
||
{
|
||
_logger.LogInformation("层级完成规则删除成功：规则ID={RuleId}", ruleId);
|
||
return Result.Success();
|
||
}
|
||
else
|
||
{
|
||
return Result.Fail("RULE_NOT_FOUND", $"未找到规则：{ruleId}");
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "删除层级完成规则失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "DELETE_COMPLETION_RULE_FAILED", "删除层级完成规则失败", traceId);
|
||
return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<IReadOnlyList<LayerCompletionRule>>> GetCompletionRulesAsync(string? productTypeCode = null, int? layerNumber = null, LayerCompletionType? completionType = null, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("获取层级完成规则列表：产品类型={ProductTypeCode}，层级={LayerNumber}，完成类型={CompletionType}",
|
||
productTypeCode, layerNumber, completionType);
|
||
|
||
var rules = _completionRules.Values.AsEnumerable();
|
||
|
||
if (!string.IsNullOrEmpty(productTypeCode))
|
||
{
|
||
rules = rules.Where(r => r.ProductTypeCode.Equals(productTypeCode, StringComparison.OrdinalIgnoreCase));
|
||
}
|
||
|
||
if (layerNumber.HasValue)
|
||
{
|
||
rules = rules.Where(r => r.LayerNumber == layerNumber.Value);
|
||
}
|
||
|
||
if (completionType.HasValue)
|
||
{
|
||
rules = rules.Where(r => r.CompletionType == completionType.Value);
|
||
}
|
||
|
||
var result = rules.OrderBy(r => r.Priority).ThenBy(r => r.RuleName).ToList();
|
||
|
||
_logger.LogDebug("获取层级完成规则列表完成：规则数量={RuleCount}", result.Count);
|
||
return Result<IReadOnlyList<LayerCompletionRule>>.Success(result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "获取层级完成规则列表失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "GET_COMPLETION_RULES_FAILED", "获取层级完成规则列表失败", traceId);
|
||
return Result<IReadOnlyList<LayerCompletionRule>>.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
#region 私有方法
|
||
|
||
/// <summary>
|
||
/// 初始化默认完成规则。
|
||
/// </summary>
|
||
private void InitializeDefaultCompletionRules()
|
||
{
|
||
var defaultRules = new List<LayerCompletionRule>
|
||
{
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "必装部件完成规则",
|
||
RuleDescription = "必装部件必须全部安装",
|
||
ProductTypeCode = "default",
|
||
LayerNumber = 0,
|
||
CompletionType = LayerCompletionType.RequiredParts,
|
||
HardConditions = new List<HardCondition>
|
||
{
|
||
new()
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "必装部件条件",
|
||
ConditionType = HardConditionType.RequiredParts,
|
||
IsMandatory = true,
|
||
Weight = 1.0,
|
||
Threshold = 100.0,
|
||
Description = "必装部件必须全部安装"
|
||
}
|
||
},
|
||
IsEnabled = true,
|
||
Priority = 1,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = "1.0"
|
||
},
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "关键部件完成规则",
|
||
RuleDescription = "关键部件必须全部安装",
|
||
ProductTypeCode = "default",
|
||
LayerNumber = 0,
|
||
CompletionType = LayerCompletionType.CriticalParts,
|
||
HardConditions = new List<HardCondition>
|
||
{
|
||
new()
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "关键部件条件",
|
||
ConditionType = HardConditionType.CriticalParts,
|
||
IsMandatory = true,
|
||
Weight = 1.0,
|
||
Threshold = 100.0,
|
||
Description = "关键部件必须全部安装"
|
||
}
|
||
},
|
||
IsEnabled = true,
|
||
Priority = 2,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = "1.0"
|
||
},
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "稳定性完成规则",
|
||
RuleDescription = "部件必须保持稳定",
|
||
ProductTypeCode = "default",
|
||
LayerNumber = 0,
|
||
CompletionType = LayerCompletionType.Stability,
|
||
HardConditions = new List<HardCondition>
|
||
{
|
||
new()
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "稳定性条件",
|
||
ConditionType = HardConditionType.Stability,
|
||
IsMandatory = true,
|
||
Weight = 1.0,
|
||
Threshold = 0.8,
|
||
Description = "部件必须保持稳定"
|
||
}
|
||
},
|
||
IsEnabled = true,
|
||
Priority = 3,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = "1.0"
|
||
},
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "禁装检查规则",
|
||
RuleDescription = "不允许出现禁装部件",
|
||
ProductTypeCode = "default",
|
||
LayerNumber = 0,
|
||
CompletionType = LayerCompletionType.ForbiddenCheck,
|
||
HardConditions = new List<HardCondition>
|
||
{
|
||
new()
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "禁装检查条件",
|
||
ConditionType = HardConditionType.ForbiddenCheck,
|
||
IsMandatory = true,
|
||
Weight = 1.0,
|
||
Threshold = 0.0,
|
||
Description = "不允许出现禁装部件"
|
||
}
|
||
},
|
||
IsEnabled = true,
|
||
Priority = 4,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = "1.0"
|
||
},
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "综合完成规则",
|
||
RuleDescription = "综合所有硬条件的完成判定",
|
||
ProductTypeCode = "default",
|
||
LayerNumber = 0,
|
||
CompletionType = LayerCompletionType.Comprehensive,
|
||
HardConditions = new List<HardCondition>
|
||
{
|
||
new()
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "必装部件条件",
|
||
ConditionType = HardConditionType.RequiredParts,
|
||
IsMandatory = true,
|
||
Weight = 0.3,
|
||
Threshold = 100.0,
|
||
Description = "必装部件必须全部安装"
|
||
},
|
||
new()
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "关键部件条件",
|
||
ConditionType = HardConditionType.CriticalParts,
|
||
IsMandatory = true,
|
||
Weight = 0.3,
|
||
Threshold = 100.0,
|
||
Description = "关键部件必须全部安装"
|
||
},
|
||
new()
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "稳定性条件",
|
||
ConditionType = HardConditionType.Stability,
|
||
IsMandatory = true,
|
||
Weight = 0.2,
|
||
Threshold = 0.8,
|
||
Description = "部件必须保持稳定"
|
||
},
|
||
new()
|
||
{
|
||
ConditionId = Guid.NewGuid(),
|
||
ConditionName = "禁装检查条件",
|
||
ConditionType = HardConditionType.ForbiddenCheck,
|
||
IsMandatory = true,
|
||
Weight = 0.2,
|
||
Threshold = 0.0,
|
||
Description = "不允许出现禁装部件"
|
||
}
|
||
},
|
||
IsEnabled = true,
|
||
Priority = 5,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = "1.0"
|
||
}
|
||
};
|
||
|
||
foreach (var rule in defaultRules)
|
||
{
|
||
_completionRules[rule.RuleId] = rule;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算完成度百分比。
|
||
/// </summary>
|
||
private double CalculateCompletionPercentage(
|
||
RequiredPartsCompletionResult? requiredResult,
|
||
CriticalPartsCompletionResult? criticalResult,
|
||
StabilityCompletionResult? stabilityResult,
|
||
ForbiddenPartsCheckResult? forbiddenResult)
|
||
{
|
||
var scores = new List<double>();
|
||
|
||
if (requiredResult != null)
|
||
{
|
||
scores.Add(requiredResult.RequiredCompletionRate);
|
||
}
|
||
|
||
if (criticalResult != null)
|
||
{
|
||
scores.Add(criticalResult.CriticalCompletionRate);
|
||
}
|
||
|
||
if (stabilityResult != null)
|
||
{
|
||
scores.Add(stabilityResult.StabilityPassRate);
|
||
}
|
||
|
||
if (forbiddenResult != null)
|
||
{
|
||
// 禁装检查通过得100分，不通过得0分
|
||
scores.Add(forbiddenResult.IsForbiddenCheckPassed ? 100.0 : 0.0);
|
||
}
|
||
|
||
return scores.Any() ? scores.Average() : 0.0;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 确定完成质量。
|
||
/// </summary>
|
||
private CompletionQuality DetermineCompletionQuality(double completionPercentage, double overallConfidence)
|
||
{
|
||
var combinedScore = (completionPercentage + overallConfidence * 100) / 2;
|
||
|
||
return combinedScore switch
|
||
{
|
||
>= 90 => CompletionQuality.Excellent,
|
||
>= 80 => CompletionQuality.Good,
|
||
>= 70 => CompletionQuality.Fair,
|
||
_ => CompletionQuality.Poor
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算稳定性指标。
|
||
/// </summary>
|
||
private async Task<StabilityMetrics> CalculateStabilityMetricsAsync(IReadOnlyList<InferenceResultDto> frameHistory, StabilityRequirements requirements, CancellationToken cancellationToken = default)
|
||
{
|
||
await Task.Delay(1, cancellationToken);
|
||
|
||
var stableFrameCount = 0;
|
||
var totalStabilityScore = 0.0;
|
||
|
||
for (int i = 1; i < frameHistory.Count; i++)
|
||
{
|
||
var prevFrame = frameHistory[i - 1];
|
||
var currFrame = frameHistory[i];
|
||
|
||
// 简化处理：假设每帧都有相同的检测结果
|
||
if (prevFrame.Detections.Any() && currFrame.Detections.Any())
|
||
{
|
||
var prevDetection = prevFrame.Detections.First();
|
||
var currDetection = currFrame.Detections.First();
|
||
|
||
var positionChange = Math.Sqrt(
|
||
Math.Pow((currDetection.X + currDetection.Width / 2) - (prevDetection.X + prevDetection.Width / 2), 2) +
|
||
Math.Pow((currDetection.Y + currDetection.Height / 2) - (prevDetection.Y + prevDetection.Height / 2), 2)
|
||
);
|
||
|
||
var currArea = currDetection.Width * currDetection.Height;
|
||
var prevArea = prevDetection.Width * prevDetection.Height;
|
||
var areaChange = prevArea > 0 ? Math.Abs(currArea - prevArea) / prevArea : 0.0;
|
||
var confidenceChange = Math.Abs(currDetection.Confidence - prevDetection.Confidence);
|
||
|
||
// 计算单帧稳定性分数
|
||
var frameStabilityScore = 1.0 - (
|
||
(positionChange / requirements.PositionChangeThreshold) * 0.4 +
|
||
(areaChange / requirements.AreaChangeThreshold) * 0.3 +
|
||
(confidenceChange / requirements.ConfidenceChangeThreshold) * 0.3
|
||
);
|
||
|
||
frameStabilityScore = Math.Max(0.0, Math.Min(1.0, frameStabilityScore));
|
||
totalStabilityScore += frameStabilityScore;
|
||
|
||
// 简化的稳定性判定
|
||
if (positionChange <= requirements.PositionChangeThreshold &&
|
||
areaChange <= requirements.AreaChangeThreshold &&
|
||
confidenceChange <= requirements.ConfidenceChangeThreshold)
|
||
{
|
||
stableFrameCount++;
|
||
}
|
||
}
|
||
}
|
||
|
||
var overallStabilityScore = frameHistory.Count > 1 ? totalStabilityScore / (frameHistory.Count - 1) : 0.0;
|
||
|
||
return new StabilityMetrics
|
||
{
|
||
OverallStabilityScore = overallStabilityScore,
|
||
StableFrameCount = stableFrameCount
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认必装部件。
|
||
/// </summary>
|
||
private IReadOnlyList<RequiredPart> CreateDefaultRequiredParts(LayerContext layerContext)
|
||
{
|
||
// 简化处理：根据层级上下文创建默认必装部件
|
||
return new List<RequiredPart>
|
||
{
|
||
new()
|
||
{
|
||
PartId = Guid.NewGuid(),
|
||
PartCode = "REQ001",
|
||
PartType = PartType.Required,
|
||
PartName = "默认必装部件1",
|
||
RequiredQuantity = 1,
|
||
Weight = 1.0
|
||
},
|
||
new()
|
||
{
|
||
PartId = Guid.NewGuid(),
|
||
PartCode = "REQ002",
|
||
PartType = PartType.Required,
|
||
PartName = "默认必装部件2",
|
||
RequiredQuantity = 1,
|
||
Weight = 1.0
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认关键部件。
|
||
/// </summary>
|
||
private IReadOnlyList<CriticalPart> CreateDefaultCriticalParts(LayerContext layerContext)
|
||
{
|
||
// 简化处理：根据层级上下文创建默认关键部件
|
||
return new List<CriticalPart>
|
||
{
|
||
new()
|
||
{
|
||
PartId = Guid.NewGuid(),
|
||
PartCode = "CRT001",
|
||
PartType = PartType.Critical,
|
||
PartName = "默认关键部件1",
|
||
CriticalityLevel = CriticalityLevel.Important,
|
||
RequiredQuantity = 1,
|
||
Weight = 1.0
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认稳定性要求。
|
||
/// </summary>
|
||
private StabilityRequirements CreateDefaultStabilityRequirements()
|
||
{
|
||
return new StabilityRequirements
|
||
{
|
||
StabilityThreshold = _options.DefaultStabilityThreshold,
|
||
MinimumStableFrames = _options.DefaultStabilityWindowSize,
|
||
PositionChangeThreshold = 5.0,
|
||
AreaChangeThreshold = 0.1,
|
||
ConfidenceChangeThreshold = 0.1
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认禁装部件。
|
||
/// </summary>
|
||
private IReadOnlyList<ForbiddenPart> CreateDefaultForbiddenParts(LayerContext layerContext)
|
||
{
|
||
// 简化处理：根据层级上下文创建默认禁装部件
|
||
return new List<ForbiddenPart>
|
||
{
|
||
new()
|
||
{
|
||
PartId = Guid.NewGuid(),
|
||
PartCode = "FRB001",
|
||
PartType = PartType.Forbidden,
|
||
PartName = "默认禁装部件1",
|
||
ViolationSeverity = ViolationSeverity.Serious,
|
||
ForbiddenReason = "此部件在此层级不允许安装"
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 添加完成历史。
|
||
/// </summary>
|
||
private async Task AddCompletionHistoryAsync(LayerCompletionResult completionResult, CancellationToken cancellationToken = default)
|
||
{
|
||
await Task.Run(() =>
|
||
{
|
||
_completionHistory.TryAdd(Guid.NewGuid(), completionResult);
|
||
|
||
// 保持历史记录数量在合理范围内
|
||
if (_completionHistory.Count > _options.MaxLayerCompletionHistoryCount)
|
||
{
|
||
var oldestRecords = _completionHistory.Values
|
||
.OrderBy(r => r.JudgmentTimeUtc)
|
||
.Take(_completionHistory.Count - _options.MaxLayerCompletionHistoryCount)
|
||
.Select(r => r.JudgmentTimeUtc)
|
||
.ToList();
|
||
|
||
foreach (var time in oldestRecords)
|
||
{
|
||
var toRemove = _completionHistory.FirstOrDefault(kvp => kvp.Value.JudgmentTimeUtc == time);
|
||
if (toRemove.Key != Guid.Empty)
|
||
{
|
||
_completionHistory.TryRemove(toRemove.Key, out _);
|
||
}
|
||
}
|
||
}
|
||
}, cancellationToken);
|
||
}
|
||
|
||
#endregion
|
||
|
||
/// <summary>
|
||
/// 稳定性指标。
|
||
/// </summary>
|
||
private sealed class StabilityMetrics
|
||
{
|
||
public double OverallStabilityScore { get; init; }
|
||
public int StableFrameCount { get; init; }
|
||
}
|
||
}
|
||
|
||
#endif
|