CPL
/
AOI_V2
1
0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
3 提交
1 分支
10 MiB
 
 
 
 
目录树: 74f686f5ec
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 '74f686f5ec'
${ noResults }
AOI_V2/halftoneproject-master/BanBoShi/ImageProcessing/DefectLib.cs

784 行
33 KiB
原始文件 Blame 文件历史 

  1. //#define Defect3

  2. //#define OpenSizeDefectComp

  3. 

  4. using System;

  5. using System.Collections.Generic;

  6. using System.Diagnostics;

  7. using System.Drawing;

  8. using System.Drawing.Imaging;

  9. using System.IO;

  10. using System.Linq;

  11. using System.Reflection;

  12. using System.Threading;

  13. using System.Threading.Tasks;

  14. using System.Windows.Forms;

  15. using MaiMuAOI.SysCtrl;

  16. using MaiMuControl.Device;

  17. using Microsoft.ML.OnnxRuntime;

  18. using Microsoft.ML.OnnxRuntime.Tensors;

  19. using Newtonsoft.Json;

  20. using OpenCvSharp;

  21. using Yolo5;

  22. 

  23. namespace MaiMuAOI.ImageProcessing

  24. {

  25.     public class DefectLib : IDisposable

  26.     {

  27.         public Action<WarningEnum, string> WarningEvent;

  28.         /// <summary>

  29.         /// 检测结果JSON(原图,结果)

  30.         /// </summary>

  31.         public Action<DefectTask> finishEvent;

  32.         /// <summary>

  33.         /// 是否打开设备成功

  34.         /// </summary>

  35.         public bool IsInit { get; private set; } = false;

  36.         //private System.Timers.Timer timer = new System.Timers.Timer();

  37.         private Yolo_Class yolo1;

  38.         private InferenceSession _onnxSession;

  39.         private Yolo_Class yolo2;

  40.         private InferenceSession _onnxSession2;

  41.         private Yolo_Class yolo3;

  42.         private InferenceSession _onnxSession3;

  43.         // 

  44.         private Thread t_task, t_task_operation, t_task_operation2, t_task_operation3, t_task_tag;

  45.         //=======task list

  46.         private List<DefectTask> taskList = new List<DefectTask>(); 

  47.         private List<DefectTask> taskOperationList = new List<DefectTask>();

  48.         private List<DefectTask> taskTagList = new List<DefectTask>();

  49. 

  50.         public DefectLib()

  51.         {

  52.         } 

  53.         public bool start()

  54.         {

  55.             try

  56.             {

  57.                 yolo1 = new Yolo_Class();

  58.                 yolo2 = new Yolo_Class();

  59. #if Defect3

  60.                 yolo3 = new Yolo_Class();

  61. #endif

  62.                 //加载模型（只加载一次即可）

  63.                 //string modelFilePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\DevCfg\\best.onnx";

  64.                 //_onnxSession = yolo1.LoadModel(modelFilePath, true);//false-CPU true-显卡

  65. 

  66.                 IsInit = true;

  67.                 //timer.Elapsed += Timer_Elapsed;

  68.                 //timer.Interval = 100;

  69.                 //timer.Enabled = true;

  70.                 taskList.Clear(); 

  71.                 taskOperationList.Clear();

  72.                 taskTagList.Clear();

  73. 

  74.                 //MessageBox.Show("11");

  75.                 t_task = new System.Threading.Thread(runStep);

  76.                 t_task.IsBackground = true;

  77.                 t_task.Start();

  78. 

  79.                 //MessageBox.Show("22");

  80.                 t_task_operation = new System.Threading.Thread(run2);

  81.                 t_task_operation.IsBackground = true;

  82.                 t_task_operation.Start();

  83. 

  84.                 //MessageBox.Show("33");

  85.                 t_task_operation2 = new System.Threading.Thread(run3);

  86.                 t_task_operation2.IsBackground = true;

  87.                 t_task_operation2.Start();

  88. 

  89.                 //MessageBox.Show("44");

  90. #if Defect3

  91.                 t_task_operation3 = new System.Threading.Thread(run4);

  92.                 t_task_operation3.IsBackground = true;

  93.                 t_task_operation3.Start();

  94. #endif

  95.                 //MessageBox.Show("55");

  96.                 return true;

  97.             }

  98.             catch (Exception ex)

  99.             {

  100.                 WarningEvent?.Invoke(WarningEnum.High, ex.Message);

  101.                 return false;

  102.             }

  103.         }

  104.         public void stop()

  105.         {

  106.             if (!IsInit) return;

  107. 

  108.             try

  109.             {

  110.                 IsInit = false;

  111.                 //timer.Elapsed -= Timer_Elapsed;

  112.                 //释放模型

  113.                 if (_onnxSession != null)

  114.                 {

  115.                     _onnxSession.Dispose();

  116.                     _onnxSession = null;

  117.                 }

  118.                 if (_onnxSession2 != null)

  119.                 {

  120.                     _onnxSession2.Dispose();

  121.                     _onnxSession2 = null;

  122.                 }

  123. #if Defect3

  124.                 if (_onnxSession3 != null)

  125.                 {

  126.                     _onnxSession3.Dispose();

  127.                     _onnxSession3 = null;

  128.                 }

  129. #endif

  130.                 _preLoadONNXFilePath = null;

  131. 

  132.                 if (t_task != null)

  133.                 {

  134.                     bool b = t_task.Join(5000);

  135.                     if (!b) t_task.Abort();

  136.                     t_task = null;

  137.                 }

  138. 

  139.                 if (t_task_operation != null)

  140.                 {

  141.                     bool b = t_task_operation.Join(5000);

  142.                     if (!b) t_task_operation.Abort();

  143.                     t_task_operation = null;

  144.                 }

  145.                 if (t_task_operation2 != null)

  146.                 {

  147.                     bool b = t_task_operation2.Join(5000);

  148.                     if (!b) t_task_operation2.Abort();

  149.                     t_task_operation2 = null;

  150.                 }

  151. #if Defect3

  152.                 if (t_task_operation3 != null)

  153.                 {

  154.                     bool b = t_task_operation3.Join(5000);

  155.                     if (!b) t_task_operation3.Abort();

  156.                     t_task_operation3 = null;

  157.                 }

  158. #endif

  159.                 if (t_task_tag != null)

  160.                 {

  161.                     bool b = t_task_tag.Join(5000);

  162.                     if (!b) t_task_tag.Abort();

  163.                     t_task_tag = null;

  164.                 }

  165.                 taskList.Clear(); 

  166.                 taskOperationList.Clear();

  167.                 taskTagList.Clear();

  168.             }

  169.             catch { }

  170.         }

  171.         private string _preLoadONNXFilePath;//记录上次成功加载的模型，不重复加载

  172.         public void loadModelFile(string onnxFilePath)

  173.         {

  174.             try

  175.             {

  176.                 //string modelFilePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\DevCfg\\best.onnx";

  177.                 //不重复加载

  178.                 if (!string.IsNullOrWhiteSpace(_preLoadONNXFilePath) && _preLoadONNXFilePath.ToLower() == onnxFilePath.ToLower())

  179.                     return;

  180. 

  181.                 //MessageBox.Show("1");

  182.                 //Task.Run(async () =>

  183.                 //{

  184.                 //    if (_onnxSession != null)

  185.                 //    {

  186.                 //        _onnxSession.Dispose();

  187.                 //        _onnxSession = null;

  188.                 //    }

  189.                 //    _onnxSession = yolo1.LoadModel(onnxFilePath, true);//false-CPU true-显卡

  190.                 //    _preLoadONNXFilePath = onnxFilePath;

  191.                 //});

  192.                 if (_onnxSession != null)

  193.                 {

  194.                     _onnxSession.Dispose();

  195.                     _onnxSession = null;

  196.                 }

  197.                 _onnxSession = yolo1.LoadModel(onnxFilePath, true);//false-CPU true-显卡

  198. 

  199.                 //MessageBox.Show("2");

  200.                 if (_onnxSession2 != null)

  201.                 {

  202.                     _onnxSession2.Dispose();

  203.                     _onnxSession2 = null;

  204.                 }

  205.                 _onnxSession2 = yolo2.LoadModel(onnxFilePath, true);//false-CPU true-显卡

  206. #if Defect3

  207.                 //MessageBox.Show("3");

  208.                 if (_onnxSession3 != null)

  209.                 {

  210.                     _onnxSession3.Dispose();

  211.                     _onnxSession3 = null;

  212.                 }

  213.                 _onnxSession3 = yolo3.LoadModel(onnxFilePath, true);//false-CPU true-显卡

  214. #endif

  215.                 //MessageBox.Show("4");

  216.                 _preLoadONNXFilePath = onnxFilePath;

  217.             }

  218.             catch (Exception ex)

  219.             {

  220.                 MessageBox.Show(ex.Message);

  221.             }

  222.         }

  223.         /// <summary>

  224.         /// 保存图片

  225.         /// </summary>

  226.         /// <param name="Img"></param>图片

  227.         /// <param name="pictureUrl"></param>保存路径

  228.         /// <param name="pictureName"></param>保存名称

  229.         private void SaveImage(Bitmap Img, string pictureUrl, string pictureName)

  230.         {

  231.             if (!Directory.Exists(pictureUrl))

  232.             {

  233.                 Directory.CreateDirectory(pictureUrl);

  234.             }

  235.             FileInfo FileUrl = new FileInfo(pictureUrl);//防止路径中有日期导致路径错误

  236. 

  237.             try

  238.             {

  239.                 using (Bitmap bitmap = new Bitmap(Img))

  240.                 {

  241.                     using (MemoryStream stream = new MemoryStream())

  242.                     {

  243.                         bitmap.Save(stream, ImageFormat.Bmp);

  244.                         System.Drawing.Image img = System.Drawing.Image.FromStream(stream);

  245.                         //img.Save(FileUrl +"\\"+ pictureName);

  246.                         //img.Dispose();

  247.                         string szURL = FileUrl + "\\" + pictureName;

  248.                         img.Save(szURL, ImageFormat.Bmp);

  249.                         img.Dispose();

  250.                     }

  251.                 }

  252.             }

  253.             catch (Exception)

  254.             {

  255.                 if (Img != null)

  256.                 {

  257.                     Img.Dispose();

  258.                 }

  259.             }

  260.         }

  261.         private void runStep()

  262.         {

  263.             while (IsInit)

  264.             {

  265.                 if (taskList.Count < 1 || _onnxSession == null)

  266.                 {

  267.                     Thread.Sleep(5);

  268.                     continue;

  269.                 }

  270. 

  271.                 //

  272.                 var task = pop(); 

  273.                 try

  274.                 {

  275.                     if (task != null)

  276.                     {

  277.                         Stopwatch stopwatch = Stopwatch.StartNew();

  278.                         //源图  

  279.                         //Bitmap bmp = yolo1.Read2Bmp(file_path);

  280.                         //切割图像，输入图像格式14208*10640

  281.                         stopwatch.Start();

  282.                         task.bmps_cut = yolo1.OpenCVToCutsMat(task.bmp, task.cut_size.Width, task.cut_size.Height);

  283.                         stopwatch.Stop();

  284.                         task.stopwatch[0] = stopwatch.ElapsedMilliseconds;

  285. 

  286.                         //Resize图像

  287.                         stopwatch.Restart();

  288.                         task.bmps_resize = yolo1.OpenCVToResizesMat(task.bmps_cut, task.resize.Width, task.resize.Height);

  289.                         stopwatch.Stop();

  290.                         task.stopwatch[1] = stopwatch.ElapsedMilliseconds;

  291. 

  292.                         //预处理模型

  293.                         stopwatch.Restart();

  294.                         task.tensors = yolo1.PreprocessImageMat(task.bmps_resize);

  295.                         stopwatch.Stop();

  296.                         task.stopwatch[2] = stopwatch.ElapsedMilliseconds;

  297. 

  298.                         lock (taskOperationList)

  299.                             taskOperationList.Add(task);

  300.                     }

  301.                     Thread.Sleep(5);

  302.                 }

  303.                 catch (Exception ex)

  304.                 {

  305.                     WarningEvent?.Invoke(WarningEnum.Low, "DefectLib task1 err:" + ex.Message);

  306.                     task.isSucceed = false;

  307.                     task.resultInfo = ex.Message;

  308.                     callback(task);

  309.                 } 

  310.             }

  311.         }  

  312. 

  313.         private void run2()

  314.         {

  315.             while (IsInit)

  316.             {

  317.                 if (taskOperationList.Count < 1)

  318.                 {

  319.                     Thread.Sleep(5);

  320.                     continue;

  321.                 }

  322. 

  323.                 //

  324.                 var task = pop2();

  325.                 int liStep = 0;

  326.                 try

  327.                 {

  328.                     if (task != null)

  329.                     {

  330.                         Stopwatch stopwatch = Stopwatch.StartNew();

  331.                         //====运行推理（必需单队列）

  332.                         WarningEvent?.Invoke(WarningEnum.Normal, $"DefectLib task2 进入推理：{task.modelType}-{task.thresholds}, {task.thresholdsClass}, {JsonConvert.SerializeObject(task.recAreaThreshold)}");

  333.                         stopwatch.Start();

  334.                         IDisposableReadOnlyCollection<DisposableNamedOnnxValue>[] results = yolo1.RunModlel(_onnxSession, task.tensors);

  335.                         liStep = 1;

  336.                         if (task.modelType == "rj")

  337.                             task.informationList = yolo1.ScreeningResults_YD_RJ(results, task.bmps_resize, task.thresholds, task.thresholdsClass, task.recAreaThreshold);

  338.                         else

  339.                             task.informationList = yolo1.ScreeningResults_YD(results, task.bmps_resize, task.thresholds, task.thresholdsClass, task.recAreaThreshold);

  340.                         liStep = 2;

  341.                          

  342.                         //当前大图上缺陷个数

  343.                         int currPicDefectCount = 0;

  344.                         for (int x = 0; x < task.informationList.Count(); x++)

  345.                             currPicDefectCount += task.informationList[x].Count();

  346.                         task.defectCount = currPicDefectCount;

  347.                         stopwatch.Stop();

  348.                         task.stopwatch[3] = stopwatch.ElapsedMilliseconds;

  349.                         liStep = 3;

  350.                         if (task.informationList.Count > 0)

  351.                         {

  352.                             liStep = 4;

  353.                             //lock (taskTagList)

  354.                             //    taskTagList.Add(task);

  355.                             //====打标 ,有缺陷返回缺陷图片数组，没缺陷返回所有图片数组 

  356.                             stopwatch.Restart();

  357. #if OpenSizeDefectComp

  358.                             task.bmps_tag = yolo1.DrawYoloPrediction2Mat(task.bmps_cut, task.informationList, 27, SixLabors.ImageSharp.Color.OrangeRed, task.resize.Width,

  359.                                 task.Xmm, task.Ymm, out task.defectInfor2RestorationDesk, out task.defectInfor2BigImage);

  360. #else

  361.                             task.bmps_tag = yolo1.DrawYoloPrediction2Mat(task.bmps_cut, task.informationList, 27, SixLabors.ImageSharp.Color.OrangeRed, task.resize.Width,

  362.                                 task.Xmm, task.Ymm, out task.defectInfor2RestorationDesk);

  363. #endif

  364. 

  365.                             liStep = 5;

  366. 

  367.                             //List<List<string>> SizedefectInfor2RestorationDesk = SysMgr.Instance.GetSizeDefectData(task.Xmm, task.Ymm);

  368.                             //task.defectInfor2RestorationDesk = yolo3.FilteringOverlappingDefects(task.defectInfor2RestorationDesk, SizedefectInfor2RestorationDesk);

  369.                             //liStep = 51;

  370. 

  371.                             if (ConfMgr.Instance.SysConfigParams.OpenFlawDistribution)

  372.                             {

  373.                                 //大图缺陷坐标转换到图纸坐标 

  374.                                 if (!string.IsNullOrWhiteSpace(task.drawingPagePath) && task.defectInfor2RestorationDesk != null && task.defectInfor2RestorationDesk.Count > 0)

  375.                                     task.defectInfor2RestorationDeskPage = yolo1.DefectDrawGerberImage(task.drawingPagePath, task.defectInfor2RestorationDesk);

  376.                             }

  377.                             stopwatch.Stop();

  378.                             task.stopwatch[4] = stopwatch.ElapsedMilliseconds;

  379. 

  380.                             liStep = 6;

  381.                             task.bmpCompress = yolo1.ResizesMat_4(task.bmp);

  382.                             //if (!ConfMgr.Instance.SysConfigParams.OpenColorB)

  383.                             //    task.bmpCompress = yolo1.ResizesMat_4(task.bmp);

  384.                             //else

  385.                             //    task.bmpCompress = yolo1.ResizesMat_4(task.srcbmp);

  386.                             task.isSucceed = true;

  387.                             callback(task);

  388.                         }

  389.                         else

  390.                         { 

  391.                             task.isSucceed = true;

  392.                             callback(task);

  393.                         }

  394.                     }

  395.                     Thread.Sleep(5);

  396.                 }

  397.                 catch (Exception ex)

  398.                 {

  399.                     WarningEvent?.Invoke(WarningEnum.Low, $"DefectLib task2 err({liStep}):" + ex.Message + $"||{task.modelType}-{task.thresholds}, {task.thresholdsClass}, {JsonConvert.SerializeObject(task.recAreaThreshold)}");

  400.                     task.isSucceed = false;

  401.                     task.resultInfo = ex.Message;

  402.                     callback(task);

  403.                 } 

  404.             }

  405.         }

  406. 

  407.         private void run3()

  408.         {

  409.             while (IsInit)

  410.             {

  411.                 if (taskOperationList.Count < 1)

  412.                 {

  413.                     Thread.Sleep(5);

  414.                     continue;

  415.                 }

  416. 

  417.                 //

  418.                 var task = pop2();

  419.                 int liStep = 0;

  420.                 try

  421.                 {

  422.                     if (task != null)

  423.                     {

  424.                         Stopwatch stopwatch = Stopwatch.StartNew();

  425.                         //====运行推理（必需单队列）

  426.                         WarningEvent?.Invoke(WarningEnum.Normal, $"DefectLib task3 进入推理：{task.modelType}-{task.thresholds}, {task.thresholdsClass}, {JsonConvert.SerializeObject(task.recAreaThreshold)}");

  427.                         stopwatch.Start();

  428.                         IDisposableReadOnlyCollection<DisposableNamedOnnxValue>[] results = yolo2.RunModlel(_onnxSession2, task.tensors);

  429.                         liStep = 1;

  430.                         if (task.modelType == "rj")

  431.                             task.informationList = yolo2.ScreeningResults_YD_RJ(results, task.bmps_resize, task.thresholds, task.thresholdsClass, task.recAreaThreshold);

  432.                         else

  433.                             task.informationList = yolo2.ScreeningResults_YD(results, task.bmps_resize, task.thresholds, task.thresholdsClass, task.recAreaThreshold);

  434.                         liStep = 2;

  435. 

  436.                         //当前大图上缺陷个数

  437.                         int currPicDefectCount = 0;

  438.                         for (int x = 0; x < task.informationList.Count(); x++)

  439.                             currPicDefectCount += task.informationList[x].Count();

  440.                         task.defectCount = currPicDefectCount;

  441.                         stopwatch.Stop();

  442.                         task.stopwatch[3] = stopwatch.ElapsedMilliseconds;

  443.                         liStep = 3;

  444.                         if (task.informationList.Count > 0)

  445.                         {

  446.                             liStep = 4;

  447.                             //lock (taskTagList)

  448.                             //    taskTagList.Add(task);

  449.                             //====打标 ,有缺陷返回缺陷图片数组，没缺陷返回所有图片数组 

  450.                             stopwatch.Restart();

  451. #if OpenSizeDefectComp

  452.                             task.bmps_tag = yolo2.DrawYoloPrediction2Mat(task.bmps_cut, task.informationList, 27, SixLabors.ImageSharp.Color.OrangeRed, task.resize.Width,

  453.                                 task.Xmm, task.Ymm, out task.defectInfor2RestorationDesk, out task.defectInfor2BigImage);

  454. #else

  455.                             task.bmps_tag = yolo2.DrawYoloPrediction2Mat(task.bmps_cut, task.informationList, 27, SixLabors.ImageSharp.Color.OrangeRed, task.resize.Width,

  456.                                 task.Xmm, task.Ymm, out task.defectInfor2RestorationDesk);

  457. #endif

  458. 

  459.                             liStep = 5;

  460. 

  461.                             //List<List<string>> SizedefectInfor2RestorationDesk = SysMgr.Instance.GetSizeDefectData(task.Xmm, task.Ymm);

  462.                             //task.defectInfor2RestorationDesk = yolo3.FilteringOverlappingDefects(task.defectInfor2RestorationDesk, SizedefectInfor2RestorationDesk);

  463.                             //liStep = 51;

  464. 

  465.                             if (ConfMgr.Instance.SysConfigParams.OpenFlawDistribution)

  466.                             {

  467.                                 //大图缺陷坐标转换到图纸坐标 

  468.                                 if (!string.IsNullOrWhiteSpace(task.drawingPagePath) && task.defectInfor2RestorationDesk != null && task.defectInfor2RestorationDesk.Count > 0)

  469.                                     task.defectInfor2RestorationDeskPage = yolo2.DefectDrawGerberImage(task.drawingPagePath, task.defectInfor2RestorationDesk);

  470.                             }

  471.                             stopwatch.Stop();

  472.                             task.stopwatch[4] = stopwatch.ElapsedMilliseconds;

  473. 

  474.                             liStep = 6;

  475.                             task.bmpCompress = yolo2.ResizesMat_4(task.bmp);

  476.                             task.isSucceed = true;

  477.                             callback(task);

  478.                         }

  479.                         else

  480.                         {

  481.                             task.isSucceed = true;

  482.                             callback(task);

  483.                         }

  484.                     }

  485.                     Thread.Sleep(5);

  486.                 }

  487.                 catch (Exception ex)

  488.                 {

  489.                     WarningEvent?.Invoke(WarningEnum.Low, $"DefectLib task3 err({liStep}):" + ex.Message + $"||{task.modelType}-{task.thresholds}, {task.thresholdsClass}, {JsonConvert.SerializeObject(task.recAreaThreshold)}");

  490.                     task.isSucceed = false;

  491.                     task.resultInfo = ex.Message;

  492.                     callback(task);

  493.                 }

  494.             }

  495.         }

  496. 

  497.         private void run4()

  498.         {

  499.             while (IsInit)

  500.             {

  501.                 if (taskOperationList.Count < 1)

  502.                 {

  503.                     Thread.Sleep(5);

  504.                     continue;

  505.                 }

  506. 

  507.                 //

  508.                 var task = pop2();

  509.                 int liStep = 0;

  510.                 try

  511.                 {

  512.                     if (task != null)

  513.                     {

  514.                         Stopwatch stopwatch = Stopwatch.StartNew();

  515.                         //====运行推理（必需单队列）

  516.                         stopwatch.Start();

  517.                         IDisposableReadOnlyCollection<DisposableNamedOnnxValue>[] results = yolo3.RunModlel(_onnxSession3, task.tensors);

  518.                         liStep = 1;

  519.                         if (task.modelType == "rj")

  520.                             task.informationList = yolo3.ScreeningResults_YD_RJ(results, task.bmps_resize, task.thresholds, task.thresholdsClass, task.recAreaThreshold);

  521.                         else

  522.                             task.informationList = yolo3.ScreeningResults_YD(results, task.bmps_resize, task.thresholds, task.thresholdsClass, task.recAreaThreshold);

  523.                         liStep = 2;

  524. 

  525.                         //当前大图上缺陷个数

  526.                         int currPicDefectCount = 0;

  527.                         for (int x = 0; x < task.informationList.Count(); x++)

  528.                             currPicDefectCount += task.informationList[x].Count();

  529.                         task.defectCount = currPicDefectCount;

  530.                         stopwatch.Stop();

  531.                         task.stopwatch[3] = stopwatch.ElapsedMilliseconds;

  532.                         liStep = 3;

  533.                         if (task.informationList.Count > 0)

  534.                         {

  535.                             liStep = 4;

  536.                             //lock (taskTagList)

  537.                             //    taskTagList.Add(task);

  538.                             //====打标 ,有缺陷返回缺陷图片数组，没缺陷返回所有图片数组 

  539.                             stopwatch.Restart();

  540. #if OpenSizeDefectComp

  541.                             task.bmps_tag = yolo3.DrawYoloPrediction2Mat(task.bmps_cut, task.informationList, 27, SixLabors.ImageSharp.Color.OrangeRed, task.resize.Width,

  542.                                 task.Xmm, task.Ymm, out task.defectInfor2RestorationDesk, out task.defectInfor2BigImage);

  543. #else

  544.                             task.bmps_tag = yolo3.DrawYoloPrediction2Mat(task.bmps_cut, task.informationList, 27, SixLabors.ImageSharp.Color.OrangeRed, task.resize.Width,

  545.                                 task.Xmm, task.Ymm, out task.defectInfor2RestorationDesk);

  546. #endif

  547. 

  548.                             liStep = 5;

  549. 

  550.                             //List<List<string>> SizedefectInfor2RestorationDesk = SysMgr.Instance.GetSizeDefectData(task.Xmm, task.Ymm);

  551.                             //task.defectInfor2RestorationDesk = yolo3.FilteringOverlappingDefects(task.defectInfor2RestorationDesk, SizedefectInfor2RestorationDesk);

  552.                             //liStep = 51;

  553. 

  554.                             if (ConfMgr.Instance.SysConfigParams.OpenFlawDistribution)

  555.                             {

  556.                                 //大图缺陷坐标转换到图纸坐标 

  557.                                 if (!string.IsNullOrWhiteSpace(task.drawingPagePath) && task.defectInfor2RestorationDesk != null && task.defectInfor2RestorationDesk.Count > 0)

  558.                                     task.defectInfor2RestorationDeskPage = yolo3.DefectDrawGerberImage(task.drawingPagePath, task.defectInfor2RestorationDesk);

  559.                             }

  560.                             stopwatch.Stop();

  561.                             task.stopwatch[4] = stopwatch.ElapsedMilliseconds;

  562. 

  563.                             liStep = 6;

  564.                             task.bmpCompress = yolo3.ResizesMat_4(task.bmp);

  565.                             task.isSucceed = true;

  566.                             callback(task);

  567.                         }

  568.                         else

  569.                         {

  570.                             task.isSucceed = true;

  571.                             callback(task);

  572.                         }

  573.                     }

  574.                     Thread.Sleep(5);

  575.                 }

  576.                 catch (Exception ex)

  577.                 {

  578.                     WarningEvent?.Invoke(WarningEnum.Low, $"DefectLib task4 err({liStep}):" + ex.Message);

  579.                     task.isSucceed = false;

  580.                     task.resultInfo = ex.Message;

  581.                     callback(task);

  582.                 }

  583.             }

  584.         }

  585.         /// <summary>

  586.         /// 已不用

  587.         /// </summary>

  588.         private void run5()

  589.         {

  590.             while (IsInit)

  591.             {

  592.                 if (taskTagList.Count < 1)

  593.                 {

  594.                     Thread.Sleep(0);

  595.                     continue;

  596.                 }

  597. 

  598.                 //

  599.                 var task = pop3(); 

  600.                 try

  601.                 {

  602.                     if (task != null)

  603.                     {

  604.                         Stopwatch stopwatch = Stopwatch.StartNew();

  605.                         //====打标 ,有缺陷返回缺陷图片数组，没缺陷返回所有图片数组

  606.                         stopwatch.Start();

  607.                         task.bmps_tag = yolo1.DrawYoloPrediction2Mat(task.bmps_cut, task.informationList, 27, SixLabors.ImageSharp.Color.OrangeRed, task.resize.Width,

  608.                             task.Xmm,task.Ymm,out task.defectInfor2RestorationDesk);          

  609.                         stopwatch.Stop();

  610.                         task.stopwatch[4] = stopwatch.ElapsedMilliseconds;

  611.                         task.isSucceed = true;

  612.                         callback(task);

  613.                     }

  614.                 }

  615.                 catch (Exception ex)

  616.                 {

  617.                     WarningEvent?.Invoke(WarningEnum.Low, "DefectLib task3 err:" + ex.Message);

  618.                     task.isSucceed = false;

  619.                     task.resultInfo = ex.Message;

  620.                     callback(task);

  621.                 } 

  622.             }

  623.         }

  624.         private void callback(DefectTask task)

  625.         {

  626.             //返回成功/失败,异步调用 

  627.             if (task.finishEvent != null || (task.finishEvent = finishEvent) != null)

  628.                 //task.finishEvent.BeginInvoke(result, errInfo, res => task.finishEvent.EndInvoke(res), null);

  629.                 System.Threading.ThreadPool.QueueUserWorkItem(waitCallback, task);

  630.         }

  631.         //异步回调

  632.         WaitCallback waitCallback = new WaitCallback(o =>

  633.         {

  634.             var task = (DefectTask)o;

  635.             task.finishEvent(task);

  636.         });

  637.         

  638.         public class DefectTask

  639.         {

  640.             public int stepIndex;

  641.             public string processName;

  642. 

  643.             //2024 03 22 加入模型类型 rj pt;

  644.             public string modelType;

  645. 

  646.             public string drawingPagePath;//图纸路径bmp

  647.             //图索引

  648.             public int index = 0;

  649.             /// <summary>

  650.             /// 绝对位置-----X2轴

  651.             /// </summary>

  652.             public double Xmm;

  653.             /// <summary>

  654.             /// 绝对位置-----Y轴

  655.             /// </summary>

  656.             public double Ymm;

  657.             /// <summary>

  658.             /// 源文件

  659.             /// </summary>

  660.             public Mat bmp;

  661.             public Mat srcbmp;

  662.             public Mat bmpCompress;//压缩有缺陷大图

  663.             public System.Drawing.Size cut_size = new System.Drawing.Size(592, 532);

  664.             public System.Drawing.Size resize = new System.Drawing.Size(224, 224);

  665.             /// <summary>

  666.             /// 阈值

  667.             /// </summary>

  668.             public float thresholds = 0.4f;

  669.             /// <summary>

  670.             /// 种类阈值

  671.             /// </summary>

  672.             public string thresholdsClass;

  673.             /// <summary>

  674.             /// 缺陷在面积内数量

  675.             /// </summary>

  676.             public Dictionary<string, float> recAreaThreshold;

  677.             /// <summary>

  678.             /// 完成后回调 

  679.             /// </summary>

  680.             public Action<DefectTask> finishEvent;

  681. 

  682.             //

  683.             public long createTime = DateTime.Now.Ticks;

  684.             public DateTime nowTime;

  685.             //中间变量，供step2使用

  686.             public Mat[] bmps_cut;

  687.             public Mat[] bmps_resize;

  688.             //预处理模型

  689.             public Tensor<float>[] tensors;

  690. 

  691.             //==结果返回

  692.             public List<Dictionary<int, List<string>[]>> informationList;

  693.             public int defectCount;//informationList中的缺陷数

  694.             

  695.             public List<List<string>> defectInfor2RestorationDesk, defectInfor2RestorationDeskPage;//打标缺陷转为图纸的坐标

  696.             public Bitmap[] bmps_tag;  //打标小图 //bmps_tag.count<=bmps_cut.count bmps_tag.count=informationList.count

  697.             public bool isSucceed;//转换是否成功

  698.             public string resultInfo = "";//成功或失败信息

  699.             public long[] stopwatch = new long[5];

  700.             public List<List<string>> defectInfor2BigImage;

  701.             //裁切原图

  702.             public Mat CutSrcbmp;

  703.         }

  704. 

  705.         public void add(DefectTask task)

  706.         {

  707.             lock (taskList)

  708.                 taskList.Add(task);

  709.         }

  710.         /// <summary>

  711.         /// 打标 返回每张图的绝对位置X,Y

  712.         /// </summary>

  713.         /// <param name="defectBmpIndex">缺陷小图索引</param>

  714.         /// <param name="X">拍照位绝对位置-----X2轴</param>

  715.         /// <param name="Y">拍照位绝对位置-----Y轴</param>

  716.         /// <param name="imagewidth">裁剪小图的宽592</param>

  717.         /// <param name="imageheight">裁剪小图的高532</param>

  718.         public List<double> makeTag(int defectBmpIndex, double X, double Y, int imagewidth, int imageheight)

  719.         {

  720.             return yolo1.ImageXY(defectBmpIndex, X, Y, imagewidth, imageheight);

  721.         }

  722.         /// <summary>

  723.         /// 用相机1查看缺陷点

  724.         /// </summary>

  725.         /// <param name="defectBmpIndex"></param>

  726.         /// <param name="X"></param>

  727.         /// <param name="Y"></param>

  728.         /// <param name="imagewidth"></param>

  729.         /// <param name="imageheight"></param>

  730.         /// <returns></returns>

  731.         public List<double> viewTag(int defectBmpIndex, double X, double Y, int imagewidth, int imageheight)

  732.         {

  733.             return yolo1.ImageXY2(defectBmpIndex, X, Y, imagewidth, imageheight);

  734.         }

  735.         private DefectTask pop()

  736.         {

  737.             lock (taskList)

  738.             {

  739.                 if (taskList.Count < 1)

  740.                     return null;

  741. 

  742.                 //int index = 0;// taskList.FindIndex(p => { return p.isSync; });

  743.                 //if (index < 0) index = 0; 

  744.                 var task = taskList[0];

  745.                 taskList.RemoveAt(0);

  746.                 return task;

  747.             }

  748.         }

  749.         private DefectTask pop2()

  750.         {

  751.             lock (taskOperationList)

  752.             {

  753.                 if (taskOperationList.Count < 1)

  754.                     return null;

  755. 

  756.                 //int index = 0;// taskList.FindIndex(p => { return p.isSync; });

  757.                 //if (index < 0) index = 0; 

  758.                 var task = taskOperationList[0];

  759.                 taskOperationList.RemoveAt(0);

  760.                 return task;

  761.             }

  762.         }

  763.         private DefectTask pop3()

  764.         {

  765.             lock (taskTagList)

  766.             {

  767.                 if (taskTagList.Count < 1)

  768.                     return null;

  769. 

  770.                 //int index = 0;// taskList.FindIndex(p => { return p.isSync; });

  771.                 //if (index < 0) index = 0; 

  772.                 var task = taskTagList[0];

  773.                 taskTagList.RemoveAt(0);

  774.                 return task;

  775.             }

  776.         } 

  777. 

  778.         public void Dispose()

  779.         {

  780.             stop();

  781.         }

  782.     }

  783. }