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.
8 Commits
2 Branches
904 MiB
 
Tree: 9ed8b006e0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9ed8b006e0'
${ noResults }
geboshi_V2/LeatherProject/GeBoShi/ImageDefect/DefectLib.cs

1421 lines
73 KiB
Raw Blame History 

  1. //#define Online_One

  2. 

  3. using CCWin.Win32.Const;

  4. using DocumentFormat.OpenXml.Office2010.ExcelAc;

  5. using DocumentFormat.OpenXml.Office2021.DocumentTasks;

  6. using DocumentFormat.OpenXml.Spreadsheet;

  7. 

  8. 

  9. //using DocumentFormat.OpenXml.Drawing.Charts;

  10. using GeBoShi.SysCtrl;

  11. using HalconDotNet;

  12. using HZH_Controls;

  13. using HZH_Controls.Controls;

  14. using MaiMuControl.Device;

  15. using MaiMuControl.Device.CamDev;

  16. using Models;

  17. using OpenCvSharp;

  18. using PG_Detect;

  19. using S7.Net.Types;

  20. using System;

  21. using System.Collections.Generic;

  22. using System.Data;

  23. using System.Diagnostics;

  24. using System.Linq;

  25. using System.Reflection;

  26. using System.Runtime.InteropServices;

  27. using System.Text;

  28. using System.Threading;

  29. using System.Threading.Tasks;

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

  31. 

  32. namespace GeBoShi.ImageDefect

  33. {

  34.     public class DefectLib

  35.     {

  36.         #region C++dll

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

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

  39.         static extern IntPtr CreateDetector(string model_path);

  40. 

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

  42.         extern static bool DestroyDetector(IntPtr detector);

  43. 

  44.         /// <summary>

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

  46.         /// </summary>

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

  48.         /// <returns></returns>

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

  50.         static extern int GetBatchSize(IntPtr detector);

  51. 

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

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

  54.           int image_num, int width, int height, int channels,

  55.           float conf_threshold, float iou_threshold,

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

  57.           int expand_pixel);

  58.         #endregion

  59. 

  60.         public Action<WarningEnum, string> WarningEvent;

  61.         /// <summary>

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

  63.         /// </summary>

  64.         public Action<DefectTask> finishEvent;

  65.         /// <summary>

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

  67.         /// </summary>

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

  69. 

  70.         private IntPtr detector = IntPtr.Zero;

  71. 

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

  73.         //=======task list

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

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

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

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

  78. 

  79.         private string preModelName = "";

  80. 

  81.         //传统算法核心

  82.         private PGDetect tPGDetect = new PGDetect();

  83.         #region 图片处理参数

  84.         private readonly int image_width = 2048;

  85.         private readonly int image_hight = 2048;

  86.         private readonly int image_channels = 3;

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

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

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

  90. 

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

  92.         #endregion

  93.         public DefectLib()

  94.         {

  95.         }

  96. 

  97.         public bool start()

  98.         {

  99.             try

  100.             {

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

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

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

  104.                 preModelName = "";

  105. 

  106.                 IsInit = true;

  107.                 taskList.Clear();

  108.                 taskOperationList.Clear();

  109.                 taskMakeTagList.Clear();

  110. 

  111. #if Online_One

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

  113.                 t_task.IsBackground = true;

  114.                 t_task.Start();

  115. #else

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

  117.                 t_task.IsBackground = true;

  118.                 t_task.Start();

  119. 

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

  121.                 t_task_operation.IsBackground = true;

  122.                 t_task_operation.Start();

  123. 

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

  125.                 t_task_maketag.IsBackground = true;

  126.                 t_task_maketag.Start();

  127. 

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

  129.                 //t_task_defectover.IsBackground = true;

  130.                 //t_task_defectover.Start();

  131. #endif

  132.                 return true;

  133.             }

  134.             catch (Exception ex)

  135.             {

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

  137.                 return false;

  138.             }

  139.         }

  140. 

  141.         public void stop()

  142.         {

  143.             if (!IsInit) return;

  144. 

  145.             try

  146.             {

  147.                 IsInit = false;

  148.                 //timer.Elapsed -= Timer_Elapsed;

  149.                 preModelName = "";

  150.                 //释放模型

  151.                 if (detector != IntPtr.Zero)

  152.                 {

  153.                     DestroyDetector(detector);

  154.                     detector = IntPtr.Zero;

  155.                 }

  156.                 if (t_task != null)

  157.                 {

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

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

  160.                     t_task = null;

  161.                 }

  162. 

  163.                 if (t_task_operation != null)

  164.                 {

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

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

  167.                     t_task_operation = null;

  168.                 }

  169. 

  170.                 if (t_task_maketag != null)

  171.                 {

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

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

  174.                     t_task_maketag = null;

  175.                 }

  176. 

  177.                 //if (t_task_defectover != null)

  178.                 //{

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

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

  181.                 //    t_task_defectover = null;

  182.                 //}

  183.                 taskList.Clear();

  184.                 taskOperationList.Clear();

  185.                 taskMakeTagList.Clear();

  186.                 taskDefectOverList.Clear();

  187.             }

  188.             catch { }

  189.         }

  190. 

  191.         /// <summary>

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

  193.         /// </summary>

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

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

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

  197.         /// <returns></returns>

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

  199.         {

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

  201.             int num = 0;

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

  203.             {

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

  205.                 {

  206.                     int x = j * width;

  207.                     int y = i * height;

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

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

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

  211.                     num++;

  212.                 }

  213.             }

  214. 

  215.             return array;

  216.         }

  217. 

  218. 

  219. 

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

  221.         {

  222.             try

  223.             {

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

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

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

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

  228.             }

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

  230.             {

  231.                 Console.Write(ex.Message);

  232.                 return null;

  233.             }

  234.         }

  235. 

  236. 

  237.         public bool LoadModel(ImageDefectType itype, string modelPath)

  238.         {

  239.             int step = 0;

  240.             try

  241.             {

  242.                 if (itype == ImageDefectType.Yolo)

  243.                 {

  244.                     if (preModelName != modelPath)

  245.                     {

  246.                         step = 3;

  247.                         //先释放模型

  248.                         if (detector != IntPtr.Zero)

  249.                         {

  250.                             step = 4;

  251.                             DestroyDetector(detector);

  252.                             detector = IntPtr.Zero;

  253.                         }

  254.                         step = 5;

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

  256.                         string tmodelPath = $".\\ConfigFiles\\Models\\{modelPath}";

  257. 

  258.                         detector = CreateDetector(tmodelPath);

  259.                         if (detector == IntPtr.Zero)

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

  261.                         step = 6;

  262.                         preModelName = modelPath;

  263.                     }

  264.                 }

  265.                 else if(itype == ImageDefectType.Anomalib)

  266.                 {

  267.                     return false;

  268.                 }

  269.                 else if (itype == ImageDefectType.Def)

  270.                 {

  271.                     HObject obj = new HObject();

  272.                     Mat mat = new Mat($"{ConfMgr.Instance.ConfigDir}\\init.bmp");

  273.                     OpencvUtils.MatToHObject(mat, out obj);

  274.                     //HOperatorSet.GenImageConst(out obj, "byte", 2048 * 8, 2048 * 2);//生成一幅图像，用byte格式，默认是黑色

  275.                     //Mat initMat = new Mat(2048 * 2, 2048 * 8, MatType.CV_8UC3);

  276.                     if(!tPGDetect.IniOptimization(obj, ConfMgr.Instance.SysConfigParams.HalconDataPath))

  277.                         throw new Exception($"传统算法({ConfMgr.Instance.SysConfigParams.HalconDataPath})初始化失败！");

  278.                 }

  279.                 else

  280.                     return false;

  281.                 return true;

  282.             }

  283.             catch (Exception e)

  284.             {

  285.                 WarningEvent?.Invoke(WarningEnum.Low, $"Load Model-{itype} err({step}):" + e.Message);

  286.                 return false;

  287.             }

  288.         }

  289.         private void runStep()

  290.         {

  291.             int step = 0;

  292.             while (IsInit)

  293.             {

  294.                 if (taskList.Count < 1)

  295.                 {

  296.                     Thread.Sleep(25);

  297.                     continue;

  298.                 }

  299. 

  300.                 //

  301.                 step = 1;

  302.                 var task = pop();

  303.                 try

  304.                 {

  305.                     if (task != null)

  306.                     {

  307.                         Stopwatch stopwatch = Stopwatch.StartNew();

  308.                         step = 2;

  309.                         LoadModel(task.iType, task.modelName);

  310. #if false  //封装使用

  311.                         if (preModelName != task.modelName)

  312.                         {

  313.                             step = 3;

  314.                             //先释放模型

  315.                             if (detector != IntPtr.Zero)

  316.                             {

  317.                                 step = 4;

  318.                                 DestroyDetector(detector);

  319.                                 detector = IntPtr.Zero;

  320.                             }

  321.                             step = 5;

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

  323.                             string modelPath = $".\\ConfigFiles\\Models\\{task.modelName}";

  324. 

  325.                             detector = CreateDetector(modelPath);

  326.                             if (detector == IntPtr.Zero)

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

  328.                             step = 6;

  329.                             preModelName = task.modelName;

  330.                         }

  331. #endif

  332.                         //源图  

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

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

  335.                         stopwatch.Start();

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

  337.                         if (task.iType == ImageDefectType.Yolo)

  338.                         {

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

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

  341.                             step = 7;

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

  343.                             stopwatch.Stop();

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

  345.                             //Resize图像

  346.                             //stopwatch.Restart();

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

  348.                             //stopwatch.Stop();

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

  350. 

  351.                             //预处理模型

  352.                             //stopwatch.Restart();

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

  354.                             //stopwatch.Stop();

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

  356.                             step = 8;

  357.                             lock (taskOperationList)

  358.                             {

  359.                                 taskOperationList.Add(task);

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

  361.                             }

  362.                             step = 9;

  363.                         }

  364.                         else if (task.iType == ImageDefectType.Anomalib)

  365.                         {

  366. 

  367.                         }

  368.                         else

  369.                         {

  370.                             step = 20;

  371.               

  372.                             

  373.                             int object_num = 0;

  374.                             //转换

  375.                             OpencvUtils.MatToHObject(task.bmp, out task.ho_Img);

  376. 

  377.                             stopwatch.Stop();

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

  379.                             stopwatch.Restart();

  380.                             step = 21;

  381.                             //预处理

  382.                             tPGDetect.Processing(task.ho_Img, out task.ho_imgG, out task.ho_ImageResult3, out task.ho_ImageSub,

  383.                                 ConfMgr.Instance.SysConfigParams.HalconDataPath,

  384.                                 out task.hv_RES, out task.hv_gauss_filter1, out task.hv_gauss_filter2, 

  385.                                 out task.hv_Energy_value, out task.hv_Region_S_value, out task.hv_class);

  386. 

  387.                             stopwatch.Stop();

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

  389.                             lock (taskOperationList)

  390.                             {

  391.                                 taskOperationList.Add(task);

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

  393.                             }

  394.                         }

  395.                         

  396.                     }

  397.                 }

  398.                 catch (Exception ex)

  399.                 {

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

  401.                     task.isSucceed = false;

  402.                     task.resultInfo = ex.Message;

  403.                     callback(task);

  404.                 }

  405.                 Thread.Sleep(5);

  406.             }

  407.         }

  408.         //推理

  409.         private void run2()

  410.         {

  411.             QualifiedLimit qualifiedLimit;

  412.             while (IsInit)

  413.             {

  414.                 if (taskOperationList.Count < 1)

  415.                 {

  416.                     Thread.Sleep(25);

  417.                     continue;

  418.                 }

  419. 

  420.                 //

  421.                 var task = pop2();

  422.                 int cut_count = 0, step = 0;

  423.                 try

  424.                 {                    

  425.                     if (task != null && task.bmps_cut.Count() > 0 && task.iType == ImageDefectType.Yolo)

  426.                     {

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

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

  429.                         Stopwatch stopwatch = Stopwatch.StartNew();

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

  431.                         stopwatch.Start();

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

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

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

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

  436.                         step = 1;

  437.                         stopwatch.Stop();

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

  439.                         stopwatch.Restart();

  440. 

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

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

  443.                         //执行推理

  444.                         step = 2;

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

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

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

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

  449.                         step = 3;

  450.                         stopwatch.Stop();

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

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

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

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

  455.                         if (ok == false)

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

  457. 

  458.                         //

  459.                         lock (taskMakeTagList)

  460.                         {

  461.                             taskMakeTagList.Add(task);

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

  463.                         }

  464.                     }

  465.                     else if (task.iType == ImageDefectType.Anomalib)

  466.                     {

  467. 

  468.                     }

  469.                     else if (task.iType == ImageDefectType.Def)

  470.                     {

  471.                         Stopwatch stopwatch = Stopwatch.StartNew();

  472.                         stopwatch.Start();

  473.                         step = 22;

  474.                         //算法处理

  475.                         tPGDetect.Detect(task.ho_Img, task.ho_imgG, task.ho_ImageResult3, task.ho_ImageSub,

  476.                             task.hv_Energy_value, task.hv_Region_S_value, task.hv_class,

  477.                             out task.hv_defectinfo, out task.object_num);

  478. 

  479.                         stopwatch.Stop();

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

  481.                         lock (taskMakeTagList)

  482.                         {

  483.                             taskMakeTagList.Add(task);

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

  485.                         }

  486.                     }

  487.                 }

  488.                 catch (Exception ex)

  489.                 {

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

  491.                     task.isSucceed = false;

  492.                     task.resultInfo = ex.Message;

  493.                     callback(task);

  494.                 }

  495.                 Thread.Sleep(5);

  496.             }

  497.         }

  498.         //打标

  499.         private void run3()

  500.         {

  501.             QualifiedLimit qualifiedLimit;

  502.             while (IsInit)

  503.             {

  504.                 if (taskMakeTagList.Count < 1)

  505.                 {

  506.                     Thread.Sleep(25);

  507.                     continue;

  508.                 }

  509. 

  510.                 //

  511.                 var task = pop3();

  512.                 int liStep = 0;

  513.                 try

  514.                 {

  515.                     Stopwatch stopwatch = Stopwatch.StartNew();

  516.                     stopwatch.Restart();

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

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

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

  520.                     int count = 0;

  521.                     liStep = 3;

  522. 

  523.                     if (task.iType == ImageDefectType.Yolo)

  524.                     {

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

  526.                         bool haveJieTou = false;

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

  528. 

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

  530.                         {

  531.                             liStep = i * 100;

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

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

  534.                             #region 检测信息汇总

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

  536.                             {

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

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

  539.                                 int index = count * detect_elem_size;

  540. 

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

  542.                                 // 获取输出信息

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

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

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

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

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

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

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

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

  551.                                 count++;

  552. 

  553.                                 liStep += 10000;//0

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

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

  556.                                                 // 打印输出信息

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

  558. 

  559.                                 DefectLabelInfoList.Add(new DefectLabelInfo()

  560.                                 {

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

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

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

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

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

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

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

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

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

  570.                                     i = i,

  571.                                     j = j,

  572.                                 });

  573.                             }

  574. 

  575.                             #endregion

  576.                         }

  577.                         liStep = 7777;

  578.                         #region 合并接头横档

  579.                         if (DefectLabelInfoList.Count > 0)

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

  581.                         if (DefectLabelInfoList.Count > 0)

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

  583.                         if (DefectLabelInfoList.Count > 0)

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

  585.                         if (DefectLabelInfoList.Count > 0)

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

  587.                         if (DefectLabelInfoList.Count > 0)

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

  589.                         if (DefectLabelInfoList.Count > 0)

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

  591.                         #endregion

  592.                         //结果过滤

  593.                         #region 结果过滤

  594. 

  595.                         liStep = 8888;

  596.                         if (DefectLabelInfoList.Count > 0)

  597.                         {

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

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

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

  601.                             {

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

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

  604.                                 {

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

  606.                                     if (qualifiedLimit != null)

  607.                                     {

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

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

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

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

  612.                                         {

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

  614.                                             continue;

  615.                                         }

  616. 

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

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

  619.                                         if (qualifiedLimit.IsOR)

  620.                                         {

  621.                                             if (!(

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

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

  624.                                             {

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

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

  627.                                                 continue;

  628.                                             }

  629.                                         }

  630.                                         else

  631.                                         {

  632.                                             if (!(

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

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

  635.                                             {

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

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

  638.                                                 continue;

  639.                                             }

  640.                                         }

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

  642.                                             haveJieTou = true;

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

  644.                                         {

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

  646.                                             continue;

  647.                                         }

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

  649.                                     }

  650.                                 }

  651.                                 liStep++;

  652.                                 //1

  653.                                 int penLine = 20;

  654.                                 //打标

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

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

  657.                                 liStep++;//2

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

  659. 

  660. 

  661. 

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

  663. 

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

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

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

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

  668.                                 liStep++;//3

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

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

  671. 

  672.                                 liStep++;//4

  673.                                          //切缺陷小图 

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

  675.                                 int left, top, decX, decY;

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

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

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

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

  680. 

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

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

  683. 

  684.                                 left = point1.X - decX;

  685.                                 top = point1.Y - decY;

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

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

  688. 

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

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

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

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

  693.                                 liStep++;//5 

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

  695.                                 liStep++;//6

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

  697.                                 {

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

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

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

  701.                                 }

  702. 

  703.                                 //保存

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

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

  706. 

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

  708.                                 liStep++;//7

  709.                             }

  710.                         }

  711.                         #endregion

  712. 

  713.                     }

  714.                     else if (task.iType == ImageDefectType.Anomalib)

  715.                     {

  716. 

  717.                     }

  718.                     else if (task.iType == ImageDefectType.Def)

  719.                     {

  720.                         stopwatch.Restart();

  721.                         //打标

  722.                         var defectinfo = task.hv_defectinfo.ToOArr();

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

  724.                         for (int i = 0; i < task.object_num; i++)

  725.                         {

  726.                             liStep = 23 + i;

  727.                             #region 检测信息汇总

  728.                             int index = i * 6;

  729. 

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

  731.                             // 获取输出信息

  732.                             int x = (int)defectinfo[index].ToInt();

  733.                             int y = (int)defectinfo[index + 1].ToInt();

  734.                             int w = (int)defectinfo[index + 2].ToInt();

  735.                             int h = (int)defectinfo[index + 3].ToInt();

  736.                             int classId = -99;//(int)defectinfo[index + 4].ToInt();

  737.                             double confidence = Math.Round(defectinfo[index + 5].ToDouble(), 2); //置信度

  738. 

  739.                             int px = x;

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

  741.                             var cmY = Math.Round((task.bmp.Height - y - h) * task.widthRatio / task.cm2px_y, 2);//外面计Y从右下角为原点

  742. 

  743.                             DefectLabelInfoList.Add(new DefectLabelInfo()

  744.                             {

  745.                                 x = x,

  746.                                 y = y,

  747.                                 w = w,

  748.                                 h = h,

  749.                                 classId = classId,

  750.                                 confidence = confidence, //置信度

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

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

  753.                                 i = i,

  754.                                 j = i,

  755.                             });

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

  757.                             task.excelTable.Rows.Add($"{task.photoIndex}", cmX, cmY,

  758.                                 Math.Round(w * task.widthRatio / task.cm2px_x, 2), Math.Round(h * task.widthRatio / task.cm2px_y, 2),

  759.                                 i, classId, confidence, 0);

  760. 

  761.                             int penLine = 20;

  762.                             //打标

  763.                             var point1 = new OpenCvSharp.Point(x, y);

  764.                             var point2 = new OpenCvSharp.Point(point1.X + w + penLine / 2, point1.Y + h + penLine / 2);

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

  766. 

  767.                             //切小图

  768.                             int left, top, decX, decY;

  769. 

  770.                             int tdecX = (w / 2) / 2;

  771.                             int tdecY = w / h > 4 ? w / 8 : (h / 1) / 2;

  772. 

  773.                             decX = (w > 236 ? tdecX : 256 - w) / 2;

  774.                             decY = (h > 236 ? tdecY : 256 - h) / 2;

  775. 

  776.                             left = point1.X - decX;

  777.                             top = point1.Y - decY;

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

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

  780. 

  781.                             int width = w + decX * 2;

  782.                             int height = h + decY * 2;

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

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

  785. 

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

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

  788.                             #endregion

  789.                         }

  790.                     }

  791.                     liStep = 99;

  792.                     stopwatch.Stop();

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

  794. 

  795.                     task.isSucceed = true;

  796. 

  797.                     //lock (taskDefectOverList)

  798.                     //{

  799.                     //    taskDefectOverList.Add(task);

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

  801.                     //}

  802. 

  803.                     callback(task);

  804.                     Thread.Sleep(5);

  805.                 }

  806.                 catch (Exception ex)

  807.                 {

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

  809.                     task.isSucceed = false;

  810.                     task.resultInfo = ex.Message;

  811.                     callback(task);

  812.                 }

  813.             }           

  814.         }

  815.         //最终处理

  816.         private void run()

  817.         {

  818.             int step = 0;

  819.             QualifiedLimit qualifiedLimit;

  820.             while (IsInit)

  821.             {

  822.                 if (taskList.Count < 1)

  823.                 {

  824.                     Thread.Sleep(5);

  825.                     continue;

  826.                 }

  827.                 step = 1;

  828.                 var task = pop();

  829.                 try

  830.                 {

  831.                     if (task != null)

  832.                     {

  833.                         Stopwatch stopwatch = Stopwatch.StartNew();

  834.                         step = 2;

  835.                         if (preModelName != task.modelName)

  836.                         {

  837.                             step = 3;

  838.                             //先释放模型

  839.                             if (detector != IntPtr.Zero)

  840.                             {

  841.                                 step = 4;

  842.                                 DestroyDetector(detector);

  843.                                 detector = IntPtr.Zero;

  844.                             }

  845.                             step = 5;

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

  847. 

  848.                             detector = CreateDetector(modelPath);

  849.                             if (detector == IntPtr.Zero)

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

  851.                             step = 6;

  852.                             preModelName = task.modelName;

  853.                         }

  854.                         //源图  

  855.                         stopwatch.Start();

  856.                         step = 7;

  857.                         //裁切

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

  859.                         stopwatch.Stop();

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

  861.                         step = 8;

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

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

  864.                         stopwatch.Restart();

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

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

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

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

  869.                         step = 9;

  870.                         stopwatch.Stop();

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

  872.                         stopwatch.Restart();

  873. 

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

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

  876.                         //执行推理

  877.                         step = 10;

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

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

  880.                         step = 11;

  881.                         stopwatch.Stop();

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

  883.                         stopwatch.Restart();

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

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

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

  887.                         if (ok == false)

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

  889.                         step = 12;

  890.                         //打标

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

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

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

  894.                         int count = 0;

  895.                         step = 13;

  896. 

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

  898.                         bool haveJieTou = false;

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

  900. 

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

  902.                         {

  903.                             step = i * 100;

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

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

  906.                             #region 检测信息汇总

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

  908.                             {

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

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

  911.                                 int index = count * detect_elem_size;

  912. 

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

  914.                                 // 获取输出信息

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

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

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

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

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

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

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

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

  923.                                 count++;

  924. 

  925.                                 step += 10000;//0

  926.                                      

  927.                                 DefectLabelInfoList.Add(new DefectLabelInfo()

  928.                                 {

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

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

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

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

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

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

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

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

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

  938.                                     i = i,

  939.                                     j = j,

  940.                                 });

  941.                             }

  942. 

  943.                             #endregion

  944.                         }

  945.                         step = 7777;

  946.                         #region 合并接头横档

  947.                         if (DefectLabelInfoList.Count > 0)

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

  949.                         if (DefectLabelInfoList.Count > 0)

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

  951.                         if (DefectLabelInfoList.Count > 0)

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

  953.                         if (DefectLabelInfoList.Count > 0)

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

  955.                         if (DefectLabelInfoList.Count > 0)

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

  957.                         #endregion

  958.                         //结果过滤

  959.                         #region 结果过滤

  960. 

  961.                         step = 8888;

  962.                         if (DefectLabelInfoList.Count > 0)

  963.                         {

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

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

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

  967.                             {

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

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

  970.                                 {

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

  972.                                     if (qualifiedLimit != null)

  973.                                     {

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

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

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

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

  978.                                         {

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

  980.                                             continue;

  981.                                         }

  982. 

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

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

  985.                                         if (qualifiedLimit.IsOR)

  986.                                         {

  987.                                             if (!(

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

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

  990.                                             {

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

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

  993.                                                 continue;

  994.                                             }

  995.                                         }

  996.                                         else

  997.                                         {

  998.                                             if (!(

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

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

  1001.                                             {

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

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

  1004.                                                 continue;

  1005.                                             }

  1006.                                         }

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

  1008.                                             haveJieTou = true;

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

  1010.                                         {

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

  1012.                                             continue;

  1013.                                         }

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

  1015.                                     }

  1016.                                 }

  1017.                                 step++;

  1018.                                 //1

  1019.                                 int penLine = 20;

  1020.                                 //打标

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

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

  1023.                                 step++;//2

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

  1025. 

  1026. 

  1027. 

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

  1029. 

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

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

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

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

  1034.                                 step++;//3

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

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

  1037. 

  1038.                                 step++;//4

  1039.                                          //切缺陷小图 

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

  1041.                                 int left, top, decX, decY;

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

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

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

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

  1046. 

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

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

  1049. 

  1050.                                 left = point1.X - decX;

  1051.                                 top = point1.Y - decY;

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

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

  1054. 

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

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

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

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

  1059.                                 step++;//5 

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

  1061.                                 step++;//6

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

  1063.                                 {

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

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

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

  1067.                                 }

  1068. 

  1069.                                 //保存

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

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

  1072. 

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

  1074.                                 step++;//7

  1075.                             }

  1076.                         }

  1077.                         #endregion

  1078.                         step = 99;

  1079.                         stopwatch.Stop();

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

  1081. 

  1082.                         task.isSucceed = true;

  1083. 

  1084.                         //lock (taskDefectOverList)

  1085.                         //{

  1086.                         //    taskDefectOverList.Add(task);

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

  1088.                         //}

  1089. 

  1090.                         callback(task);

  1091.                     }

  1092.                 }

  1093.                 catch (Exception ex)

  1094.                 {

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

  1096.                     task.isSucceed = false;

  1097.                     task.resultInfo = ex.Message;

  1098.                     callback(task);

  1099.                 }

  1100.                 Thread.Sleep(5);

  1101.             }

  1102.         }

  1103.        

  1104.         #region 词条合并

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

  1106.         {

  1107.             int fw = 2000;

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

  1109. 

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

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

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

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

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

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

  1116. 

  1117.             DefectLabelInfo stpoint = DefectLabelInfoList[0];

  1118. 

  1119.             int colNum = Width / image_width;

  1120.             //寻找在一条线上

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

  1122.             {

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

  1124.                 {

  1125.                     int max = stpoint.y + fw;

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

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

  1128.                     {

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

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

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

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

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

  1134.                     }

  1135.                     else

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

  1137.                 }               

  1138.                 else

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

  1140.             }

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

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

  1143.             if (XcHeBingList.Count > 0)

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

  1145. 

  1146. 

  1147.             //多个jietou合并

  1148.             if (HeBingList.Count > 0)

  1149.             {

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

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

  1152. 

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

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

  1155. 

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

  1157.                 double eDBD = 0;

  1158.                 double DBD = 0;

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

  1160.                 {

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

  1162.                     {

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

  1164.                         DBD = xDBD[i];

  1165.                     }

  1166.                 }

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

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

  1169.                 outList.Add(new DefectLabelInfo()

  1170.                 {

  1171.                     x = stIt.x,

  1172.                     y = edIt.y,

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

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

  1175.                     classId = eZXD.classId,

  1176.                     confidence = eZXD.confidence,

  1177.                     contrast = DBD,

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

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

  1180.                     i = stIt.i,

  1181.                     j = stIt.j,

  1182.                 });

  1183.             }

  1184.             

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

  1186.             return outList;

  1187.         }

  1188.         #endregion

  1189. 

  1190.         #region 结果回调

  1191.         private void callback(DefectTask task)

  1192.         {

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

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

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

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

  1197.         }

  1198.         //异步回调

  1199.         WaitCallback waitCallback = new WaitCallback(o =>

  1200.         {

  1201.             var task = (DefectTask)o;

  1202.             task.finishEvent(task);

  1203.         });

  1204.         #endregion

  1205. 

  1206.         #region 处理队列

  1207.         public string GetDefectInfo()

  1208.         {

  1209.             string str = "";

  1210.             int cnt1, cnt2, cnt3;

  1211.             lock (taskList)

  1212.             {

  1213.                 cnt1 = taskList.Count;

  1214.             }

  1215.             lock (taskOperationList)

  1216.             {

  1217.                 cnt2 = taskOperationList.Count;

  1218.             }

  1219.             lock (taskMakeTagList)

  1220.             {

  1221.                 cnt3 = taskMakeTagList.Count;

  1222.             }

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

  1224.             return str; ;

  1225.         }

  1226. 

  1227.         public void add(DefectTask task)

  1228.         {

  1229.             lock (taskList)

  1230.             {

  1231.                 taskList.Add(task);

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

  1233.             }

  1234.         }

  1235. 

  1236. 

  1237.         private DefectTask pop()

  1238.         {

  1239.             lock (taskList)

  1240.             {

  1241.                 if (taskList.Count < 1)

  1242.                     return null;

  1243. 

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

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

  1246.                 var task = taskList[0];

  1247.                 taskList.RemoveAt(0);

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

  1249.                 return task;

  1250.             }

  1251.         }

  1252.         private DefectTask pop2()

  1253.         {

  1254.             lock (taskOperationList)

  1255.             {

  1256.                 if (taskOperationList.Count < 1)

  1257.                     return null;

  1258. 

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

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

  1261.                 var task = taskOperationList[0];

  1262.                 taskOperationList.RemoveAt(0);

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

  1264.                 return task;

  1265.             }

  1266.         }

  1267.         private DefectTask pop3()

  1268.         {

  1269.             lock (taskMakeTagList)

  1270.             {

  1271.                 if (taskMakeTagList.Count < 1)

  1272.                     return null;

  1273. 

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

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

  1276.                 var task = taskMakeTagList[0];

  1277.                 taskMakeTagList.RemoveAt(0);

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

  1279.                 return task;

  1280.             }

  1281.         }

  1282.         private DefectTask pop4()

  1283.         {

  1284.             lock (taskDefectOverList)

  1285.             {

  1286.                 if (taskDefectOverList.Count < 1)

  1287.                     return null;

  1288. 

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

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

  1291.                 var task = taskDefectOverList[0];

  1292.                 taskDefectOverList.RemoveAt(0);

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

  1294.                 return task;

  1295.             }

  1296.         }

  1297.         #endregion

  1298. 

  1299.         public void Dispose()

  1300.         {

  1301.             stop();

  1302.         }

  1303. 

  1304.         private class DefectLabelInfo

  1305.         {

  1306.             public int x { get; set; }

  1307.             public int y { get; set; }

  1308.             public int w { get; set; }

  1309.             public int h { get; set; }

  1310.             public int classId { get; set; }

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

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

  1313. 

  1314.             public double cmW { get; set; }

  1315.             public double cmH { get; set; }

  1316. 

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

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

  1319.         }

  1320.     }

  1321. 

  1322.     public class DefectTask

  1323.     {

  1324.         public DefectTask()

  1325.         {

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

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

  1328.             // 添加列到 DataTable

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

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

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

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

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

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

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

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

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

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

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

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

  1341.         }

  1342.         /// <summary>

  1343.         /// 处理参数

  1344.         /// </summary>

  1345.         public int expand_pixel;

  1346.         public int cm2px_x;

  1347.         public int cm2px_y;

  1348. 

  1349.         public Dictionary<int, string> labelDic;

  1350.         /// <summary>

  1351.         /// 模型名字

  1352.         /// </summary>

  1353.         public string modelName;

  1354. 

  1355.         public Models.Records record;

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

  1357.         /// <summary>

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

  1359.         /// </summary>

  1360.         public Mat bmp;

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

  1362. 

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

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

  1365.         public Mat bmpTag;

  1366.         /// <summary>

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

  1368.         /// </summary>

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

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

  1371.                                 //切割后

  1372.         public Mat[] bmps_cut;

  1373. 

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

  1375.         public List<QualifiedLimit> qualifiedLimitList;

  1376. 

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

  1378.         public float[] output;

  1379.         public int[] output_num;

  1380. 

  1381.         //

  1382.         /// <summary>

  1383.         /// 完成后回调 

  1384.         /// </summary>

  1385.         public Action<DefectTask> finishEvent;

  1386.         //==结果返回    

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

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

  1389. 

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

  1391.         /// <summary>

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

  1393.         /// </summary>

  1394.         public DataTable excelTable = new DataTable();

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

  1396. 

  1397.         /// <summary>

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

  1399.         /// </summary>

  1400.         public int xw;

  1401. 

  1402.         /// <summary>

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

  1404.         /// </summary>

  1405.         public double CurrDis;

  1406. 

  1407.         /// <summary>

  1408.         /// 算法选择

  1409.         /// </summary>

  1410.         public ImageDefectType iType;

  1411. 

  1412.         //传统算法使用

  1413.         public HObject ho_Img = new HObject();

  1414.         public HObject ho_imgG = new HObject();

  1415.         public HObject ho_ImageResult3 = new HObject();

  1416.         public HObject ho_ImageSub = new HObject();

  1417.         public HTuple hv_RES, hv_gauss_filter1, hv_gauss_filter2, hv_Energy_value, hv_Region_S_value, hv_class, hv_defectinfo;

  1418.         public int object_num = 0;

  1419.     }

  1420. }