DHDHSoftware/DHSoftware/MainWindow.cs

using AntdUI;
using AntdUI.Svg;
using DH.Devices.Camera;
using DH.Devices.PLC;
using DH.Devices.Vision;
using DHSoftware.Languages;
using DHSoftware.Models;
using DHSoftware.Utils;
using DVPCameraType;
using Microsoft.Win32;
using OpenCvSharp;
using System;
using System.CodeDom;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using System.Windows.Forms;
using static AntdUI.Math3D;
using Camera = DHSoftware.Models.Camera;

namespace DHSoftware
{



    public partial class MainWindow : AntdUI.Window
    {
        private UserControl currControl;
        private bool isUpdatingTabs = false;//用于阻止Tabs更新
        private bool isLight = true;
        // 定义一个语言切换事件
        public event EventHandler LanguageChanged;


        private System.Windows.Forms.Timer refreshTimer;
        private int testCounter = 1;

        Dictionary<string, List<string>> _cameraRelatedDetectionDict = null;
        public MainWindow()
        {
            InitializeComponent();
            refreshTimer = new System.Windows.Forms.Timer();
            refreshTimer.Interval = 1000; // 1秒间隔
            refreshTimer.Tick += RefreshTimer_Tick;
            //refreshTimer.Start();
            //初始化数据
            InitData();
            //绑定事件
            BindEventHandler();
            tabImgDisplay.Pages.Clear();
            List<Camera> Cameras = new List<Camera>
        {
            new Camera
            {
                DeviceName = "Cam1",
                Alias = "相机1",
                ImagePath = @"D:\1.jpeg"
            },
            new Camera
            {
              DeviceName = "Cam2",
                Alias = "相机2",
                ImagePath = @"D:\2.jpeg"
            },
            new Camera
            {
               DeviceName = "Cam3",
                Alias = "相机3",
                ImagePath = @"D:\3.jpeg"
            },
            new Camera
            {
               DeviceName = "Cam4",
                Alias = "相机4",
                ImagePath = @"D:\4.jpeg"
            },
            new Camera
            {
                DeviceName = "Cam5",
                Alias = "相机5",
                ImagePath = @"D:\5.jpeg"
            }
        };

            if (Cameras.Count > 0)
            {
                tabImgDisplay.Controls.Clear();
                foreach (var cam in Cameras)
                {
                    AntdUI.TabPage tabPage = new AntdUI.TabPage();
                    tabPage.Name = $"tab{cam.DeviceName}";
                    tabPage.Text = cam.Alias;
                    //ImgDisplayControl imgDisplayControl = new ImgDisplayControl();
                    //imgDisplayControl.Name = $"img{cam.DeviceName}";
                    //imgDisplayControl.Dock = DockStyle.Fill;
                    //tabPage.Controls.Add(imgDisplayControl);
                    PictureBox pictureBox = new PictureBox();
                    pictureBox.Name = $"pic{cam.DeviceName}";
                    pictureBox.Dock = DockStyle.Fill;
                    pictureBox.SizeMode = PictureBoxSizeMode.Zoom;
                    tabPage.Controls.Add(pictureBox);
                    tabImgDisplay.Pages.Add(tabPage);

                }

            }
        }

        private void RefreshTimer_Tick(object sender, EventArgs e)
        {
            // 获取相机1的控件（通过控件名称查找）
            var targetControl = FindControlRecursive(tabImgDisplay, "picCam1") as PictureBox;

            if (targetControl != null)
            {
                // 生成测试路径（示例路径）
                string testPath = $@"D:\{testCounter}.png"; // 循环1-5的图片
                testCounter++;

                // 加载并显示图片
                targetControl.Image = Image.FromFile(testPath);
                if (testCounter == 5)
                {
                    testCounter = 1;
                }
                targetControl.Parent.Invalidate();
            }
        }
        // 递归查找控件的方法
        private Control FindControlRecursive(Control parent, string name)
        {
            if (parent.Name == name) return parent;

            foreach (Control child in parent.Controls)
            {
                var found = FindControlRecursive(child, name);
                if (found != null) return found;
            }
            return null;
        }
        // 触发事件
        protected virtual void OnLanguageChanged(EventArgs e)
        {
            LanguageChanged?.Invoke(this, e);
        }

        private void InitData()
        {

            //根据系统亮暗初始化一次
            isLight = ThemeHelper.IsLightMode();
            button_color.Toggle = !isLight;
            ThemeHelper.SetColorMode(this, isLight);
            //初始化消息弹出位置
            Config.ShowInWindow = true;





        }

