CPL
/
banboshi_V2
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 1 Вики Активность
版博士V2.0程序
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
67 коммитов
5 Ветки
6.2 GiB
 
 
 
 
Дерево: 924cf71a67
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из '924cf71a67'
${ noResults }
banboshi_V2/halftoneproject-master/BanBoShi/ImageProcessing/DefectLib.cs

782 строки
33 KiB
Исходник Вина История 

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

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

  334.                         liStep = 1;

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

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

  337.                         else

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

  339.                         liStep = 2;

  340.                          

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

  342.                         int currPicDefectCount = 0;

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

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

  345.                         task.defectCount = currPicDefectCount;

  346.                         stopwatch.Stop();

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

  348.                         liStep = 3;

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

  350.                         {

  351.                             liStep = 4;

  352.                             //lock (taskTagList)

  353.                             //    taskTagList.Add(task);

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

  355.                             stopwatch.Restart();

  356. #if OpenSizeDefectComp

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

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

  359. #else

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

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

  362. #endif

  363. 

  364.                             liStep = 5;

  365. 

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

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

  368.                             //liStep = 51;

  369. 

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

  371.                             {

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

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

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

  375.                             }

  376.                             stopwatch.Stop();

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

  378. 

  379.                             liStep = 6;

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

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

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

  383.                             //else

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

  385.                             task.isSucceed = true;

  386.                             callback(task);

  387.                         }

  388.                         else

  389.                         { 

  390.                             task.isSucceed = true;

  391.                             callback(task);

  392.                         }

  393.                     }

  394.                     Thread.Sleep(5);

  395.                 }

  396.                 catch (Exception ex)

  397.                 {

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

  399.                     task.isSucceed = false;

  400.                     task.resultInfo = ex.Message;

  401.                     callback(task);

  402.                 } 

  403.             }

  404.         }

  405. 

  406.         private void run3()

  407.         {

  408.             while (IsInit)

  409.             {

  410.                 if (taskOperationList.Count < 1)

  411.                 {

  412.                     Thread.Sleep(5);

  413.                     continue;

  414.                 }

  415. 

  416.                 //

  417.                 var task = pop2();

  418.                 int liStep = 0;

  419.                 try

  420.                 {

  421.                     if (task != null)

  422.                     {

  423.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  425.                         stopwatch.Start();

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

  427.                         liStep = 1;

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

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

  430.                         else

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

  432.                         liStep = 2;

  433. 

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

  435.                         int currPicDefectCount = 0;

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

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

  438.                         task.defectCount = currPicDefectCount;

  439.                         stopwatch.Stop();

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

  441.                         liStep = 3;

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

  443.                         {

  444.                             liStep = 4;

  445.                             //lock (taskTagList)

  446.                             //    taskTagList.Add(task);

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

  448.                             stopwatch.Restart();

  449. #if OpenSizeDefectComp

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

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

  452. #else

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

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

  455. #endif

  456. 

  457.                             liStep = 5;

  458. 

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

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

  461.                             //liStep = 51;

  462. 

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

  464.                             {

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

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

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

  468.                             }

  469.                             stopwatch.Stop();

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

  471. 

  472.                             liStep = 6;

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

  474.                             task.isSucceed = true;

  475.                             callback(task);

  476.                         }

  477.                         else

  478.                         {

  479.                             task.isSucceed = true;

  480.                             callback(task);

  481.                         }

  482.                     }

  483.                     Thread.Sleep(5);

  484.                 }

  485.                 catch (Exception ex)

  486.                 {

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

  488.                     task.isSucceed = false;

  489.                     task.resultInfo = ex.Message;

  490.                     callback(task);

  491.                 }

  492.             }

  493.         }

  494. 

  495.         private void run4()

  496.         {

  497.             while (IsInit)

  498.             {

  499.                 if (taskOperationList.Count < 1)

  500.                 {

  501.                     Thread.Sleep(5);

  502.                     continue;

  503.                 }

  504. 

  505.                 //

  506.                 var task = pop2();

  507.                 int liStep = 0;

  508.                 try

  509.                 {

  510.                     if (task != null)

  511.                     {

  512.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  514.                         stopwatch.Start();

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

  516.                         liStep = 1;

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

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

  519.                         else

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

  521.                         liStep = 2;

  522. 

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

  524.                         int currPicDefectCount = 0;

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

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

  527.                         task.defectCount = currPicDefectCount;

  528.                         stopwatch.Stop();

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

  530.                         liStep = 3;

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

  532.                         {

  533.                             liStep = 4;

  534.                             //lock (taskTagList)

  535.                             //    taskTagList.Add(task);

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

  537.                             stopwatch.Restart();

  538. #if OpenSizeDefectComp

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

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

  541. #else

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

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

  544. #endif

  545. 

  546.                             liStep = 5;

  547. 

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

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

  550.                             //liStep = 51;

  551. 

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

  553.                             {

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

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

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

  557.                             }

  558.                             stopwatch.Stop();

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

  560. 

  561.                             liStep = 6;

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

  563.                             task.isSucceed = true;

  564.                             callback(task);

  565.                         }

  566.                         else

  567.                         {

  568.                             task.isSucceed = true;

  569.                             callback(task);

  570.                         }

  571.                     }

  572.                     Thread.Sleep(5);

  573.                 }

  574.                 catch (Exception ex)

  575.                 {

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

  577.                     task.isSucceed = false;

  578.                     task.resultInfo = ex.Message;

  579.                     callback(task);

  580.                 }

  581.             }

  582.         }

  583.         /// <summary>

  584.         /// 已不用

  585.         /// </summary>

  586.         private void run5()

  587.         {

  588.             while (IsInit)

  589.             {

  590.                 if (taskTagList.Count < 1)

  591.                 {

  592.                     Thread.Sleep(0);

  593.                     continue;

  594.                 }

  595. 

  596.                 //

  597.                 var task = pop3(); 

  598.                 try

  599.                 {

  600.                     if (task != null)

  601.                     {

  602.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  604.                         stopwatch.Start();

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

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

  607.                         stopwatch.Stop();

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

  609.                         task.isSucceed = true;

  610.                         callback(task);

  611.                     }

  612.                 }

  613.                 catch (Exception ex)

  614.                 {

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

  616.                     task.isSucceed = false;

  617.                     task.resultInfo = ex.Message;

  618.                     callback(task);

  619.                 } 

  620.             }

  621.         }

  622.         private void callback(DefectTask task)

  623.         {

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

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

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

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

  628.         }

  629.         //异步回调

  630.         WaitCallback waitCallback = new WaitCallback(o =>

  631.         {

  632.             var task = (DefectTask)o;

  633.             task.finishEvent(task);

  634.         });

  635.         

  636.         public class DefectTask

  637.         {

  638.             public int stepIndex;

  639.             public string processName;

  640. 

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

  642.             public string modelType;

  643. 

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

  645.             //图索引

  646.             public int index = 0;

  647.             /// <summary>

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

  649.             /// </summary>

  650.             public double Xmm;

  651.             /// <summary>

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

  653.             /// </summary>

  654.             public double Ymm;

  655.             /// <summary>

  656.             /// 源文件

  657.             /// </summary>

  658.             public Mat bmp;

  659.             public Mat srcbmp;

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

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

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

  663.             /// <summary>

  664.             /// 阈值

  665.             /// </summary>

  666.             public float thresholds = 0.4f;

  667.             /// <summary>

  668.             /// 种类阈值

  669.             /// </summary>

  670.             public string thresholdsClass;

  671.             /// <summary>

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

  673.             /// </summary>

  674.             public Dictionary<string, float> recAreaThreshold;

  675.             /// <summary>

  676.             /// 完成后回调 

  677.             /// </summary>

  678.             public Action<DefectTask> finishEvent;

  679. 

  680.             //

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

  682.             public DateTime nowTime;

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

  684.             public Mat[] bmps_cut;

  685.             public Mat[] bmps_resize;

  686.             //预处理模型

  687.             public Tensor<float>[] tensors;

  688. 

  689.             //==结果返回

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

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

  692.             

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

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

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

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

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

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

  699.             //裁切原图

  700.             public Mat CutSrcbmp;

  701.         }

  702. 

  703.         public void add(DefectTask task)

  704.         {

  705.             lock (taskList)

  706.                 taskList.Add(task);

  707.         }

  708.         /// <summary>

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

  710.         /// </summary>

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

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

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

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

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

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

  717.         {

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

  719.         }

  720.         /// <summary>

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

  722.         /// </summary>

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

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

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

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

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

  728.         /// <returns></returns>

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

  730.         {

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

  732.         }

  733.         private DefectTask pop()

  734.         {

  735.             lock (taskList)

  736.             {

  737.                 if (taskList.Count < 1)

  738.                     return null;

  739. 

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

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

  742.                 var task = taskList[0];

  743.                 taskList.RemoveAt(0);

  744.                 return task;

  745.             }

  746.         }

  747.         private DefectTask pop2()

  748.         {

  749.             lock (taskOperationList)

  750.             {

  751.                 if (taskOperationList.Count < 1)

  752.                     return null;

  753. 

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

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

  756.                 var task = taskOperationList[0];

  757.                 taskOperationList.RemoveAt(0);

  758.                 return task;

  759.             }

  760.         }

  761.         private DefectTask pop3()

  762.         {

  763.             lock (taskTagList)

  764.             {

  765.                 if (taskTagList.Count < 1)

  766.                     return null;

  767. 

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

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

  770.                 var task = taskTagList[0];

  771.                 taskTagList.RemoveAt(0);

  772.                 return task;

  773.             }

  774.         } 

  775. 

  776.         public void Dispose()

  777.         {

  778.             stop();

  779.         }

  780.     }

  781. }