CPL
/
banboshi_V2
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 1 Wiki Activiteit
版博士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.
67 Commits
5 Branches
6.2 GiB
 
 
 
 
Tree: 924cf71a67
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van '924cf71a67'
${ noResults }
banboshi_V2/halftoneproject-master/DefectInferTool/Defect/DefectLib.cs

790 regels
33 KiB
Ruw Blame Geschiedenis 

  1. //#define Defect3

  2. //#define OpenSizeDefectComp

  3. 

  4. using System;

  5. using System.Collections.Generic;

  6. using System.ComponentModel;

  7. using System.Diagnostics;

  8. using System.Drawing;

  9. using System.Drawing.Imaging;

  10. using System.IO;

  11. using System.Linq;

  12. using System.Reflection;

  13. using System.Threading;

  14. using System.Threading.Tasks;

  15. using System.Windows.Forms;

  16. using Microsoft.ML.OnnxRuntime;

  17. using Microsoft.ML.OnnxRuntime.Tensors;

  18. using Newtonsoft.Json;

  19. using OpenCvSharp;

  20. using Yolo5;

  21. 

  22. namespace MaiMuAOI.ImageProcessing

  23. {

  24.     public enum WarningEnum

  25.     {

  26.         [Description("正常")]

  27.         Normal,

  28.         [Description("低(可继续)")]

  29.         Low,

  30.         [Description("严重")]

  31.         High

  32.     }

  33. 

  34.     public class DefectLib : IDisposable

  35.     {

  36.         public Action<WarningEnum, string> WarningEvent;

  37.         /// <summary>

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

  39.         /// </summary>

  40.         public Action<DefectTask> finishEvent;

  41.         /// <summary>

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

  43.         /// </summary>

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

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

  46.         private Yolo_Class yolo1;

  47.         private InferenceSession _onnxSession;

  48.         private Yolo_Class yolo2;

  49.         private InferenceSession _onnxSession2;

  50.         private Yolo_Class yolo3;

  51.         private InferenceSession _onnxSession3;

  52.         // 

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

  54.         //=======task list

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

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

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

  58. 

  59.         public DefectLib()

  60.         {

  61.         } 

  62.         public bool start()

  63.         {

  64.             try

  65.             {

  66.                 yolo1 = new Yolo_Class();

  67.                 yolo2 = new Yolo_Class();

  68. #if Defect3

  69.                 yolo3 = new Yolo_Class();

  70. #endif

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

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

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

  74. 

  75.                 IsInit = true;

  76.                 //timer.Elapsed += Timer_Elapsed;

  77.                 //timer.Interval = 100;

  78.                 //timer.Enabled = true;

  79.                 taskList.Clear(); 

  80.                 taskOperationList.Clear();

  81.                 taskTagList.Clear();

  82. 

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

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

  85.                 t_task.IsBackground = true;

  86.                 t_task.Start();

  87. 

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

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

  90.                 t_task_operation.IsBackground = true;

  91.                 t_task_operation.Start();

  92. 

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

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

  95.                 t_task_operation2.IsBackground = true;

  96.                 t_task_operation2.Start();

  97. 

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

  99. #if Defect3

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

  101.                 t_task_operation3.IsBackground = true;

  102.                 t_task_operation3.Start();

  103. #endif

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

  105.                 return true;

  106.             }

  107.             catch (Exception ex)

  108.             {

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

  110.                 return false;

  111.             }

  112.         }

  113.         public void stop()

  114.         {

  115.             if (!IsInit) return;

  116. 

  117.             try

  118.             {

  119.                 IsInit = false;

  120.                 //timer.Elapsed -= Timer_Elapsed;

  121.                 //释放模型

  122.                 if (_onnxSession != null)

  123.                 {

  124.                     _onnxSession.Dispose();

  125.                     _onnxSession = null;

  126.                 }

  127.                 if (_onnxSession2 != null)

  128.                 {

  129.                     _onnxSession2.Dispose();

  130.                     _onnxSession2 = null;

  131.                 }

  132. #if Defect3

  133.                 if (_onnxSession3 != null)

  134.                 {

  135.                     _onnxSession3.Dispose();

  136.                     _onnxSession3 = null;

  137.                 }

  138. #endif

  139.                 _preLoadONNXFilePath = null;

  140. 

  141.                 if (t_task != null)

  142.                 {

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

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

  145.                     t_task = null;

  146.                 }

  147. 

  148.                 if (t_task_operation != null)

  149.                 {

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

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

  152.                     t_task_operation = null;

  153.                 }

  154.                 if (t_task_operation2 != null)

  155.                 {

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

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

  158.                     t_task_operation2 = null;

  159.                 }

  160. #if Defect3

  161.                 if (t_task_operation3 != null)

  162.                 {

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

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

  165.                     t_task_operation3 = null;

  166.                 }

  167. #endif

  168.                 if (t_task_tag != null)

  169.                 {

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

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

  172.                     t_task_tag = null;

  173.                 }

  174.                 taskList.Clear(); 

  175.                 taskOperationList.Clear();

  176.                 taskTagList.Clear();

  177.             }

  178.             catch { }

  179.         }

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

  181.         public void loadModelFile(string onnxFilePath, bool UseGPU)

  182.         {

  183.             try

  184.             {

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

  186.                 //不重复加载

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

  188.                     return;

  189. 

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

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

  192.                 //{

  193.                 //    if (_onnxSession != null)

  194.                 //    {

  195.                 //        _onnxSession.Dispose();

  196.                 //        _onnxSession = null;

  197.                 //    }

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

  199.                 //    _preLoadONNXFilePath = onnxFilePath;

  200.                 //});

  201.                 if (_onnxSession != null)

  202.                 {

  203.                     _onnxSession.Dispose();

  204.                     _onnxSession = null;

  205.                 }

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

  207. 

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

  209.                 if (_onnxSession2 != null)

  210.                 {

  211.                     _onnxSession2.Dispose();

  212.                     _onnxSession2 = null;

  213.                 }

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

  215. #if Defect3

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

  217.                 if (_onnxSession3 != null)

  218.                 {

  219.                     _onnxSession3.Dispose();

  220.                     _onnxSession3 = null;

  221.                 }

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

  223. #endif

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

  225.                 _preLoadONNXFilePath = onnxFilePath;

  226.             }

  227.             catch (Exception ex)

  228.             {

  229.                 MessageBox.Show(ex.Message);

  230.             }

  231.         }

  232.         /// <summary>

  233.         /// 保存图片

  234.         /// </summary>

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

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

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

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

  239.         {

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

  241.             {

  242.                 Directory.CreateDirectory(pictureUrl);

  243.             }

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

  245. 

  246.             try

  247.             {

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

  249.                 {

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

  251.                     {

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

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

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

  255.                         //img.Dispose();

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

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

  258.                         img.Dispose();

  259.                     }

  260.                 }

  261.             }

  262.             catch (Exception)

  263.             {

  264.                 if (Img != null)

  265.                 {

  266.                     Img.Dispose();

  267.                 }

  268.             }

  269.         }

  270.         private void runStep()

  271.         {

  272.             while (IsInit)

  273.             {

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

  275.                 {

  276.                     Thread.Sleep(5);

  277.                     continue;

  278.                 }

  279. 

  280.                 //

  281.                 var task = pop(); 

  282.                 try

  283.                 {

  284.                     if (task != null)

  285.                     {

  286.                         Stopwatch stopwatch = Stopwatch.StartNew();

  287.                         //源图  

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

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

  290.                         stopwatch.Start();

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

  292.                         stopwatch.Stop();

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

  294. 

  295.                         //Resize图像

  296.                         stopwatch.Restart();

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

  298.                         stopwatch.Stop();

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

  300. 

  301.                         //预处理模型

  302.                         stopwatch.Restart();

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

  304.                         stopwatch.Stop();

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

  306. 

  307.                         lock (taskOperationList)

  308.                             taskOperationList.Add(task);

  309.                     }

  310.                     Thread.Sleep(5);

  311.                 }

  312.                 catch (Exception ex)

  313.                 {

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

  315.                     task.isSucceed = false;

  316.                     task.resultInfo = ex.Message;

  317.                     callback(task);

  318.                 } 

  319.             }

  320.         }  

  321. 

  322.         private void run2()

  323.         {

  324.             while (IsInit)

  325.             {

  326.                 if (taskOperationList.Count < 1)

  327.                 {

  328.                     Thread.Sleep(5);

  329.                     continue;

  330.                 }

  331. 

  332.                 //

  333.                 var task = pop2();

  334.                 int liStep = 0;

  335.                 try

  336.                 {

  337.                     if (task != null)

  338.                     {

  339.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  341.                         stopwatch.Start();

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

  343.                         liStep = 1;

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

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

  346.                         else

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

  348.                         liStep = 2;

  349.                          

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

  351.                         int currPicDefectCount = 0;

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

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

  354.                         task.defectCount = currPicDefectCount;

  355.                         stopwatch.Stop();

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

  357.                         liStep = 3;

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

  359.                         {

  360.                             liStep = 4;

  361.                             //lock (taskTagList)

  362.                             //    taskTagList.Add(task);

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

  364.                             stopwatch.Restart();

  365. #if OpenSizeDefectComp

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

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

  368. #else

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

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

  371. #endif

  372. 

  373.                             liStep = 5;

  374. 

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

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

  377.                             //liStep = 51;

  378. 

  379.                             //if (ConfMgr.Instance.SysConfigParams.OpenFlawDistribution)

  380.                             //{

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

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

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

  384.                             //}

  385. 

  386.                             stopwatch.Stop();

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

  388. 

  389.                             liStep = 6;

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

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

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

  393.                             //else

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

  395.                             task.isSucceed = true;

  396.                             callback(task);

  397.                         }

  398.                         else

  399.                         { 

  400.                             task.isSucceed = true;

  401.                             callback(task);

  402.                         }

  403.                     }

  404.                     Thread.Sleep(5);

  405.                 }

  406.                 catch (Exception ex)

  407.                 {

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

  409.                     task.isSucceed = false;

  410.                     task.resultInfo = ex.Message;

  411.                     callback(task);

  412.                 } 

  413.             }

  414.         }

  415. 

  416.         private void run3()

  417.         {

  418.             while (IsInit)

  419.             {

  420.                 if (taskOperationList.Count < 1)

  421.                 {

  422.                     Thread.Sleep(5);

  423.                     continue;

  424.                 }

  425. 

  426.                 //

  427.                 var task = pop2();

  428.                 int liStep = 0;

  429.                 try

  430.                 {

  431.                     if (task != null)

  432.                     {

  433.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  435.                         stopwatch.Start();

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

  437.                         liStep = 1;

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

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

  440.                         else

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

  442.                         liStep = 2;

  443. 

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

  445.                         int currPicDefectCount = 0;

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

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

  448.                         task.defectCount = currPicDefectCount;

  449.                         stopwatch.Stop();

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

  451.                         liStep = 3;

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

  453.                         {

  454.                             liStep = 4;

  455.                             //lock (taskTagList)

  456.                             //    taskTagList.Add(task);

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

  458.                             stopwatch.Restart();

  459. #if OpenSizeDefectComp

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

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

  462. #else

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

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

  465. #endif

  466. 

  467.                             liStep = 5;

  468. 

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

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

  471.                             //liStep = 51;

  472. 

  473.                             //if (ConfMgr.Instance.SysConfigParams.OpenFlawDistribution)

  474.                             //{

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

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

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

  478.                             //}

  479.                             stopwatch.Stop();

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

  481. 

  482.                             liStep = 6;

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

  484.                             task.isSucceed = true;

  485.                             callback(task);

  486.                         }

  487.                         else

  488.                         {

  489.                             task.isSucceed = true;

  490.                             callback(task);

  491.                         }

  492.                     }

  493.                     Thread.Sleep(5);

  494.                 }

  495.                 catch (Exception ex)

  496.                 {

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

  498.                     task.isSucceed = false;

  499.                     task.resultInfo = ex.Message;

  500.                     callback(task);

  501.                 }

  502.             }

  503.         }

  504. 

  505.         private void run4()

  506.         {

  507.             while (IsInit)

  508.             {

  509.                 if (taskOperationList.Count < 1)

  510.                 {

  511.                     Thread.Sleep(5);

  512.                     continue;

  513.                 }

  514. 

  515.                 //

  516.                 var task = pop2();

  517.                 int liStep = 0;

  518.                 try

  519.                 {

  520.                     if (task != null)

  521.                     {

  522.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  524.                         stopwatch.Start();

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

  526.                         liStep = 1;

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

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

  529.                         else

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

  531.                         liStep = 2;

  532. 

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

  534.                         int currPicDefectCount = 0;

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

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

  537.                         task.defectCount = currPicDefectCount;

  538.                         stopwatch.Stop();

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

  540.                         liStep = 3;

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

  542.                         {

  543.                             liStep = 4;

  544.                             //lock (taskTagList)

  545.                             //    taskTagList.Add(task);

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

  547.                             stopwatch.Restart();

  548. #if OpenSizeDefectComp

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

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

  551. #else

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

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

  554. #endif

  555. 

  556.                             liStep = 5;

  557. 

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

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

  560.                             //liStep = 51;

  561. 

  562.                             //if (ConfMgr.Instance.SysConfigParams.OpenFlawDistribution)

  563.                             //{

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

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

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

  567.                             //}

  568.                             stopwatch.Stop();

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

  570. 

  571.                             liStep = 6;

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

  573.                             task.isSucceed = true;

  574.                             callback(task);

  575.                         }

  576.                         else

  577.                         {

  578.                             task.isSucceed = true;

  579.                             callback(task);

  580.                         }

  581.                     }

  582.                     Thread.Sleep(5);

  583.                 }

  584.                 catch (Exception ex)

  585.                 {

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

  587.                     task.isSucceed = false;

  588.                     task.resultInfo = ex.Message;

  589.                     callback(task);

  590.                 }

  591.             }

  592.         }

  593.         /// <summary>

  594.         /// 已不用

  595.         /// </summary>

  596.         private void run5()

  597.         {

  598.             while (IsInit)

  599.             {

  600.                 if (taskTagList.Count < 1)

  601.                 {

  602.                     Thread.Sleep(0);

  603.                     continue;

  604.                 }

  605. 

  606.                 //

  607.                 var task = pop3(); 

  608.                 try

  609.                 {

  610.                     if (task != null)

  611.                     {

  612.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  614.                         stopwatch.Start();

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

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

  617.                         stopwatch.Stop();

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

  619.                         task.isSucceed = true;

  620.                         callback(task);

  621.                     }

  622.                 }

  623.                 catch (Exception ex)

  624.                 {

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

  626.                     task.isSucceed = false;

  627.                     task.resultInfo = ex.Message;

  628.                     callback(task);

  629.                 } 

  630.             }

  631.         }

  632.         private void callback(DefectTask task)

  633.         {

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

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

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

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

  638.         }

  639.         //异步回调

  640.         WaitCallback waitCallback = new WaitCallback(o =>

  641.         {

  642.             var task = (DefectTask)o;

  643.             task.finishEvent(task);

  644.         });

  645.         

  646.         public class DefectTask

  647.         {

  648.             public int stepIndex;

  649.             public string processName;

  650. 

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

  652.             public string modelType;

  653. 

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

  655.             //图索引

  656.             public int index = 0;

  657.             /// <summary>

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

  659.             /// </summary>

  660.             public double Xmm;

  661.             /// <summary>

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

  663.             /// </summary>

  664.             public double Ymm;

  665.             /// <summary>

  666.             /// 源文件

  667.             /// </summary>

  668.             public Mat bmp;

  669.             public Mat srcbmp;

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

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

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

  673.             /// <summary>

  674.             /// 阈值

  675.             /// </summary>

  676.             public float thresholds = 0.4f;

  677.             /// <summary>

  678.             /// 种类阈值

  679.             /// </summary>

  680.             public string thresholdsClass;

  681.             /// <summary>

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

  683.             /// </summary>

  684.             public Dictionary<string, float> recAreaThreshold;

  685.             /// <summary>

  686.             /// 完成后回调 

  687.             /// </summary>

  688.             public Action<DefectTask> finishEvent;

  689. 

  690.             //

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

  692.             public DateTime nowTime;

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

  694.             public Mat[] bmps_cut;

  695.             public Mat[] bmps_resize;

  696.             //预处理模型

  697.             public Tensor<float>[] tensors;

  698. 

  699.             //==结果返回

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

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

  702.             

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

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

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

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

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

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

  709.         }

  710. 

  711.         public void add(DefectTask task)

  712.         {

  713.             lock (taskList)

  714.                 taskList.Add(task);

  715.         }

  716.         /// <summary>

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

  718.         /// </summary>

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

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

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

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

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

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

  725.         {

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

  727.         }

  728.         /// <summary>

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

  730.         /// </summary>

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

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

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

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

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

  736.         /// <returns></returns>

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

  738.         {

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

  740.         }

  741.         private DefectTask pop()

  742.         {

  743.             lock (taskList)

  744.             {

  745.                 if (taskList.Count < 1)

  746.                     return null;

  747. 

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

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

  750.                 var task = taskList[0];

  751.                 taskList.RemoveAt(0);

  752.                 return task;

  753.             }

  754.         }

  755.         private DefectTask pop2()

  756.         {

  757.             lock (taskOperationList)

  758.             {

  759.                 if (taskOperationList.Count < 1)

  760.                     return null;

  761. 

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

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

  764.                 var task = taskOperationList[0];

  765.                 taskOperationList.RemoveAt(0);

  766.                 return task;

  767.             }

  768.         }

  769.         private DefectTask pop3()

  770.         {

  771.             lock (taskTagList)

  772.             {

  773.                 if (taskTagList.Count < 1)

  774.                     return null;

  775. 

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

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

  778.                 var task = taskTagList[0];

  779.                 taskTagList.RemoveAt(0);

  780.                 return task;

  781.             }

  782.         } 

  783. 

  784.         public void Dispose()

  785.         {

  786.             stop();

  787.         }

  788.     }

  789. }