CPL
/
geboshi_V2
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
革博士V2程序
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.
5 Commits
2 Branches
904 MiB
 
Tree: 1020667987
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1020667987'
${ noResults }
geboshi_V2/LeatherProject/GeBoShi/ImageDefect/DefectLib.cs

1201 lines
61 KiB
Raw Blame History 

  1. //#define Online_One

  2. 

  3. using CCWin.Win32.Const;

  4. using DocumentFormat.OpenXml.Office2010.ExcelAc;

  5. using GeBoShi.SysCtrl;

  6. using HZH_Controls.Controls;

  7. using MaiMuControl.Device;

  8. using Models;

  9. using OpenCvSharp;

  10. using S7.Net.Types;

  11. using System;

  12. using System.Collections.Generic;

  13. using System.Data;

  14. using System.Diagnostics;

  15. using System.Linq;

  16. using System.Reflection;

  17. using System.Runtime.InteropServices;

  18. using System.Text;

  19. using System.Threading;

  20. using System.Threading.Tasks;

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

  22. 

  23. namespace GeBoShi.ImageDefect

  24. {

  25.     public class DefectLib

  26.     {

  27.         #region C++dll

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

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

  30.         static extern IntPtr CreateDetector(string model_path);

  31. 

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

  33.         extern static bool DestroyDetector(IntPtr detector);

  34. 

  35.         /// <summary>

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

  37.         /// </summary>

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

  39.         /// <returns></returns>

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

  41.         static extern int GetBatchSize(IntPtr detector);

  42. 

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

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

  45.           int image_num, int width, int height, int channels,

  46.           float conf_threshold, float iou_threshold,

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

  48.           int expand_pixel);

  49.         #endregion

  50. 

  51.         public Action<WarningEnum, string> WarningEvent;

  52.         /// <summary>

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

  54.         /// </summary>

  55.         public Action<DefectTask> finishEvent;

  56.         /// <summary>

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

  58.         /// </summary>

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

  60. 

  61.         private IntPtr detector = IntPtr.Zero;

  62. 

  63.         private Thread t_task, t_task_operation, t_task_maketag, t_task_defectover;

  64.         //=======task list

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

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

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

  68.         private List<DefectTask> taskDefectOverList = new List<DefectTask>();

  69. 

  70.         private string preModelName = "";

  71. 

  72.         #region 图片处理参数

  73.         private readonly int image_width = 2048;

  74.         private readonly int image_hight = 2048;

  75.         private readonly int image_channels = 3;

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

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

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

  79. 

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

  81.         #endregion

  82.         public DefectLib()

  83.         {

  84.         }

  85. 

  86.         public bool start()

  87.         {

  88.             try

  89.             {

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

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

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

  93.                 preModelName = "";

  94. 

  95.                 IsInit = true;

  96.                 taskList.Clear();

  97.                 taskOperationList.Clear();

  98.                 taskMakeTagList.Clear();

  99. 

  100. #if Online_One

  101.                 t_task = new System.Threading.Thread(run);

  102.                 t_task.IsBackground = true;

  103.                 t_task.Start();

  104. #else

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

  106.                 t_task.IsBackground = true;

  107.                 t_task.Start();

  108. 

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

  110.                 t_task_operation.IsBackground = true;

  111.                 t_task_operation.Start();

  112. 

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

  114.                 t_task_maketag.IsBackground = true;

  115.                 t_task_maketag.Start();

  116. 

  117.                 //t_task_defectover = new System.Threading.Thread(run4);

  118.                 //t_task_defectover.IsBackground = true;

  119.                 //t_task_defectover.Start();

  120. #endif

  121.                 return true;

  122.             }

  123.             catch (Exception ex)

  124.             {

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

  126.                 return false;

  127.             }

  128.         }

  129. 

  130.         public void stop()

  131.         {

  132.             if (!IsInit) return;

  133. 

  134.             try

  135.             {

  136.                 IsInit = false;

  137.                 //timer.Elapsed -= Timer_Elapsed;

  138.                 preModelName = "";

  139.                 //释放模型

  140.                 if (detector != IntPtr.Zero)

  141.                 {

  142.                     DestroyDetector(detector);

  143.                     detector = IntPtr.Zero;

  144.                 }

  145.                 if (t_task != null)

  146.                 {

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

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

  149.                     t_task = null;

  150.                 }

  151. 

  152.                 if (t_task_operation != null)

  153.                 {

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

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

  156.                     t_task_operation = null;

  157.                 }

  158. 

  159.                 if (t_task_maketag != null)

  160.                 {

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

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

  163.                     t_task_maketag = null;

  164.                 }

  165. 

  166.                 //if (t_task_defectover != null)

  167.                 //{

  168.                 //    bool b = t_task_defectover.Join(5000);

  169.                 //    if (!b) t_task_defectover.Abort();

  170.                 //    t_task_defectover = null;

  171.                 //}

  172.                 taskList.Clear();

  173.                 taskOperationList.Clear();

  174.                 taskMakeTagList.Clear();

  175.                 taskDefectOverList.Clear();

  176.             }

  177.             catch { }

  178.         }

  179. 

  180.         /// <summary>

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

  182.         /// </summary>

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

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

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

  186.         /// <returns></returns>

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

  188.         {

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

  190.             int num = 0;

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

  192.             {

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

  194.                 {

  195.                     int x = j * width;

  196.                     int y = i * height;

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

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

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

  200.                     num++;

  201.                 }

  202.             }

  203. 

  204.             return array;

  205.         }

  206. 

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

  208.         {

  209.             try

  210.             {

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

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

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

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

  215.             }

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

  217.             {

  218.                 Console.Write(ex.Message);

  219.                 return null;

  220.             }

  221.         }

  222. 

  223.         private void runStep()

  224.         {

  225.             int step = 0;

  226.             while (IsInit)

  227.             {

  228.                 if (taskList.Count < 1)

  229.                 {

  230.                     Thread.Sleep(25);

  231.                     continue;

  232.                 }

  233. 

  234.                 //

  235.                 step = 1;

  236.                 var task = pop();

  237.                 try

  238.                 {

  239.                     if (task != null)

  240.                     {

  241.                         Stopwatch stopwatch = Stopwatch.StartNew();

  242.                         step = 2;

  243.                         if (preModelName != task.modelName)

  244.                         {

  245.                             step = 3;

  246.                             //先释放模型

  247.                             if (detector != IntPtr.Zero)

  248.                             {

  249.                                 step = 4;

  250.                                 DestroyDetector(detector);

  251.                                 detector = IntPtr.Zero;

  252.                             }

  253.                             step = 5;

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

  255. 

  256.                             detector = CreateDetector(modelPath);

  257.                             if (detector == IntPtr.Zero)

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

  259.                             step = 6;

  260.                             preModelName = task.modelName;

  261.                         }

  262.                         //源图  

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

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

  265.                         stopwatch.Start();

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

  267. 

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

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

  270.                         step = 7;

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

  272.                         stopwatch.Stop();

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

  274. 

  275.                         //Resize图像

  276.                         //stopwatch.Restart();

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

  278.                         //stopwatch.Stop();

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

  280. 

  281.                         //预处理模型

  282.                         //stopwatch.Restart();

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

  284.                         //stopwatch.Stop();

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

  286.                         step = 8;

  287.                         lock (taskOperationList)

  288.                         {

  289.                             taskOperationList.Add(task);

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

  291.                         }

  292.                         step = 9;

  293.                     }

  294.                 }

  295.                 catch (Exception ex)

  296.                 {

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

  298.                     task.isSucceed = false;

  299.                     task.resultInfo = ex.Message;

  300.                     callback(task);

  301.                 }

  302.                 Thread.Sleep(5);

  303.             }

  304.         }

  305.         //推理

  306.         private void run2()

  307.         {

  308.             QualifiedLimit qualifiedLimit;

  309.             while (IsInit)

  310.             {

  311.                 if (taskOperationList.Count < 1)

  312.                 {

  313.                     Thread.Sleep(25);

  314.                     continue;

  315.                 }

  316. 

  317.                 //

  318.                 var task = pop2();

  319.                 int cut_count = 0, step = 0;

  320.                 try

  321.                 {

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

  323.                     {

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

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

  326.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  328.                         stopwatch.Start();

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

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

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

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

  333.                         step = 1;

  334.                         stopwatch.Stop();

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

  336.                         stopwatch.Restart();

  337. 

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

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

  340.                         //执行推理

  341.                         step = 2;

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

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

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

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

  346.                         step = 3;

  347.                         stopwatch.Stop();

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

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

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

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

  352.                         if (ok == false)

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

  354. 

  355.                         //

  356.                         lock (taskMakeTagList)

  357.                         {

  358.                             taskMakeTagList.Add(task);

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

  360.                         }

  361.                     }

  362.                 }

  363.                 catch (Exception ex)

  364.                 {

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

  366.                     task.isSucceed = false;

  367.                     task.resultInfo = ex.Message;

  368.                     callback(task);

  369.                 }

  370.                 Thread.Sleep(5);

  371.             }

  372.         }

  373.         //打标

  374.         private void run3()

  375.         {

  376.             QualifiedLimit qualifiedLimit;

  377.             while (IsInit)

  378.             {

  379.                 if (taskMakeTagList.Count < 1)

  380.                 {

  381.                     Thread.Sleep(25);

  382.                     continue;

  383.                 }

  384. 

  385.                 //

  386.                 var task = pop3();

  387.                 int liStep = 0;

  388.                 try

  389.                 {

  390.                     Stopwatch stopwatch = Stopwatch.StartNew();

  391.                     stopwatch.Restart();

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

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

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

  395.                     int count = 0;

  396.                     liStep = 3;

  397. 

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

  399.                     bool haveJieTou = false;

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

  401. 

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

  403.                     {

  404.                         liStep = i * 100;

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

  406.                         //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";

  407.                         #region 检测信息汇总

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

  409.                         {

  410.                             liStep += j + 10000;//0

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

  412.                             int index = count * detect_elem_size;

  413. 

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

  415.                             // 获取输出信息

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

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

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

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

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

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

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

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

  424.                             count++;

  425. 

  426.                             liStep+= 10000;//0

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

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

  429.                             // 打印输出信息

  430.                             //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";

  431. 

  432.                             DefectLabelInfoList.Add(new DefectLabelInfo()

  433.                             {

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

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

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

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

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

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

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

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

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

  443.                                 i = i,

  444.                                 j = j,

  445.                             });

  446.                         }

  447. 

  448.                         #endregion

  449.                     }

  450.                     liStep = 7777;

  451.                     #region 合并接头横档

  452.                     if (DefectLabelInfoList.Count > 0)

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

  454.                     if (DefectLabelInfoList.Count > 0)

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

  456.                     if (DefectLabelInfoList.Count > 0)

  457.                         DefectLabelInfoList = HeBingDefect(task.bmp.Width, "jt", DefectLabelInfoList);

  458.                     if (DefectLabelInfoList.Count > 0)

  459.                         DefectLabelInfoList = HeBingDefect(task.bmp.Width, "hd", DefectLabelInfoList);

  460.                     if (DefectLabelInfoList.Count > 0)

  461.                         DefectLabelInfoList = HeBingDefect(task.bmp.Width, "bj", DefectLabelInfoList);

  462.                     if (DefectLabelInfoList.Count > 0)

  463.                         DefectLabelInfoList = HeBingDefect(task.bmp.Width, "zj", DefectLabelInfoList);

  464.                     #endregion

  465.                     //结果过滤

  466.                     #region 结果过滤

  467. 

  468.                     liStep = 8888;

  469.                     if (DefectLabelInfoList.Count > 0)

  470.                     {

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

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

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

  474.                         {

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

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

  477.                             {

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

  479.                                 if (qualifiedLimit != null)

  480.                                 {

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

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

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

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

  485.                                     {

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

  487.                                         continue;

  488.                                     }

  489. 

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

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

  492.                                     if (qualifiedLimit.IsOR)

  493.                                     {

  494.                                         if (!(

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

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

  497.                                         {

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

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

  500.                                             continue;

  501.                                         }

  502.                                     }

  503.                                     else

  504.                                     {

  505.                                         if (!(

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

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

  508.                                         {

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

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

  511.                                             continue;

  512.                                         }

  513.                                     }

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

  515.                                         haveJieTou = true;

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

  517.                                     {

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

  519.                                         continue;

  520.                                     }

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

  522.                                 }

  523.                             }

  524.                             liStep++;

  525.                             //1

  526.                             int penLine = 20;

  527.                             //打标

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

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

  530.                             liStep++;//2

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

  532. 

  533.                             

  534.                             

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

  536. 

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

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

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

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

  541.                             liStep++;//3

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

  543.                             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));

  544. 

  545.                             liStep++;//4

  546.                                      //切缺陷小图 

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

  548.                             int left, top, decX, decY;

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

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

  551.                             int tdecX = (DefectLabelInfoList[q].w /2 ) / 2;

  552.                             int tdecY = DefectLabelInfoList[q].w/ DefectLabelInfoList[q].h > 4 ? DefectLabelInfoList[q].w /8 : (DefectLabelInfoList[q].h /1 ) / 2;

  553. 

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

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

  556. 

  557.                             left = point1.X - decX;

  558.                             top = point1.Y - decY;

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

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

  561. 

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

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

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

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

  566.                             liStep++;//5 

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

  568.                             liStep++;//6

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

  570.                             {

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

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

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

  574.                             }

  575. 

  576.                             //保存

  577.                             //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";

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

  579. 

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

  581.                             liStep++;//7

  582.                         }

  583.                     }

  584.                     #endregion

  585.                     liStep = 99;

  586.                     stopwatch.Stop();

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

  588. 

  589.                     task.isSucceed = true;

  590. 

  591.                     //lock (taskDefectOverList)

  592.                     //{

  593.                     //    taskDefectOverList.Add(task);

  594.                     //    QueueCountEvent?.BeginInvoke(3, taskDefectOverList.Count, null, null);

  595.                     //}

  596. 

  597.                     callback(task);

  598.                     Thread.Sleep(5);

  599.                 }

  600.                 catch (Exception ex)

  601.                 {

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

  603.                     task.isSucceed = false;

  604.                     task.resultInfo = ex.Message;

  605.                     callback(task);

  606.                 }

  607.             }           

  608.         }

  609.         //最终处理

  610.         private void run()

  611.         {

  612.             int step = 0;

  613.             QualifiedLimit qualifiedLimit;

  614.             while (IsInit)

  615.             {

  616.                 if (taskList.Count < 1)

  617.                 {

  618.                     Thread.Sleep(5);

  619.                     continue;

  620.                 }

  621.                 step = 1;

  622.                 var task = pop();

  623.                 try

  624.                 {

  625.                     if (task != null)

  626.                     {

  627.                         Stopwatch stopwatch = Stopwatch.StartNew();

  628.                         step = 2;

  629.                         if (preModelName != task.modelName)

  630.                         {

  631.                             step = 3;

  632.                             //先释放模型

  633.                             if (detector != IntPtr.Zero)

  634.                             {

  635.                                 step = 4;

  636.                                 DestroyDetector(detector);

  637.                                 detector = IntPtr.Zero;

  638.                             }

  639.                             step = 5;

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

  641. 

  642.                             detector = CreateDetector(modelPath);

  643.                             if (detector == IntPtr.Zero)

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

  645.                             step = 6;

  646.                             preModelName = task.modelName;

  647.                         }

  648.                         //源图  

  649.                         stopwatch.Start();

  650.                         step = 7;

  651.                         //裁切

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

  653.                         stopwatch.Stop();

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

  655.                         step = 8;

  656.                         int cut_count = task.bmps_cut.Count();

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

  658.                         stopwatch.Restart();

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

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

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

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

  663.                         step = 9;

  664.                         stopwatch.Stop();

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

  666.                         stopwatch.Restart();

  667. 

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

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

  670.                         //执行推理

  671.                         step = 10;

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

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

  674.                         step = 11;

  675.                         stopwatch.Stop();

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

  677.                         stopwatch.Restart();

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

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

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

  681.                         if (ok == false)

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

  683.                         step = 12;

  684.                         //打标

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

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

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

  688.                         int count = 0;

  689.                         step = 13;

  690. 

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

  692.                         bool haveJieTou = false;

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

  694. 

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

  696.                         {

  697.                             step = i * 100;

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

  699.                             //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";

  700.                             #region 检测信息汇总

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

  702.                             {

  703.                                 step += j + 10000;//0

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

  705.                                 int index = count * detect_elem_size;

  706. 

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

  708.                                 // 获取输出信息

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

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

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

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

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

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

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

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

  717.                                 count++;

  718. 

  719.                                 step += 10000;//0

  720.                                      

  721.                                 DefectLabelInfoList.Add(new DefectLabelInfo()

  722.                                 {

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

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

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

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

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

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

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

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

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

  732.                                     i = i,

  733.                                     j = j,

  734.                                 });

  735.                             }

  736. 

  737.                             #endregion

  738.                         }

  739.                         step = 7777;

  740.                         #region 合并接头横档

  741.                         if (DefectLabelInfoList.Count > 0)

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

  743.                         if (DefectLabelInfoList.Count > 0)

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

  745.                         if (DefectLabelInfoList.Count > 0)

  746.                             DefectLabelInfoList = HeBingDefect(task.bmp.Width, "jt", DefectLabelInfoList);

  747.                         if (DefectLabelInfoList.Count > 0)

  748.                             DefectLabelInfoList = HeBingDefect(task.bmp.Width, "hd", DefectLabelInfoList);

  749.                         if (DefectLabelInfoList.Count > 0)

  750.                             DefectLabelInfoList = HeBingDefect(task.bmp.Width, "bj", DefectLabelInfoList);

  751.                         #endregion

  752.                         //结果过滤

  753.                         #region 结果过滤

  754. 

  755.                         step = 8888;

  756.                         if (DefectLabelInfoList.Count > 0)

  757.                         {

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

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

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

  761.                             {

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

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

  764.                                 {

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

  766.                                     if (qualifiedLimit != null)

  767.                                     {

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

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

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

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

  772.                                         {

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

  774.                                             continue;

  775.                                         }

  776. 

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

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

  779.                                         if (qualifiedLimit.IsOR)

  780.                                         {

  781.                                             if (!(

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

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

  784.                                             {

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

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

  787.                                                 continue;

  788.                                             }

  789.                                         }

  790.                                         else

  791.                                         {

  792.                                             if (!(

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

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

  795.                                             {

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

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

  798.                                                 continue;

  799.                                             }

  800.                                         }

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

  802.                                             haveJieTou = true;

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

  804.                                         {

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

  806.                                             continue;

  807.                                         }

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

  809.                                     }

  810.                                 }

  811.                                 step++;

  812.                                 //1

  813.                                 int penLine = 20;

  814.                                 //打标

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

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

  817.                                 step++;//2

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

  819. 

  820. 

  821. 

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

  823. 

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

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

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

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

  828.                                 step++;//3

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

  830.                                 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));

  831. 

  832.                                 step++;//4

  833.                                          //切缺陷小图 

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

  835.                                 int left, top, decX, decY;

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

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

  838.                                 int tdecX = (DefectLabelInfoList[q].w / 2) / 2;

  839.                                 int tdecY = DefectLabelInfoList[q].w / DefectLabelInfoList[q].h > 4 ? DefectLabelInfoList[q].w / 8 : (DefectLabelInfoList[q].h / 1) / 2;

  840. 

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

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

  843. 

  844.                                 left = point1.X - decX;

  845.                                 top = point1.Y - decY;

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

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

  848. 

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

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

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

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

  853.                                 step++;//5 

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

  855.                                 step++;//6

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

  857.                                 {

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

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

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

  861.                                 }

  862. 

  863.                                 //保存

  864.                                 //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";

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

  866. 

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

  868.                                 step++;//7

  869.                             }

  870.                         }

  871.                         #endregion

  872.                         step = 99;

  873.                         stopwatch.Stop();

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

  875. 

  876.                         task.isSucceed = true;

  877. 

  878.                         //lock (taskDefectOverList)

  879.                         //{

  880.                         //    taskDefectOverList.Add(task);

  881.                         //    QueueCountEvent?.BeginInvoke(3, taskDefectOverList.Count, null, null);

  882.                         //}

  883. 

  884.                         callback(task);

  885.                     }

  886.                 }

  887.                 catch (Exception ex)

  888.                 {

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

  890.                     task.isSucceed = false;

  891.                     task.resultInfo = ex.Message;

  892.                     callback(task);

  893.                 }

  894.                 Thread.Sleep(5);

  895.             }

  896.         }

  897.         #region 词条合并

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

  899.         {

  900.             int fw = 2000;

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

  902. 

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

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

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

  906.             List<int> yPos = new List<int>();

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

  908.             List<double> xDBD = new List<double>();

  909. 

  910.             DefectLabelInfo stpoint = DefectLabelInfoList[0];

  911. 

  912.             int colNum = Width / image_width;

  913.             //寻找在一条线上

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

  915.             {

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

  917.                 {

  918.                     int max = stpoint.y + fw;

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

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

  921.                     {

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

  923.                         xPos.Add((DefectLabelInfoList[q].i % colNum) * image_width + DefectLabelInfoList[q].x);

  924.                         yPos.Add((DefectLabelInfoList[q].i / colNum) * image_hight + DefectLabelInfoList[q].y);

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

  926.                         xDBD.Add(DefectLabelInfoList[q].contrast);

  927.                     }

  928.                     else

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

  930.                 }               

  931.                 else

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

  933.             }

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

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

  936.             if (XcHeBingList.Count > 0)

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

  938. 

  939. 

  940.             //多个jietou合并

  941.             if (HeBingList.Count > 0)

  942.             {

  943.                 var stIt = HeBingList.Find(x =>  ((x.i % colNum) * image_width + x.x) == xPos.Min());

  944.                 var edIt = HeBingList.Find(x => ((x.i % colNum) * image_width + x.x) == xPos.Max());

  945. 

  946.                 var stIty = HeBingList.Find(x => ((x.i / colNum) * image_hight + x.y) == yPos.Min());

  947.                 var edIty = HeBingList.Find(x => ((x.i / colNum) * image_hight + x.y) == yPos.Max());

  948. 

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

  950.                 double eDBD = 0;

  951.                 double DBD = 0;

  952.                 for (int i = 0; i < xDBD.Count; i++)

  953.                 {

  954.                     if (Math.Abs(xDBD[i] - 1) >= eDBD)

  955.                     {

  956.                         eDBD = Math.Abs(xDBD[i] - 1);

  957.                         DBD = xDBD[i];

  958.                     }

  959.                 }

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

  961.                 int newh = Math.Abs(((edIt.i / colNum) * image_hight + edIt.y) - ((stIt.i / colNum) * image_hight + stIt.y)) + edIt.h;

  962.                 outList.Add(new DefectLabelInfo()

  963.                 {

  964.                     x = stIt.x,

  965.                     y = edIt.y,

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

  967.                     h = newh, //多图叠加

  968.                     classId = eZXD.classId,

  969.                     confidence = eZXD.confidence,

  970.                     contrast = DBD,

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

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

  973.                     i = stIt.i,

  974.                     j = stIt.j,

  975.                 });

  976.             }

  977.             

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

  979.             return outList;

  980.         }

  981.         #endregion

  982. 

  983.         #region 结果回调

  984.         private void callback(DefectTask task)

  985.         {

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

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

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

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

  990.         }

  991.         //异步回调

  992.         WaitCallback waitCallback = new WaitCallback(o =>

  993.         {

  994.             var task = (DefectTask)o;

  995.             task.finishEvent(task);

  996.         });

  997.         #endregion

  998. 

  999.         #region 处理队列

  1000.         public string GetDefectInfo()

  1001.         {

  1002.             string str = "";

  1003.             int cnt1, cnt2, cnt3;

  1004.             lock (taskList)

  1005.             {

  1006.                 cnt1 = taskList.Count;

  1007.             }

  1008.             lock (taskOperationList)

  1009.             {

  1010.                 cnt2 = taskOperationList.Count;

  1011.             }

  1012.             lock (taskMakeTagList)

  1013.             {

  1014.                 cnt3 = taskMakeTagList.Count;

  1015.             }

  1016.             str = $"预处理:{cnt1},推理:{cnt2},打标:{cnt3}";

  1017.             return str; ;

  1018.         }

  1019. 

  1020.         public void add(DefectTask task)

  1021.         {

  1022.             lock (taskList)

  1023.             {

  1024.                 taskList.Add(task);

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

  1026.             }

  1027.         }

  1028. 

  1029. 

  1030.         private DefectTask pop()

  1031.         {

  1032.             lock (taskList)

  1033.             {

  1034.                 if (taskList.Count < 1)

  1035.                     return null;

  1036. 

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

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

  1039.                 var task = taskList[0];

  1040.                 taskList.RemoveAt(0);

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

  1042.                 return task;

  1043.             }

  1044.         }

  1045.         private DefectTask pop2()

  1046.         {

  1047.             lock (taskOperationList)

  1048.             {

  1049.                 if (taskOperationList.Count < 1)

  1050.                     return null;

  1051. 

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

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

  1054.                 var task = taskOperationList[0];

  1055.                 taskOperationList.RemoveAt(0);

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

  1057.                 return task;

  1058.             }

  1059.         }

  1060.         private DefectTask pop3()

  1061.         {

  1062.             lock (taskMakeTagList)

  1063.             {

  1064.                 if (taskMakeTagList.Count < 1)

  1065.                     return null;

  1066. 

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

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

  1069.                 var task = taskMakeTagList[0];

  1070.                 taskMakeTagList.RemoveAt(0);

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

  1072.                 return task;

  1073.             }

  1074.         }

  1075.         private DefectTask pop4()

  1076.         {

  1077.             lock (taskDefectOverList)

  1078.             {

  1079.                 if (taskDefectOverList.Count < 1)

  1080.                     return null;

  1081. 

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

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

  1084.                 var task = taskDefectOverList[0];

  1085.                 taskDefectOverList.RemoveAt(0);

  1086.                 QueueCountEvent?.BeginInvoke(3, taskDefectOverList.Count, null, null);

  1087.                 return task;

  1088.             }

  1089.         }

  1090.         #endregion

  1091. 

  1092.         public void Dispose()

  1093.         {

  1094.             stop();

  1095.         }

  1096. 

  1097.         private class DefectLabelInfo

  1098.         {

  1099.             public int x { get; set; }

  1100.             public int y { get; set; }

  1101.             public int w { get; set; }

  1102.             public int h { get; set; }

  1103.             public int classId { get; set; }

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

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

  1106. 

  1107.             public double cmW { get; set; }

  1108.             public double cmH { get; set; }

  1109. 

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

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

  1112.         }

  1113.     }

  1114. 

  1115.     public class DefectTask

  1116.     {

  1117.         public DefectTask()

  1118.         {

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

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

  1121.             // 添加列到 DataTable

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

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

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

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

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

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

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

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

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

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

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

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

  1134.         }

  1135.         /// <summary>

  1136.         /// 处理参数

  1137.         /// </summary>

  1138.         public int expand_pixel;

  1139.         public int cm2px_x;

  1140.         public int cm2px_y;

  1141. 

  1142.         public Dictionary<int, string> labelDic;

  1143.         /// <summary>

  1144.         /// 模型名字

  1145.         /// </summary>

  1146.         public string modelName;

  1147. 

  1148.         public Models.Records record;

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

  1150.         /// <summary>

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

  1152.         /// </summary>

  1153.         public Mat bmp;

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

  1155. 

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

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

  1158.         public Mat bmpTag;

  1159.         /// <summary>

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

  1161.         /// </summary>

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

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

  1164.                                 //切割后

  1165.         public Mat[] bmps_cut;

  1166. 

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

  1168.         public List<QualifiedLimit> qualifiedLimitList;

  1169. 

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

  1171.         public float[] output;

  1172.         public int[] output_num;

  1173. 

  1174.         //

  1175.         /// <summary>

  1176.         /// 完成后回调 

  1177.         /// </summary>

  1178.         public Action<DefectTask> finishEvent;

  1179.         //==结果返回    

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

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

  1182. 

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

  1184.         /// <summary>

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

  1186.         /// </summary>

  1187.         public DataTable excelTable = new DataTable();

  1188.         public long[] stopwatch = new long[6];

  1189. 

  1190.         /// <summary>

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

  1192.         /// </summary>

  1193.         public int xw;

  1194. 

  1195.         /// <summary>

  1196.         /// 当前图像计米器位置

  1197.         /// </summary>

  1198.         public double CurrDis;

  1199.     }

  1200. }