CPL
/
geboshi_V1
1
0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
革博士程序V1仓库
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
11 Révisions
3 Branches
1.4 GiB
 
Aborescence: 5f50916938
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '5f50916938'
${ noResults }
geboshi_V1/LeatherProject/GeBoShi/ImageDefect/DefectLib.cs

799 lignes
37 KiB
Brut Annotations Historique 

  1. using CCWin.Win32.Const;

  2. using GeBoShi.SysCtrl;

  3. using HZH_Controls.Controls;

  4. using MaiMuControl.Device;

  5. using Models;

  6. using OpenCvSharp;

  7. using S7.Net.Types;

  8. using System;

  9. using System.Collections.Generic;

  10. using System.Data;

  11. using System.Diagnostics;

  12. using System.Linq;

  13. using System.Reflection;

  14. using System.Runtime.InteropServices;

  15. using System.Text;

  16. using System.Threading;

  17. using System.Threading.Tasks;

  18. using static System.ComponentModel.Design.ObjectSelectorEditor;

  19. 

  20. namespace GeBoShi.ImageDefect

  21. {

  22.     public class DefectLib

  23.     {

  24.         #region C++dll

  25.         private const string dll_path = "yolo_trt.dll";

  26.         [DllImport(dll_path, CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)]

  27.         static extern IntPtr CreateDetector(string model_path);

  28. 

  29.         [DllImport(dll_path, CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]

  30.         extern static bool DestroyDetector(IntPtr detector);

  31. 

  32.         /// <summary>

  33.         /// 非0值表示成功，0表示失败 返回小图张数

  34.         /// </summary>

  35.         /// <param name="detector"></param>

  36.         /// <returns></returns>

  37.         [DllImport(dll_path, CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)]

  38.         static extern int GetBatchSize(IntPtr detector);

  39. 

  40.         [DllImport(dll_path, CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)]

  41.         static extern bool Detect(IntPtr detector, ref byte bgrs_data,

  42.           int image_num, int width, int height, int channels,

  43.           float conf_threshold, float iou_threshold,

  44.           ref float output, int output_size, ref int object_num,

  45.           int expand_pixel);

  46.         #endregion

  47. 

  48.         public Action<WarningEnum, string> WarningEvent;

  49.         /// <summary>

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

  51.         /// </summary>

  52.         public Action<DefectTask> finishEvent;

  53.         /// <summary>

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

  55.         /// </summary>

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

  57. 

  58.         private IntPtr detector = IntPtr.Zero;

  59. 

  60.         private Thread t_task, t_task_operation, t_task_maketag;

  61.         //=======task list

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

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

  64.         private List<DefectTask> taskMakeTagList = new List<DefectTask>();

  65. 

  66.         private string preModelName = "";

  67. 

  68.         #region 图片处理参数

  69.         private readonly int image_width = 2048;

  70.         private readonly int image_hight = 2048;

  71.         private readonly int image_channels = 3;

  72.         private readonly int image_bytes = 2048 * 2048 * 3;

  73.         private readonly int detect_elem_size = 7; //维度数据结果，x y w h conf classid

  74.         private readonly int detect_max_object_num = 20;//这个指的是一张子图可能最多给你返回的目标个球

  75. 

  76.         public Action<int, int> QueueCountEvent;//0/1/2, 数量

  77.         #endregion

  78.         public DefectLib()

  79.         {

  80.         }

  81. 

  82.         public bool start()

  83.         {

  84.             try

  85.             {

  86.                 //detector = CreateDetector(Config.model_path, Config.labels_path, true, 6); 

  87.                 //if (detector == IntPtr.Zero)

  88.                 //    throw new Exception("模型初始化失败！");

  89.                 preModelName = "";

  90. 

  91.                 IsInit = true;

  92.                 taskList.Clear();

  93.                 taskOperationList.Clear();

  94.                 taskMakeTagList.Clear();

  95. 

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

  97.                 t_task.IsBackground = true;

  98.                 t_task.Start();

  99. 

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

  101.                 t_task_operation.IsBackground = true;

  102.                 t_task_operation.Start();

  103. 

  104.                 t_task_maketag = new System.Threading.Thread(run3);

  105.                 t_task_maketag.IsBackground = true;

  106.                 t_task_maketag.Start();

  107. 

  108.                 return true;

  109.             }

  110.             catch (Exception ex)

  111.             {

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

  113.                 return false;

  114.             }

  115.         }

  116. 

  117.         public void stop()

  118.         {

  119.             if (!IsInit) return;

  120. 

  121.             try

  122.             {

  123.                 IsInit = false;

  124.                 //timer.Elapsed -= Timer_Elapsed;

  125.                 preModelName = "";

  126.                 //释放模型

  127.                 if (detector != IntPtr.Zero)

  128.                 {

  129.                     DestroyDetector(detector);

  130.                     detector = IntPtr.Zero;

  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. 

  146.                 if (t_task_maketag != null)

  147.                 {

  148.                     bool b = t_task_maketag.Join(5000);

  149.                     if (!b) t_task_maketag.Abort();

  150.                     t_task_maketag = null;

  151.                 }

  152.                 taskList.Clear();

  153.                 taskOperationList.Clear();

  154.                 taskMakeTagList.Clear();

  155.             }

  156.             catch { }

  157.         }

  158. 

  159.         /// <summary>

  160.         /// 切割(先左右，后上下)

  161.         /// </summary>

  162.         /// <param name="mat"></param>

  163.         /// <param name="width"></param>

  164.         /// <param name="height"></param>

  165.         /// <returns></returns>

  166.         private Mat[] OpenCVToCutsMat(Mat mat, int width, int height)

  167.         {

  168.             Mat[] array = new Mat[mat.Width / width * mat.Height / height];

  169.             int num = 0;

  170.             for (int i = 0; i < mat.Height / height; i++)

  171.             {

  172.                 for (int j = 0; j < mat.Width / width; j++)

  173.                 {

  174.                     int x = j * width;

  175.                     int y = i * height;

  176.                     System.Drawing.Rectangle rectangle = new System.Drawing.Rectangle(x, y, width, height);

  177.                     Rect roi = new Rect(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);

  178.                     array[num] = new Mat(mat, roi).Clone();

  179.                     num++;

  180.                 }

  181.             }

  182. 

  183.             return array;

  184.         }

  185. 

  186.         public static string ToGB2312(int codepage, string str)

  187.         {

  188.             try

  189.             {

  190.                 Encoding cp850 = Encoding.GetEncoding(codepage);

  191.                 Encoding gb2312 = Encoding.GetEncoding("gb2312");//Encoding.Default ,936

  192.                 byte[] temp = cp850.GetBytes(str);

  193.                 return Encoding.GetEncoding("gb2312").GetString(temp, 0, temp.Length);

  194.             }

  195.             catch (Exception ex)//(UnsupportedEncodingException ex)

  196.             {

  197.                 Console.Write(ex.Message);

  198.                 return null;

  199.             }

  200.         }

  201. 

  202.         private void runStep()

  203.         {

  204.             int step = 0;

  205.             while (IsInit)

  206.             {

  207.                 if (taskList.Count < 1)

  208.                 {

  209.                     Thread.Sleep(0);

  210.                     continue;

  211.                 }

  212. 

  213.                 //

  214.                 step = 1;

  215.                 var task = pop();

  216.                 try

  217.                 {

  218.                     if (task != null)

  219.                     {

  220.                         Stopwatch stopwatch = Stopwatch.StartNew();

  221.                         step = 2;

  222.                         if (preModelName != task.modelName)

  223.                         {

  224.                             step = 3;

  225.                             //先释放模型

  226.                             if (detector != IntPtr.Zero)

  227.                             {

  228.                                 step = 4;

  229.                                 DestroyDetector(detector);

  230.                                 detector = IntPtr.Zero;

  231.                             }

  232.                             step = 5;

  233.                             string modelPath = $"{ConfMgr.Instance.SysConfigParams.AIModelPath}\\{task.modelName}";

  234. 

  235.                             detector = CreateDetector(modelPath);

  236.                             if (detector == IntPtr.Zero)

  237.                                 throw new Exception($"模型({modelPath})初始化失败！");

  238.                             step = 6;

  239.                             preModelName = task.modelName;

  240.                         }

  241.                         //源图  

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

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

  244.                         stopwatch.Start();

  245.                         //task.resizeBmp = OpenCVUtil.resize( task.bmp.Clone(), task.resize.Width, task.resize.Height);//在外面已做了resize

  246. 

  247.                         //Cv2.CvtColor(task.bmp, task.bmpBgr2rgb, ColorConversionCodes.BGR2RGB); 

  248.                         //task.bmps_cut = OpenCVToCutsMat(task.bmpBgr2rgb, image_width, image_hight); //这里cut时之前加的clone 

  249.                         step = 7;

  250.                         task.bmps_cut = OpenCVToCutsMat(task.bmp, image_width, image_hight); //这里cut时之前加的clone 

  251.                         stopwatch.Stop();

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

  253. 

  254.                         //Resize图像

  255.                         //stopwatch.Restart();

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

  257.                         //stopwatch.Stop();

  258.                         //task.stopwatch[1] = stopwatch.ElapsedMilliseconds;

  259. 

  260.                         //预处理模型

  261.                         //stopwatch.Restart();

  262.                         //task.tensors = yolo1.PreprocessImageMat(task.bmps_resize);

  263.                         //stopwatch.Stop();

  264.                         //task.stopwatch[2] = stopwatch.ElapsedMilliseconds;

  265.                         step = 8;

  266.                         lock (taskOperationList)

  267.                         {

  268.                             taskOperationList.Add(task);

  269.                             QueueCountEvent?.BeginInvoke(1, taskOperationList.Count, null, null);

  270.                         }

  271.                         step = 9;

  272.                     }

  273.                 }

  274.                 catch (Exception ex)

  275.                 {

  276.                     WarningEvent?.Invoke(WarningEnum.Low, $"DefectLib task1 err({step}):" + ex.Message);

  277.                     task.isSucceed = false;

  278.                     task.resultInfo = ex.Message;

  279.                     callback(task);

  280.                 }

  281.             }

  282.         }

  283.         //推理

  284.         private void run2()

  285.         {

  286.             QualifiedLimit qualifiedLimit;

  287.             while (IsInit)

  288.             {

  289.                 if (taskOperationList.Count < 1)

  290.                 {

  291.                     Thread.Sleep(0);

  292.                     continue;

  293.                 }

  294. 

  295.                 //

  296.                 var task = pop2();

  297.                 int cut_count = 0, step = 0;

  298.                 try

  299.                 {

  300.                     if (task != null && task.bmps_cut.Count() > 0)

  301.                     {

  302.                         //WarningEvent?.Invoke(DateTime.Now,WarningEnum.Low, "DefectLib tasks 运行推理...");

  303.                         cut_count = task.bmps_cut.Count();

  304.                         Stopwatch stopwatch = Stopwatch.StartNew();

  305.                         //====推理（必需单队列）

  306.                         stopwatch.Start();

  307.                         // 把数据转为byte数组，【h, w, c】的bgr格式，第一张在前，第二张在后

  308.                         byte[] imgData = new byte[image_bytes * cut_count];

  309.                         for (int i = 0; i < cut_count; i++)

  310.                             Marshal.Copy(task.bmps_cut[i].Data, imgData, image_bytes * i, image_bytes);

  311.                         step = 1;

  312.                         stopwatch.Stop();

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

  314.                         stopwatch.Restart();

  315. 

  316.                         task.output = new float[cut_count * detect_elem_size * detect_max_object_num];

  317.                         task.output_num = new int[cut_count];

  318.                         //执行推理

  319.                         step = 2;

  320.                         bool ok = Detect(detector, ref imgData[0], cut_count, image_width, image_hight, image_channels,

  321.                             0.25f, 0.45f, ref task.output[0], task.output.Length, ref task.output_num[0], task.expand_pixel);

  322.                         //bool ok = Detect(_detector, ref imgData[0], imgs.Count, ImageWidth, image_hight, image_channels,

  323.                         //    0.25f, 0.45f, ref output[0],      output.Length,      ref output_num[0]);

  324.                         step = 3;

  325.                         stopwatch.Stop();

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

  327.                         //WarningEvent?.Invoke(DateTime.Now,WarningEnum.Low, $"DefectLib tasks 结果推理={ok}");

  328.                         for (int i = 0; i < cut_count; i++)

  329.                             task.bmps_cut[i].Dispose();

  330.                         if (ok == false)

  331.                             throw new Exception($"推理失败或者输入数组太小（{cut_count}）");

  332. 

  333.                         //

  334.                         lock (taskMakeTagList)

  335.                         {

  336.                             taskMakeTagList.Add(task);

  337.                             QueueCountEvent?.BeginInvoke(2, taskMakeTagList.Count, null, null);

  338.                         }

  339.                     }

  340.                 }

  341.                 catch (Exception ex)

  342.                 {

  343.                     WarningEvent?.Invoke(WarningEnum.Low, $"DefectLib task2 err({step}):({cut_count}){ex.Message}");

  344.                     task.isSucceed = false;

  345.                     task.resultInfo = ex.Message;

  346.                     callback(task);

  347.                 }

  348.             }

  349.         }

  350.         //打标

  351.         private void run3()

  352.         {

  353.             QualifiedLimit qualifiedLimit;

  354.             while (IsInit)

  355.             {

  356.                 if (taskMakeTagList.Count < 1)

  357.                 {

  358.                     Thread.Sleep(0);

  359.                     continue;

  360.                 }

  361. 

  362.                 //

  363.                 var task = pop3();

  364.                 int liStep = 0;

  365.                 try

  366.                 {

  367.                     Stopwatch stopwatch = Stopwatch.StartNew();

  368.                     stopwatch.Restart();

  369.                     int cut_count = task.bmps_cut.Count();//上面bmps_cut已销毁

  370.                     int colNum = task.bmp.Width / image_width;

  371.                     int rowNum = task.bmp.Height / image_hight;

  372.                     int count = 0;

  373.                     liStep = 3;

  374. 

  375.                     //车用革去除接头处横档误判

  376.                     bool haveJieTou = false;

  377.                     List<DefectLabelInfo> DefectLabelInfoList = new List<DefectLabelInfo>();

  378. 

  379.                     for (int i = 0; i < cut_count; i++)

  380.                     {

  381.                         liStep = i * 100;

  382.                         task.resultInfo += $"第 {i}/{cut_count} 张小图(大图索引{task.photoIndex}): 缺陷数 = {task.output_num[i]}\n";

  383.                         //task.resultInfo +=$"大图({task.tag})[{task.bmp.Width}*{task.bmp.Height}],第 {i + 1}/{cut_count} 张小图[{task.bmps_cut[i].Width}*{task.bmps_cut[i].Height}]: 瑕疵output_num = {output_num[i]}\n";

  384.                         #region 检测信息汇总

  385.                         for (int j = 0; j < task.output_num[i]; j++)//缺陷数

  386.                         {

  387.                             liStep += j;//0

  388.                                         //WarningEvent?.Invoke(DateTime.Now,WarningEnum.Low, $"-------");

  389.                             int index = count * detect_elem_size;

  390. 

  391.                             // 打印输出信息（示例代码，根据实际情况进行修改和格式化）

  392.                             // 获取输出信息

  393.                             int x = (int)task.output[index];

  394.                             int y = (int)task.output[index + 1];

  395.                             int w = (int)task.output[index + 2];

  396.                             int h = (int)task.output[index + 3];

  397.                             int classId = (int)task.output[index + 4];

  398.                             double confidence = Math.Round(task.output[index + 5], 2); //置信度

  399.                             double contrast = Math.Round(task.output[index + 6], 3);//对比度

  400.                             //y = image_hight-y-h;//转到右下角为原点

  401.                             count++;

  402. 

  403.                             //var cmW = Math.Round(w * task.widthRatio / task.cm2px_x, 2);

  404.                             //var cmH = Math.Round(h * task.widthRatio / task.cm2px_y, 2);

  405.                             // 打印输出信息

  406.                             task.resultInfo += $"----{i}----col:{i % colNum}/{colNum} row:{i / colNum}/{colNum}-----------\n目标:{j + 1} 类别ID:{classId} 置信度:{confidence} 对比度:{contrast} 坐标:({x},{y})-({x + w},{y + h}) 宽高:w={w},h={h}; \n";

  407. 

  408.                             DefectLabelInfoList.Add(new DefectLabelInfo()

  409.                             {

  410.                                 x = (int)task.output[index],

  411.                                 y = (int)task.output[index + 1],

  412.                                 w = (int)task.output[index + 2],

  413.                                 h = (int)task.output[index + 3],

  414.                                 classId = (int)task.output[index + 4],

  415.                                 confidence = Math.Round(task.output[index + 5], 2), //置信度

  416.                                 contrast = Math.Round(task.output[index + 6], 3),//对比度

  417.                                 cmW = Math.Round(w * task.widthRatio / task.cm2px_x, 2),

  418.                                 cmH = Math.Round(h * task.widthRatio / task.cm2px_y, 2),

  419.                                 i = i,

  420.                                 j = j,

  421.                             });

  422.                         }

  423. 

  424.                         #endregion

  425.                     }

  426. 

  427.                     #region 合并接头横档

  428.                     if(DefectLabelInfoList.Count >0)

  429.                         DefectLabelInfoList = HeBingDefect(task.bmp.Width, "jietou", DefectLabelInfoList);

  430.                     if (DefectLabelInfoList.Count > 0)

  431.                         DefectLabelInfoList = HeBingDefect(task.bmp.Width, "hengdang", DefectLabelInfoList);

  432.                     #endregion

  433.                     //结果过滤

  434.                     #region 结果过滤

  435.                     //降序排序，先得到是否有接头检出

  436.                     List<DefectLabelInfo> DefectLabelInfoListByClassID = DefectLabelInfoList.OrderByDescending(t => t.classId).ToList();//降序

  437.                     for (int q = 0; q < DefectLabelInfoList.Count; q++)

  438.                     {

  439.                         //是否满足此产品标准

  440.                         if (task.qualifiedLimitList != null && task.qualifiedLimitList.Count > 0)

  441.                         {

  442.                             qualifiedLimit = task.qualifiedLimitList.FirstOrDefault(m => m.Code == task.labelDic[DefectLabelInfoList[q].classId]);

  443.                             if (qualifiedLimit != null)

  444.                             {

  445.                                 //if ((qualifiedLimit.ZXD > 0 && qualifiedLimit.ZXD > confidence)

  446.                                 //    || (qualifiedLimit.ContrastTop + qualifiedLimit.ContrastLower > 0 && x> qualifiedLimit.ContrastLower && x < qualifiedLimit.ContrastTop)

  447.                                 //    || (qualifiedLimit.Area > 0 && qualifiedLimit.Area > cmW * cmH))

  448.                                 if (DefectLabelInfoList[q].confidence <= qualifiedLimit.ZXD)//confidence > qualifiedLimit.ZXD 是瑕疵 才继续判断下面的两个条件

  449.                                 {

  450.                                     task.resultInfo += $"   置信度不满足此产品瑕疵标准，跳过！ \n";

  451.                                     continue;

  452.                                 }

  453. 

  454.                                 //下限<对比度<上限：不是瑕疵

  455.                                 var ContrastTotal = qualifiedLimit.ContrastTop + qualifiedLimit.ContrastLower;

  456.                                 if (qualifiedLimit.IsOR)

  457.                                 {

  458.                                     if (!(

  459.                                         (qualifiedLimit.Area <= 0 || DefectLabelInfoList[q].cmW * DefectLabelInfoList[q].cmH >= qualifiedLimit.Area) ||

  460.                                         (ContrastTotal <= 0 || (DefectLabelInfoList[q].contrast < qualifiedLimit.ContrastLower || DefectLabelInfoList[q].contrast > qualifiedLimit.ContrastTop))))

  461.                                     {

  462.                                         task.resultInfo += $"   不满足此产品瑕疵标准，跳过！ \n";

  463.                                         //WarningEvent?.Invoke(DateTime.Now,WarningEnum.Low, $"判断不是瑕疵：类别ID:{classId}； 置信度({confidence},[{qualifiedLimit.ZXD}]); isOr({qualifiedLimit.IsOR}); 面积({cmW * cmH},[{ qualifiedLimit.Area}]); 对比度({contrast},[{qualifiedLimit.ContrastLower}-{qualifiedLimit.ContrastTop}])");

  464.                                         continue;

  465.                                     }

  466.                                 }

  467.                                 else

  468.                                 {

  469.                                     if (!(

  470.                                         (qualifiedLimit.Area <= 0 || DefectLabelInfoList[q].cmW * DefectLabelInfoList[q].cmH >= qualifiedLimit.Area) &&

  471.                                         (ContrastTotal <= 0 || (DefectLabelInfoList[q].contrast < qualifiedLimit.ContrastLower || DefectLabelInfoList[q].contrast > qualifiedLimit.ContrastTop))))

  472.                                     {

  473.                                         task.resultInfo += $"   不满足此产品瑕疵标准，跳过！ \n";

  474.                                         //WarningEvent?.Invoke(DateTime.Now,WarningEnum.Low, $"判断不是瑕疵：类别ID:{classId}； 置信度({confidence},[{qualifiedLimit.ZXD}]); isOr({qualifiedLimit.IsOR}); 面积({cmW * cmH},[{ qualifiedLimit.Area}]); 对比度({contrast},[{qualifiedLimit.ContrastLower}-{qualifiedLimit.ContrastTop}])");

  475.                                         continue;

  476.                                     }

  477.                                 }

  478.                                 if (task.labelDic[DefectLabelInfoList[q].classId] == "jietou")

  479.                                     haveJieTou = true;

  480.                                 if (haveJieTou && (task.labelDic[DefectLabelInfoList[q].classId] == "hengdang"))

  481.                                 {

  482.                                     task.resultInfo += $"   判断为接头处横档，跳过！ \n";

  483.                                     continue;

  484.                                 }

  485.                                 //WarningEvent?.Invoke(DateTime.Now,WarningEnum.Low, $"判断是瑕疵：类别ID:{classId}； 置信度({confidence},[{qualifiedLimit.ZXD}]); isOr({qualifiedLimit.IsOR}); 面积({cmW * cmH},[{ qualifiedLimit.Area}]); 对比度({contrast},[{qualifiedLimit.ContrastLower}-{qualifiedLimit.ContrastTop}])");

  486.                             }

  487.                         }

  488.                         liStep++;//1

  489.                                  //打标

  490.                         var point1 = new OpenCvSharp.Point((DefectLabelInfoList[q].i % colNum) * image_width + DefectLabelInfoList[q].x, (DefectLabelInfoList[q].i / colNum) * image_hight + DefectLabelInfoList[q].y);

  491.                         var point2 = new OpenCvSharp.Point(point1.X + DefectLabelInfoList[q].w, point1.Y + DefectLabelInfoList[q].h);

  492.                         liStep++;//2

  493.                         task.resultInfo += $"   转换到大图坐标(px)：p1={point1.X},{point1.Y}; p2={point2.X},{point2.Y}\n";

  494.                         Cv2.Rectangle(task.bmpTag, point1, point2, new Scalar(0.0, 0.0, 255.0), 1);//画打标点 

  495. 

  496.                         //WarningEvent?.Invoke(DateTime.Now,WarningEnum.Low, $"保存第 {count} 行缺陷信息；");

  497.                         int px = (point1.X - task.xw) > 0 ? (point1.X - task.xw) : 0;

  498.                         var cmX = Math.Round(px * task.widthRatio / task.cm2px_x, 2);

  499.                         var cmY = Math.Round((task.bmp.Height - point1.Y - DefectLabelInfoList[q].h) * task.widthRatio / task.cm2px_y, 2);//外面计Y从右下角为原点

  500.                         liStep++;//3

  501.                         task.resultInfo += $"   转换到大图坐标(cm)[widthRatio={task.widthRatio}]：x={cmX},y={cmY}; w={DefectLabelInfoList[q].cmW},h={DefectLabelInfoList[q].cmH}\n";

  502.                         task.excelTable.Rows.Add($"{task.photoIndex}", cmX, cmY, DefectLabelInfoList[q].cmW, DefectLabelInfoList[q].cmH, DefectLabelInfoList[q].j + 1, DefectLabelInfoList[q].classId, DefectLabelInfoList[q].confidence, Utils.ContrastToPercent(DefectLabelInfoList[q].contrast));

  503. 

  504.                         liStep++;//4

  505.                                  //切缺陷小图 

  506.                                  //WarningEvent?.Invoke(DateTime.Now,WarningEnum.Low, $"保存第 {count} 个缺陷小图；");

  507.                         int left, top, decX, decY;

  508.                         decX = (DefectLabelInfoList[q].w > 236 ? 20 : 256 - DefectLabelInfoList[q].w) / 2;

  509.                         decY = (DefectLabelInfoList[q].h > 236 ? 20 : 256 - DefectLabelInfoList[q].h) / 2;

  510.                         left = point1.X - decX;

  511.                         top = point1.Y - decY;

  512.                         if (left < 0) left = 0;

  513.                         if (top < 0) top = 0;

  514. 

  515.                         int width = DefectLabelInfoList[q].w + decX * 2;

  516.                         int height = DefectLabelInfoList[q].h + decY * 2;

  517.                         if (left + width > task.bmp.Width - 1) width = task.bmp.Width - left - 1;

  518.                         if (top + height > task.bmp.Height - 1) height = task.bmp.Height - top - 1;

  519.                         liStep++;//5 

  520.                         Rect roi = new Rect(left, top, width, height);

  521.                         liStep++;//6

  522.                         if (height < 1 || width < 1)

  523.                         {

  524.                             task.resultInfo += $"   打标到大图坐标Rect(px)：left={left},top={top}; width={width},height={height}\n";

  525.                             task.resultInfo += $"   test  point1.Y={point1.Y},h={DefectLabelInfoList[q].h}; top={top},mat.Height={task.bmp.Height}\n================\n";

  526.                             WarningEvent?.Invoke(WarningEnum.Normal, task.resultInfo);

  527.                         }

  528. 

  529.                         //保存

  530.                         //string filename = $"{Config.appBasePath}\\temp\\{task.tag}\\{task.tag}_X{mmX.ToString()}_Y{mmY.ToString()}_W{mmW.ToString()}_H{mmH.ToString()}_目标{j + 1}_类别{classId}_置信度{confidence}.bmp";

  531.                         //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(new Mat(task.bmp, roi)).Save(filename, ImageFormat.Jpeg);

  532. 

  533.                         task.lstDefectBmp.Add(new Mat(task.bmpTag, roi).Clone());

  534.                         liStep++;//7

  535.                     }

  536.                     #endregion

  537.                     liStep = 99;

  538.                     stopwatch.Stop();

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

  540. 

  541.                     task.isSucceed = true;

  542.                     callback(task);

  543.                 }

  544.                 catch (Exception ex)

  545.                 {

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

  547.                     task.isSucceed = false;

  548.                     task.resultInfo = ex.Message;

  549.                     callback(task);

  550.                 }

  551.             }           

  552.         }

  553. 

  554.         #region 词条合并

  555.         private List<DefectLabelInfo> HeBingDefect(int Width, string label, List<DefectLabelInfo> DefectLabelInfoList)

  556.         {

  557.             int fw = 500;

  558.             List<DefectLabelInfo> outList = new List<DefectLabelInfo>();

  559. 

  560.             List<DefectLabelInfo> HeBingList = new List<DefectLabelInfo>();

  561.             List<DefectLabelInfo> XcHeBingList = new List<DefectLabelInfo>();

  562.             List<int> xPos = new List<int>();

  563.             List<double> xZXD = new List<double>();

  564. 

  565.             DefectLabelInfo stpoint = DefectLabelInfoList[0];

  566. 

  567.             int colNum = Width / image_width;

  568.             //寻找在一条线上

  569.             for (int q = 0; q < DefectLabelInfoList.Count; q++)

  570.             {

  571.                 if (SysMgr.Instance.GetDefectCode()[DefectLabelInfoList[q].classId] == label)

  572.                 {

  573.                     int max = stpoint.y + fw;

  574.                     int min = stpoint.y - fw > 0 ? stpoint.y - fw : 0;

  575.                     if (DefectLabelInfoList[q].y >= min && DefectLabelInfoList[q].y <= max)

  576.                     {

  577.                         HeBingList.Add(DefectLabelInfoList[q]);

  578.                         xPos.Add(DefectLabelInfoList[q].x);

  579.                         xZXD.Add(DefectLabelInfoList[q].confidence);

  580.                     }

  581.                     else

  582.                         XcHeBingList.Add(DefectLabelInfoList[q]);

  583.                 }               

  584.                 else

  585.                     outList.Add(DefectLabelInfoList[q]);

  586.             }

  587.             //递归下次合并数据

  588.             List<DefectLabelInfo> dg1 = new List<DefectLabelInfo>();

  589.             if (XcHeBingList.Count > 0)

  590.                 dg1 = HeBingDefect(Width, label, XcHeBingList);

  591. 

  592. 

  593.             //多个jietou合并

  594.             if (HeBingList.Count > 0)

  595.             {

  596.                 var stIt = HeBingList.Find(x => x.x == xPos.Min());

  597.                 var edIt = HeBingList.Find(x => x.x == xPos.Max());

  598.                 var eZXD = HeBingList.Find(x => x.confidence == xZXD.Max());

  599.                 int newW = Math.Abs((edIt.i % colNum) * image_width + edIt.x) - ((stIt.i % colNum) * image_width + stIt.x) + edIt.w;

  600.                 outList.Add(new DefectLabelInfo()

  601.                 {

  602.                     x = stIt.x,

  603.                     y = edIt.y,

  604.                     w = newW, //多图叠加

  605.                     h = edIt.h,

  606.                     classId = eZXD.classId,

  607.                     confidence = eZXD.confidence,

  608.                     contrast = eZXD.contrast,

  609.                     cmH = Math.Round(edIt.h * 1.0 / ConfMgr.Instance.SysConfigParams.Cm2px_y, 2),

  610.                     cmW = Math.Round(newW * 1.0 / ConfMgr.Instance.SysConfigParams.Cm2px_x, 2),

  611.                     i = stIt.i,

  612.                     j = stIt.j,

  613.                 });

  614.             }

  615.             

  616.             outList = outList.Concat(dg1).ToList<DefectLabelInfo>();//保留重复项

  617.             return outList;

  618.         }

  619.         #endregion

  620. 

  621.         #region 结果回调

  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.         #endregion

  636. 

  637.         #region 处理队列

  638.         public void add(DefectTask task)

  639.         {

  640.             lock (taskList)

  641.             {

  642.                 taskList.Add(task);

  643.                 QueueCountEvent?.BeginInvoke(0, taskList.Count, null, null);

  644.             }

  645.         }

  646. 

  647. 

  648.         private DefectTask pop()

  649.         {

  650.             lock (taskList)

  651.             {

  652.                 if (taskList.Count < 1)

  653.                     return null;

  654. 

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

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

  657.                 var task = taskList[0];

  658.                 taskList.RemoveAt(0);

  659.                 QueueCountEvent?.BeginInvoke(0, taskList.Count, null, null);

  660.                 return task;

  661.             }

  662.         }

  663.         private DefectTask pop2()

  664.         {

  665.             lock (taskOperationList)

  666.             {

  667.                 if (taskOperationList.Count < 1)

  668.                     return null;

  669. 

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

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

  672.                 var task = taskOperationList[0];

  673.                 taskOperationList.RemoveAt(0);

  674.                 QueueCountEvent?.BeginInvoke(1, taskOperationList.Count, null, null);

  675.                 return task;

  676.             }

  677.         }

  678.         private DefectTask pop3()

  679.         {

  680.             lock (taskMakeTagList)

  681.             {

  682.                 if (taskMakeTagList.Count < 1)

  683.                     return null;

  684. 

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

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

  687.                 var task = taskMakeTagList[0];

  688.                 taskMakeTagList.RemoveAt(0);

  689.                 QueueCountEvent?.BeginInvoke(2, taskMakeTagList.Count, null, null);

  690.                 return task;

  691.             }

  692.         }

  693.         #endregion

  694. 

  695.         public void Dispose()

  696.         {

  697.             stop();

  698.         }

  699. 

  700.         private class DefectLabelInfo

  701.         {

  702.             public int x { get; set; }

  703.             public int y { get; set; }

  704.             public int w { get; set; }

  705.             public int h { get; set; }

  706.             public int classId { get; set; }

  707.             public double confidence { get; set; } //置信度

  708.             public double contrast { get; set; }//对比度

  709. 

  710.             public double cmW { get; set; }

  711.             public double cmH { get; set; }

  712. 

  713.             public int i { get; set; }//小图index

  714.             public int j { get; set; }//缺陷index

  715.         }

  716.     }

  717. 

  718.     public class DefectTask

  719.     {

  720.         public DefectTask()

  721.         {

  722.             // 创建一个 DataTable 对象来存储数据

  723.             excelTable = new DataTable("MyData");

  724.             // 添加列到 DataTable

  725.             excelTable.Columns.Add("FileName", typeof(string));

  726.             excelTable.Columns.Add("X", typeof(decimal));

  727.             excelTable.Columns.Add("Y", typeof(decimal));

  728.             excelTable.Columns.Add("W", typeof(decimal));

  729.             excelTable.Columns.Add("H", typeof(decimal));

  730.             excelTable.Columns.Add("目标", typeof(int));

  731.             excelTable.Columns.Add("类别", typeof(int));

  732.             excelTable.Columns.Add("置信度", typeof(decimal));

  733.             excelTable.Columns.Add("对比度", typeof(decimal));

  734.             // 向 DataTable 中添加数据行

  735.             //excelTable.Rows.Add("John Doe", 30);

  736.             //excelTable.Rows.Add("Jane Smith", 25);

  737.         }

  738.         /// <summary>

  739.         /// 处理参数

  740.         /// </summary>

  741.         public int expand_pixel;

  742.         public int cm2px_x;

  743.         public int cm2px_y;

  744. 

  745.         public Dictionary<int, string> labelDic;

  746.         /// <summary>

  747.         /// 模型名字

  748.         /// </summary>

  749.         public string modelName;

  750. 

  751.         public Models.Records record;

  752.         //public string bmpPath;//源图路径（仅目录）

  753.         /// <summary>

  754.         /// 源图(resize后的)

  755.         /// </summary>

  756.         public Mat bmp;

  757.         //public Mat bmpBgr2rgb=new Mat();

  758. 

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

  760.         //public Mat resizeBmp;//resize后 BGR2RGB图，只用于识别

  761.         public Mat bmpTag;

  762.         /// <summary>

  763.         /// 图片索引0-n

  764.         /// </summary>

  765.         public int photoIndex;//excel中对应的图像路径标识

  766.         public float widthRatio;//宽度比例，resize前/resize后

  767.                                 //切割后

  768.         public Mat[] bmps_cut;

  769. 

  770.         //用于比对参数 }//置信度 面积 对比度 

  771.         public List<QualifiedLimit> qualifiedLimitList;

  772. 

  773.         //推理后结果用于打标

  774.         public float[] output;

  775.         public int[] output_num;

  776. 

  777.         //

  778.         /// <summary>

  779.         /// 完成后回调 

  780.         /// </summary>

  781.         public Action<DefectTask> finishEvent;

  782.         //==结果返回    

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

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

  785. 

  786.         public List<Mat> lstDefectBmp = new List<Mat>();

  787.         /// <summary>

  788.         /// fileIndex,x_mm,y_mm,w_mm,h_mm,目标,类别ID,置信度

  789.         /// </summary>

  790.         public DataTable excelTable = new DataTable();

  791.         public long[] stopwatch = new long[4];

  792. 

  793.         /// <summary>

  794.         /// 等比例填充的宽度

  795.         /// </summary>

  796.         public int xw;

  797.     }

  798. }