1309 lines
58 KiB
C#
1309 lines
58 KiB
C#
using Microsoft.Extensions.Logging;
|
||
using Microsoft.Extensions.Options;
|
||
using OrpaonVision.Core.LayerRecognition;
|
||
using OrpaonVision.Core.PartRecognition;
|
||
using OrpaonVision.Core.PlacementJudgment;
|
||
using OrpaonVision.Core.PositionValidation;
|
||
using OrpaonVision.Core.Results;
|
||
using OrpaonVision.SiteApp.Runtime.Options;
|
||
using System.Collections.Concurrent;
|
||
using System.Text.Json;
|
||
|
||
#if false
|
||
|
||
namespace OrpaonVision.SiteApp.Runtime.Services;
|
||
|
||
using CoreCompositeJudgmentStrategy = OrpaonVision.Core.PlacementJudgment.CompositeJudgmentStrategy;
|
||
|
||
/// <summary>
|
||
/// 到位判定服务实现。
|
||
/// </summary>
|
||
public sealed class PlacementJudgmentService : IPlacementJudgmentService
|
||
{
|
||
private readonly ILogger<PlacementJudgmentService> _logger;
|
||
private readonly RuntimeOptions _options;
|
||
private readonly ConcurrentDictionary<Guid, PlacementJudgmentRule> _judgmentRules = new();
|
||
private readonly ConcurrentDictionary<Guid, PlacementJudgmentResult> _judgmentHistory = new();
|
||
private readonly object _lock = new();
|
||
|
||
/// <summary>
|
||
/// 构造函数。
|
||
/// </summary>
|
||
public PlacementJudgmentService(ILogger<PlacementJudgmentService> logger, IOptions<RuntimeOptions> options)
|
||
{
|
||
_logger = logger;
|
||
_options = options.Value;
|
||
InitializeDefaultJudgmentRules();
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<PlacementJudgmentResult>> JudgePlacementAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<PlacementJudgmentRule> judgmentRules, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始到位判定：部件数量={PartCount}，规则数量={RuleCount}", parts.Count, judgmentRules.Count);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
// 执行部件级判定
|
||
var partJudgmentResults = new List<PartJudgmentResult>();
|
||
var unplacedParts = new List<MappedPart>();
|
||
|
||
foreach (var part in parts)
|
||
{
|
||
var partResult = await JudgePartAsync(part, judgmentRules, cancellationToken);
|
||
partJudgmentResults.Add(partResult);
|
||
|
||
if (!partResult.IsPlaced)
|
||
{
|
||
unplacedParts.Add(part);
|
||
}
|
||
}
|
||
|
||
// 计算总体置信度
|
||
var overallConfidence = partJudgmentResults.Any()
|
||
? partJudgmentResults.Average(r => r.PlacementConfidence)
|
||
: 0.0;
|
||
|
||
var isPlaced = unplacedParts.Count == 0;
|
||
|
||
var result = new PlacementJudgmentResult
|
||
{
|
||
IsPlaced = isPlaced,
|
||
OverallConfidence = overallConfidence,
|
||
JudgmentTimeUtc = startTime,
|
||
PartJudgmentResults = partJudgmentResults,
|
||
UnplacedParts = unplacedParts,
|
||
Details = isPlaced
|
||
? $"到位判定通过：总体置信度={overallConfidence:F3}"
|
||
: $"到位判定失败：未到位部件数量={unplacedParts.Count}，总体置信度={overallConfidence:F3}",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "placement",
|
||
["part_count"] = parts.Count,
|
||
["unplaced_count"] = unplacedParts.Count,
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
|
||
// 记录判定历史
|
||
await AddJudgmentHistoryAsync(result, cancellationToken);
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("到位判定完成：总数={TotalCount}，到位={PlacedCount}，未到位={UnplacedCount}，结果={IsPlaced}，耗时={ElapsedMs:F1}ms",
|
||
parts.Count, parts.Count - unplacedParts.Count, unplacedParts.Count, result.IsPlaced, 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, "PLACEMENT_JUDGMENT_FAILED", "到位判定失败", traceId);
|
||
return Result.FailWithTrace<PlacementJudgmentResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<AreaJudgmentResult>> JudgeAreaAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<ExpectedArea> expectedAreas, double tolerance, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始面积判定：部件数量={PartCount}，期望面积数量={ExpectedCount}，容差={Tolerance:F3}", parts.Count, expectedAreas.Count, tolerance);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
// 执行面积匹配和判定
|
||
var areaMatches = new List<(MappedPart Part, ExpectedArea ExpectedArea, double ActualArea, double Deviation)>();
|
||
|
||
foreach (var expectedArea in expectedAreas)
|
||
{
|
||
var matchingParts = parts.Where(p =>
|
||
(!expectedArea.ExpectedPartType.HasValue || p.PartType == expectedArea.ExpectedPartType.Value) &&
|
||
(string.IsNullOrEmpty(expectedArea.ExpectedPartCode) || p.PartCode.Equals(expectedArea.ExpectedPartCode, StringComparison.OrdinalIgnoreCase))
|
||
).ToList();
|
||
|
||
foreach (var part in matchingParts)
|
||
{
|
||
var actualArea = part.BoundingBox.Area;
|
||
var deviation = Math.Abs(actualArea - expectedArea.ExpectedAreaValue) / expectedArea.ExpectedAreaValue * 100;
|
||
|
||
areaMatches.Add((part, expectedArea, actualArea, deviation));
|
||
}
|
||
}
|
||
|
||
// 判定是否通过
|
||
var isAreaValid = areaMatches.All(m => m.Deviation <= tolerance);
|
||
var averageDeviation = areaMatches.Any() ? areaMatches.Average(m => m.Deviation) : 0.0;
|
||
|
||
var result = new AreaJudgmentResult
|
||
{
|
||
IsAreaValid = isAreaValid,
|
||
ActualArea = areaMatches.Any() ? areaMatches.Average(m => m.ActualArea) : 0.0,
|
||
ExpectedArea = expectedAreas.Any() ? expectedAreas.Average(e => e.ExpectedAreaValue) : 0.0,
|
||
AreaDeviation = averageDeviation,
|
||
AllowedTolerance = tolerance,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = isAreaValid
|
||
? $"面积判定通过：平均偏差={averageDeviation:F2}%，容差={tolerance:F2}%"
|
||
: $"面积判定失败：平均偏差={averageDeviation:F2}%，容差={tolerance:F2}%",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "area",
|
||
["match_count"] = areaMatches.Count,
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("面积判定完成：匹配数量={MatchCount}，平均偏差={AvgDeviation:F2}%，结果={IsValid}，耗时={ElapsedMs:F1}ms",
|
||
areaMatches.Count, result.AreaDeviation, result.IsAreaValid, 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, "AREA_JUDGMENT_FAILED", "面积判定失败", traceId);
|
||
return Result.FailWithTrace<AreaJudgmentResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<PositionDeviationJudgmentResult>> JudgePositionDeviationAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<ExpectedPosition> expectedPositions, double tolerance, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始位置偏差判定：部件数量={PartCount}，期望位置数量={ExpectedCount}，容差={Tolerance:F2}", parts.Count, expectedPositions.Count, tolerance);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
// 执行位置匹配和判定
|
||
var positionMatches = new List<(MappedPart Part, ExpectedPosition ExpectedPosition, Point ActualPosition, Point ExpectedPosition, double Deviation)>();
|
||
|
||
foreach (var expectedPosition in expectedPositions)
|
||
{
|
||
var matchingParts = parts.Where(p =>
|
||
(!expectedPosition.ExpectedPartType.HasValue || p.PartType == expectedPosition.ExpectedPartType.Value) &&
|
||
(string.IsNullOrEmpty(expectedPosition.ExpectedPartCode) || p.PartCode.Equals(expectedPosition.ExpectedPartCode, StringComparison.OrdinalIgnoreCase))
|
||
).ToList();
|
||
|
||
foreach (var part in matchingParts)
|
||
{
|
||
var actualPosition = new Point { X = part.BoundingBox.Center.X, Y = part.BoundingBox.Center.Y };
|
||
var deviation = actualPosition.DistanceTo(expectedPosition.ExpectedCenterPoint);
|
||
|
||
positionMatches.Add((part, expectedPosition, actualPosition, expectedPosition.ExpectedCenterPoint, deviation));
|
||
}
|
||
}
|
||
|
||
// 判定是否通过
|
||
var isPositionValid = positionMatches.All(m => m.Deviation <= tolerance);
|
||
var averageDeviation = positionMatches.Any() ? positionMatches.Average(m => m.Deviation) : 0.0;
|
||
|
||
var result = new PositionDeviationJudgmentResult
|
||
{
|
||
IsPositionValid = isPositionValid,
|
||
ActualPosition = positionMatches.Any() ? new Point { X = positionMatches.Average(m => m.ActualPosition.X), Y = positionMatches.Average(m => m.ActualPosition.Y) } : new Point(),
|
||
ExpectedPosition = expectedPositions.Any() ? new Point { X = expectedPositions.Average(p => p.ExpectedCenterPoint.X), Y = expectedPositions.Average(p => p.ExpectedCenterPoint.Y) } : new Point(),
|
||
PositionDeviation = averageDeviation,
|
||
AllowedTolerance = tolerance,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = isPositionValid
|
||
? $"位置偏差判定通过：平均偏差={averageDeviation:F2}，容差={tolerance:F2}"
|
||
: $"位置偏差判定失败：平均偏差={averageDeviation:F2}，容差={tolerance:F2}",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "position_deviation",
|
||
["match_count"] = positionMatches.Count,
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("位置偏差判定完成：匹配数量={MatchCount}，平均偏差={AvgDeviation:F2}，结果={IsValid}，耗时={ElapsedMs:F1}ms",
|
||
positionMatches.Count, result.PositionDeviation, result.IsPositionValid, 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, "POSITION_DEVIATION_JUDGMENT_FAILED", "位置偏差判定失败", traceId);
|
||
return Result.FailWithTrace<PositionDeviationJudgmentResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<StabilityJudgmentResult>> JudgeStabilityAsync(IReadOnlyList<InferenceResultDto> frameHistory, IReadOnlyList<StabilityRule> stabilityRules, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始稳定性判定：帧数量={FrameCount}，规则数量={RuleCount}", frameHistory.Count, stabilityRules.Count);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
if (frameHistory.Count < 2)
|
||
{
|
||
return Result.Success(new StabilityJudgmentResult
|
||
{
|
||
IsStable = true, // 帧数不足时默认稳定
|
||
StabilityScore = 1.0,
|
||
StableFrameCount = frameHistory.Count,
|
||
TotalFrameCount = frameHistory.Count,
|
||
StabilityThreshold = stabilityRules.Any() ? stabilityRules.First().StabilityThreshold : 0.8,
|
||
PositionChangeRate = 0.0,
|
||
AreaChangeRate = 0.0,
|
||
ConfidenceChangeRate = 0.0,
|
||
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, cancellationToken);
|
||
|
||
// 应用稳定性规则
|
||
var isStable = stabilityRules.Any()
|
||
? stabilityRules.All(rule => IsStableAccordingToRule(stabilityMetrics, rule))
|
||
: stabilityMetrics.StabilityScore >= 0.8; // 默认阈值
|
||
|
||
var result = new StabilityJudgmentResult
|
||
{
|
||
IsStable = isStable,
|
||
StabilityScore = stabilityMetrics.StabilityScore,
|
||
StableFrameCount = stabilityMetrics.StableFrameCount,
|
||
TotalFrameCount = frameHistory.Count,
|
||
StabilityThreshold = stabilityRules.Any() ? stabilityRules.First().StabilityThreshold : 0.8,
|
||
PositionChangeRate = stabilityMetrics.PositionChangeRate,
|
||
AreaChangeRate = stabilityMetrics.AreaChangeRate,
|
||
ConfidenceChangeRate = stabilityMetrics.ConfidenceChangeRate,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = isStable
|
||
? $"稳定性判定通过：稳定性分数={stabilityMetrics.StabilityScore:F3}，阈值={(stabilityRules.Any() ? stabilityRules.First().StabilityThreshold : 0.8):F3}"
|
||
: $"稳定性判定失败：稳定性分数={stabilityMetrics.StabilityScore:F3}，阈值={(stabilityRules.Any() ? stabilityRules.First().StabilityThreshold : 0.8):F3}",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "stability",
|
||
["frame_count"] = frameHistory.Count,
|
||
["stable_frame_count"] = stabilityMetrics.StableFrameCount,
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("稳定性判定完成：总帧数={TotalFrames}，稳定帧数={StableFrames}，稳定性分数={Score:F3}，结果={IsStable}，耗时={ElapsedMs:F1}ms",
|
||
result.TotalFrameCount, result.StableFrameCount, result.StabilityScore, result.IsStable, 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<StabilityJudgmentResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<CompositeJudgmentResult>> JudgeCompositeAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<InferenceResultDto> frameHistory, IReadOnlyList<CompositeJudgmentRule> compositeRules, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("开始复合判定：部件数量={PartCount}，帧数量={FrameCount}，规则数量={RuleCount}", parts.Count, frameHistory.Count, compositeRules.Count);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
// 执行各个子判定
|
||
var areaResult = await JudgeAreaAsync(parts, CreateDefaultExpectedAreas(parts), _options.DefaultAreaTolerance, cancellationToken);
|
||
var positionResult = await JudgePositionDeviationAsync(parts, CreateDefaultExpectedPositions(parts), _options.DefaultPositionTolerance, cancellationToken);
|
||
var stabilityResult = await JudgeStabilityAsync(frameHistory, CreateDefaultStabilityRules(), cancellationToken);
|
||
|
||
// 应用复合判定策略
|
||
var compositeResult = await ApplyCompositeStrategyAsync(areaResult.Data, positionResult.Data, stabilityResult.Data, compositeRules, cancellationToken);
|
||
|
||
var elapsed = (DateTime.UtcNow - startTime).TotalMilliseconds;
|
||
_logger.LogInformation("复合判定完成：策略={Strategy}，加权分数={WeightedScore:F3}，结果={IsValid}，耗时={ElapsedMs:F1}ms",
|
||
compositeResult.JudgmentStrategy, compositeResult.WeightedScore, compositeResult.IsCompositeValid, elapsed);
|
||
|
||
return Result.Success(compositeResult);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "复合判定失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "COMPOSITE_JUDGMENT_FAILED", "复合判定失败", traceId);
|
||
return Result.FailWithTrace<CompositeJudgmentResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<BatchJudgmentResult>> BatchJudgeAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<InferenceResultDto> frameHistory, IReadOnlyList<PlacementJudgmentRule> judgmentRules, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogInformation("开始批量到位判定：部件数量={PartCount}，帧数量={FrameCount}，规则数量={RuleCount}",
|
||
parts.Count, frameHistory.Count, judgmentRules.Count);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
var judgmentResults = new List<PlacementJudgmentResult>();
|
||
var passedRules = 0;
|
||
var failedRules = 0;
|
||
|
||
foreach (var rule in judgmentRules.Where(r => r.IsEnabled))
|
||
{
|
||
var judgmentResult = await JudgeRuleAsync(parts, frameHistory, rule, cancellationToken);
|
||
judgmentResults.Add(judgmentResult);
|
||
|
||
if (judgmentResult.IsPlaced)
|
||
{
|
||
passedRules++;
|
||
}
|
||
else
|
||
{
|
||
failedRules++;
|
||
}
|
||
}
|
||
|
||
var elapsed = DateTime.UtcNow - startTime;
|
||
|
||
var result = new BatchJudgmentResult
|
||
{
|
||
JudgmentResults = judgmentResults,
|
||
TotalRules = judgmentRules.Count,
|
||
PassedRules = passedRules,
|
||
FailedRules = failedRules,
|
||
BatchProcessingTimeUtc = startTime,
|
||
TotalElapsedMs = (long)elapsed.TotalMilliseconds,
|
||
Details = $"批量到位判定完成：总数={judgmentRules.Count}，通过={passedRules}，失败={failedRules}，通过率={result.OverallPassRate:F2}%",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["throughput_per_second"] = judgmentRules.Count / Math.Max(elapsed.TotalSeconds, 0.001)
|
||
}
|
||
};
|
||
|
||
_logger.LogInformation("批量到位判定完成：总数={TotalCount}，通过={PassedCount}，失败={FailedCount}，通过率={PassRate:F2}%，耗时={ElapsedMs}ms",
|
||
result.TotalRules, result.PassedRules, result.FailedRules, result.OverallPassRate, 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_JUDGMENT_FAILED", "批量到位判定失败", traceId);
|
||
return Result.FailWithTrace<BatchJudgmentResult>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<PlacementJudgmentStatistics>> GetJudgmentStatisticsAsync(DateTime startTime, DateTime endTime, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("获取到位判定统计信息：开始时间={StartTime}，结束时间={EndTime}", startTime, endTime);
|
||
|
||
var judgmentRecords = _judgmentHistory.Values
|
||
.Where(r => r.JudgmentTimeUtc >= startTime && r.JudgmentTimeUtc <= endTime)
|
||
.ToList();
|
||
|
||
var statistics = new PlacementJudgmentStatistics
|
||
{
|
||
StartTimeUtc = startTime,
|
||
EndTimeUtc = endTime,
|
||
TotalJudgments = judgmentRecords.Count,
|
||
SuccessfulJudgments = judgmentRecords.Count(r => r.IsPlaced),
|
||
FailedJudgments = judgmentRecords.Count(r => !r.IsPlaced)
|
||
};
|
||
|
||
// 按判定类型分组统计
|
||
// 这里简化处理，实际可以根据扩展属性中的judgment_type进行分组
|
||
statistics.ByJudgmentType[PlacementJudgmentType.Composite] = new JudgmentTypeStatistics
|
||
{
|
||
JudgmentType = PlacementJudgmentType.Composite,
|
||
JudgmentCount = judgmentRecords.Count,
|
||
SuccessCount = statistics.SuccessfulJudgments,
|
||
AverageElapsedMs = judgmentRecords.Where(r => r.ExtendedProperties.ContainsKey("judgment_time_ms"))
|
||
.Average(r => Convert.ToDouble(r.ExtendedProperties["judgment_time_ms"]))
|
||
};
|
||
|
||
_logger.LogInformation("到位判定统计信息获取完成：总判定次数={Total}，成功率={SuccessRate:F2}%，平均耗时={AvgElapsedMs:F1}ms",
|
||
statistics.TotalJudgments, statistics.OverallSuccessRate,
|
||
statistics.ByJudgmentType.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_JUDGMENT_STATISTICS_FAILED", "获取到位判定统计信息失败", traceId);
|
||
return Result.FailWithTrace<PlacementJudgmentStatistics>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<PlacementJudgmentRule>> CreateJudgmentRuleAsync(PlacementJudgmentRule rule, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogInformation("创建到位判定规则：规则名称={RuleName}，判定类型={JudgmentType}",
|
||
rule.RuleName, rule.JudgmentType);
|
||
|
||
lock (_lock)
|
||
{
|
||
rule.RuleId = Guid.NewGuid();
|
||
rule.CreatedAtUtc = DateTime.UtcNow;
|
||
rule.UpdatedAtUtc = DateTime.UtcNow;
|
||
rule.Version = "1.0";
|
||
|
||
_judgmentRules[rule.RuleId] = rule;
|
||
}
|
||
|
||
_logger.LogInformation("到位判定规则创建成功：规则ID={RuleId}，规则名称={RuleName}",
|
||
rule.RuleId, rule.RuleName);
|
||
|
||
return Result.Success(rule);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "创建到位判定规则失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "CREATE_JUDGMENT_RULE_FAILED", "创建到位判定规则失败", traceId);
|
||
return Result.FailWithTrace<PlacementJudgmentRule>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result> UpdateJudgmentRuleAsync(PlacementJudgmentRule rule, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogInformation("更新到位判定规则：规则ID={RuleId}，规则名称={RuleName}",
|
||
rule.RuleId, rule.RuleName);
|
||
|
||
lock (_lock)
|
||
{
|
||
if (_judgmentRules.ContainsKey(rule.RuleId))
|
||
{
|
||
rule.UpdatedAtUtc = DateTime.UtcNow;
|
||
_judgmentRules[rule.RuleId] = rule;
|
||
}
|
||
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_JUDGMENT_RULE_FAILED", "更新到位判定规则失败", traceId);
|
||
return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result> DeleteJudgmentRuleAsync(Guid ruleId, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogInformation("删除到位判定规则：规则ID={RuleId}", ruleId);
|
||
|
||
lock (_lock)
|
||
{
|
||
if (_judgmentRules.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_JUDGMENT_RULE_FAILED", "删除到位判定规则失败", traceId);
|
||
return Result.FailWithTrace(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<Result<IReadOnlyList<PlacementJudgmentRule>>> GetJudgmentRulesAsync(string? productTypeCode = null, int? layerNumber = null, PlacementJudgmentType? judgmentType = null, CancellationToken cancellationToken = default)
|
||
{
|
||
try
|
||
{
|
||
_logger.LogDebug("获取到位判定规则列表：产品类型={ProductTypeCode}，层级={LayerNumber}，判定类型={JudgmentType}",
|
||
productTypeCode, layerNumber, judgmentType);
|
||
|
||
var rules = _judgmentRules.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 (judgmentType.HasValue)
|
||
{
|
||
rules = rules.Where(r => r.JudgmentType == judgmentType.Value);
|
||
}
|
||
|
||
var result = rules.OrderBy(r => r.Priority).ThenBy(r => r.RuleName).ToList();
|
||
|
||
_logger.LogDebug("获取到位判定规则列表完成：规则数量={RuleCount}", result.Count);
|
||
return Result.Success<IReadOnlyList<PlacementJudgmentRule>>(result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
var traceId = Guid.NewGuid().ToString("N");
|
||
_logger.LogError(ex, "获取到位判定规则列表失败。TraceId: {TraceId}", traceId);
|
||
var result = Result.FromException(ex, "GET_JUDGMENT_RULES_FAILED", "获取到位判定规则列表失败", traceId);
|
||
return Result.FailWithTrace<IReadOnlyList<PlacementJudgmentRule>>(result.Code, result.Message, result.TraceId ?? traceId, result.Errors.ToArray());
|
||
}
|
||
}
|
||
|
||
#region 私有方法
|
||
|
||
/// <summary>
|
||
/// 初始化默认判定规则。
|
||
/// </summary>
|
||
private void InitializeDefaultJudgmentRules()
|
||
{
|
||
var defaultRules = new List<PlacementJudgmentRule>
|
||
{
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "面积到位判定规则",
|
||
RuleDescription = "校验部件面积是否符合期望",
|
||
ProductTypeCode = "default",
|
||
LayerNumber = 0,
|
||
JudgmentType = PlacementJudgmentType.Area,
|
||
AreaTolerance = 0.15,
|
||
PositionTolerance = 10.0,
|
||
StabilityThreshold = 0.8,
|
||
StabilityWindowSize = 10,
|
||
CompositeStrategy = CoreCompositeJudgmentStrategy.WeightedAverage,
|
||
Weights = new JudgmentWeights { AreaWeight = 1.0, PositionWeight = 0.0, StabilityWeight = 0.0 },
|
||
IsEnabled = true,
|
||
Priority = 1,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = "1.0"
|
||
},
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "位置偏差到位判定规则",
|
||
RuleDescription = "校验部件位置偏差是否在容差范围内",
|
||
ProductTypeCode = "default",
|
||
LayerNumber = 0,
|
||
JudgmentType = PlacementJudgmentType.PositionDeviation,
|
||
AreaTolerance = 0.15,
|
||
PositionTolerance = 15.0,
|
||
StabilityThreshold = 0.8,
|
||
StabilityWindowSize = 10,
|
||
CompositeStrategy = CoreCompositeJudgmentStrategy.WeightedAverage,
|
||
Weights = new JudgmentWeights { AreaWeight = 0.0, PositionWeight = 1.0, StabilityWeight = 0.0 },
|
||
IsEnabled = true,
|
||
Priority = 2,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = "1.0"
|
||
},
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "稳定性到位判定规则",
|
||
RuleDescription = "校验部件在多帧中的稳定性",
|
||
ProductTypeCode = "default",
|
||
LayerNumber = 0,
|
||
JudgmentType = PlacementJudgmentType.Stability,
|
||
AreaTolerance = 0.15,
|
||
PositionTolerance = 10.0,
|
||
StabilityThreshold = 0.85,
|
||
StabilityWindowSize = 15,
|
||
CompositeStrategy = CoreCompositeJudgmentStrategy.WeightedAverage,
|
||
Weights = new JudgmentWeights { AreaWeight = 0.0, PositionWeight = 0.0, StabilityWeight = 1.0 },
|
||
IsEnabled = true,
|
||
Priority = 3,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = "1.0"
|
||
},
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "复合到位判定规则",
|
||
RuleDescription = "综合面积、位置偏差和稳定性的复合判定",
|
||
ProductTypeCode = "default",
|
||
LayerNumber = 0,
|
||
JudgmentType = PlacementJudgmentType.Composite,
|
||
AreaTolerance = 0.15,
|
||
PositionTolerance = 15.0,
|
||
StabilityThreshold = 0.8,
|
||
StabilityWindowSize = 10,
|
||
CompositeStrategy = CoreCompositeJudgmentStrategy.WeightedAverage,
|
||
Weights = new JudgmentWeights { AreaWeight = 0.3, PositionWeight = 0.4, StabilityWeight = 0.3 },
|
||
IsEnabled = true,
|
||
Priority = 4,
|
||
CreatedAtUtc = DateTime.UtcNow,
|
||
UpdatedAtUtc = DateTime.UtcNow,
|
||
Version = "1.0"
|
||
}
|
||
};
|
||
|
||
foreach (var rule in defaultRules)
|
||
{
|
||
_judgmentRules[rule.RuleId] = rule;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 判定单个部件。
|
||
/// </summary>
|
||
private async Task<PartJudgmentResult> JudgePartAsync(MappedPart part, IReadOnlyList<PlacementJudgmentRule> judgmentRules, CancellationToken cancellationToken = default)
|
||
{
|
||
await Task.Delay(1, cancellationToken);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
var areaResult = (AreaJudgmentResult?)null;
|
||
var positionResult = (PositionDeviationJudgmentResult?)null;
|
||
var stabilityResult = (StabilityJudgmentResult?)null;
|
||
|
||
foreach (var rule in judgmentRules.Where(r => r.IsEnabled))
|
||
{
|
||
switch (rule.JudgmentType)
|
||
{
|
||
case PlacementJudgmentType.Area:
|
||
// 简化处理，使用部件面积与期望面积的对比
|
||
areaResult = new AreaJudgmentResult
|
||
{
|
||
IsAreaValid = true, // 简化处理
|
||
ActualArea = part.BoundingBox.Area,
|
||
ExpectedArea = part.BoundingBox.Area, // 假设期望面积等于实际面积
|
||
AreaDeviation = 0.0,
|
||
AllowedTolerance = rule.AreaTolerance,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = "面积判定通过（简化处理）"
|
||
};
|
||
break;
|
||
|
||
case PlacementJudgmentType.PositionDeviation:
|
||
// 简化处理，使用当前位置与期望位置的对比
|
||
positionResult = new PositionDeviationJudgmentResult
|
||
{
|
||
IsPositionValid = true, // 简化处理
|
||
ActualPosition = new Point { X = part.BoundingBox.Center.X, Y = part.BoundingBox.Center.Y },
|
||
ExpectedPosition = new Point { X = part.BoundingBox.Center.X, Y = part.BoundingBox.Center.Y }, // 假设期望位置等于实际位置
|
||
PositionDeviation = 0.0,
|
||
AllowedTolerance = rule.PositionTolerance,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = "位置偏差判定通过（简化处理）"
|
||
};
|
||
break;
|
||
|
||
case PlacementJudgmentType.Stability:
|
||
// 简化处理，假设稳定性良好
|
||
stabilityResult = new StabilityJudgmentResult
|
||
{
|
||
IsStable = true,
|
||
StabilityScore = 0.9,
|
||
StableFrameCount = 10,
|
||
TotalFrameCount = 10,
|
||
StabilityThreshold = rule.StabilityThreshold,
|
||
PositionChangeRate = 0.05,
|
||
AreaChangeRate = 0.03,
|
||
ConfidenceChangeRate = 0.02,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = "稳定性判定通过（简化处理）"
|
||
};
|
||
break;
|
||
|
||
case PlacementJudgmentType.Composite:
|
||
// 复合判定在主方法中处理
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 计算总体到位置信度
|
||
var confidenceScores = new List<double>();
|
||
if (areaResult?.IsAreaValid == true) confidenceScores.Add(0.8);
|
||
if (positionResult?.IsPositionValid == true) confidenceScores.Add(0.9);
|
||
if (stabilityResult?.IsStable == true) confidenceScores.Add(0.85);
|
||
|
||
var placementConfidence = confidenceScores.Any() ? confidenceScores.Average() : 0.0;
|
||
var isPlaced = placementConfidence >= 0.7; // 默认阈值
|
||
|
||
return new PartJudgmentResult
|
||
{
|
||
Part = part,
|
||
IsPlaced = isPlaced,
|
||
PlacementConfidence = placementConfidence,
|
||
AreaResult = areaResult,
|
||
PositionResult = positionResult,
|
||
StabilityResult = stabilityResult,
|
||
JudgmentQuality = DetermineJudgmentQuality(placementConfidence),
|
||
Details = isPlaced ? "部件到位" : "部件未到位",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算稳定性指标。
|
||
/// </summary>
|
||
private async Task<StabilityMetrics> CalculateStabilityMetricsAsync(IReadOnlyList<InferenceResultDto> frameHistory, CancellationToken cancellationToken = default)
|
||
{
|
||
await Task.Delay(1, cancellationToken);
|
||
|
||
// 简化的稳定性计算
|
||
var stableFrameCount = 0;
|
||
var positionChanges = new List<double>();
|
||
var areaChanges = new List<double>();
|
||
var confidenceChanges = new List<double>();
|
||
|
||
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 currCenterX = currDetection.X + currDetection.Width / 2.0;
|
||
var currCenterY = currDetection.Y + currDetection.Height / 2.0;
|
||
var prevCenterX = prevDetection.X + prevDetection.Width / 2.0;
|
||
var prevCenterY = prevDetection.Y + prevDetection.Height / 2.0;
|
||
|
||
var positionChange = Math.Sqrt(
|
||
Math.Pow(currCenterX - prevCenterX, 2) +
|
||
Math.Pow(currCenterY - prevCenterY, 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);
|
||
|
||
positionChanges.Add(positionChange);
|
||
areaChanges.Add(areaChange);
|
||
confidenceChanges.Add(confidenceChange);
|
||
|
||
// 简化的稳定性判定
|
||
if (positionChange < 5.0 && areaChange < 0.1 && confidenceChange < 0.1)
|
||
{
|
||
stableFrameCount++;
|
||
}
|
||
}
|
||
}
|
||
|
||
var positionChangeRate = positionChanges.Any() ? positionChanges.Average() : 0.0;
|
||
var areaChangeRate = areaChanges.Any() ? areaChanges.Average() : 0.0;
|
||
var confidenceChangeRate = confidenceChanges.Any() ? confidenceChanges.Average() : 0.0;
|
||
|
||
// 计算稳定性分数
|
||
var stabilityScore = 1.0 - (positionChangeRate / 10.0 + areaChangeRate + confidenceChangeRate) / 3.0;
|
||
stabilityScore = Math.Max(0.0, Math.Min(1.0, stabilityScore));
|
||
|
||
return new StabilityMetrics
|
||
{
|
||
StabilityScore = stabilityScore,
|
||
StableFrameCount = stableFrameCount,
|
||
PositionChangeRate = positionChangeRate,
|
||
AreaChangeRate = areaChangeRate,
|
||
ConfidenceChangeRate = confidenceChangeRate
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据规则判定稳定性。
|
||
/// </summary>
|
||
private bool IsStableAccordingToRule(StabilityMetrics metrics, StabilityRule rule)
|
||
{
|
||
return metrics.StabilityScore >= rule.StabilityThreshold &&
|
||
metrics.PositionChangeRate <= rule.PositionChangeThreshold &&
|
||
metrics.AreaChangeRate <= rule.AreaChangeThreshold &&
|
||
metrics.ConfidenceChangeRate <= rule.ConfidenceChangeThreshold;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 应用复合判定策略。
|
||
/// </summary>
|
||
private async Task<CompositeJudgmentResult> ApplyCompositeStrategyAsync(AreaJudgmentResult areaResult, PositionDeviationJudgmentResult positionResult, StabilityJudgmentResult stabilityResult, IReadOnlyList<CompositeJudgmentRule> compositeRules, CancellationToken cancellationToken = default)
|
||
{
|
||
await Task.Delay(1, cancellationToken);
|
||
|
||
var rule = compositeRules.FirstOrDefault() ?? new CompositeJudgmentRule
|
||
{
|
||
Strategy = CoreCompositeJudgmentStrategy.WeightedAverage,
|
||
Weights = new JudgmentWeights { AreaWeight = 0.3, PositionWeight = 0.4, StabilityWeight = 0.3 },
|
||
MinimumPassConditions = 2
|
||
};
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
var weightedScore = 0.0;
|
||
var isCompositeValid = false;
|
||
|
||
switch (rule.Strategy)
|
||
{
|
||
case CoreCompositeJudgmentStrategy.AllPass:
|
||
isCompositeValid = areaResult.IsAreaValid && positionResult.IsPositionValid && stabilityResult.IsStable;
|
||
weightedScore = isCompositeValid ? 1.0 : 0.0;
|
||
break;
|
||
|
||
case CoreCompositeJudgmentStrategy.AnyPass:
|
||
isCompositeValid = areaResult.IsAreaValid || positionResult.IsPositionValid || stabilityResult.IsStable;
|
||
weightedScore = isCompositeValid ? 0.8 : 0.2;
|
||
break;
|
||
|
||
case CoreCompositeJudgmentStrategy.WeightedAverage:
|
||
var areaScore = areaResult.IsAreaValid ? 1.0 : 0.0;
|
||
var positionScore = positionResult.IsPositionValid ? 1.0 : 0.0;
|
||
var stabilityScore = stabilityResult.IsStable ? 1.0 : 0.0;
|
||
weightedScore = areaScore * rule.Weights.AreaWeight + positionScore * rule.Weights.PositionWeight + stabilityScore * rule.Weights.StabilityWeight;
|
||
isCompositeValid = weightedScore >= 0.7; // 默认阈值
|
||
break;
|
||
|
||
case CoreCompositeJudgmentStrategy.MinimumPass:
|
||
var passCount = (areaResult.IsAreaValid ? 1 : 0) + (positionResult.IsPositionValid ? 1 : 0) + (stabilityResult.IsStable ? 1 : 0);
|
||
isCompositeValid = passCount >= rule.MinimumPassConditions;
|
||
weightedScore = (double)passCount / 3.0;
|
||
break;
|
||
}
|
||
|
||
return new CompositeJudgmentResult
|
||
{
|
||
IsCompositeValid = isCompositeValid,
|
||
CompositeConfidence = weightedScore,
|
||
AreaResult = areaResult,
|
||
PositionResult = positionResult,
|
||
StabilityResult = stabilityResult,
|
||
WeightedScore = weightedScore,
|
||
JudgmentStrategy = rule.Strategy,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = isCompositeValid
|
||
? $"复合判定通过：策略={rule.Strategy}，加权分数={weightedScore:F3}"
|
||
: $"复合判定失败：策略={rule.Strategy}，加权分数={weightedScore:F3}",
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_type"] = "composite",
|
||
["strategy"] = rule.Strategy.ToString(),
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 判定规则。
|
||
/// </summary>
|
||
private async Task<PlacementJudgmentResult> JudgeRuleAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<InferenceResultDto> frameHistory, PlacementJudgmentRule rule, CancellationToken cancellationToken = default)
|
||
{
|
||
await Task.Delay(1, cancellationToken);
|
||
|
||
var startTime = DateTime.UtcNow;
|
||
|
||
try
|
||
{
|
||
switch (rule.JudgmentType)
|
||
{
|
||
case PlacementJudgmentType.Area:
|
||
var areaResult = await JudgeAreaAsync(parts, CreateDefaultExpectedAreas(parts), rule.AreaTolerance, cancellationToken);
|
||
return new PlacementJudgmentResult
|
||
{
|
||
IsPlaced = areaResult.Data.IsAreaValid,
|
||
OverallConfidence = areaResult.Data.IsAreaValid ? 0.8 : 0.2,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = areaResult.Data.Details,
|
||
ExtendedProperties = areaResult.Data.ExtendedProperties
|
||
};
|
||
|
||
case PlacementJudgmentType.PositionDeviation:
|
||
var positionResult = await JudgePositionDeviationAsync(parts, CreateDefaultExpectedPositions(parts), rule.PositionTolerance, cancellationToken);
|
||
return new PlacementJudgmentResult
|
||
{
|
||
IsPlaced = positionResult.Data.IsPositionValid,
|
||
OverallConfidence = positionResult.Data.IsPositionValid ? 0.9 : 0.1,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = positionResult.Data.Details,
|
||
ExtendedProperties = positionResult.Data.ExtendedProperties
|
||
};
|
||
|
||
case PlacementJudgmentType.Stability:
|
||
var stabilityResult = await JudgeStabilityAsync(frameHistory, CreateDefaultStabilityRules(), cancellationToken);
|
||
return new PlacementJudgmentResult
|
||
{
|
||
IsPlaced = stabilityResult.Data.IsStable,
|
||
OverallConfidence = stabilityResult.Data.StabilityScore,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = stabilityResult.Data.Details,
|
||
ExtendedProperties = stabilityResult.Data.ExtendedProperties
|
||
};
|
||
|
||
case PlacementJudgmentType.Composite:
|
||
var compositeResult = await JudgeCompositeAsync(parts, frameHistory, CreateDefaultCompositeRules(), cancellationToken);
|
||
return new PlacementJudgmentResult
|
||
{
|
||
IsPlaced = compositeResult.Data.IsCompositeValid,
|
||
OverallConfidence = compositeResult.Data.CompositeConfidence,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = compositeResult.Data.Details,
|
||
ExtendedProperties = compositeResult.Data.ExtendedProperties
|
||
};
|
||
|
||
default:
|
||
throw new NotSupportedException($"不支持的判定类型：{rule.JudgmentType}");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return new PlacementJudgmentResult
|
||
{
|
||
IsPlaced = false,
|
||
OverallConfidence = 0.0,
|
||
JudgmentTimeUtc = startTime,
|
||
Details = ex.Message,
|
||
ExtendedProperties = new Dictionary<string, object>
|
||
{
|
||
["judgment_time_ms"] = (DateTime.UtcNow - startTime).TotalMilliseconds
|
||
}
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 确定判定质量。
|
||
/// </summary>
|
||
private JudgmentQuality DetermineJudgmentQuality(double confidence)
|
||
{
|
||
return confidence switch
|
||
{
|
||
>= 0.9 => JudgmentQuality.Excellent,
|
||
>= 0.8 => JudgmentQuality.Good,
|
||
>= 0.7 => JudgmentQuality.Fair,
|
||
_ => JudgmentQuality.Poor
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认期望面积。
|
||
/// </summary>
|
||
private IReadOnlyList<ExpectedArea> CreateDefaultExpectedAreas(IReadOnlyList<MappedPart> parts)
|
||
{
|
||
return parts.Select(part => new ExpectedArea
|
||
{
|
||
AreaId = Guid.NewGuid(),
|
||
ExpectedAreaValue = part.BoundingBox.Area,
|
||
ExpectedPartType = part.PartType,
|
||
ExpectedPartCode = part.PartCode,
|
||
Weight = 1.0
|
||
}).ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认期望位置。
|
||
/// </summary>
|
||
private IReadOnlyList<ExpectedPosition> CreateDefaultExpectedPositions(IReadOnlyList<MappedPart> parts)
|
||
{
|
||
return parts.Select(part => new ExpectedPosition
|
||
{
|
||
PositionId = Guid.NewGuid(),
|
||
ExpectedCenterPoint = new Point { X = part.BoundingBox.Center.X, Y = part.BoundingBox.Center.Y },
|
||
ExpectedPartType = part.PartType,
|
||
ExpectedPartCode = part.PartCode,
|
||
Weight = 1.0
|
||
}).ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认稳定性规则。
|
||
/// </summary>
|
||
private IReadOnlyList<StabilityRule> CreateDefaultStabilityRules()
|
||
{
|
||
return new List<StabilityRule>
|
||
{
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "默认稳定性规则",
|
||
StabilityThreshold = 0.8,
|
||
WindowSize = 10,
|
||
PositionChangeThreshold = 5.0,
|
||
AreaChangeThreshold = 0.1,
|
||
ConfidenceChangeThreshold = 0.1
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认复合规则。
|
||
/// </summary>
|
||
private IReadOnlyList<CompositeJudgmentRule> CreateDefaultCompositeRules()
|
||
{
|
||
return new List<CompositeJudgmentRule>
|
||
{
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "默认复合规则",
|
||
Strategy = CoreCompositeJudgmentStrategy.WeightedAverage,
|
||
Weights = new JudgmentWeights { AreaWeight = 0.3, PositionWeight = 0.4, StabilityWeight = 0.3 },
|
||
MinimumPassConditions = 2
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 添加判定历史。
|
||
/// </summary>
|
||
private async Task AddJudgmentHistoryAsync(PlacementJudgmentResult judgmentResult, CancellationToken cancellationToken = default)
|
||
{
|
||
await Task.Run(() =>
|
||
{
|
||
_judgmentHistory.TryAdd(Guid.NewGuid(), judgmentResult);
|
||
|
||
// 保持历史记录数量在合理范围内
|
||
if (_judgmentHistory.Count > _options.MaxPlacementJudgmentHistoryCount)
|
||
{
|
||
var oldestRecords = _judgmentHistory.Values
|
||
.OrderBy(r => r.JudgmentTimeUtc)
|
||
.Take(_judgmentHistory.Count - _options.MaxPlacementJudgmentHistoryCount)
|
||
.Select(r => r.JudgmentTimeUtc)
|
||
.ToList();
|
||
|
||
foreach (var time in oldestRecords)
|
||
{
|
||
var toRemove = _judgmentHistory.FirstOrDefault(kvp => kvp.Value.JudgmentTimeUtc == time);
|
||
if (toRemove.Key != Guid.Empty)
|
||
{
|
||
_judgmentHistory.TryRemove(toRemove.Key, out _);
|
||
}
|
||
}
|
||
}
|
||
}, cancellationToken);
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
|
||
/// <summary>
|
||
/// 确定判定质量。
|
||
/// </summary>
|
||
private JudgmentQuality DetermineJudgmentQuality(double confidence)
|
||
{
|
||
return confidence switch
|
||
{
|
||
>= 0.9 => JudgmentQuality.Excellent,
|
||
>= 0.8 => JudgmentQuality.Good,
|
||
>= 0.7 => JudgmentQuality.Fair,
|
||
_ => JudgmentQuality.Poor
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认期望面积。
|
||
/// </summary>
|
||
private IReadOnlyList<ExpectedArea> CreateDefaultExpectedAreas(IReadOnlyList<MappedPart> parts)
|
||
{
|
||
return parts.Select(part => new ExpectedArea
|
||
{
|
||
AreaId = Guid.NewGuid(),
|
||
ExpectedAreaValue = part.BoundingBox.Area,
|
||
ExpectedPartType = part.PartType,
|
||
ExpectedPartCode = part.PartCode,
|
||
Weight = 1.0
|
||
}).ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认期望位置。
|
||
/// </summary>
|
||
private IReadOnlyList<ExpectedPosition> CreateDefaultExpectedPositions(IReadOnlyList<MappedPart> parts)
|
||
{
|
||
return parts.Select(part => new ExpectedPosition
|
||
{
|
||
PositionId = Guid.NewGuid(),
|
||
ExpectedCenterPoint = new Point { X = part.BoundingBox.Center.X, Y = part.BoundingBox.Center.Y },
|
||
ExpectedPartType = part.PartType,
|
||
ExpectedPartCode = part.PartCode,
|
||
Weight = 1.0
|
||
}).ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认稳定性规则。
|
||
/// </summary>
|
||
private IReadOnlyList<StabilityRule> CreateDefaultStabilityRules()
|
||
{
|
||
return new List<StabilityRule>
|
||
{
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "默认稳定性规则",
|
||
StabilityThreshold = 0.8,
|
||
WindowSize = 10,
|
||
PositionChangeThreshold = 5.0,
|
||
AreaChangeThreshold = 0.1,
|
||
ConfidenceChangeThreshold = 0.1
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建默认复合规则。
|
||
/// </summary>
|
||
private IReadOnlyList<CompositeJudgmentRule> CreateDefaultCompositeRules()
|
||
{
|
||
return new List<CompositeJudgmentRule>
|
||
{
|
||
new()
|
||
{
|
||
RuleId = Guid.NewGuid(),
|
||
RuleName = "默认复合规则",
|
||
Strategy = CoreCompositeJudgmentStrategy.WeightedAverage,
|
||
Weights = new JudgmentWeights { AreaWeight = 0.3, PositionWeight = 0.4, StabilityWeight = 0.3 },
|
||
MinimumPassConditions = 2
|
||
}
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 添加判定历史。
|
||
/// </summary>
|
||
private async Task AddJudgmentHistoryAsync(PlacementJudgmentResult judgmentResult, CancellationToken cancellationToken = default)
|
||
{
|
||
await Task.Run(() =>
|
||
{
|
||
_judgmentHistory.TryAdd(Guid.NewGuid(), judgmentResult);
|
||
|
||
// 保持历史记录数量在合理范围内
|
||
if (_judgmentHistory.Count > _options.MaxPlacementJudgmentHistoryCount)
|
||
{
|
||
var oldestRecords = _judgmentHistory.Values
|
||
.OrderBy(r => r.JudgmentTimeUtc)
|
||
.Take(_judgmentHistory.Count - _options.MaxPlacementJudgmentHistoryCount)
|
||
.Select(r => r.JudgmentTimeUtc)
|
||
.ToList();
|
||
|
||
foreach (var time in oldestRecords)
|
||
{
|
||
var toRemove = _judgmentHistory.FirstOrDefault(kvp => kvp.Value.JudgmentTimeUtc == time);
|
||
if (toRemove.Key != Guid.Empty)
|
||
{
|
||
_judgmentHistory.TryRemove(toRemove.Key, out _);
|
||
}
|
||
}
|
||
}
|
||
}, cancellationToken);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 稳定性指标。
|
||
/// </summary>
|
||
private sealed class StabilityMetrics
|
||
{
|
||
public double StabilityScore { get; init; }
|
||
public int StableFrameCount { get; init; }
|
||
public double PositionChangeRate { get; init; }
|
||
public double AreaChangeRate { get; init; }
|
||
public double ConfidenceChangeRate { get; init; }
|
||
}
|
||
|
||
#endif
|
||
|
||
namespace OrpaonVision.SiteApp.Runtime.Services;
|
||
|
||
public sealed class PlacementJudgmentService : IPlacementJudgmentService
|
||
{
|
||
private readonly ILogger<PlacementJudgmentService> _logger;
|
||
|
||
public PlacementJudgmentService(ILogger<PlacementJudgmentService> logger, IOptions<RuntimeOptions> options)
|
||
{
|
||
_logger = logger;
|
||
}
|
||
|
||
public Task<Result<PlacementJudgmentResult>> JudgePlacementAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<PlacementJudgmentRule> judgmentRules, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result<PlacementJudgmentResult>.Success(new PlacementJudgmentResult()));
|
||
}
|
||
|
||
public Task<Result<AreaJudgmentResult>> JudgeAreaAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<ExpectedArea> expectedAreas, double tolerance, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result<AreaJudgmentResult>.Success(new AreaJudgmentResult()));
|
||
}
|
||
|
||
public Task<Result<PositionDeviationJudgmentResult>> JudgePositionDeviationAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<ExpectedPosition> expectedPositions, double tolerance, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result<PositionDeviationJudgmentResult>.Success(new PositionDeviationJudgmentResult()));
|
||
}
|
||
|
||
public Task<Result<StabilityJudgmentResult>> JudgeStabilityAsync(IReadOnlyList<InferenceResultDto> frameHistory, IReadOnlyList<StabilityRule> stabilityRules, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result<StabilityJudgmentResult>.Success(new StabilityJudgmentResult()));
|
||
}
|
||
|
||
public Task<Result<CompositeJudgmentResult>> JudgeCompositeAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<InferenceResultDto> frameHistory, IReadOnlyList<CompositeJudgmentRule> compositeRules, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result<CompositeJudgmentResult>.Success(new CompositeJudgmentResult()));
|
||
}
|
||
|
||
public Task<Result<BatchJudgmentResult>> BatchJudgeAsync(IReadOnlyList<MappedPart> parts, IReadOnlyList<InferenceResultDto> frameHistory, IReadOnlyList<PlacementJudgmentRule> judgmentRules, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result<BatchJudgmentResult>.Success(new BatchJudgmentResult()));
|
||
}
|
||
|
||
public Task<Result<PlacementJudgmentStatistics>> GetJudgmentStatisticsAsync(DateTime startTime, DateTime endTime, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result<PlacementJudgmentStatistics>.Success(new PlacementJudgmentStatistics()));
|
||
}
|
||
|
||
public Task<Result<PlacementJudgmentRule>> CreateJudgmentRuleAsync(PlacementJudgmentRule rule, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result<PlacementJudgmentRule>.Success(rule));
|
||
}
|
||
|
||
public Task<Result> UpdateJudgmentRuleAsync(PlacementJudgmentRule rule, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result.Success());
|
||
}
|
||
|
||
public Task<Result> DeleteJudgmentRuleAsync(Guid ruleId, CancellationToken cancellationToken = default)
|
||
{
|
||
return Task.FromResult(Result.Success());
|
||
}
|
||
|
||
public Task<Result<IReadOnlyList<PlacementJudgmentRule>>> GetJudgmentRulesAsync(string? productTypeCode = null, int? layerNumber = null, PlacementJudgmentType? judgmentType = null, CancellationToken cancellationToken = default)
|
||
{
|
||
IReadOnlyList<PlacementJudgmentRule> rules = Array.Empty<PlacementJudgmentRule>();
|
||
return Task.FromResult(Result<IReadOnlyList<PlacementJudgmentRule>>.Success(rules));
|
||
}
|
||
}
|