        private void BindEventHandler()
        {
            buttonSZ.Click += ButtonSZ_Click;
            button_color.Click += Button_color_Click;




            //监听系统深浅色变化
            SystemEvents.UserPreferenceChanged += SystemEvents_UserPreferenceChanged;
        }








        private void SystemEvents_UserPreferenceChanged(object sender, UserPreferenceChangedEventArgs e)
        {
            if (e.Category == UserPreferenceCategory.General)
            {
                isLight = ThemeHelper.IsLightMode();
                button_color.Toggle = !isLight;
                ThemeHelper.SetColorMode(this, isLight);
            }
        }

        private void Button_color_Click(object sender, EventArgs e)
        {
            isLight = !isLight;
            //这里使用了Toggle属性切换图标
            button_color.Toggle = !isLight;
            ThemeHelper.SetColorMode(this, isLight);
        }

        private void ButtonSZ_Click(object sender, EventArgs e)
        {

        }





        public List<Do3ThinkCamera> Cameras { get; } = new List<Do3ThinkCamera>();
        public Dictionary<string, SimboObjectDetection> Dectection { get; } = new Dictionary<string, SimboObjectDetection>();
        public XinJEPLCTcpNet PLC { get; } = new XinJEPLCTcpNet();
        private void MainWindow_Load(object sender, EventArgs e)
        {

        }

        private void MainWindow_FormClosed(object sender, FormClosedEventArgs e)
        {
            foreach (var camera in Cameras)
            {
                camera.CameraDisConnect();
            }

            PLC.PLCDisConnect();
        }

