添加 MX-PD-盘古项目文件

将 MX-PD-盘古 - new 目录下的所有文件添加到主仓库
2026-05-18 11:43:09 +08:00
parent 03632a379d
commit e31d3560bb
739 changed files with 99783 additions and 0 deletions
--- a/new/PanGu.DieBonderApp/MainShell/Vision/CommonAlgorithm/CommonVisionAlgorithmService.cs
+++ b/new/PanGu.DieBonderApp/MainShell/Vision/CommonAlgorithm/CommonVisionAlgorithmService.cs
@@ -0,0 +1,324 @@
+using JM1Vision;
+using MainShell.Common;
+using MainShell.Log;
+using MainShell.Vision.Common;
+using MwFramework.Device;
+using MwFramework.Device.Model;
+using MwFramework.ManagerService;
+using SemiconductorVisionAlgorithm.SemiCalib;
+using SemiconductorVisionAlgorithm.SemiParams;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using Jm1RecheckDiePoint = JM1.JM1Params.RecheckDiePoint;
+using SemiPoint = SemiconductorVisionAlgorithm.SemiParams.Point;
+
+
+namespace MainShell.Vision
+{
+    /// <summary>
+    /// 通用视觉算法服务。
+    /// </summary>
+    public class CommonVisionAlgorithmService : ICommonVisionAlgorithmService
+    {
+        public Task<VisionProcessResult> GenWaferMapXAsync(
+            string fileDirectory,
+            double[] edgePtRow,
+            double[] edgePtCol,
+            double[] edgePtAngle,
+            double[] inPtRow,
+            double[] inPtCol,
+            double[] inPtAngle,
+            double upThresholdAngle,
+            double upRowDistance,
+            double upColDistance,
+            int upRowNumber,
+            int upColNumber,
+            double firstPosRow,
+            double firstPosCol,
+            double distanceThreshold,
+            double angleThreshold,
+            double rotateAngle,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteBoolAlgorithmAsync(
+                nameof(GenWaferMapXAsync),
+                delegate ()
+                {
+                    return JM1Manager.Instance.gen_wafer_map_x(
+                        fileDirectory,
+                        edgePtRow,
+                        edgePtCol,
+                        edgePtAngle,
+                        inPtRow,
+                        inPtCol,
+                        inPtAngle,
+                        upThresholdAngle,
+                        upRowDistance,
+                        upColDistance,
+                        upRowNumber,
+                        upColNumber,
+                        firstPosRow,
+                        firstPosCol,
+                        distanceThreshold,
+                        angleThreshold,
+                        rotateAngle);
+                },
+                cancellationToken);
+        }
+
+        public Task<VisionProcessResult> RecheckPosRgbAsync(
+            List<Jm1RecheckDiePoint> edgeDiePoints,
+            List<Jm1RecheckDiePoint> inDiePoints,
+            double threshold,
+            List<Jm1RecheckDiePoint> existingPoints,
+            RecheckDieMap padPos,
+            double diePitch,
+            int rowNumber,
+            int colNumber,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteBoolAlgorithmAsync(
+                nameof(RecheckPosRgbAsync),
+                delegate ()
+                {
+                    Dictionary<int, Dictionary<int, Jm1RecheckDiePoint>> rawPadPos = padPos;
+
+                    return JM1Manager.Instance.recheck_posRGB(
+                        edgeDiePoints,
+                        inDiePoints,
+                        threshold,
+                        existingPoints,
+                        rawPadPos,
+                        diePitch,
+                        rowNumber,
+                        colNumber);
+                },
+                cancellationToken);
+        }
+
+        public Task<VisionProcessResult> ClearRecheckDiePosAsync(
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteBoolAlgorithmAsync(
+                nameof(ClearRecheckDiePosAsync),
+                delegate ()
+                {
+                    return JM1Manager.Instance.ClearRecheckdiepos();
+                },
+                cancellationToken);
+        }
+
+        public Task<VisionProcessResult> ClearMapAsync(
+            int flag,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteBoolAlgorithmAsync(
+                nameof(ClearMapAsync),
+                delegate ()
+                {
+                    return JM1Manager.Instance.ClearMap(flag);
+                },
+                cancellationToken);
+        }
+
+        public Task<VisionProcessResult<(RecheckDieMap UpMap, List<Jm1RecheckDiePoint> PatchPos, List<Jm1RecheckDiePoint> ExceptPos)>> GetMapAsync(
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteDataAlgorithmAsync(
+                nameof(GetMapAsync),
+                delegate ()
+                {
+                    Dictionary<int, Dictionary<int, Jm1RecheckDiePoint>> upMap;
+                    List<Jm1RecheckDiePoint> patchPos;
+                    List<Jm1RecheckDiePoint> exceptPos;
+
+                    bool executeResult = JM1Manager.Instance.GetMap(out upMap, out patchPos, out exceptPos);
+                    EnsureExecutionSucceeded(nameof(GetMapAsync), executeResult);
+                    return (new RecheckDieMap(upMap), patchPos, exceptPos);
+                },
+                cancellationToken);
+        }
+
+        public Task<VisionProcessResult<(RecheckDieMap Map, List<Jm1RecheckDiePoint> ExposedPoints)>> GetRecheckDiePosAsync(
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteDataAlgorithmAsync(
+                nameof(GetRecheckDiePosAsync),
+                delegate ()
+                {
+                    Dictionary<int, Dictionary<int, Jm1RecheckDiePoint>> map;
+                    List<Jm1RecheckDiePoint> exposedPoints;
+
+                    bool executeResult = JM1Manager.Instance.GetRecheckdiepos(out map, out exposedPoints);
+                    EnsureExecutionSucceeded(nameof(GetRecheckDiePosAsync), executeResult);
+                    return (new RecheckDieMap(map), exposedPoints);
+                },
+                cancellationToken);
+        }
+
+        public Task<VisionProcessResult> CalProductAffineAsync(
+            List<SemiPoint> sourcePoints,
+            List<SemiPoint> targetPoints,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteBoolAlgorithmAsync(
+                nameof(CalProductAffineAsync),
+                delegate ()
+                {
+                    return JM1Manager.Instance.cal_product_affine(sourcePoints, targetPoints);
+                },
+                cancellationToken);
+        }
+
+        public Task<VisionProcessResult<double>> CalculateLineAngleAsync(
+            SemiPoint point1,
+            SemiPoint point2,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteDataAlgorithmAsync(
+                nameof(CalculateLineAngleAsync),
+                delegate ()
+                {
+                    double deg;
+                    bool executeResult = JM1Manager.Instance.calculate_line_angle(point1, point2, out deg);
+                    EnsureExecutionSucceeded(nameof(CalculateLineAngleAsync), executeResult);
+                    return deg;
+                },
+                cancellationToken);
+        }
+
+        public Task<VisionProcessResult> SetWorkAreaAsync(
+            string fileDirectory,
+            double heightY,
+            double widthX,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteBoolAlgorithmAsync(
+                nameof(SetWorkAreaAsync),
+                delegate ()
+                {
+                    return JM1Manager.Instance.set_workarea(fileDirectory, heightY, widthX);
+                },
+                cancellationToken);
+        }
+
+        public Task<VisionProcessResult> SetDirectionAsync(
+            string fileDirectory,
+            int xDirection,
+            int yDirection,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return ExecuteBoolAlgorithmAsync(
+                nameof(SetDirectionAsync),
+                delegate ()
+                {
+                    return JM1Manager.Instance.set_direction(fileDirectory, xDirection, yDirection);
+                },
+                cancellationToken);
+        }
+
+
+        private static Task<VisionProcessResult> ExecuteBoolAlgorithmAsync(
+            string algorithmName,
+            Func<bool> execute,
+            CancellationToken cancellationToken)
+        {
+            if (execute == null)
+            {
+                throw new ArgumentNullException(nameof(execute));
+            }
+
+            try
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                bool executeResult = execute();
+                EnsureExecutionSucceeded(algorithmName, executeResult);
+
+                string message = $"CommonVisionAlgorithmService: algorithm {algorithmName} completed.";
+                message.LogInfo();
+                return Task.FromResult(VisionProcessResult.Success());
+            }
+            catch (OperationCanceledException ex)
+            {
+                string message = $"CommonVisionAlgorithmService: algorithm {algorithmName} was cancelled.";
+                message.LogInfo();
+                return Task.FromResult(VisionProcessResult.Failure(
+                    VisionFailureCategory.Cancelled,
+                    VisionErrorCode.OperationCancelled,
+                    null,
+                    MessageKey.VisionOperationCancelled,
+                    message,
+                    ex));
+            }
+            catch (Exception ex)
+            {
+                string message = $"CommonVisionAlgorithmService: algorithm {algorithmName} failed. {ex.Message}";
+                message.LogSysError();
+                return Task.FromResult(VisionProcessResult.Failure(
+                    VisionFailureCategory.Algorithm,
+                    VisionErrorCode.CommonAlgorithmExecutionFailed,
+                    VisionAlarmIds.CommonAlgorithmExecutionFailed,
+                    MessageKey.VisionCommonAlgorithmExecutionFailed,
+                    message,
+                    ex));
+            }
+        }
+
+        private static Task<VisionProcessResult<TData>> ExecuteDataAlgorithmAsync<TData>(
+            string algorithmName,
+            Func<TData> execute,
+            CancellationToken cancellationToken)
+        {
+            if (execute == null)
+            {
+                throw new ArgumentNullException(nameof(execute));
+            }
+
+            try
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                TData result = execute();
+                string message = $"CommonVisionAlgorithmService: algorithm {algorithmName} completed.";
+                message.LogInfo();
+                return Task.FromResult(VisionProcessResult<TData>.Success(result));
+            }
+            catch (OperationCanceledException ex)
+            {
+                string message = $"CommonVisionAlgorithmService: algorithm {algorithmName} was cancelled.";
+                message.LogInfo();
+                return Task.FromResult(VisionProcessResult<TData>.Failure(
+                    VisionFailureCategory.Cancelled,
+                    VisionErrorCode.OperationCancelled,
+                    null,
+                    MessageKey.VisionOperationCancelled,
+                    message,
+                    ex));
+            }
+            catch (Exception ex)
+            {
+                string message = $"CommonVisionAlgorithmService: algorithm {algorithmName} failed. {ex.Message}";
+                message.LogSysError();
+                return Task.FromResult(VisionProcessResult<TData>.Failure(
+                    VisionFailureCategory.Algorithm,
+                    VisionErrorCode.CommonAlgorithmExecutionFailed,
+                    VisionAlarmIds.CommonAlgorithmExecutionFailed,
+                    MessageKey.VisionCommonAlgorithmExecutionFailed,
+                    message,
+                    ex));
+            }
+        }
+
+        private static void EnsureExecutionSucceeded(string algorithmName, bool executeResult)
+        {
+            if (!executeResult)
+            {
+                throw new InvalidOperationException($"CommonVisionAlgorithmService: algorithm {algorithmName} returned false.");
+            }
+        }
+    }
+}
--- a/new/PanGu.DieBonderApp/MainShell/Vision/CommonAlgorithm/ICommonVisionAlgorithmService.cs
+++ b/new/PanGu.DieBonderApp/MainShell/Vision/CommonAlgorithm/ICommonVisionAlgorithmService.cs
@@ -0,0 +1,83 @@
+using MwFramework.Device.Model;
+using SemiconductorVisionAlgorithm.SemiParams;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jm1RecheckDiePoint = JM1.JM1Params.RecheckDiePoint;
+using SemiPoint = SemiconductorVisionAlgorithm.SemiParams.Point;
+
+namespace MainShell.Vision
+{
+    /// <summary>
+    /// 通用视觉算法服务接口。
+    /// </summary>
+    public interface ICommonVisionAlgorithmService
+    {
+        Task<VisionProcessResult> GenWaferMapXAsync(
+            string fileDirectory,
+            double[] edgePtRow,
+            double[] edgePtCol,
+            double[] edgePtAngle,
+            double[] inPtRow,
+            double[] inPtCol,
+            double[] inPtAngle,
+            double upThresholdAngle,
+            double upRowDistance,
+            double upColDistance,
+            int upRowNumber,
+            int upColNumber,
+            double firstPosRow,
+            double firstPosCol,
+            double distanceThreshold,
+            double angleThreshold,
+            double rotateAngle,
+            CancellationToken cancellationToken = default(CancellationToken));
+
+        Task<VisionProcessResult> RecheckPosRgbAsync(
+            List<Jm1RecheckDiePoint> edgeDiePoints,
+            List<Jm1RecheckDiePoint> inDiePoints,
+            double threshold,
+            List<Jm1RecheckDiePoint> existingPoints,
+            RecheckDieMap padPos,
+            double diePitch,
+            int rowNumber,
+            int colNumber,
+            CancellationToken cancellationToken = default(CancellationToken));
+
+        Task<VisionProcessResult> ClearRecheckDiePosAsync(
+            CancellationToken cancellationToken = default(CancellationToken));
+
+        Task<VisionProcessResult> ClearMapAsync(
+            int flag,
+            CancellationToken cancellationToken = default(CancellationToken));
+
+        Task<VisionProcessResult<(RecheckDieMap UpMap, List<Jm1RecheckDiePoint> PatchPos, List<Jm1RecheckDiePoint> ExceptPos)>> GetMapAsync(
+            CancellationToken cancellationToken = default(CancellationToken));
+
+        Task<VisionProcessResult<(RecheckDieMap Map, List<Jm1RecheckDiePoint> ExposedPoints)>> GetRecheckDiePosAsync(
+            CancellationToken cancellationToken = default(CancellationToken));
+
+        Task<VisionProcessResult> CalProductAffineAsync(
+            List<SemiPoint> sourcePoints,
+            List<SemiPoint> targetPoints,
+            CancellationToken cancellationToken = default(CancellationToken));
+
+        Task<VisionProcessResult<double>> CalculateLineAngleAsync(
+            SemiPoint point1,
+            SemiPoint point2,
+            CancellationToken cancellationToken = default(CancellationToken));
+
+        Task<VisionProcessResult> SetWorkAreaAsync(
+            string fileDirectory,
+            double heightY,
+            double widthX,
+            CancellationToken cancellationToken = default(CancellationToken));
+
+        Task<VisionProcessResult> SetDirectionAsync(
+            string fileDirectory,
+            int xDirection,
+            int yDirection,
+            CancellationToken cancellationToken = default(CancellationToken));
+
+    }
+}
--- a/new/PanGu.DieBonderApp/MainShell/Vision/CommonAlgorithm/RecheckDieMap.cs
+++ b/new/PanGu.DieBonderApp/MainShell/Vision/CommonAlgorithm/RecheckDieMap.cs
@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+using Jm1RecheckDiePoint = JM1.JM1Params.RecheckDiePoint;
+
+namespace MainShell.Vision
+{
+    /// <summary>
+    /// 复检 Die Map。
+    /// </summary>
+    public class RecheckDieMap : Dictionary<int, Dictionary<int, Jm1RecheckDiePoint>>
+    {
+        public RecheckDieMap()
+        {
+        }
+
+        public RecheckDieMap(IDictionary<int, Dictionary<int, Jm1RecheckDiePoint>> source)
+            : base(source ?? new Dictionary<int, Dictionary<int, Jm1RecheckDiePoint>>())
+        {
+        }
+    }
+}