CPL
/
banboshi_V2
1
0
複製 0
程式碼 問題管理 0 合併請求 0 版本發佈 1 Wiki Activity
版博士V2.0程序
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
75 Commit
5 分支
6.2 GiB
 
 
 
 
目錄樹: dfa1d64666
分支列表 標籤列表
${ item.name }
Create branch ${ searchTerm }
from 'dfa1d64666'
${ noResults }
banboshi_V2/halftoneproject-master/BanBoShi/ImageProcessing/DefectLib.cs

783 line
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.                 WarningEvent?.Invoke(WarningEnum.High, "加载模型失败:" + ex.Message);

  221.                 MessageBox.Show(ex.Message);

  222.             }

  223.         }

  224.         /// <summary>

  225.         /// 保存图片

  226.         /// </summary>

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

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

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

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

  231.         {

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

  233.             {

  234.                 Directory.CreateDirectory(pictureUrl);

  235.             }

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

  237. 

  238.             try

  239.             {

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

  241.                 {

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

  243.                     {

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

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

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

  247.                         //img.Dispose();

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

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

  250.                         img.Dispose();

  251.                     }

  252.                 }

  253.             }

  254.             catch (Exception)

  255.             {

  256.                 if (Img != null)

  257.                 {

  258.                     Img.Dispose();

  259.                 }

  260.             }

  261.         }

  262.         private void runStep()

  263.         {

  264.             while (IsInit)

  265.             {

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

  267.                 {

  268.                     Thread.Sleep(5);

  269.                     continue;

  270.                 }

  271. 

  272.                 //

  273.                 var task = pop(); 

  274.                 try

  275.                 {

  276.                     if (task != null)

  277.                     {

  278.                         Stopwatch stopwatch = Stopwatch.StartNew();

  279.                         //源图  

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

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

  282.                         stopwatch.Start();

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

  284.                         stopwatch.Stop();

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

  286. 

  287.                         //Resize图像

  288.                         stopwatch.Restart();

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

  290.                         stopwatch.Stop();

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

  292. 

  293.                         //预处理模型

  294.                         stopwatch.Restart();

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

  296.                         stopwatch.Stop();

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

  298. 

  299.                         lock (taskOperationList)

  300.                             taskOperationList.Add(task);

  301.                     }

  302.                     Thread.Sleep(5);

  303.                 }

  304.                 catch (Exception ex)

  305.                 {

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

  307.                     task.isSucceed = false;

  308.                     task.resultInfo = ex.Message;

  309.                     callback(task);

  310.                 } 

  311.             }

  312.         }  

  313. 

  314.         private void run2()

  315.         {

  316.             while (IsInit)

  317.             {

  318.                 if (taskOperationList.Count < 1)

  319.                 {

  320.                     Thread.Sleep(5);

  321.                     continue;

  322.                 }

  323. 

  324.                 //

  325.                 var task = pop2();

  326.                 int liStep = 0;

  327.                 try

  328.                 {

  329.                     if (task != null)

  330.                     {

  331.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  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.                         stopwatch.Start();

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

  428.                         liStep = 1;

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

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

  431.                         else

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

  433.                         liStep = 2;

  434. 

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

  436.                         int currPicDefectCount = 0;

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

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

  439.                         task.defectCount = currPicDefectCount;

  440.                         stopwatch.Stop();

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

  442.                         liStep = 3;

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

  444.                         {

  445.                             liStep = 4;

  446.                             //lock (taskTagList)

  447.                             //    taskTagList.Add(task);

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

  449.                             stopwatch.Restart();

  450. #if OpenSizeDefectComp

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

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

  453. #else

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

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

  456. #endif

  457. 

  458.                             liStep = 5;

  459. 

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

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

  462.                             //liStep = 51;

  463. 

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

  465.                             {

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

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

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

  469.                             }

  470.                             stopwatch.Stop();

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

  472. 

  473.                             liStep = 6;

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

  475.                             task.isSucceed = true;

  476.                             callback(task);

  477.                         }

  478.                         else

  479.                         {

  480.                             task.isSucceed = true;

  481.                             callback(task);

  482.                         }

  483.                     }

  484.                     Thread.Sleep(5);

  485.                 }

  486.                 catch (Exception ex)

  487.                 {

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

  489.                     task.isSucceed = false;

  490.                     task.resultInfo = ex.Message;

  491.                     callback(task);

  492.                 }

  493.             }

  494.         }

  495. 

  496.         private void run4()

  497.         {

  498.             while (IsInit)

  499.             {

  500.                 if (taskOperationList.Count < 1)

  501.                 {

  502.                     Thread.Sleep(5);

  503.                     continue;

  504.                 }

  505. 

  506.                 //

  507.                 var task = pop2();

  508.                 int liStep = 0;

  509.                 try

  510.                 {

  511.                     if (task != null)

  512.                     {

  513.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  515.                         stopwatch.Start();

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

  517.                         liStep = 1;

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

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

  520.                         else

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

  522.                         liStep = 2;

  523. 

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

  525.                         int currPicDefectCount = 0;

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

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

  528.                         task.defectCount = currPicDefectCount;

  529.                         stopwatch.Stop();

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

  531.                         liStep = 3;

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

  533.                         {

  534.                             liStep = 4;

  535.                             //lock (taskTagList)

  536.                             //    taskTagList.Add(task);

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

  538.                             stopwatch.Restart();

  539. #if OpenSizeDefectComp

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

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

  542. #else

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

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

  545. #endif

  546. 

  547.                             liStep = 5;

  548. 

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

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

  551.                             //liStep = 51;

  552. 

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

  554.                             {

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

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

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

  558.                             }

  559.                             stopwatch.Stop();

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

  561. 

  562.                             liStep = 6;

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

  564.                             task.isSucceed = true;

  565.                             callback(task);

  566.                         }

  567.                         else

  568.                         {

  569.                             task.isSucceed = true;

  570.                             callback(task);

  571.                         }

  572.                     }

  573.                     Thread.Sleep(5);

  574.                 }

  575.                 catch (Exception ex)

  576.                 {

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

  578.                     task.isSucceed = false;

  579.                     task.resultInfo = ex.Message;

  580.                     callback(task);

  581.                 }

  582.             }

  583.         }

  584.         /// <summary>

  585.         /// 已不用

  586.         /// </summary>

  587.         private void run5()

  588.         {

  589.             while (IsInit)

  590.             {

  591.                 if (taskTagList.Count < 1)

  592.                 {

  593.                     Thread.Sleep(0);

  594.                     continue;

  595.                 }

  596. 

  597.                 //

  598.                 var task = pop3(); 

  599.                 try

  600.                 {

  601.                     if (task != null)

  602.                     {

  603.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  605.                         stopwatch.Start();

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

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

  608.                         stopwatch.Stop();

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

  610.                         task.isSucceed = true;

  611.                         callback(task);

  612.                     }

  613.                 }

  614.                 catch (Exception ex)

  615.                 {

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

  617.                     task.isSucceed = false;

  618.                     task.resultInfo = ex.Message;

  619.                     callback(task);

  620.                 } 

  621.             }

  622.         }

  623.         private void callback(DefectTask task)

  624.         {

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

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

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

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

  629.         }

  630.         //异步回调

  631.         WaitCallback waitCallback = new WaitCallback(o =>

  632.         {

  633.             var task = (DefectTask)o;

  634.             task.finishEvent(task);

  635.         });

  636.         

  637.         public class DefectTask

  638.         {

  639.             public int stepIndex;

  640.             public string processName;

  641. 

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

  643.             public string modelType;

  644. 

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

  646.             //图索引

  647.             public int index = 0;

  648.             /// <summary>

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

  650.             /// </summary>

  651.             public double Xmm;

  652.             /// <summary>

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

  654.             /// </summary>

  655.             public double Ymm;

  656.             /// <summary>

  657.             /// 源文件

  658.             /// </summary>

  659.             public Mat bmp;

  660.             public Mat srcbmp;

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

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

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

  664.             /// <summary>

  665.             /// 阈值

  666.             /// </summary>

  667.             public float thresholds = 0.4f;

  668.             /// <summary>

  669.             /// 种类阈值

  670.             /// </summary>

  671.             public string thresholdsClass;

  672.             /// <summary>

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

  674.             /// </summary>

  675.             public Dictionary<string, float> recAreaThreshold;

  676.             /// <summary>

  677.             /// 完成后回调 

  678.             /// </summary>

  679.             public Action<DefectTask> finishEvent;

  680. 

  681.             //

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

  683.             public DateTime nowTime;

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

  685.             public Mat[] bmps_cut;

  686.             public Mat[] bmps_resize;

  687.             //预处理模型

  688.             public Tensor<float>[] tensors;

  689. 

  690.             //==结果返回

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

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

  693.             

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

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

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

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

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

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

  700.             //裁切原图

  701.             public Mat CutSrcbmp;

  702.         }

  703. 

  704.         public void add(DefectTask task)

  705.         {

  706.             lock (taskList)

  707.                 taskList.Add(task);

  708.         }

  709.         /// <summary>

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

  711.         /// </summary>

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

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

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

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

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

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

  718.         {

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

  720.         }

  721.         /// <summary>

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

  723.         /// </summary>

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

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

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

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

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

  729.         /// <returns></returns>

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

  731.         {

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

  733.         }

  734.         private DefectTask pop()

  735.         {

  736.             lock (taskList)

  737.             {

  738.                 if (taskList.Count < 1)

  739.                     return null;

  740. 

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

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

  743.                 var task = taskList[0];

  744.                 taskList.RemoveAt(0);

  745.                 return task;

  746.             }

  747.         }

  748.         private DefectTask pop2()

  749.         {

  750.             lock (taskOperationList)

  751.             {

  752.                 if (taskOperationList.Count < 1)

  753.                     return null;

  754. 

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

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

  757.                 var task = taskOperationList[0];

  758.                 taskOperationList.RemoveAt(0);

  759.                 return task;

  760.             }

  761.         }

  762.         private DefectTask pop3()

  763.         {

  764.             lock (taskTagList)

  765.             {

  766.                 if (taskTagList.Count < 1)

  767.                     return null;

  768. 

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

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

  771.                 var task = taskTagList[0];

  772.                 taskTagList.RemoveAt(0);

  773.                 return task;

  774.             }

  775.         } 

  776. 

  777.         public void Dispose()

  778.         {

  779.             stop();

  780.         }

  781.     }

  782. }