        private void segmented1_SelectIndexChanged(object sender, EventArgs e)
        {
            // Get the index of the selected item
            int selectedIndex = segmented1.SelectIndex;

            // Handle each button based on its index
            switch (selectedIndex)
            {
                case 0: // "启动" (Start)
                    HandleStartButton();
                    break;
                case 1: // "停止" (Stop)
                    HandleStopButton();
                    break;
                case 2: // "复位" (Reset)
                    HandleResetButton();
                    break;
                case 3: // "设置" (Settings)
                    HandleSettingsButton();
                    break;
                case 4: // "登录" (Login)
                    HandleLoginButton();
                    break;
                default:
                    break;
            }
        }
        public bool CurrentMachine = false;
        public volatile int ProductNum_Total = 0;
        public volatile int ProductNum_OK = 0;
        private readonly object _cameraSummaryLock = new object();
        List<DetectionConfig> detectionList = new List<DetectionConfig>();
        public List<RecongnitionLabel> RecongnitionLabelList { get; set; } = new List<RecongnitionLabel>();
        public DateTime sraerttime;
        private void HandleStartButton()
        {
            CurrentMachine = true;
            //[Category("深度学习检测配置")]
            //[DisplayName("检测标签定义集合")]
            //[Description("定义检测标签的集合，例如：Seg/Detection模式：断裂、油污、划伤...；Class模式：ok、ng、上面、下面、套环、正常...")]
            //[TypeConverter(typeof(CollectionCountConvert))]
            //[Editor(typeof(ComplexCollectionEditor<RecongnitionLabel>), typeof(UITypeEditor))]
            RecongnitionLabel recongnition=new RecongnitionLabel
            {
                LabelName="youwu",
                LabelDescription="油污",
                LabelCategory="A_NG"
            };
            RecongnitionLabel recongnition2 = new RecongnitionLabel
            {
                LabelName = "youwu",
                LabelDescription = "油污",
                LabelCategory = "A_NG"
            };
            RecongnitionLabel recongnition3 = new RecongnitionLabel
            {
                LabelName = "youwu",
                LabelDescription = "油污",
                LabelCategory = "A_NG"
            };
            RecongnitionLabelList.Add(recongnition);
            RecongnitionLabelList.Add(recongnition2);
            RecongnitionLabelList.Add(recongnition3);



            var det1 = new DetectionConfig("相机1", MLModelType.ObjectDetection, @"D:\DHSoftware\DHSoftware\Models\yolov3.cfg", false, "Cam1");
            var det2 = new DetectionConfig("相机2", MLModelType.ObjectDetection, @"D:\DHSoftware\DHSoftware\Models\yolov3.cfg", false, "Cam2");
            var det3 = new DetectionConfig("相机3", MLModelType.ObjectDetection, @"D:\DHSoftware\DHSoftware\Models\yolov3.cfg", false, "Cam3");
            var det4 = new DetectionConfig("相机4", MLModelType.ObjectDetection, @"D:\DHSoftware\DHSoftware\Models\yolov3.cfg", false, "Cam4");
            List<RelatedCamera> CameraCollects=new List<RelatedCamera>();
            CameraCollects.Add(new RelatedCamera("Cam1"));
            List<RelatedCamera> CameraCollects2 = new List<RelatedCamera>();
            CameraCollects2.Add(new RelatedCamera("Cam2"));
            List<RelatedCamera> CameraCollects3 = new List<RelatedCamera>();
            CameraCollects3.Add(new RelatedCamera("Cam3"));
            List<RelatedCamera> CameraCollects4 = new List<RelatedCamera>();
            CameraCollects4.Add(new RelatedCamera("Cam4"));
            List<RelatedCamera> CameraCollects5 = new List<RelatedCamera>();
            CameraCollects5.Add(new RelatedCamera("Cam5"));
            float Conf = 0.5f;
            det1.CameraCollects = CameraCollects;
            det1.ModelconfThreshold = Conf;
            det1.ModelWidth = 640;
            det1.ModelHeight = 640;
            det1.in_lable_path = " D:\\PROJECTS\\MaodingTest1\\Vision\\cam1.txt";


            det2.CameraCollects = CameraCollects2;
            det2.ModelconfThreshold = Conf;
            det2.ModelWidth = 640;
            det2.ModelHeight = 640;
            det2.in_lable_path = " D:\\PROJECTS\\MaodingTest1\\Vision\\cam2.txt";

            det3.CameraCollects = CameraCollects3;
            det3.ModelconfThreshold = Conf;
            det3.ModelWidth = 640;
            det3.ModelHeight = 640;
            det3.in_lable_path = " D:\\PROJECTS\\MaodingTest1\\Vision\\cam3.txt";

            det4.CameraCollects = CameraCollects4;
            det4.ModelconfThreshold = Conf;
            det4.ModelWidth = 640;
            det4.ModelHeight = 640;
            det4.in_lable_path = " D:\\PROJECTS\\MaodingTest1\\Vision\\cam4.txt";

            detectionList.Add(det1);
            detectionList.Add(det2);
            detectionList.Add(det3);
            detectionList.Add(det4);
            Cameras.Clear();
            Dectection.Clear();
            _cameraRelatedDetectionDict = new();
           

            detectionList.ForEach(detection =>
            {

                 detection.CameraCollects.ForEach(cam =>
                {
                    List<string> Dets = new List<string>
                    {
                        detection.Id
                    };
                    if (!_cameraRelatedDetectionDict.ContainsKey(cam.CameraSourceId))
                    {
                        _cameraRelatedDetectionDict.Add(cam.CameraSourceId, Dets);
                    }
                    else
                    {
                        _cameraRelatedDetectionDict[cam.CameraSourceId].Add(detection.Id);
                    }


                }
                );
            });
          
            //Add the code for the "启动" button click here
            Do3ThinkCamera do3ThinkCamera1 = new Do3ThinkCamera();
         
            do3ThinkCamera1.dvpStreamFormat = dvpStreamFormat.S_MONO8;
            do3ThinkCamera1.CameraName = "Cam1";
            Do3ThinkCamera do3ThinkCamera2 = new Do3ThinkCamera();

            do3ThinkCamera2.dvpStreamFormat = dvpStreamFormat.S_RGB24;
            do3ThinkCamera2.CameraName = "Cam2";
            Cameras.Add(do3ThinkCamera1);
            Cameras.Add(do3ThinkCamera2);
            do3ThinkCamera1.CameraConnect();
            do3ThinkCamera2.CameraConnect();
            do3ThinkCamera1.OnHImageOutput += OnCameraHImageOutput;
            do3ThinkCamera2.OnHImageOutput += OnCameraHImageOutput;
            var simbo1 = new SimboObjectDetection();
            MLInit mLInit;
            string inferenceDevice = "CPU";

            mLInit = new MLInit($"D:\\PROJECTS\\MaodingTest1\\Vision\\cam1.onnx", "images", inferenceDevice, 640, 640);


            simbo1.Load(mLInit);
           

            Dectection.Add(det1.Id, simbo1);

            var simbo2 = new SimboObjectDetection();
            MLInit mLInit2;
            string inferenceDevice2 = "CPU";

            mLInit2 = new MLInit($"D:\\PROJECTS\\MaodingTest1\\Vision\\cam2.onnx", "images", inferenceDevice2, 640, 640);


            simbo2.Load(mLInit2);
           
            Dectection.Add(det2.Id, simbo2);

            PLC.IP = "192.168.6.6";
            PLC.Port = 502;
            PLC.PLCConnect();
            PLC.OnNewPieces -= MainMotion_NewPieces;
            PLC.OnNewPieces += MainMotion_NewPieces;
            ProductBaseCount = 2;
            for (int i = 0; i < ProductBaseCount * ProductListMulti; i++)
            {
                ConcurrentDictionary<uint, ProductData> products = new ConcurrentDictionary<uint, ProductData>();
                _productLists.Add(products);
            }
            sraerttime=DateTime.Now;
        }
        private uint PieceCount = 0;
        private List<ConcurrentDictionary<uint, ProductData>> _productLists = new List<ConcurrentDictionary<uint, ProductData>>();
        private int ProductListMulti = 2;
        private int ProductBaseCount = 0;
        private int PieceNumberToIndex(uint pn)
        {
            // 物料编号，取余 集合数量
            //int multiple = (int)(pn / ProductBaseCount) % 2;
            //int offset = (int)(pn % ProductBaseCount);
            //int ret = (ProductBaseCount * multiple) + offset;

            //int ret = (int)(pn % ProductBaseCount);
            int ret = (int)(pn % (ProductBaseCount * ProductListMulti));
            return ret;
        }
        DateTime _ctTime = DateTime.Now;
        public async void MainMotion_NewPieces(int axisIndex, uint pieceNumber)
        {
            //if (MachineState != MachineState.Running && MachineState != MachineState.Warning)
            //{
            //    return;
            //}


            PieceCount++;

          
            int index = PieceNumberToIndex(pieceNumber);
            // productDatas.Add(pData);
            //转盘2 的物料是不是重新覆盖之前的pDta
            if (axisIndex == 1)
            {
                ProductData pData = new ProductData("", pieceNumber, ProductBaseCount);
                _productLists[index][pieceNumber] = pData;
            }
           string logStr = $"时间：{DateTime.Now} 轴{axisIndex}新产品{pieceNumber}加入队列{index}----入料计数{PieceCount}\n";
            Task.Run(() => {
                this.BeginInvoke(new MethodInvoker(delegate () { richTextBox1.AppendText(logStr); }));

            });
            DateTime dtNow = DateTime.Now;
            UpdateCT(null, (float)(dtNow - _ctTime).TotalSeconds);
            _ctTime = dtNow;


        }
        public async Task UpdateCT(object objData, float ctTime)
        {
            await Task.Run(() =>
            {
               //OnUpdateCT?.Invoke(objData, ctTime);
            });
        }
        private void OnCameraHImageOutput(DateTime dt, CameraBase camera, Mat imageSet)
        {
            // 获取该相机的拍照计数
            uint productNumber = (uint)camera.SnapshotCount;

            Task.Run(async () =>
            {
                using (Mat localImageSet = imageSet.Clone())  // 复制 Mat 避免并发问题
                {
                    // 拍照计数与物件编号一致，查找对应的产品
                    ProductData product = null;
                    //内外壁模组多个相机的处理方法
                    //计算队列的方法不变
                    int index = PieceNumberToIndex(productNumber);
                    // 找到产品存放在哪个队列里
                    ConcurrentDictionary<uint, ProductData> tmpDic = _productLists[index];

                    try
                    {
                        int retryTimes = 100;
                        while (product == null && retryTimes > 0)
                        {
                            if (tmpDic.ContainsKey(productNumber))
                            {
                                product = tmpDic[productNumber];
                            }
                            else
                            {
                                Thread.Sleep(20);
                            }
                            retryTimes--;
                        }
                        // 如果产品为空，则销毁图片，提示错误
                        if (null == product)
                        {
                            List<uint> pnList = tmpDic.Keys.ToList();

                            string pnStr = "";
                            if (pnList != null && pnList.Count > 0)
                            {
                                pnStr = string.Join(",", pnList);
                            }

                            //LogAsync(DateTime.Now, LogLevel.Error, $"{camera.Name} 未找到产品，编号：{productNumber}，队列{index}数量：{tmpDic.Count}，列表：{pnStr}");
                            localImageSet.Dispose();
                            return;
                        }

                        // LogAsync(DateTime.Now, LogLevel.Information, $"{camera.Name} 找到产品{productNumber}，队列{index}数量：{tmpDic.Count}");

                        if (!_cameraRelatedDetectionDict.ContainsKey(camera.CameraName))
                        {

                            localImageSet.Dispose();
                            //  LogAsync(DateTime.Now, LogLevel.Warning, $"{camera.Name} 找到产品{productNumber}，但是没有推理1");

                            return;
                        }


                        double totalTime = 0.0;
                        List<ResultState> resultStates = new List<ResultState>();
                        List<string>? detectionDict = _cameraRelatedDetectionDict[camera.CameraName];
                    

                        for (int i = 0; i < detectionDict.Count; i++)
                        {
                            string detectionId = detectionDict[i];
                            try
                            {
                                DetectionConfig detectConfig = null;
                                //找到对应的配置
                                if (!string.IsNullOrWhiteSpace(detectionId))
                                {
                                    detectConfig = detectionList.FirstOrDefault(u => u.Id == detectionId);
                                }
                                else
                                {
                                    detectConfig = detectionList.FirstOrDefault(u => u.CameraSourceId == camera.CameraName);
                                }

                                if (detectConfig == null)
                                {

                                    //未能获得检测配置
                                    return;
                                }


                                #region 1.预处理
                                #endregion
                                #region 2.深度学习推理
                                var req = new MLRequest();

                                req.mImage = localImageSet.Clone();
                                //req.ResizeWidth = detectConfig.ModelWidth;
                                //req.ResizeHeight = detectConfig.ModelHeight;
                                //req.confThreshold = detectConfig.ModelconfThreshold;
                                //req.iouThreshold = 0.3f;
                                //req.out_node_name = detectConfig.ModeloutNodeName;
                                //req.in_lable_path = detectConfig.in_lable_path;
                                req.ResizeWidth = 640;
                                req.ResizeHeight = 640;
                                req.confThreshold = 0.5f;
                                req.iouThreshold = 0.3f;
                                req.out_node_name = "output0";
                                req.in_lable_path = "D:\\PROJECTS\\MaodingTest1\\Vision\\cam1.txt";
                                //req.LabelNames = dc.GetLabelNames();

                                //HOperatorSet.WriteImage(req.HImage, "png", 0, @"D:\\666.png");
                                Stopwatch
                            sw = new Stopwatch();
                                sw.Start();


                                var result = Dectection[detectionId].RunInference(req);
                                sw.Stop();
                                //LogAsync(DateTime.Now, LogLevel.Information, $"{camera.Name} 推理进度1.1，产品{productNumber}，耗时{sw.ElapsedMilliseconds}ms");
                                #endregion
                                this.BeginInvoke(new MethodInvoker(delegate ()
                                {
                                    if (pictureBox1.Image != null)
                                    {
                                        pictureBox1.Image.Dispose();  // 释放旧图像
                                    }
                                    pictureBox1.Image = result.ResultMap;
                                    richTextBox1.AppendText($"推理成功 {productNumber}, {result.IsSuccess} 耗时 {sw.ElapsedMilliseconds}ms\n");
                                }));
                                req.mImage.Dispose();
#if true

                                #region 3.后处理
                                DetectStationResult detectResult = new DetectStationResult();
                                if (result == null || (result != null && !result.IsSuccess))
                                {
                                    detectResult.IsMLDetectDone = false;
                                }
                                if (result != null && result.IsSuccess)
                                {
                                    detectResult.DetectDetails = result.ResultDetails;
                                    if (detectResult.DetectDetails != null)
                                    {
                                    }
                                    else
                                    {
                                        detectResult.IsMLDetectDone = false;
                                    }
                                }

                                #endregion
                                #region 3.后处理
                                #endregion
                                //根据那些得分大于阈值的推理结果，判断产品是否成功
                                #region 4.最终过滤（逻辑过滤）
                                detectResult.DetectDetails?.ForEach(d =>
                                {


                                    //当前检测项的 过滤条件
                                    //var conditionList = detectConfig.DetectionFilterList
                                    //    .Where(u => u.IsEnabled && u.LabelName == d.LabelName)
                                    //    .GroupBy(u => u.ResultState)
                                    //    .OrderBy(u => u.Key)
                                    //    .ToList();
                                    //当前检测项的 过滤条件
                                    var conditionList = detectConfig.DetectionFilterList
                                        .Where(u => u.IsEnabled && u.LabelName == d.LabelName)
                                        .GroupBy(u => u.ResultState)
                                        .OrderBy(u => u.Key)
                                        .ToList();

                                    if (conditionList.Count == 0)
                                    {

                                        if (d.LabelName.ToLower() == "ok")
                                        {
                                            d.FinalResult = d.InferenceResult = ResultState.OK;
                                        }
                                        else
                                        {
                                            d.FinalResult = d.InferenceResult = ResultState.DetectNG;
                                        }
                                    }
                                    else
                                    {
                                        if (detectConfig.IsMixModel)
                                        {
                                            d.FinalResult = d.InferenceResult = ResultState.A_NG;
                                        }
                                        else
                                        {
                                            //将所有已将筛选出来的缺陷进行过滤
                                            d.FinalResult = d.InferenceResult = ResultState.OK;
                                        }


                                    }


                                    foreach (IGrouping<ResultState, DetectionFilter> group in conditionList)
                                    {
                                        bool b = group.ToList().Any(f =>
                                        {
                                            return f.FilterOperation(d);
                                        });


                                        if (b)
                                        {
                                            d.FinalResult = group.Key;
                                            break;
                                        }
                                        //else 
                                        //{
                                        //    d.FinalResult = d.InferenceResult = ResultState.OK;
                                        //}
                                    }
                                });
                                #endregion
                                #region 5.统计缺陷过滤结果或预处理直接NG
                                if (detectResult.DetectDetails?.Count > 0)
                                {
                                    detectResult.ResultState = detectResult.DetectDetails.GroupBy(u => u.FinalResult).OrderBy(u => u.Key).First().First().FinalResult;
                                    detectResult.ResultLabel = detectResult.ResultLabel;
                                    detectResult.ResultLabelCategoryId = detectResult.ResultLabel;//TODO:设置优先级
                                                                                                  //////根据优先级设置ResultLabel
                                                                                                  //if (detectionLabels.Count > 0)
                                                                                                  //{
                                                                                                  //    foreach (var l in detectionLabels)
                                                                                                  //    {
                                                                                                  //        var isExist = DetectDetails.Any(o => NormalizeAndClean(o.LabelName) == NormalizeAndClean(l.LabelName) && o.FinalResult == ResultState.DetectNG);
                                                                                                  //        if (isExist)
                                                                                                  //        {

                                    //            ResultLabelCategoryId = l.LabelCategoryId;
                                    //            break;
                                    //        }
                                    //    }
                                    //}

                                    return;
                                }
                                #endregion
                                resultStates.Add(detectResult.ResultState);

                                product.ResultCollection.Add(detectResult);



#endif



                                //DetectStationResult temp;
                                ////LogAsync(DateTime.Now, LogLevel.Information, $"{camera.Name} 推理进度1.4，产品{productNumber}");
                                //// 检测结果
                                //if (temp != null)
                                //{
                                //  //  LogAsync(DateTime.Now, LogLevel.Information, $"{camera.Name} 推理进度1.5，产品{productNumber}");
                                //    //var totalElapsed = (temp.EndTime - temp.VisionImageSet.ImageTime).TotalMilliseconds;
                                //    //totalTime += totalElapsed;
                                //    resultStates.Add(temp.ResultState);

                                //    product.ResultCollection.Add(temp);
                                //   // LogAsync(DateTime.Now, LogLevel.Information, $"{camera.Name} 推理进度1.6，产品{productNumber}");
                                //}
                                //else
                                //{
                                //    //LogAsync(DateTime.Now, LogLevel.Information, $"{camera.Name} 检测失败，物料编号：{productNumber}，检测项：{d}");
                                //}

                                //  imageSet.Dispose();
                            }
                            catch (Exception ex)
                            {
                                //  LogAsync(DateTime.Now, LogLevel.Information, $"{camera.Name} 推理异常，物料编号：{productNumber}，检测项：{d}, {ex.GetExceptionMessage}");
                            }
                        }

                        //detectionDict.ForEach(d =>
                        //{

                        //});

                        // LogAsync(DateTime.Now, LogLevel.Information, $"{camera.Name} 推理进度2，产品{productNumber}");


                        imageSet.Dispose();
                        product.InferenceOne(() =>
                        {
                            ;
                        }, () =>
                        {
                            ;
                        });

                        // LogAsync(DateTime.Now, LogLevel.Information, $"{camera.Name} 推理完成，产品{productNumber}");

                        if (!product.InferenceFinished())
                        {

                            return;
                        }
                        ProductNum_Total++;
                        CalculateOEE();
                        this.BeginInvoke(new MethodInvoker(delegate ()
                        {

                            int currentScrollPosition = richTextBox1.GetPositionFromCharIndex(richTextBox1.TextLength).Y;

                            richTextBox1.AppendText($"统计结果成功，{productNumber}吹气！\n");

                            // 设置回原来的滚动位置
                            richTextBox1.SelectionStart = richTextBox1.TextLength;
                            richTextBox1.ScrollToCaret();
                        }));
                        #region 6.统计产品结果
                        if (product.ResultCollection.Any(u => u.ResultState != ResultState.OK))
                        {
                            //检测结果TBD
                            //  CurTrigger = TriggerSettings.FirstOrDefault(u => u.TriggerType == TriggerType.B_NG);
                            product.ProductResult = ResultState.B_NG;
                            product.ProductLabelCategory = ResultState.B_NG.GetEnumDescription();
                            product.ProductLabel = ResultState.B_NG.GetEnumDescription();


                        }
                        else
                        {
                            // CurTrigger = TriggerSettings.FirstOrDefault(u => u.TriggerType == TriggerType.OK);
                            product.ProductResult = ResultState.OK;
                            product.ProductLabelCategory = ResultState.OK.GetEnumDescription();
                            product.ProductLabel = ResultState.OK.GetEnumDescription();
                        }
                        #endregion
                        #region 7.产品吹气

                        #endregion



                        //LogAsync(DateTime.Now, LogLevel.Information, $"推理完成，产品{product.PieceNumber}获取结果");

                        // 统计产品结果
                        //Task resultTask = product.SetProductResult(_totalDetectionNum, X017Config.IsTBDPriority, labelCategoryLists);

                        //await resultTask.ContinueWith(t =>
                        //{
                        //    try
                        //    {
                        //        UpdateTriggerCount(DateTime.Now, "获取结果");
                        //        UpdateResult(DateTime.Now, camera, product.ProductResult.GetEnumDescription());
                        //        UpdateResultNew(DateTime.Now, camera, "合计");
                        //        LogAsync(DateTime.Now, LogLevel.Information, $"产品{product.PieceNumber}获取结果：{product.ProductResult} {(product.IsA2B ? "产品IsA2B" : "")}");

                        //    }
                        //    catch (Exception ex)
                        //    {
                        //        LogAsync(DateTime.Now, LogLevel.Information, $"产品{product.PieceNumber}获取结果异常：{product.ProductResult} {(product.IsA2B ? "产品IsA2B" : "")}，" +
                        //            $"异常信息：{ex.GetExceptionMessage}");

                        //    }

                        //    // 吹气 
                        //    DateTime dtNow = DateTime.Now;
                        //    product.BlowOutTime = dtNow;


                        //    var setting = X017Config.ProductBlowSettings.FirstOrDefault(s => product.ProductResult.Equals(s.ProductResult));

                        //    if (setting != null)
                        //    {
                        //        uint NGNumC = 0;
                        //        uint OKNumC = 0;

                        //        CMCDLL_NET.MCF_Sorting_Get_Lose_Blow_NG_Count_Net(ref NGNumC, 0);
                        //        CMCDLL_NET.MCF_Sorting_Get_Lose_Blow_OK_Count_Net(ref OKNumC, 0);
                        //        _mainMotion.Blow(product.PieceNumber, setting.BindBlow);
                        //        LogAsync(DateTime.Now, LogLevel.Action, $"产品{product.PieceNumber}吹气{NGNumC}+ {OKNumC}");
                        //        //if (product.ProductResult == ResultState.OK)
                        //        //{
                        //        //    //OKProcessNum++;
                        //        //    OKNum++;
                        //        //}
                        //    }

                        //    //判断超时出队    
                        //    foreach (var kvp in tmpDic)
                        //    {
                        //        try
                        //        {
                        //            ProductData dataN = kvp.Value;
                        //            TimeSpan timeDifference = DateTime.Now - dataN.CreateTime;
                        //            if (timeDifference.TotalMinutes >= 1)
                        //            {

                        //                //出队
                        //                bool isremoved = tmpDic.TryRemove(kvp.Key, out _);
                        //                if (isremoved)
                        //                {
                        //                    LogAsync(DateTime.Now, LogLevel.Error, $"====产品{kvp.Key}超时出列成功" +
                        //                   $"产品结果：{dataN.ProductResult.GetEnumDescription()} {dataN.ProductResult}，" +
                        //                   $"当前队列产品数量：{tmpDic.Count}====");

                        //                    try
                        //                    {
                        //                        //重新生成实例 销毁之前的实例
                        //                        var saveData = dataN.GetProductData();
                        //                        var productDefects = dataN.GetDetectDetailData();
                        //                        SaveProductDataAsync(saveData, productDefects);
                        //                        dataN = null;
                        //                    }
                        //                    catch (Exception) { }

                        //                    dataN?.Dispose();
                        //                }
                        //                else
                        //                {
                        //                    LogAsync(DateTime.Now, LogLevel.Error, $"=====产品{kvp.Key}超时出列失败" +
                        //                    $"当前队列产品数量：{tmpDic.Count}=====");
                        //                }
                        //            }
                        //        }
                        //        catch (Exception ex)
                        //        {
                        //            LogAsync(DateTime.Now, LogLevel.Error, $"=====产品{kvp.Key}超时出列失败" +
                        //                    $"当前队列产品数量：{tmpDic.Count}====={ex.GetExceptionMessage}");
                        //        }
                        //    }



                        // 出列  
                        ProductData temp = null;

                        int tryTimes = 5;
                        while (temp == null && tryTimes > 0)
                        {
                            var isSuccess = tmpDic.Remove(productNumber, out temp);

                            if (isSuccess)
                            {
                                string logStr = $"{DateTime.Now}产品{productNumber}出列成功：{isSuccess}，" +
                               $"产品结果：{temp.ProductResult.GetEnumDescription()}，" +
                               $"当前队列产品数量：{tmpDic.Count}";
                                this.BeginInvoke(new MethodInvoker(delegate ()
                                {

                                    int currentScrollPosition = richTextBox1.GetPositionFromCharIndex(richTextBox1.TextLength).Y;

                                    richTextBox1.AppendText(logStr);

                                    // 设置回原来的滚动位置
                                    richTextBox1.SelectionStart = richTextBox1.TextLength;
                                    richTextBox1.ScrollToCaret();
                                }));
                            }
                            tryTimes--;
                            Thread.Sleep(1);
                        }
                        if (temp == null)
                        {
                            //LogAsync(DateTime.Now, LogLevel.Assist, $"产品{productNumber}出列失败，" +
                            // $"当前队列产品数量：{tmpDic.Count}");
                        }
                        else
                        {
                            try
                            {
                                //重新生成实例 销毁之前的实例
                                var saveData = temp.GetProductData();


                            }
                            catch (Exception) { }
                            finally
                            {
                                // temp.Dispose();
                                temp = null;
                            }
                        }

                        // UpdateCT((float)(dtNow - _ctTime).TotalSeconds);
                        //_ctTime = dtNow; 
                        // });


                    }
                    catch (Exception ex)
                    {
                        //LogAsync(DateTime.Now, LogLevel.Error, $"流程检测未捕获的异常：{ex.GetExceptionMessage()}");
                        product?.Dispose();
                    }
                }
            });
        }
        public void SetResult()
        {
            

            


            ////  detectResult.IsPreTreatDone = detectResult.VisionImageSet.PreTreatedFlag
            ////2024-02-29 目标检测不能全是NG
            //if (IsPreTreatNG || IsObjectDetectNG)
            //{
            //    return;
            //}



            //if (IsPreTreatDone && IsMLDetectDone && IsAfterTreatDone)
            //{
            //    ResultState = ResultState.OK;
            //    ResultLabel = ResultState.OK.GetEnumDescription();
            //}

        }
        private void HandleStopButton()
        {
            Cameras.Clear();
            Dectection.Clear();
            // Add the code for the "停止" button click here
          PLC.TurntableStop();
            CurrentMachine = true;
        }
        public int UPH=0;
        public void CalculateOEE()
        {
            TimeSpan timeSpan = DateTime.Now - sraerttime;

                UPH = (int)(ProductNum_Total / timeSpan.TotalHours) + 100;
            //UPM = (int)UPH / 60;
            this.BeginInvoke(new MethodInvoker(delegate () {
            label1.Text = UPH.ToString();
            }));



        }
        private void HandleResetButton()
        {
            // Add the code for the "复位" button click here
            MessageBox.Show("复位按钮按下");
        }

        private void HandleSettingsButton()
        {
            // Add the code for the "设置" button click here
            MessageBox.Show("设置按钮按下");
        }

        private void HandleLoginButton()
        {
            // Add the code for the "登录" button click here
            MessageBox.Show("登录按钮按下");
        }

    }
}